void make_vector(ea_t addr, char *name)
{
doDwrd(addr, 4);
create_insn(get_long(addr));
add_func(get_long(addr), BADADDR);
add_cref(addr, get_long(addr), fl_CF);
if (name != NULL)
set_name(addr, name);
}
void
one_switch_entry(ea_t ea, ea_t ptr)
{
if ( !isData(ea) )
do_unknown_range(ea, 4, true);
add_cref(ea, ptr,
#if (IDP_INTERFACE_VERSION > 65)
fl_USobsolete
#else
fl_US
#endif
);
char abuf[0x10];
btoa(abuf, 0x10, ptr, 0x10);
rp_set_comment(ea, abuf, false );
ua_code(ptr);
doDwrd(ea, 4);
#ifdef PIC_DEBUG
RP_TRACE2("add_cref %X to %X\n", ea, ptr );
#endif
}
void
make_RTStruct(ea_t adr, size_t namelen)
{
/* form struct */
do_unknown_range(adr, RT_len, true);
doDwrd(adr,4);
doDwrd(adr+4,4);
doDwrd(adr+8,4);
doDwrd(adr+12,4);
doDwrd(adr+16,4);
// doDwrd(adr+20,4);
/* add dref to class name */
ea_t ptr = get_long(adr);
make_ascii_string(ptr, namelen, ASCSTR_C);
add_dref(adr, ptr, dr_O);
op_offset(adr, OPND_MASK, REF_OFF32, ptr);
rp_set_comment(adr+4, "Size", false);
/* add cref to constructor */
ptr = get_long(adr+12);
if ( ptr )
{
add_cref(adr+12, ptr, fl_CN);
op_offset(adr+12, OPND_MASK, REF_OFF32, ptr);
}
/* add dref to base class struct */
ptr = get_long(adr+16);
if ( ptr )
{
add_dref(adr+16,ptr,dr_O);
op_offset(adr+16, OPND_MASK, REF_OFF32, ptr);
}
/* add dref to next class */
/* ptr = get_long(adr+20);
if ( ptr )
{
add_dref(adr+20,ptr,dr_O);
op_offset(adr+20, OPND_MASK, REF_OFF32, ptr);
}
*/
}
// Emulate an operand.
static void handle_operand(op_t &op) {
bool offset = false;
switch ( op.type ) {
case o_near:
ua_add_cref(op.offb, toEA(cmd.cs, op.addr), (cmd.itype == fr_call) ? fl_CN : fl_JN);
break;
case o_mem:
{
enum dref_t mode = dr_U;
if ( op.specflag1 & OP_ADDR_R ) mode = dr_R;
else if ( op.specflag1 & OP_ADDR_W ) mode = dr_W;
ea_t ea = toEA(cmd.cs, op.addr);
ua_add_dref(op.offb, ea, mode);
ua_dodata2(op.offb, ea, op.dtyp);
}
break;
case o_imm:
// if current insn is ldi:32 #imm, r1
// and next insn is call @r1,
// replace the immediate value with an offset.
if (cmd.itype == fr_ldi_32 &&
cmd.Op1.type == o_imm &&
cmd.Op2.type == o_reg)
{
const int callreg = cmd.Op2.reg;
insn_t cmd_backup = cmd;
if ( next_insn(cmd.ea + cmd.size ) > 0 &&
cmd.itype == fr_call &&
cmd.Op1.type == o_phrase &&
cmd.Op1.specflag2 == fIGR &&
cmd.Op1.reg == callreg)
{
offset = true;
}
const ea_t from = cmd.ea;
cmd = cmd_backup;
if ( !isDefArg(uFlag, 0) && offset && set_offset(cmd.ea, 0, 0) )
add_cref(from, toEA(cmd.cs, cmd.Op1.value), fl_CN);
}
doImmd(cmd.ea);
if ( !offset )
// if the value was converted to an offset, then create a data xref:
if ( isOff(uFlag, op.n) )
ua_add_off_drefs2(op, dr_O, 0);
// create stack variables if necessary
{
bool ok = false;
// ldi8 #our_value, R1
// extsb R1
// addn R14, R1
if (cmd.itype == fr_ldi_8 &&
cmd.Op2.type == o_reg &&
cmd.Op2.reg == rR1)
{
insn_t current_insn = cmd;
next_insn(cmd.ea + cmd.size);
if (cmd.itype == fr_extsb &&
cmd.Op1.type == o_reg &&
cmd.Op1.reg == rR1)
{
ok = true;
}
if ( ok ) {
ok = false;
next_insn(cmd.ea + cmd.size);
if (cmd.itype == fr_addn &&
cmd.Op1.type == o_reg &&
cmd.Op1.reg == rR14 &&
cmd.Op2.type == o_reg &&
cmd.Op2.reg == rR1)
{
ok = true;
}
}
cmd = current_insn;
}
// ldi32 #our_value, Ri
// addn R14, Ri
//
// (where Ri is either R1 or R2)
else if (cmd.itype == fr_ldi_32 &&
cmd.Op2.type == o_reg &&
(cmd.Op2.reg == rR1 || cmd.Op2.reg == rR2))
{
ushort the_reg = cmd.Op2.reg;
insn_t current_insn = cmd;
next_insn(cmd.ea + cmd.size);
if (cmd.itype == fr_addn &&
cmd.Op1.type == o_reg &&
cmd.Op1.reg == rR14 &&
cmd.Op2.type == o_reg &&
cmd.Op2.reg == the_reg)
{
ok = true;
}
cmd = current_insn;
}
if ( ok && may_create_stkvars() && !isDefArg(uFlag, op.n) ) {
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && pfn->flags & FUNC_FRAME ) {
if ( ua_stkvar2(op, op.value, 0) ) {
op_stkvar(cmd.ea, op.n);
}
}
}
}
break;
case o_displ:
case o_phrase: // XXX
case o_reglist:
case o_void:
case o_reg:
break;
default:
INTERR(10017);
}
}
int idaapi emu()
{
char szLabel[MAXSTR];
insn_t saved;
segment_t* pSegment;
ea_t ea, length, offset;
flags_t flags;
uint32 dwFeature, i;
dwFeature = cmd.get_canon_feature();
fFlow = !(dwFeature & CF_STOP);
if (dwFeature & CF_USE1) op_emu(cmd.Op1, 1);
if (dwFeature & CF_USE2) op_emu(cmd.Op2, 1);
if (dwFeature & CF_CHG1) op_emu(cmd.Op1, 0);
if (dwFeature & CF_CHG2) op_emu(cmd.Op2, 0);
saved = cmd;
switch (cmd.itype)
{
case M8B_MOV:
if (!cmd.Op1.is_reg(rPSP))
break;
case M8B_SWAP:
if (cmd.itype == M8B_SWAP && !cmd.Op2.is_reg(rDSP))
break;
for (i = 0; i < 5; ++i)
{
ea = decode_prev_insn(cmd.ea);
if (ea == BADADDR) break;
if (cmd.itype == M8B_MOV && cmd.Op1.is_reg(rA) && cmd.Op2.type == o_imm)
{
ea = toRAM(cmd.Op2.value);
if (ea != BADADDR)
{
qsnprintf(szLabel, sizeof(szLabel), "%s_%0.2X", cmd.itype == M8B_MOV ? "psp" : "dsp", cmd.Op2.value);
ua_add_dref(cmd.Op2.offb, ea, dr_O);
set_name(ea, szLabel, SN_NOWARN);
}
break;
}
}
break;
case M8B_JACC:
pSegment = getseg(cmd.ea);
if (!pSegment) break;
length = pSegment->endEA - cmd.ea;
if (length > 256) length = 256;
for (offset = 2; offset < length; offset += 2)
{
ea = toROM(saved.Op1.addr + offset);
if (ea == BADADDR) break;
flags = getFlags(ea);
if (!hasValue(flags) || (has_any_name(flags) || hasRef(flags)) || !create_insn(ea)) break;
switch (cmd.itype)
{
case M8B_JMP:
case M8B_RET:
case M8B_RETI:
case M8B_IPRET:
add_cref(saved.ea, ea, fl_JN);
break;
default:
offset = length;
}
}
break;
case M8B_IORD:
case M8B_IOWR:
case M8B_IOWX:
for (i = 0; i < 5; ++i)
{
ea = (saved.itype == M8B_IORD) ? decode_insn(cmd.ea + cmd.size) : decode_prev_insn(cmd.ea);
if (ea == BADADDR) break;
if (cmd.Op1.is_reg(rA) && cmd.Op2.type == o_imm)
{
qsnprintf(szLabel, sizeof(szLabel), "[A=%0.2Xh] ", cmd.Op2.value);
if (get_portbits_sym(szLabel + qstrlen(szLabel), saved.Op1.addr, cmd.Op2.value))
set_cmt(saved.ea, szLabel, false);
break;
}
}
}
cmd = saved;
if ((cmd.ea & 0xFF) == 0xFF)
{
switch (cmd.itype)
{
case M8B_RET:
case M8B_RETI:
case M8B_XPAGE:
break;
default:
QueueMark(Q_noValid, cmd.ea);
}
}
if (fFlow) ua_add_cref(0, cmd.ea + cmd.size, fl_F);
return 1;
}
