419 lines
9.0 KiB
C
419 lines
9.0 KiB
C
/* MSPDebug - debugging tool for MSP430 MCUs
|
|
* Copyright (C) 2009, 2010 Daniel Beer
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
|
|
#include "dis.h"
|
|
#include "output_util.h"
|
|
#include "stab.h"
|
|
#include "util.h"
|
|
#include "demangle.h"
|
|
#include "opdb.h"
|
|
|
|
static char* copy_string(int lowercase_dis, char *dst, const char *const end,
|
|
const char *src)
|
|
{
|
|
int c;
|
|
|
|
if (src != NULL) {
|
|
while (dst < end && (c = *src++) != '\0') {
|
|
if (lowercase_dis && isupper(c))
|
|
c = tolower(c);
|
|
*dst++ = c;
|
|
}
|
|
}
|
|
*dst = '\0';
|
|
return dst;
|
|
}
|
|
|
|
static const char *opcode_name_with_size(const struct msp430_instruction *insn)
|
|
{
|
|
static char buf[10];
|
|
const char *const end = buf + sizeof(buf) - 1;
|
|
const char *opname = dis_opcode_name(insn->op);
|
|
const int lowercase_dis = opdb_get_boolean("lowercase_dis");
|
|
const char *suffix = NULL;
|
|
char *dst;
|
|
|
|
if (!opname)
|
|
opname = "???";
|
|
|
|
if (insn->dsize == MSP430_DSIZE_BYTE)
|
|
suffix = ".B";
|
|
else if (insn->dsize == MSP430_DSIZE_AWORD)
|
|
suffix = ".A";
|
|
else if (insn->dsize == MSP430_DSIZE_UNKNOWN)
|
|
suffix = ".?";
|
|
|
|
/* Don't show the .A suffix for these instructions */
|
|
if (insn->op == MSP430_OP_MOVA || insn->op == MSP430_OP_CMPA ||
|
|
insn->op == MSP430_OP_SUBA || insn->op == MSP430_OP_ADDA ||
|
|
insn->op == MSP430_OP_BRA || insn->op == MSP430_OP_RETA)
|
|
suffix = NULL;
|
|
|
|
dst = copy_string(lowercase_dis, buf, end, opname);
|
|
dst = copy_string(lowercase_dis, dst, end, suffix);
|
|
return buf;
|
|
}
|
|
|
|
static const char *reg_name(const msp430_reg_t reg)
|
|
{
|
|
static char buf[4];
|
|
const char *const end = buf + sizeof(buf) - 1;
|
|
const int lowercase_dis = opdb_get_boolean("lowercase_dis");
|
|
const char *name = dis_reg_name(reg);
|
|
|
|
if (!name)
|
|
return "???";
|
|
if (lowercase_dis == 0)
|
|
return name;
|
|
copy_string(lowercase_dis, buf, end, name);
|
|
return buf;
|
|
}
|
|
|
|
static int format_addr(msp430_amode_t amode, address_t addr,
|
|
msp430_dsize_t dsize)
|
|
{
|
|
char name[MAX_SYMBOL_LENGTH];
|
|
const char *prefix = "";
|
|
int print_flags = PRINT_ADDRESS_EXACT;
|
|
|
|
switch (amode) {
|
|
case MSP430_AMODE_REGISTER:
|
|
case MSP430_AMODE_INDIRECT:
|
|
case MSP430_AMODE_INDIRECT_INC:
|
|
return 0;
|
|
|
|
case MSP430_AMODE_IMMEDIATE:
|
|
prefix = "#";
|
|
if (dsize == MSP430_DSIZE_BYTE)
|
|
print_flags |= PRINT_BYTE_DATA;
|
|
case MSP430_AMODE_INDEXED:
|
|
break;
|
|
|
|
case MSP430_AMODE_ABSOLUTE:
|
|
prefix = "&";
|
|
break;
|
|
|
|
case MSP430_AMODE_SYMBOLIC:
|
|
break;
|
|
}
|
|
|
|
print_address(addr, name, sizeof(name), print_flags);
|
|
return printc("%s\x1b[1m%s\x1b[0m", prefix, name);
|
|
}
|
|
|
|
static int format_reg(msp430_amode_t amode, msp430_reg_t reg)
|
|
{
|
|
const char *prefix = "";
|
|
const char *suffix = "";
|
|
|
|
switch (amode) {
|
|
case MSP430_AMODE_REGISTER:
|
|
break;
|
|
|
|
case MSP430_AMODE_INDEXED:
|
|
prefix = "(";
|
|
suffix = ")";
|
|
break;
|
|
|
|
case MSP430_AMODE_IMMEDIATE:
|
|
case MSP430_AMODE_SYMBOLIC:
|
|
case MSP430_AMODE_ABSOLUTE:
|
|
return 0;
|
|
|
|
case MSP430_AMODE_INDIRECT_INC:
|
|
suffix = "+";
|
|
case MSP430_AMODE_INDIRECT:
|
|
prefix = "@";
|
|
break;
|
|
}
|
|
|
|
return printc("%s\x1b[33m%s\x1b[0m%s", prefix, reg_name(reg), suffix);
|
|
}
|
|
|
|
/* Given an operands addressing mode, value and associated register,
|
|
* print the canonical representation of it to stdout.
|
|
*
|
|
* Returns the number of characters printed.
|
|
*/
|
|
static int format_operand(msp430_amode_t amode, address_t addr,
|
|
msp430_reg_t reg, msp430_dsize_t dsize)
|
|
{
|
|
int len = 0;
|
|
|
|
len += format_addr(amode, addr, dsize);
|
|
len += format_reg(amode, reg);
|
|
|
|
return len;
|
|
}
|
|
|
|
/* Write assembly language for the instruction to this buffer */
|
|
static int dis_format(const struct msp430_instruction *insn)
|
|
{
|
|
int len = 0;
|
|
|
|
len += printc("\x1b[36m%s\x1b[0m", opcode_name_with_size(insn));
|
|
while (len < 8)
|
|
len += printc(" ");
|
|
|
|
/* Source operand */
|
|
if (insn->itype == MSP430_ITYPE_DOUBLE) {
|
|
len += format_operand(insn->src_mode,
|
|
insn->src_addr,
|
|
insn->src_reg,
|
|
insn->dsize);
|
|
|
|
len += printc(",");
|
|
while (len < 15)
|
|
len += printc(" ");
|
|
len += printc(" ");
|
|
}
|
|
|
|
/* Destination operand */
|
|
if (insn->itype != MSP430_ITYPE_NOARG)
|
|
len += format_operand(insn->dst_mode,
|
|
insn->dst_addr,
|
|
insn->dst_reg,
|
|
insn->dsize);
|
|
|
|
/* Repetition count */
|
|
if (insn->rep_register)
|
|
len += printc(" [repeat %s]", reg_name(insn->rep_index));
|
|
else if (insn->rep_index)
|
|
len += printc(" [repeat %d]", insn->rep_index + 1);
|
|
|
|
return len;
|
|
}
|
|
|
|
address_t disassemble(address_t offset, const uint8_t *data, int length,
|
|
powerbuf_t power)
|
|
{
|
|
int first_line = 1;
|
|
unsigned long long ua_total = 0;
|
|
int samples_total = 0;
|
|
address_t next_offset = offset;
|
|
|
|
while (length) {
|
|
struct msp430_instruction insn = {0};
|
|
int retval;
|
|
int count;
|
|
int i;
|
|
address_t oboff;
|
|
char obname[MAX_SYMBOL_LENGTH];
|
|
|
|
if (first_line ||
|
|
(!stab_nearest(offset, obname, sizeof(obname), &oboff) &&
|
|
!oboff)) {
|
|
char buffer[MAX_SYMBOL_LENGTH];
|
|
|
|
print_address(offset, buffer, sizeof(buffer), 0);
|
|
printc("\x1b[m%s\x1b[0m:\n", buffer);
|
|
}
|
|
first_line = 0;
|
|
|
|
retval = dis_decode(data, offset, length, &insn);
|
|
if (retval > 0)
|
|
next_offset = offset + retval;
|
|
count = retval > 0 ? retval : 2;
|
|
if (count > length)
|
|
count = length;
|
|
|
|
printc(" \x1b[36m%05x\x1b[0m:", offset);
|
|
|
|
for (i = 0; i < count; i++)
|
|
printc(" %02x", data[i]);
|
|
|
|
while (i < 9) {
|
|
printc(" ");
|
|
i++;
|
|
}
|
|
|
|
if (retval >= 0)
|
|
i = dis_format(&insn);
|
|
|
|
if (power) {
|
|
unsigned long long ua;
|
|
int samples;
|
|
|
|
while (i < 40) {
|
|
printc(" ");
|
|
i++;
|
|
}
|
|
|
|
samples = powerbuf_get_by_mab(power, offset, &ua);
|
|
if (samples) {
|
|
printc(" ;; %.01f uA",
|
|
(double)ua / (double)samples);
|
|
ua_total += ua;
|
|
samples_total += samples;
|
|
}
|
|
}
|
|
|
|
printc("\n");
|
|
|
|
offset += count;
|
|
length -= count;
|
|
data += count;
|
|
}
|
|
|
|
if (power && samples_total)
|
|
printc(";; Total over this block: "
|
|
"%.01f uAs in %.01f ms (%.01f uA avg)\n",
|
|
(double)(ua_total * power->interval_us) / 1000000.0,
|
|
(double)(samples_total * power->interval_us) / 1000.0,
|
|
(double)ua_total / (double)samples_total);
|
|
|
|
return next_offset;
|
|
}
|
|
|
|
void hexdump(address_t addr, const uint8_t *data, int data_len)
|
|
{
|
|
int offset = 0;
|
|
|
|
while (offset < data_len) {
|
|
int i, j;
|
|
|
|
/* Address label */
|
|
printc(" \x1b[36m%05x:\x1b[0m", offset + addr);
|
|
|
|
/* Hex portion */
|
|
for (i = 0; i < 16 && offset + i < data_len; i++)
|
|
printc(" %02x", data[offset + i]);
|
|
for (j = i; j < 16; j++)
|
|
printc(" ");
|
|
|
|
/* Printable characters */
|
|
printc(" \x1b[32m|");
|
|
for (j = 0; j < i; j++) {
|
|
int c = data[offset + j];
|
|
|
|
printc("%c", (c >= 32 && c <= 126) ? c : '.');
|
|
}
|
|
for (; j < 16; j++)
|
|
printc(" ");
|
|
printc("|\x1b[0m\n");
|
|
|
|
offset += i;
|
|
}
|
|
}
|
|
|
|
void show_regs(const address_t *regs)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
int j;
|
|
|
|
printc(" ");
|
|
for (j = 0; j < 4; j++) {
|
|
int k = j * 4 + i;
|
|
|
|
printc("(\x1b[1m%3s:\x1b[0m %05x) ",
|
|
reg_name(k), regs[k]);
|
|
}
|
|
|
|
printc("\n");
|
|
}
|
|
}
|
|
|
|
int print_address(address_t addr, char *out, int max_len,
|
|
print_address_flags_t f)
|
|
{
|
|
char name[MAX_SYMBOL_LENGTH];
|
|
address_t offset;
|
|
|
|
if (!stab_nearest(addr, name, sizeof(name), &offset)) {
|
|
char demangled[MAX_SYMBOL_LENGTH];
|
|
int len;
|
|
|
|
if (offset) {
|
|
if (f & PRINT_ADDRESS_EXACT) {
|
|
snprintf(out, max_len, "0x%04x", addr);
|
|
return 0;
|
|
}
|
|
|
|
len = snprintf(out, max_len, "%s+0x%x", name, offset);
|
|
} else {
|
|
len = snprintf(out, max_len, "%s", name);
|
|
}
|
|
|
|
if (demangle(name, demangled, sizeof(demangled)) > 0)
|
|
snprintf(out + len, max_len - len, " (%s)", demangled);
|
|
|
|
return 1;
|
|
}
|
|
|
|
snprintf(out, max_len, (f & PRINT_BYTE_DATA) ? "0x%02x" : "0x%04x", addr);
|
|
return 0;
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name lists
|
|
*/
|
|
|
|
static int namelist_cmp(const void *a, const void *b)
|
|
{
|
|
return strcasecmp(*(const char **)a, *(const char **)b);
|
|
}
|
|
|
|
void namelist_print(struct vector *v)
|
|
{
|
|
int i;
|
|
int max_len = 0;
|
|
int rows, cols;
|
|
|
|
qsort(v->ptr, v->size, v->elemsize, namelist_cmp);
|
|
|
|
for (i = 0; i < v->size; i++) {
|
|
const char *text = VECTOR_AT(*v, i, const char *);
|
|
int len = strlen(text);
|
|
|
|
if (len > max_len)
|
|
max_len = len;
|
|
}
|
|
|
|
max_len += 2;
|
|
cols = 72 / max_len;
|
|
rows = (v->size + cols - 1) / cols;
|
|
|
|
for (i = 0; i < rows; i++) {
|
|
int j;
|
|
|
|
printc(" ");
|
|
for (j = 0; j < cols; j++) {
|
|
int k = j * rows + i;
|
|
const char *text;
|
|
|
|
if (k >= v->size)
|
|
break;
|
|
|
|
text = VECTOR_AT(*v, k, const char *);
|
|
printc("%s", text);
|
|
for (k = strlen(text); k < max_len; k++)
|
|
printc(" ");
|
|
}
|
|
|
|
printc("\n");
|
|
}
|
|
}
|