342 lines
9.2 KiB
C++
342 lines
9.2 KiB
C++
/*
|
|
* Interactive disassembler (IDA).
|
|
* Copyright (c) 1990-2000 by Ilfak Guilfanov.
|
|
* ALL RIGHTS RESERVED.
|
|
* E-mail: ig@datarescue.com
|
|
*
|
|
*
|
|
*/
|
|
|
|
#include "st7.hpp"
|
|
#include <diskio.hpp>
|
|
int data_id;
|
|
|
|
//--------------------------------------------------------------------------
|
|
static const char *const register_names[] =
|
|
{
|
|
"a", "x", "y", "cc", "s",
|
|
"ds", "cs",
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
static const uchar retcode0[] = { 0x80 }; // iret 80
|
|
static const uchar retcode1[] = { 0x81 }; // ret 81
|
|
static const bytes_t retcodes[] =
|
|
{
|
|
{ sizeof(retcode0), retcode0 },
|
|
{ sizeof(retcode1), retcode1 },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------
|
|
// STMicroelectronics - Assembler - rel. 4.10
|
|
// We support Motorola format
|
|
//-----------------------------------------------------------------------
|
|
static const char *const st7_headers[] =
|
|
{
|
|
"st7/",
|
|
"",
|
|
NULL
|
|
};
|
|
|
|
static const asm_t stasm =
|
|
{
|
|
ASH_HEXF4 // $1234
|
|
|ASD_DECF0 // 1234
|
|
|ASB_BINF2 // %1010
|
|
|ASO_OCTF6 // ~1234
|
|
|AS_NOXRF // Disable xrefs during the output file generation
|
|
|AS_ONEDUP, // one array definition per line
|
|
0,
|
|
"STMicroelectronics - Assembler",
|
|
0,
|
|
st7_headers, // header lines
|
|
"org", // org
|
|
"end", // end
|
|
|
|
";", // comment string
|
|
'\"', // string delimiter
|
|
'\'', // char delimiter
|
|
"'\"", // special symbols in char and string constants
|
|
|
|
"dc.b", // ascii string directive
|
|
"dc.b", // byte directive
|
|
"dc.w", // word directive
|
|
"dc.l", // double words
|
|
NULL, // qwords
|
|
NULL, // oword (16 bytes)
|
|
NULL, // float (4 bytes)
|
|
NULL, // double (8 bytes)
|
|
NULL, // tbyte (10/12 bytes)
|
|
NULL, // packed decimal real
|
|
"skip#s( )#d, #v", // arrays (#h,#d,#v,#s(...) ONLY BYTE ARRAYS!!!
|
|
"ds.b %s", // uninited arrays
|
|
"equ", // equ
|
|
NULL, // 'seg' prefix (example: push seg seg001)
|
|
"*", // current IP (instruction pointer)
|
|
NULL, // func_header
|
|
NULL, // func_footer
|
|
"public", // "public" name keyword
|
|
NULL, // "weak" name keyword
|
|
"extern", // "extrn" name keyword
|
|
// .extern directive requires an explicit object size
|
|
NULL, // "comm" (communal variable)
|
|
NULL, // get_type_name
|
|
NULL, // "align" keyword
|
|
'{', '}', // lbrace, rbrace
|
|
NULL, // mod
|
|
"and", // and
|
|
"or", // or
|
|
"xor", // xor
|
|
NULL, // not
|
|
"shl", // shl
|
|
"shr", // shr
|
|
NULL, // sizeof
|
|
AS2_BRACE,
|
|
};
|
|
|
|
static const asm_t *const asms[] = { &stasm, NULL };
|
|
|
|
//--------------------------------------------------------------------------
|
|
//static const char cfgname[] = "st7.cfg";
|
|
|
|
//----------------------------------------------------------------------
|
|
const ioport_t *st7_t::find_sym(ea_t address)
|
|
{
|
|
const ioport_t *port = find_ioport(ioh.ports, address);
|
|
return port;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void st7_t::create_words(void)
|
|
{
|
|
for ( int i=0; i < ioh.ports.size(); i++ )
|
|
{
|
|
ea_t ea = ioh.ports[i].address;
|
|
if ( is_tail(get_flags(ea)) )
|
|
del_items(ea, DELIT_SIMPLE);
|
|
create_word(ea, 2);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
const char *st7_t::set_idp_options(
|
|
const char *keyword,
|
|
int /*value_type*/,
|
|
const void * /*value*/,
|
|
bool /*idb_loaded*/)
|
|
{
|
|
if ( keyword != NULL )
|
|
return IDPOPT_BADKEY;
|
|
char cfgfile[QMAXFILE];
|
|
ioh.get_cfg_filename(cfgfile, sizeof(cfgfile));
|
|
if ( choose_ioport_device(&ioh.device, cfgfile) )
|
|
ioh.set_device_name(ioh.device.c_str(), IORESP_PORT|IORESP_INT);
|
|
return IDPOPT_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
void st7_t::load_from_idb()
|
|
{
|
|
ioh.restore_device();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// This old-style callback only returns the processor module object.
|
|
static ssize_t idaapi notify(void *, int msgid, va_list)
|
|
{
|
|
if ( msgid == processor_t::ev_get_procmod )
|
|
return size_t(SET_MODULE_DATA(st7_t));
|
|
return 0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
ssize_t idaapi st7_t::on_event(ssize_t msgid, va_list va)
|
|
{
|
|
int code = 0;
|
|
switch ( msgid )
|
|
{
|
|
case processor_t::ev_init:
|
|
helper.create(PROCMOD_NODE_NAME);
|
|
inf_set_be(true);
|
|
break;
|
|
|
|
case processor_t::ev_term:
|
|
ioh.ports.clear();
|
|
clr_module_data(data_id);
|
|
break;
|
|
|
|
case processor_t::ev_newfile: // new file loaded
|
|
{
|
|
char cfgfile[QMAXFILE];
|
|
ioh.get_cfg_filename(cfgfile, sizeof(cfgfile));
|
|
if ( choose_ioport_device(&ioh.device, cfgfile) )
|
|
ioh.set_device_name(ioh.device.c_str(), IORESP_ALL);
|
|
create_words();
|
|
}
|
|
break;
|
|
|
|
case processor_t::ev_ending_undo:
|
|
case processor_t::ev_oldfile: // old file loaded
|
|
load_from_idb();
|
|
break;
|
|
|
|
case processor_t::ev_is_jump_func:
|
|
{
|
|
const func_t *pfn = va_arg(va, const func_t *);
|
|
ea_t *jump_target = va_arg(va, ea_t *);
|
|
return is_jump_func(pfn, jump_target);
|
|
}
|
|
|
|
case processor_t::ev_is_sane_insn:
|
|
{
|
|
const insn_t *insn = va_arg(va, insn_t *);
|
|
int no_crefs = va_arg(va, int);
|
|
return is_sane_insn(*insn, no_crefs) == 1 ? 1 : -1;
|
|
}
|
|
|
|
case processor_t::ev_may_be_func:
|
|
{
|
|
const insn_t *insn = va_arg(va, insn_t *);
|
|
return may_be_func(*insn);
|
|
}
|
|
|
|
case processor_t::ev_out_header:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
st7_header(*ctx);
|
|
return 1;
|
|
}
|
|
|
|
case processor_t::ev_out_footer:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
st7_footer(*ctx);
|
|
return 1;
|
|
}
|
|
|
|
case processor_t::ev_out_segstart:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
segment_t *seg = va_arg(va, segment_t *);
|
|
st7_segstart(*ctx, seg);
|
|
return 1;
|
|
}
|
|
|
|
case processor_t::ev_out_segend:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
segment_t *seg = va_arg(va, segment_t *);
|
|
st7_segend(*ctx, seg);
|
|
return 1;
|
|
}
|
|
|
|
case processor_t::ev_ana_insn:
|
|
{
|
|
insn_t *out = va_arg(va, insn_t *);
|
|
return st7_ana(out);
|
|
}
|
|
|
|
case processor_t::ev_emu_insn:
|
|
{
|
|
const insn_t *insn = va_arg(va, const insn_t *);
|
|
return st7_emu(*insn) ? 1 : -1;
|
|
}
|
|
|
|
case processor_t::ev_out_insn:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
out_insn(*ctx);
|
|
return 1;
|
|
}
|
|
|
|
case processor_t::ev_out_operand:
|
|
{
|
|
outctx_t *ctx = va_arg(va, outctx_t *);
|
|
const op_t *op = va_arg(va, const op_t *);
|
|
return out_opnd(*ctx, *op) ? 1 : -1;
|
|
}
|
|
|
|
case processor_t::ev_set_idp_options:
|
|
{
|
|
const char *keyword = va_arg(va, const char *);
|
|
int value_type = va_arg(va, int);
|
|
const char *value = va_arg(va, const char *);
|
|
const char **errmsg = va_arg(va, const char **);
|
|
bool idb_loaded = va_argi(va, bool);
|
|
const char *ret = set_idp_options(keyword, value_type, value, idb_loaded);
|
|
if ( ret == IDPOPT_OK )
|
|
return 1;
|
|
if ( errmsg != NULL )
|
|
*errmsg = ret;
|
|
return -1;
|
|
}
|
|
|
|
case processor_t::ev_is_align_insn:
|
|
{
|
|
ea_t ea = va_arg(va, ea_t);
|
|
return is_align_insn(ea);
|
|
}
|
|
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return code;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
#define FAMILY "SGS-Thomson ST7:"
|
|
static const char *const shnames[] = { "st7", NULL };
|
|
static const char *const lnames[] =
|
|
{
|
|
FAMILY"SGS-Thomson ST7",
|
|
NULL
|
|
};
|
|
|
|
//-----------------------------------------------------------------------
|
|
// Processor Definition
|
|
//-----------------------------------------------------------------------
|
|
processor_t LPH =
|
|
{
|
|
IDP_INTERFACE_VERSION, // version
|
|
PLFM_ST7, // id
|
|
// flag
|
|
PRN_HEX
|
|
| PR_RNAMESOK,
|
|
// flag2
|
|
PR2_IDP_OPTS, // the module has processor-specific configuration options
|
|
8, // 8 bits in a byte for code segments
|
|
8, // 8 bits in a byte for other segments
|
|
|
|
shnames,
|
|
lnames,
|
|
|
|
asms,
|
|
|
|
notify,
|
|
|
|
register_names, // Register names
|
|
qnumber(register_names), // Number of registers
|
|
|
|
ds, // first
|
|
cs, // last
|
|
2, // size of a segment register
|
|
cs, ds,
|
|
|
|
NULL, // No known code start sequences
|
|
retcodes,
|
|
|
|
ST7_null,
|
|
ST7_last,
|
|
Instructions, // instruc
|
|
0, // int tbyte_size; -- doesn't exist
|
|
{ 0, 7, 15, 0 }, // char real_width[4];
|
|
// number of symbols after decimal point
|
|
// 2byte float (0-does not exist)
|
|
// normal float
|
|
// normal double
|
|
// long double
|
|
ST7_ret, // Icode of return instruction. It is ok to give any of possible return instructions
|
|
};
|