olari/sigmaker-ida
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update to ida 7.6, add builds

Browse Source
This commit is contained in:
josh
2021-10-31 21:20:46 +02:00
parent e0e0f2be99
commit b1809fe2d9
1408 changed files with 279193 additions and 302468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

440
idasdk76/module/i960/reg.cpp Normal file
View File

@@ -0,0 +1,440 @@
/*
* Interactive disassembler (IDA).
* Copyright (c) 1990-2001 by Ilfak Guilfanov.
* ALL RIGHTS RESERVED.
* E-mail: ig@datarescue.com
*
*
*/
#include "i960.hpp"
#include <diskio.hpp>
#include <typeinf.hpp>
#include <ieee.h>
int data_id;
//--------------------------------------------------------------------------
static const char *const register_names[] =
{
"pfp", "sp", "rip", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
"g8", "g9", "g10", "g11", "g12", "g13", "g14", "fp",
"sf0", "sf1", "sf2", "sf3", "sf4", "sf5", "sf6", "sf7",
"sf8", "sf9", "sf10", "sf11", "sf12", "sf13", "sf14", "sf15",
"sf16", "sf17","sf18", "sf19", "sf20", "sf21", "sf22", "sf23",
"sf24", "sf25","sf26", "sf27", "sf28", "sf29", "sf30", "sf31",
"pc", "ac", "ip", "tc",
"fp0", "fp1", "fp2", "fp3",
"ds", "cs",
};
//--------------------------------------------------------------------------
static const bytes_t retcodes[] =
{
// { sizeof(retcode0), retcode0 },
{ 0, NULL }
};
//-----------------------------------------------------------------------
// GNU assembler
//-----------------------------------------------------------------------
static const asm_t gnuasm =
{
AS_ASCIIC|AS_ALIGN2|ASH_HEXF3|ASD_DECF0|ASB_BINF3|ASO_OCTF1|AS_COLON|AS_N2CHR|AS_NCMAS|AS_ONEDUP,
0,
"GNU assembler",
0,
NULL, // header lines
".org", // org
NULL, // end
"#", // comment string
'"', // string delimiter
'\'', // char delimiter
"\"'", // special symbols in char and string constants
".ascii", // ascii string directive
".byte", // byte directive
".short", // word directive
".long", // double words
".quad", // qwords
".octa", // oword (16 bytes)
".float", // float (4 bytes)
".double", // double (8 bytes)
".extended", // tbyte (10/12 bytes)
NULL, // packed decimal real
".fill #d, #s(1,2,4,8), #v", // arrays (#h,#d,#v,#s(...)
".space %s", // uninited arrays
"=", // equ
NULL, // 'seg' prefix (example: push seg seg001)
".", // current IP (instruction pointer)
NULL, // func_header
NULL, // func_footer
".global", // "public" name keyword
NULL, // "weak" name keyword
".extern", // "extrn" name keyword
// .extern directive requires an explicit object size
".comm", // "comm" (communal variable)
NULL, // get_type_name
".align", // "align" keyword
'(', ')', // lbrace, rbrace
"%", // mod
"&", // and
"|", // or
"^", // xor
"~", // not
"<<", // shl
">>", // shr
NULL, // sizeof
};
static const asm_t *const asms[] = { &gnuasm, NULL };
//--------------------------------------------------------------------------
static const char *const cfgname = "i960.cfg";
void i960_t::load_symbols(void)
{
ioh.ports.clear();
read_ioports(&ioh.ports, &ioh.device, cfgname);
}
const char *i960_t::find_sym(ea_t address)
{
const ioport_t *port = find_ioport(ioh.ports, address);
return port ? port->name.c_str() : NULL;
}
//--------------------------------------------------------------------------
void i960_t::choose_device()
{
if ( choose_ioport_device(&ioh.device, cfgname) )
{
ioh.set_device_name(ioh.device.c_str(), IORESP_NONE);
load_symbols();
}
}
//--------------------------------------------------------------------------
static int idaapi choose_device_cb(int, form_actions_t &fa)
{
i960_t &pm = *(i960_t *)fa.get_ud();
pm.choose_device();
return 0;
}
//--------------------------------------------------------------------------
const char *i960_t::set_idp_options(
const char *keyword,
int value_type,
const void * value,
bool idb_loaded)
{
static const char form[] =
"HELP\n"
"Intel 960 specific options\n"
"\n"
" Choose device name\n"
" Here you may select a specific Intel 960 device\n"
" IDA will use the definitions in the I960.CFG file for\n"
" the i/o port names\n"
"\n"
" Strictly adhere to instruction encodings\n"
" If this option is on, IDA will check that unused fields\n"
" of instructions are filled by zeroes. If they are not,\n"
" it will refuse to disassemble the instruction.\n"
"\n"
"ENDHELP\n"
"Intel 960 specific options\n"
"%*\n"
" <~C~hoose device name:B:0:::>\n"
"\n"
" <~S~trictly adhere to instruction encodings:C>>\n"
"\n"
"\n";
if ( keyword == NULL )
{
CASSERT(sizeof(idpflags) == sizeof(ushort));
ask_form(form, this, choose_device_cb, &idpflags);
OK:
if ( idb_loaded )
save_idpflags();
return IDPOPT_OK;
}
else
{
if ( value_type != IDPOPT_BIT )
return IDPOPT_BADTYPE;
if ( strcmp(keyword, "I960_STRICT") == 0 )
{
setflag(idpflags, IDP_STRICT, *(int*)value != 0);
goto OK;
}
}
return IDPOPT_BADKEY;
}
//--------------------------------------------------------------------------
void i960_t::load_from_idb()
{
// restore ptype
int n = ph.get_proc_index();
inf_set_be((n > 1));
idpflags = helper.altval(-1);
ioh.restore_device();
load_symbols();
}
//----------------------------------------------------------------------
// 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(i960_t));
return 0;
}
//--------------------------------------------------------------------------
ssize_t idaapi i960_t::on_event(ssize_t msgid, va_list va)
{
switch ( msgid )
{
case processor_t::ev_init:
helper.create(PROCMOD_NODE_NAME);
break;
case processor_t::ev_term:
ioh.ports.clear();
clr_module_data(data_id);
break;
case processor_t::ev_newfile: // new file loaded
choose_device();
save_idpflags();
break;
case processor_t::ev_oldfile: // old file loaded
ioh.upgrade_device_index();
// fall through
case processor_t::ev_ending_undo:
load_from_idb();
break;
case processor_t::ev_newprc:
{
int n = va_arg(va, int);
bool keep_cfg = va_argi(va, bool);
if ( !keep_cfg )
inf_set_be((n > 1));
}
break;
// +++ TYPE CALLBACKS
case processor_t::ev_decorate_name:
{
qstring *outbuf = va_arg(va, qstring *);
const char *name = va_arg(va, const char *);
bool mangle = va_argi(va, bool);
cm_t cc = va_argi(va, cm_t);
tinfo_t *type = va_arg(va, tinfo_t *);
return gen_decorate_name(outbuf, name, mangle, cc, type) ? 1 : 0;
}
case processor_t::ev_max_ptr_size:
return 4;
case processor_t::ev_calc_arglocs:
return -1;
case processor_t::ev_use_stkarg_type:
return 0;
case processor_t::ev_use_regarg_type:
return -1;
case processor_t::ev_get_cc_regs:
{
callregs_t *callregs = va_arg(va, callregs_t *);
cm_t cc = va_argi(va, cm_t);
if ( cc == CM_CC_FASTCALL || cc == CM_CC_THISCALL )
{
callregs->reset();
return 1;
}
}
break;
case processor_t::ev_calc_cdecl_purged_bytes:// calculate number of purged bytes after call
{
// ea_t ea = va_arg(va, ea_t);
return 0;
}
case processor_t::ev_get_stkarg_offset: // get offset from SP to the first stack argument
// args: none
// returns: the offset
return 0;
// --- TYPE CALLBACKS
case processor_t::ev_out_mnem:
{
outctx_t *ctx = va_arg(va, outctx_t *);
out_mnem(*ctx);
return 1;
}
case processor_t::ev_out_header:
{
outctx_t *ctx = va_arg(va, outctx_t *);
i960_header(*ctx);
return 1;
}
case processor_t::ev_out_footer:
{
outctx_t *ctx = va_arg(va, outctx_t *);
i960_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 *);
i960_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 *);
i960_segend(*ctx, seg);
return 1;
}
case processor_t::ev_ana_insn:
{
insn_t *out = va_arg(va, insn_t *);
return i960_ana(out);
}
case processor_t::ev_emu_insn:
{
const insn_t *insn = va_arg(va, const insn_t *);
return i960_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 0;
}
//-----------------------------------------------------------------------
#define FAMILY "Intel 960:"
static const char *const shnames[] =
{
"i960",
"i960l",
"i960b",
NULL
};
static const char *const lnames[] =
{
FAMILY"Intel 960 little endian (default)",
"Intel 960 little endian",
"Intel 960 big endian",
NULL
};
//-----------------------------------------------------------------------
// Processor Definition
//-----------------------------------------------------------------------
processor_t LPH =
{
IDP_INTERFACE_VERSION, // version
PLFM_I960, // id
// flag
PRN_HEX
| PR_RNAMESOK
| PR_SEGS
| PR_USE32
| PR_DEFSEG32
| PR_TYPEINFO,
// 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,
I960_null,
I960_last,
Instructions, // instruc
10, // int tbyte_size (0-doesn't exist)
{ 0, 7, 15, 19 }, // char real_width[4];
// number of symbols after decimal point
// 2byte float (0-does not exist)
// normal float
// normal double
// long double
I960_ret, // Icode of return instruction. It is ok to give any of possible return instructions
};