Separated and simplified output processing.
This commit is contained in:
Daniel Beer
parent
984ffe6e88
commit
e834241e90
4
Makefile
4
Makefile
|
|
@ -55,8 +55,8 @@ install: mspdebug mspdebug.man
|
|||
|
||||
mspdebug: main.o fet.o rf2500.o dis.o uif.o olimex.o ihex.o elf32.o stab.o \
|
||||
util.o bsl.o sim.o symmap.o gdb.o btree.o rtools.o sym.o devcmd.o \
|
||||
cproc.o vector.o cproc_util.o expr.o fet_error.o binfile.o fet_db.o \
|
||||
usbutil.o titext.o srec.o device.o coff.o opdb.o
|
||||
cproc.o vector.o output_util.o expr.o fet_error.o binfile.o \
|
||||
fet_db.o usbutil.o titext.o srec.o device.o coff.o opdb.o output.o
|
||||
$(CC) $(LDFLAGS) $(MACPORTS_LDFLAGS) -o $@ $^ -lusb $(READLINE_LIBS)
|
||||
|
||||
.c.o:
|
||||
|
|
|
|||
44
cproc.c
44
cproc.c
|
|
@ -34,6 +34,7 @@
|
|||
#include "vector.h"
|
||||
#include "stab.h"
|
||||
#include "util.h"
|
||||
#include "output.h"
|
||||
|
||||
struct cproc {
|
||||
struct vector command_list;
|
||||
|
|
@ -150,16 +151,14 @@ static int cmd_help(cproc_t cp, char **arg)
|
|||
struct opdb_key key;
|
||||
|
||||
if (cmd) {
|
||||
cproc_printf(cp, "\x1b[1mCOMMAND: %s\x1b[0m\n",
|
||||
cmd->name);
|
||||
fputs(cmd->help, stdout);
|
||||
printc("\x1b[1mCOMMAND: %s\x1b[0m\n\n%s\n",
|
||||
cmd->name, cmd->help);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!opdb_get(topic, &key, NULL)) {
|
||||
cproc_printf(cp, "\x1b[1mOPTION: %s (%s)\x1b[0m\n",
|
||||
key.name, type_text(key.type));
|
||||
fputs(key.help, stdout);
|
||||
printc("\x1b[1mOPTION: %s (%s)\x1b[0m\n\n%s\n",
|
||||
key.name, type_text(key.type), key.help);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -343,39 +342,6 @@ int cproc_register_commands(cproc_t cp, const struct cproc_command *cmd,
|
|||
return 0;
|
||||
}
|
||||
|
||||
void cproc_printf(cproc_t cp, const char *fmt, ...)
|
||||
{
|
||||
char buf[256];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
if (!opdb_get_boolean("color")) {
|
||||
char *src = buf;
|
||||
char *dst = buf;
|
||||
|
||||
for (;;) {
|
||||
if (*src == 27) {
|
||||
while (*src && !isalpha(*src))
|
||||
src++;
|
||||
if (*src)
|
||||
src++;
|
||||
}
|
||||
|
||||
if (!*src)
|
||||
break;
|
||||
|
||||
*(dst++) = *(src++);
|
||||
}
|
||||
|
||||
*dst = 0;
|
||||
}
|
||||
|
||||
puts(buf);
|
||||
}
|
||||
|
||||
void cproc_modify(cproc_t cp, int flags)
|
||||
{
|
||||
cp->modify_flags |= flags;
|
||||
|
|
|
|||
7
cproc.h
7
cproc.h
|
|
@ -71,13 +71,6 @@ void cproc_destroy(cproc_t cp);
|
|||
int cproc_register_commands(cproc_t cp, const struct cproc_command *cmd,
|
||||
int count);
|
||||
|
||||
/* Print a line of text on the command processor's standard output.
|
||||
*
|
||||
* ANSI colour codes can be embedded in the output text, and will be stripped
|
||||
* out if colour is disabled.
|
||||
*/
|
||||
void cproc_printf(cproc_t cp, const char *fmt, ...);
|
||||
|
||||
/* This should be called before a destructive operation to give the user
|
||||
* a chance to abort. If it returns 1, then the operation should be aborted.
|
||||
*
|
||||
|
|
|
|||
12
devcmd.c
12
devcmd.c
|
|
@ -27,7 +27,7 @@
|
|||
#include "stab.h"
|
||||
#include "expr.h"
|
||||
#include "cproc.h"
|
||||
#include "cproc_util.h"
|
||||
#include "output_util.h"
|
||||
#include "util.h"
|
||||
#include "dis.h"
|
||||
|
||||
|
|
@ -39,7 +39,7 @@ static int cmd_regs(cproc_t cp, char **arg)
|
|||
|
||||
if (device_default->getregs(device_default, regs) < 0)
|
||||
return -1;
|
||||
cproc_regs(cp, regs);
|
||||
show_regs(regs);
|
||||
|
||||
/* Try to disassemble the instruction at PC */
|
||||
if (len > 0x10000 - regs[0])
|
||||
|
|
@ -47,7 +47,7 @@ static int cmd_regs(cproc_t cp, char **arg)
|
|||
if (device_default->readmem(device_default, regs[0], code, len) < 0)
|
||||
return 0;
|
||||
|
||||
cproc_disassemble(cp, regs[0], (uint8_t *)code, len);
|
||||
disassemble(regs[0], (uint8_t *)code, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ static int cmd_md(cproc_t cp, char **arg)
|
|||
if (device_default->readmem(device_default,
|
||||
offset, buf, blen) < 0)
|
||||
return -1;
|
||||
cproc_hexdump(cp, offset, buf, blen);
|
||||
hexdump(offset, buf, blen);
|
||||
|
||||
offset += blen;
|
||||
length -= blen;
|
||||
|
|
@ -240,7 +240,7 @@ static int cmd_set(cproc_t cp, char **arg)
|
|||
if (device_default->setregs(device_default, regs) < 0)
|
||||
return -1;
|
||||
|
||||
cproc_regs(cp, regs);
|
||||
show_regs(regs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -284,7 +284,7 @@ static int cmd_dis(cproc_t cp, char **arg)
|
|||
return -1;
|
||||
}
|
||||
|
||||
cproc_disassemble(cp, offset, buf, length);
|
||||
disassemble(offset, buf, length);
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,68 @@
|
|||
/* 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 <stdarg.h>
|
||||
#include "opdb.h"
|
||||
#include "output.h"
|
||||
|
||||
static char out_buf[1024];
|
||||
static int out_len;
|
||||
static int in_code;
|
||||
|
||||
static int write_text(const char *buf)
|
||||
{
|
||||
int want_color = opdb_get_boolean("color");
|
||||
int len = 0;
|
||||
|
||||
while (*buf) {
|
||||
if (*buf == 27)
|
||||
in_code = 1;
|
||||
|
||||
if (!in_code)
|
||||
len++;
|
||||
|
||||
if (*buf == '\n') {
|
||||
out_buf[out_len] = 0;
|
||||
puts(out_buf);
|
||||
out_len = 0;
|
||||
} else if ((want_color || !in_code) &&
|
||||
out_len + 1 < sizeof(out_buf)) {
|
||||
out_buf[out_len++] = *buf;
|
||||
}
|
||||
|
||||
if (isalpha(*buf))
|
||||
in_code = 0;
|
||||
|
||||
buf++;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int printc(const char *fmt, ...)
|
||||
{
|
||||
char buf[1024];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
return write_text(buf);
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* 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
|
||||
*/
|
||||
|
||||
#ifndef OUTPUT_H_
|
||||
#define OUTPUT_H_
|
||||
|
||||
/* Print output. ANSI colour codes may be embedded, and these will be
|
||||
* stripped on output if colour output is disabled.
|
||||
*
|
||||
* Returns the number of characters printed (not including colour
|
||||
* codes).
|
||||
*/
|
||||
int printc(const char *fmt, ...);
|
||||
|
||||
#endif
|
||||
|
|
@ -20,12 +20,11 @@
|
|||
#include <assert.h>
|
||||
|
||||
#include "dis.h"
|
||||
#include "cproc_util.h"
|
||||
#include "output_util.h"
|
||||
#include "stab.h"
|
||||
#include "util.h"
|
||||
|
||||
static int format_addr(char *buf, int max_len,
|
||||
msp430_amode_t amode, uint16_t addr)
|
||||
static int format_addr(msp430_amode_t amode, uint16_t addr)
|
||||
{
|
||||
char name[64];
|
||||
address_t offset;
|
||||
|
|
@ -56,18 +55,14 @@ static int format_addr(char *buf, int max_len,
|
|||
(addr >= 0x200 && addr < 0xfff0)) &&
|
||||
!stab_nearest(stab_default, addr, name, sizeof(name), &offset) &&
|
||||
!offset)
|
||||
return snprintf(buf, max_len,
|
||||
"%s\x1b[1m%s\x1b[0m", prefix, name);
|
||||
return printc("%s\x1b[1m%s\x1b[0m", prefix, name);
|
||||
else if (numeric)
|
||||
return snprintf(buf, max_len,
|
||||
"%s\x1b[1m0x%x\x1b[0m", prefix, addr);
|
||||
return printc("%s\x1b[1m0x%x\x1b[0m", prefix, addr);
|
||||
else
|
||||
return snprintf(buf, max_len,
|
||||
"%s\x1b[1m0x%04x\x1b[0m", prefix, addr);
|
||||
return printc("%s\x1b[1m0x%04x\x1b[0m", prefix, addr);
|
||||
}
|
||||
|
||||
static int format_reg(char *buf, int max_len,
|
||||
msp430_amode_t amode, msp430_reg_t reg)
|
||||
static int format_reg(msp430_amode_t amode, msp430_reg_t reg)
|
||||
{
|
||||
const char *prefix = "";
|
||||
const char *suffix = "";
|
||||
|
|
@ -98,9 +93,7 @@ static int format_reg(char *buf, int max_len,
|
|||
if (!name)
|
||||
name = "???";
|
||||
|
||||
return snprintf(buf, max_len,
|
||||
"%s\x1b[33m%s\x1b[0m%s",
|
||||
prefix, name, suffix);
|
||||
return printc("%s\x1b[33m%s\x1b[0m%s", prefix, name, suffix);
|
||||
}
|
||||
|
||||
/* Given an operands addressing mode, value and associated register,
|
||||
|
|
@ -108,24 +101,21 @@ static int format_reg(char *buf, int max_len,
|
|||
*
|
||||
* Returns the number of characters printed.
|
||||
*/
|
||||
static int format_operand(char *buf, int max_len,
|
||||
msp430_amode_t amode, uint16_t addr,
|
||||
static int format_operand(msp430_amode_t amode, uint16_t addr,
|
||||
msp430_reg_t reg)
|
||||
{
|
||||
int len = 0;
|
||||
|
||||
len += format_addr(buf, max_len, amode, addr);
|
||||
len += format_reg(buf + len, max_len - len, amode, reg);
|
||||
len += format_addr(amode, addr);
|
||||
len += format_reg(amode, reg);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
/* Write assembly language for the instruction to this buffer */
|
||||
static int dis_format(char *buf, int max_len,
|
||||
const struct msp430_instruction *insn)
|
||||
static int dis_format(const struct msp430_instruction *insn)
|
||||
{
|
||||
int len;
|
||||
int tlen;
|
||||
int total = 0;
|
||||
int len = 0;
|
||||
const char *opname = dis_opcode_name(insn->op);
|
||||
const char *suffix = "";
|
||||
|
||||
|
|
@ -145,67 +135,38 @@ static int dis_format(char *buf, int max_len,
|
|||
insn->op == MSP430_OP_BRA || insn->op == MSP430_OP_RETA)
|
||||
suffix = "";
|
||||
|
||||
len = snprintf(buf + total, max_len - total,
|
||||
"\x1b[36m%s%s\x1b[0m", opname, suffix);
|
||||
tlen = textlen(buf + total);
|
||||
total += len;
|
||||
|
||||
while (tlen < 8 && total < max_len) {
|
||||
buf[total++] = ' ';
|
||||
tlen++;
|
||||
}
|
||||
len += printc("\x1b[36m%s%s\x1b[0m", opname, suffix);
|
||||
while (len < 8)
|
||||
len += printc(" ");
|
||||
|
||||
/* Source operand */
|
||||
if (insn->itype == MSP430_ITYPE_DOUBLE) {
|
||||
len = format_operand(buf + total,
|
||||
max_len - total,
|
||||
insn->src_mode,
|
||||
len += format_operand(insn->src_mode,
|
||||
insn->src_addr,
|
||||
insn->src_reg);
|
||||
tlen = textlen(buf + total);
|
||||
total += len;
|
||||
|
||||
if (total < max_len)
|
||||
buf[total++] = ',';
|
||||
|
||||
while (tlen < 15 && total < max_len) {
|
||||
tlen++;
|
||||
buf[total++] = ' ';
|
||||
}
|
||||
|
||||
if (total < max_len)
|
||||
buf[total++] = ' ';
|
||||
printc(",");
|
||||
while (len < 15)
|
||||
len += printc(" ");
|
||||
printc(" ");
|
||||
}
|
||||
|
||||
/* Destination operand */
|
||||
if (insn->itype != MSP430_ITYPE_NOARG)
|
||||
total += format_operand(buf + total,
|
||||
max_len - total,
|
||||
insn->dst_mode,
|
||||
len += format_operand(insn->dst_mode,
|
||||
insn->dst_addr,
|
||||
insn->dst_reg);
|
||||
|
||||
/* Repetition count */
|
||||
if (insn->rep_register)
|
||||
total += snprintf(buf + total, max_len - total,
|
||||
" [repeat %s]",
|
||||
dis_reg_name(insn->rep_index));
|
||||
len += printc(" [repeat %s]", dis_reg_name(insn->rep_index));
|
||||
else if (insn->rep_index)
|
||||
total += snprintf(buf + total, max_len - total,
|
||||
" [repeat %d]", insn->rep_index + 1);
|
||||
len += printc(" [repeat %d]", insn->rep_index + 1);
|
||||
|
||||
if (total < max_len)
|
||||
buf[total] = 0;
|
||||
else if (total) {
|
||||
total--;
|
||||
buf[total] = 0;
|
||||
return len;
|
||||
}
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
void cproc_disassemble(cproc_t cp,
|
||||
address_t offset, const uint8_t *data, int length)
|
||||
void disassemble(address_t offset, const uint8_t *data, int length)
|
||||
{
|
||||
int first_line = 1;
|
||||
|
||||
|
|
@ -216,15 +177,13 @@ void cproc_disassemble(cproc_t cp,
|
|||
int i;
|
||||
address_t oboff;
|
||||
char obname[64];
|
||||
char buf[256];
|
||||
int len = 0;
|
||||
|
||||
if (!stab_nearest(stab_default, offset, obname, sizeof(obname),
|
||||
&oboff)) {
|
||||
if (!oboff)
|
||||
cproc_printf(cp, "\x1b[m%s:\x1b[0m", obname);
|
||||
printc("\x1b[m%s:\x1b[0m\n", obname);
|
||||
else if (first_line)
|
||||
cproc_printf(cp, "\x1b[m%s+0x%x:\x1b[0m",
|
||||
printc("\x1b[m%s+0x%x:\x1b[0m\n",
|
||||
obname, oboff);
|
||||
}
|
||||
first_line = 0;
|
||||
|
|
@ -234,92 +193,72 @@ void cproc_disassemble(cproc_t cp,
|
|||
if (count > length)
|
||||
count = length;
|
||||
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
" \x1b[36m%05x\x1b[0m:", offset);
|
||||
printc(" \x1b[36m%05x\x1b[0m:", offset);
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
" %02x", data[i]);
|
||||
printc(" %02x", data[i]);
|
||||
|
||||
while (i < 9) {
|
||||
buf[len++] = ' ';
|
||||
buf[len++] = ' ';
|
||||
buf[len++] = ' ';
|
||||
printc(" ");
|
||||
i++;
|
||||
}
|
||||
|
||||
if (retval >= 0)
|
||||
len += dis_format(buf + len, sizeof(buf) - len,
|
||||
&insn);
|
||||
dis_format(&insn);
|
||||
printc("\n");
|
||||
|
||||
buf[len] = 0;
|
||||
cproc_printf(cp, "%s", buf);
|
||||
offset += count;
|
||||
length -= count;
|
||||
data += count;
|
||||
}
|
||||
}
|
||||
|
||||
void cproc_hexdump(cproc_t cp, address_t addr, const uint8_t *data, int data_len)
|
||||
void hexdump(address_t addr, const uint8_t *data, int data_len)
|
||||
{
|
||||
int offset = 0;
|
||||
|
||||
while (offset < data_len) {
|
||||
char buf[128];
|
||||
int len = 0;
|
||||
int i, j;
|
||||
|
||||
/* Address label */
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
" \x1b[36m%05x:\x1b[0m", offset + addr);
|
||||
printc(" \x1b[36m%05x:\x1b[0m", offset + addr);
|
||||
|
||||
/* Hex portion */
|
||||
for (i = 0; i < 16 && offset + i < data_len; i++)
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
" %02x", data[offset + i]);
|
||||
for (j = i; j < 16; j++) {
|
||||
buf[len++] = ' ';
|
||||
buf[len++] = ' ';
|
||||
buf[len++] = ' ';
|
||||
}
|
||||
printc(" %02x", data[offset + i]);
|
||||
for (j = i; j < 16; j++)
|
||||
printc(" ");
|
||||
|
||||
/* Printable characters */
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
" \x1b[32m|");
|
||||
printc(" \x1b[32m|");
|
||||
for (j = 0; j < i; j++) {
|
||||
int c = data[offset + j];
|
||||
|
||||
buf[len++] = (c >= 32 && c <= 126) ? c : '.';
|
||||
printc("%c", (c >= 32 && c <= 126) ? c : '.');
|
||||
}
|
||||
for (; j < 16; j++)
|
||||
buf[len++] = ' ';
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
"|\x1b[0m");
|
||||
printc(" ");
|
||||
printc("|\x1b[0m\n");
|
||||
|
||||
cproc_printf(cp, "%s", buf);
|
||||
offset += i;
|
||||
}
|
||||
}
|
||||
|
||||
void cproc_regs(cproc_t cp, const address_t *regs)
|
||||
void show_regs(const address_t *regs)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
int j;
|
||||
char buf[128];
|
||||
int len = 0;
|
||||
|
||||
for (j = 0; j < 4; j++)
|
||||
buf[len++] = ' ';
|
||||
printc(" ");
|
||||
for (j = 0; j < 4; j++) {
|
||||
int k = j * 4 + i;
|
||||
|
||||
len += snprintf(buf + len, sizeof(buf) - len,
|
||||
"(\x1b[1m%3s:\x1b[0m %05x) ",
|
||||
printc("(\x1b[1m%3s:\x1b[0m %05x) ",
|
||||
dis_reg_name(k), regs[k]);
|
||||
}
|
||||
|
||||
cproc_printf(cp, "%s", buf);
|
||||
printc("\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -16,21 +16,19 @@
|
|||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef CPROC_UTIL_H_
|
||||
#define CPROC_UTIL_H_
|
||||
#ifndef OUTPUT_UTIL_H_
|
||||
#define OUTPUT_UTIL_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include "cproc.h"
|
||||
#include "output.h"
|
||||
#include "util.h"
|
||||
|
||||
/* Print colorized disassembly on command processor standard output */
|
||||
void cproc_disassemble(cproc_t cp, address_t addr,
|
||||
const uint8_t *buf, int len);
|
||||
void disassemble(address_t addr, const uint8_t *buf, int len);
|
||||
|
||||
/* Print colorized hexdump on standard output */
|
||||
void cproc_hexdump(cproc_t cp, address_t addr,
|
||||
const uint8_t *buf, int len);
|
||||
void hexdump(address_t addr, const uint8_t *buf, int len);
|
||||
|
||||
/* Colorized register dump */
|
||||
void cproc_regs(cproc_t cp, const address_t *regs);
|
||||
void show_regs(const address_t *regs);
|
||||
|
||||
#endif
|
||||
4
rtools.c
4
rtools.c
|
|
@ -28,7 +28,7 @@
|
|||
#include "rtools.h"
|
||||
#include "stab.h"
|
||||
#include "expr.h"
|
||||
#include "cproc_util.h"
|
||||
#include "output_util.h"
|
||||
#include "vector.h"
|
||||
|
||||
/************************************************************************
|
||||
|
|
@ -366,7 +366,7 @@ static int do_isearch(cproc_t cp, address_t addr, address_t len,
|
|||
int count = dis_decode(mbuf + i, addr + i, len - i, &insn);
|
||||
|
||||
if (count >= 0 && isearch_match(&insn, q))
|
||||
cproc_disassemble(cp, addr + i, mbuf + i, count);
|
||||
disassemble(addr + i, mbuf + i, count);
|
||||
}
|
||||
|
||||
free(mbuf);
|
||||
|
|
|
|||
Loading…
Reference in New Issue