488 lines
12 KiB
C++
488 lines
12 KiB
C++
/*
|
|
This module has been created by Petr Novak
|
|
*/
|
|
|
|
#include "xa.hpp"
|
|
#include <fpro.h>
|
|
#include <diskio.hpp>
|
|
|
|
//----------------------------------------------------------------------
|
|
class out_xa_t : public outctx_t
|
|
{
|
|
out_xa_t(void) = delete; // not used
|
|
public:
|
|
void OutReg(int rgnum)
|
|
{
|
|
out_register(ph.reg_names[rgnum]);
|
|
}
|
|
bool out_operand(const op_t &x);
|
|
void out_insn(void);
|
|
void out_proc_mnem(void);
|
|
|
|
void do_out_equ(const char *name, uchar off);
|
|
int out_equ(void);
|
|
};
|
|
CASSERT(sizeof(out_xa_t) == sizeof(outctx_t));
|
|
|
|
DECLARE_OUT_FUNCS(out_xa_t)
|
|
|
|
//----------------------------------------------------------------------
|
|
AS_PRINTF(1, 0) static void vlog(const char *format, va_list va)
|
|
{
|
|
static FILE *fp = NULL;
|
|
if ( fp == NULL )
|
|
fp = fopenWT("debug_log");
|
|
qvfprintf(fp, format, va);
|
|
qflush(fp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
AS_PRINTF(1, 2) inline void log(const char *format, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, format);
|
|
vlog(format, va);
|
|
va_end(va);
|
|
}
|
|
|
|
#define AT COLSTR("@", SCOLOR_SYMBOL)
|
|
#define PLUS COLSTR("+", SCOLOR_SYMBOL)
|
|
|
|
static const char *const phrases[] =
|
|
{
|
|
AT COLSTR("A", SCOLOR_REG) PLUS COLSTR("DPTR", SCOLOR_REG),
|
|
AT COLSTR("A", SCOLOR_REG) PLUS COLSTR("PC", SCOLOR_REG)
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// generate the text representation of an operand
|
|
|
|
bool out_xa_t::out_operand(const op_t &x)
|
|
{
|
|
uval_t v = 0;
|
|
int dir, bit;
|
|
qstring qbuf;
|
|
switch ( x.type )
|
|
{
|
|
case o_reg:
|
|
OutReg(x.reg);
|
|
break;
|
|
|
|
case o_phrase:
|
|
switch ( x.phrase )
|
|
{
|
|
case fAdptr:
|
|
case fApc:
|
|
out_colored_register_line(phrases[x.phrase]);
|
|
break;
|
|
case fRi:
|
|
out_symbol('[');
|
|
OutReg(x.indreg);
|
|
out_symbol(']');
|
|
break;
|
|
case fRip:
|
|
out_symbol('[');
|
|
OutReg(x.indreg);
|
|
out_symbol('+');
|
|
out_symbol(']');
|
|
break;
|
|
case fRii:
|
|
out_symbol('[');
|
|
out_symbol('[');
|
|
OutReg(x.indreg);
|
|
out_symbol(']');
|
|
out_symbol(']');
|
|
break;
|
|
case fRipi:
|
|
out_symbol('[');
|
|
out_symbol('[');
|
|
OutReg(x.indreg);
|
|
out_symbol('+');
|
|
out_symbol(']');
|
|
out_symbol(']');
|
|
break;
|
|
case fRlistL:
|
|
case fRlistH:
|
|
v = x.indreg;
|
|
dir = (x.dtype == dt_byte) ? rR0L : rR0;
|
|
if ( x.phrase == fRlistH )
|
|
dir += 8;
|
|
for ( bit = 0; bit < 8; bit++,dir++,v >>= 1 )
|
|
{
|
|
if ( v&1 )
|
|
{
|
|
OutReg(dir);
|
|
if ( v & 0xfe )
|
|
out_symbol(',');
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case o_displ:
|
|
if ( insn.itype != XA_lea )
|
|
out_symbol('[');
|
|
OutReg(x.indreg);
|
|
if ( x.indreg == rR7 || x.phrase != fRi )
|
|
out_value(x, OOF_ADDR | OOFS_NEEDSIGN | OOF_SIGNED | OOFW_16);
|
|
if ( insn.itype != XA_lea )
|
|
out_symbol(']');
|
|
break;
|
|
|
|
case o_imm:
|
|
out_symbol('#');
|
|
out_value(x, OOFS_IFSIGN | /* OOF_SIGNED | */ OOFW_IMM);
|
|
break;
|
|
|
|
case o_mem:
|
|
case o_near:
|
|
case o_far:
|
|
switch ( x.type )
|
|
{
|
|
case o_mem:
|
|
v = map_addr(x.addr);
|
|
break;
|
|
case o_near:
|
|
v = to_ea(insn.cs, x.addr);
|
|
break;
|
|
case o_far:
|
|
v = x.addr + (x.specval<<16);
|
|
break;
|
|
}
|
|
if ( get_name_expr(&qbuf, insn.ea+x.offb, x.n, v, x.addr & 0xFFFF) <= 0 )
|
|
{
|
|
if ( x.type == o_far )
|
|
{
|
|
// print the segment part
|
|
out_long(x.specval, 16);
|
|
out_symbol(':');
|
|
}
|
|
// now print the offset
|
|
out_value(x, OOF_ADDR | OOF_NUMBER | OOFS_NOSIGN | OOFW_32);
|
|
remember_problem(PR_NONAME, insn.ea);
|
|
break;
|
|
}
|
|
|
|
// we want to output SFR register names always in COLOR_REG,
|
|
// so remove the color tags and output it manually:
|
|
|
|
if ( x.type == o_mem && x.addr >= 0x400 )
|
|
{
|
|
tag_remove(&qbuf);
|
|
out_register(qbuf.begin());
|
|
break;
|
|
}
|
|
out_line(qbuf.begin());
|
|
break;
|
|
|
|
case o_void:
|
|
return 0;
|
|
|
|
case o_bitnot:
|
|
out_symbol('/');
|
|
// fallthrough
|
|
case o_bit:
|
|
dir = int(x.addr >> 3);
|
|
bit = x.addr & 7;
|
|
if ( dir & 0x40 ) // SFR
|
|
{
|
|
dir += 0x3c0;
|
|
}
|
|
else if ( (dir & 0x20) == 0 ) // Register file
|
|
{
|
|
dir = int(x.addr >> 4);
|
|
bit = x.addr & 15;
|
|
OutReg(rR0+dir);
|
|
out_symbol(ash.uflag & UAS_NOBIT ? '_' : '.');
|
|
if ( bit > 9 )
|
|
{
|
|
out_symbol('1');
|
|
bit -= 10;
|
|
}
|
|
out_symbol(char('0'+bit));
|
|
break;
|
|
}
|
|
if ( ash.uflag & UAS_PBIT )
|
|
{
|
|
xa_t &pm = *static_cast<xa_t *>(procmod);
|
|
const predefined_t *predef = pm.GetPredefinedBits(dir, bit);
|
|
if ( predef != NULL )
|
|
{
|
|
out_line(predef->name, COLOR_REG);
|
|
break;
|
|
}
|
|
}
|
|
{
|
|
v = map_addr(dir);
|
|
bool ok = get_name_expr(&qbuf, insn.ea+x.offb, x.n, v, dir) > 0;
|
|
if ( ok && strchr(qbuf.begin(), '+') == NULL )
|
|
{
|
|
|
|
// we want to output the bit names always in COLOR_REG,
|
|
// so remove the color tags and output it manually:
|
|
|
|
if ( dir < 0x80 )
|
|
{
|
|
out_line(qbuf.begin());
|
|
}
|
|
else
|
|
{
|
|
tag_remove(&qbuf);
|
|
out_register(qbuf.begin());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
out_long(dir, 16);
|
|
}
|
|
out_symbol(ash.uflag & UAS_NOBIT ? '_' : '.');
|
|
out_symbol(char('0'+bit));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
warning("out: %a: bad optype %d", insn.ea, x.type);
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void out_xa_t::out_proc_mnem(void)
|
|
{
|
|
if ( insn.Op1.type != o_void )
|
|
{
|
|
switch ( insn.Op1.dtype )
|
|
{
|
|
case dt_byte:
|
|
out_mnem(8,".b");
|
|
break;
|
|
case dt_word:
|
|
out_mnem(8,".w");
|
|
break;
|
|
case dt_dword:
|
|
out_mnem(8,".d");
|
|
break;
|
|
default:
|
|
out_mnem();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
out_mnem(); // output instruction mnemonics
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// generate a text representation of an instruction
|
|
// the information about the instruction is in the insn structure
|
|
|
|
void out_xa_t::out_insn(void)
|
|
{
|
|
out_mnemonic();
|
|
out_one_operand(0); // output the first operand
|
|
|
|
if ( insn.Op2.type != o_void )
|
|
{
|
|
out_symbol(',');
|
|
out_char(' ');
|
|
out_one_operand(1); // output the second operand
|
|
}
|
|
|
|
if ( insn.Op3.type != o_void )
|
|
{
|
|
out_symbol(',');
|
|
out_char(' ');
|
|
out_one_operand(2); // output the third operand
|
|
}
|
|
|
|
|
|
// output a character representation of the immediate values
|
|
// embedded in the instruction as comments
|
|
out_immchar_cmts();
|
|
flush_outbuf();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// generate start of the disassembly
|
|
|
|
void xa_t::xa_header(outctx_t &ctx)
|
|
{
|
|
ctx.gen_header(GH_PRINT_ALL_BUT_BYTESEX);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// generate start of a segment
|
|
|
|
//lint -esym(1764, ctx) could be made const
|
|
//lint -esym(818, Sarea) could be made const
|
|
void xa_t::xa_segstart(outctx_t &ctx, segment_t *Sarea)
|
|
{
|
|
qstring sname;
|
|
get_visible_segm_name(&sname, Sarea);
|
|
|
|
if ( ash.uflag & UAS_SECT )
|
|
{
|
|
if ( Sarea->type == SEG_IMEM )
|
|
ctx.flush_buf(".RSECT", DEFAULT_INDENT);
|
|
else
|
|
ctx.gen_printf(0, COLSTR("%s: .section", SCOLOR_ASMDIR), sname.c_str());
|
|
}
|
|
else
|
|
{
|
|
if ( ash.uflag & UAS_NOSEG )
|
|
ctx.gen_printf(DEFAULT_INDENT, COLSTR("%s.segment %s", SCOLOR_AUTOCMT),
|
|
ash.cmnt, sname.c_str());
|
|
else
|
|
ctx.gen_printf(DEFAULT_INDENT, COLSTR("segment %s",SCOLOR_ASMDIR), sname.c_str());
|
|
if ( ash.uflag & UAS_SELSG )
|
|
ctx.flush_buf(sname.c_str(), DEFAULT_INDENT);
|
|
if ( ash.uflag & UAS_CDSEG )
|
|
ctx.flush_buf(Sarea->type == SEG_IMEM
|
|
? COLSTR("DSEG", SCOLOR_ASMDIR)
|
|
: COLSTR("CSEG", SCOLOR_ASMDIR),
|
|
DEFAULT_INDENT);
|
|
// XSEG - eXternal memory
|
|
}
|
|
if ( (inf_get_outflags() & OFLG_GEN_ORG) != 0 )
|
|
{
|
|
adiff_t org = ctx.insn_ea - get_segm_base(Sarea);
|
|
if ( org != 0 )
|
|
{
|
|
char buf[MAX_NUMBUF];
|
|
btoa(buf, sizeof(buf), org);
|
|
ctx.gen_cmt_line("%s %s", ash.origin, buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// generate end of the disassembly
|
|
|
|
void xa_t::xa_footer(outctx_t &ctx)
|
|
{
|
|
if ( ash.end != NULL )
|
|
{
|
|
ctx.gen_empty_line();
|
|
ctx.out_line(ash.end, COLOR_ASMDIR);
|
|
qstring name;
|
|
if ( get_colored_name(&name, inf_get_start_ea()) > 0 )
|
|
{
|
|
ctx.out_char(' ');
|
|
if ( ash.uflag & UAS_NOENS )
|
|
ctx.out_line(ash.cmnt);
|
|
ctx.out_line(name.begin());
|
|
}
|
|
ctx.flush_outbuf(DEFAULT_INDENT);
|
|
}
|
|
else
|
|
{
|
|
ctx.gen_cmt_line("end of file");
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// output one "equ" directive
|
|
|
|
void out_xa_t::do_out_equ(const char *name, uchar off)
|
|
{
|
|
if ( (ash.uflag & UAS_PSAM) != 0 )
|
|
{
|
|
out_line(ash.a_equ, COLOR_KEYWORD);
|
|
out_char(' ');
|
|
out_line(name);
|
|
out_symbol(',');
|
|
}
|
|
else
|
|
{
|
|
out_line(name);
|
|
if ( ash.uflag & UAS_EQCLN )
|
|
out_symbol(':');
|
|
out_char(' ');
|
|
out_line(ash.a_equ, COLOR_KEYWORD);
|
|
out_char(' ');
|
|
}
|
|
out_long(off, 16);
|
|
clr_gen_label();
|
|
out_tagoff(COLOR_SYMBOL);
|
|
flush_outbuf(0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// output "equ" directive(s) if necessary
|
|
int out_xa_t::out_equ(void)
|
|
{
|
|
ea_t ea = insn.ea;
|
|
segment_t *s = getseg(ea);
|
|
if ( s != NULL && s->type == SEG_IMEM && ash.a_equ != NULL )
|
|
{
|
|
qstring name;
|
|
if ( get_visible_name(&name, ea) > 0
|
|
&& ((ash.uflag & UAS_PBYTNODEF) == 0 || !xa_t::IsPredefined(name.begin())) )
|
|
{
|
|
get_colored_name(&name, ea);
|
|
uchar off = uchar(ea - get_segm_base(s));
|
|
do_out_equ(name.begin(), off);
|
|
if ( (ash.uflag & UAS_AUBIT) == 0 && (off & 0xF8) == off )
|
|
{
|
|
qstring tmp;
|
|
out_tagon(COLOR_SYMBOL);
|
|
out_char(ash.uflag & UAS_NOBIT ? '_' : '.');
|
|
tmp.swap(outbuf);
|
|
for ( int i=0; i < 8; i++,off++ )
|
|
{
|
|
qstring full = tmp;
|
|
full.append('0' + i);
|
|
do_out_equ(full.begin(), off);
|
|
}
|
|
gen_empty_line();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
clr_gen_label();
|
|
flush_buf("");
|
|
}
|
|
return 1;
|
|
}
|
|
if ( (ash.uflag & UAS_NODS) != 0 )
|
|
{
|
|
if ( !is_loaded(ea) && s->type == SEG_CODE )
|
|
{
|
|
adiff_t org = ea - get_segm_base(s) + get_item_size(ea);
|
|
char buf[MAX_NUMBUF];
|
|
btoa(buf, sizeof(buf), org);
|
|
gen_printf(DEFAULT_INDENT, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// generate a data representation
|
|
// usually all the job is handled by the kernel's standard procedure,
|
|
// out_data()
|
|
// But 8051 has its own quirks (namely, "equ" directives) and out_data()
|
|
// can't handle them. So we output "equ" ourselves and pass everything
|
|
// else to out_data()
|
|
// Again, let's repeat: usually the data items are output by the kernel
|
|
// function out_data(). You have to override it only if the processor
|
|
// has special features and the data itesm should be displayed in a
|
|
// special way.
|
|
|
|
void xa_t::xa_data(outctx_t &ctx, bool analyze_only)
|
|
{
|
|
// the kernel's standard routine which outputs the data knows nothing
|
|
// about "equ" directives. So we do the following:
|
|
// - try to output an "equ" directive
|
|
// - if we succeed, then ok
|
|
// - otherwise let the standard data output routine, out_data()
|
|
// do all the job
|
|
|
|
out_xa_t *p = (out_xa_t *)&ctx;
|
|
if ( !p->out_equ() )
|
|
ctx.out_data(analyze_only);
|
|
}
|