//----------------------------------------------------------------------
static void process_operand(op_t &x, bool isload)
{
ea_t ea;
dref_t dref;
if ( is_forced_operand(cmd.ea, x.n) ) return;
switch ( x.type )
{
case o_reg:
case o_phrase:
break;
case o_imm:
if ( !isload ) interr("emu1");
process_immediate_number(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOFS_IFSIGN|OOFW_IMM);
break;
case o_mem:
ea = calc_mem(x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
dref = cmd.itype == I960_lda ? dr_O : isload ? dr_R : dr_W;
ua_add_dref(x.offb, ea, dref);
break;
case o_near:
{
cref_t ftype = fl_JN;
ea = calc_mem(x.addr);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
flow = func_does_return(ea);
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_displ:
dref = cmd.itype == I960_lda ? dr_O : isload ? dr_R : dr_W;
process_immediate_number(x.n);
if ( x.reg == IP )
{
ea_t ea = cmd.ea + 8 + x.addr;
ua_add_dref(x.offb, ea, dref);
}
else
{
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dref, OOFS_IFSIGN|OOF_SIGNED|OOF_ADDR|OOFW_32);
}
break;
default:
interr("emu");
}
}
static void handle_operand(op_t &op) {
switch (op.type) {
// code address
case o_near:
{
ea_t ea = toEA(cmd.cs, op.addr);
cref_t mode = fl_JN;
if (cmd.itype == m740_jsr)
{
if ( !func_does_return(ea) )
flow = false;
mode = fl_CN;
}
ua_add_cref(op.offb, ea, mode);
}
break;
// data address
case o_mem:
{
enum dref_t mode = dr_U;
if (is_addr_ind(op)) mode = dr_R; /* NOT dr_O */
else if (is_addr_read(op)) mode = dr_R;
else if (is_addr_write(op)) mode = dr_W;
ua_add_dref(op.offb, toEA(cmd.cs, op.addr), mode);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// immediate
case o_imm:
handle_imm(op);
// 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);
break;
// displ
case o_displ:
if (isOff(uFlag, op.n)) {
ua_add_off_drefs2(op, dr_O, OOF_ADDR);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// reg - do nothing
case o_reg:
case o_void:
break;
default:
IDA_ERROR("Invalid op.type in handle_operand()");
}
}
//----------------------------------------------------------------------
static void TouchArg( op_t &x, int isload )
{
switch( x.type )
{
case o_imm:
doImmd(cmd.ea);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOF_SIGNED);
break;
case o_indexed: // addr[value]
doImmd(cmd.ea);
if ( x.value == 0 && !isDefArg(uFlag, x.n) )
set_offset(cmd.ea, x.n, toEA(cmd.cs, 0));
if ( isOff(uFlag, x.n) ) // xref to addr
{
uval_t saved = x.value;
x.value = x.addr;
ua_add_off_drefs2(x, saved ? dr_O : isload ? dr_R : dr_W, OOF_SIGNED|OOF_ADDR);
x.value = saved;
}
if ( x.value != 0 ) // xref to value
{ // no references to ZERO_REG
ea_t ea = toEA(cmd.cs, x.value);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W );
ua_dodata2(x.offb, ea, x.dtyp);
}
break;
case o_indirect:
case o_indirect_inc:
case o_mem:
{
ea_t dea = toEA( cmd.cs, x.addr );
ua_dodata2(x.offb, dea, x.dtyp);
if( !isload )
doVar(dea);
ua_add_dref( x.offb, dea, isload ? dr_R : dr_W );
if ( !isload && (x.addr == 0x14 || x.addr == 0x15) )
{
sel_t wsrval = BADSEL;
if ( cmd.Op2.type == o_imm ) wsrval = sel_t(cmd.Op2.value);
splitSRarea1(cmd.ea, x.addr == 0x14 ? WSR : WSR1, wsrval, SR_auto);
}
}
break;
case o_near:
ea_t ea = toEA( cmd.cs, x.addr );
int iscall = InstrIsSet( cmd.itype, CF_CALL );
ua_add_cref( x.offb, ea, iscall ? fl_CN : fl_JN );
if ( flow && iscall )
flow = func_does_return(ea);
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
case o_phrase:
case o_port:
break;
case o_imm:
if ( !isload ) goto badTouch;
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOF_SIGNED);
break;
case o_displ:
doImmdValue(x.n);
if ( isAlt ) break;
if ( isOff(uFlag, x.n) )
{
ua_add_off_drefs2(x, isload ? dr_R : dr_W, OOF_ADDR);
ea_t ea = calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
}
break;
case o_near:
{
cref_t ftype = fl_JN;
ea_t ea = toEA(cmd.cs, x.addr);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_mem:
{
ea_t ea = toEA(dataSeg(), x.addr);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
}
break;
default:
badTouch:
if ( cmd.itype != AVR_lpm && cmd.itype != AVR_elpm )
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
break;
default:
// interr("emu");
break;
case o_imm:
// if ( !isload ) interr("emu2");
process_immediate_number(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, x.amode & amode_signed ? OOF_SIGNED : 0);
break;
case o_phrase:
if ( !isAlt && isOff(uFlag, x.n) )
{
ua_add_off_drefs2(x, isload ? dr_R : dr_W, OOF_ADDR);
ea_t ea = calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload ) doVar(ea);
}
break;
case o_mem:
{
ea_t ea = calc_mem(x);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload ) doVar(ea);
}
break;
case o_near:
add_near_ref(x, calc_mem(x));
break;
case o_textphrase:
break;
case o_local: // local variables
if ( may_create_stkvars() )
{
func_t *pfn = get_func(cmd.ea);
if ( (pfn != NULL) && (pfn->flags & FUNC_FRAME) && ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
op_stkvar(cmd.ea, x.n);
}
break;
}
}
static void TouchArg( op_t &x, int isload )
{
switch( x.type )
{
case o_displ:
case o_imm:
if ( isOff(uFlag, x.n) )
{
int outf = x.type != o_imm ? OOF_ADDR : 0;
ua_add_off_drefs2(x, dr_O, outf|OOF_SIGNED);
}
break;
case o_mem:
case o_ind_mem:
{
ea_t dea = intmem + x.addr;
ua_dodata2(x.offb, dea, x.dtyp);
if( !isload )
doVar( dea );
ua_add_dref( x.offb, dea, isload ? dr_R : dr_W );
}
break;
case o_near:
ea_t ea = toEA( cmd.cs, x.addr );
int iscall = InstrIsSet( cmd.itype, CF_CALL );
ua_add_cref( x.offb, ea, iscall ? fl_CN : fl_JN );
if( flow && iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
break;
default:
// interr("emu");
break;
case o_imm:
process_immediate_number(x.n);
if ( op_adds_xrefs(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOFS_IFSIGN);
break;
case o_phrase:
if ( !isAlt && op_adds_xrefs(uFlag, x.n) )
{
ea_t ea = ua_add_off_drefs2(x, isload ? dr_R : dr_W, OOF_ADDR);
if ( ea != BADADDR )
{
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
}
}
break;
case o_mem:
{
ea_t ea = calc_mem(x);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
if ( x.amode & amode_l )
{
ea = ymem + x.addr;
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
}
}
break;
case o_near:
add_near_ref(x, calc_mem(x));
break;
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x, int isload)
{
switch ( x.type )
{
case o_displ:
case o_imm:
if ( op_adds_xrefs(uFlag, x.n) )
{
int outf = x.type != o_imm ? OOF_ADDR : 0;
ua_add_off_drefs2(x, dr_O, outf|OOF_SIGNED);
}
break;
case o_mem:
case o_ind_mem:
case o_reg:
case o_ind_reg:
{
ea_t dea;
if ( x.type == o_mem || x.type == o_ind_mem )
{
dea = map_addr(x.addr, x.n, true);
}
else
{
if ( x.reg >= rRR0 )
dea = map_addr(x.reg - rRR0, x.n, true);
else
dea = map_addr(x.reg - rR0, x.n, true);
}
ua_dodata2(x.offb, dea, x.dtyp);
if ( !isload )
doVar(dea);
ua_add_dref(x.offb, dea, isload ? dr_R : dr_W);
if ( !has_user_name(get_flags_novalue(dea)) && dea > intmem)
{
char buf[10];
int num = dea - intmem;
if ( num < 0x100 )
{
qsnprintf(buf, sizeof(buf), "R%d", num);
}
else if ( num < 0x1000 )
{
qsnprintf(buf, sizeof(buf), "ERF_%X_%d", num >> 8, num & 0xFF);
}
else
{
int reg_no = ((num >> 4) & 0xF0) + (num & 0xF);
int subbank_no = ((num >> 4) & 0xF) + 1;
qsnprintf(buf, sizeof(buf), "R%d_%X", reg_no, subbank_no);
}
set_name(dea, buf, SN_NOWARN);
}
//----------------------------------------------------------------------
static bool TouchArg(op_t &x,int isload)
{
dref_t xreftype;
uchar outf;
switch ( x.type )
{
case o_phrase: // 2 registers
case o_reg:
break;
case o_imm:
if ( !isload )
goto badTouch;
xreftype = dr_O;
outf = OOF_SIGNED;
goto makeImm;
case o_displ:
xreftype = isload ? dr_R : dr_W;
outf = OOF_SIGNED|OOF_ADDR;
makeImm:
doImmdValue();
if ( op_adds_xrefs(uFlag, x.n) )
ua_add_off_drefs2(x, xreftype, outf);
break;
case o_mem:
ua_dodata2(x.offb, x.addr, x.dtyp);
if ( !isload )
doVar(x.addr);
ua_add_dref(x.offb,x.addr,isload ? dr_R : dr_W);
break;
case o_near:
{
int iscall = InstrIsSet(cmd.itype,CF_CALL);
ua_add_cref(x.offb,x.addr,iscall ? fl_CN : fl_JN);
if ( iscall && !func_does_return(x.addr) )
return false;
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
return true;
}
//----------------------------------------------------------------------
static void SaveArg(op_t &x)
{
switch ( x.type )
{
case o_reg:
{
// if ( x.reg == R_sp ) return;
// AbstractRegister *out = &i5_getreg(x.reg);
// if ( ! isDef(r) ) {
// out->undef();
// } else {
// out->doInt(r.value());
// }
return;
}
case o_mem:
{
ea_t ea = toEA(dataSeg_op(x.n),x.addr);
ua_dodata2(x.offb, ea, x.dtyp);
doVar(ea);
ua_add_dref(x.offb,ea,dr_W);
}
break;
case o_displ:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_W, OOF_ADDR);
case o_phrase:
break;
default:
switch ( cmd.itype )
{
case Z80_in0:
case Z80_outaw:
break;
default:
// warning("%a: %s,%d: bad save optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
break;
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
switch ( x.type )
{
case o_regpair:
case o_reg:
case o_phrase:
case o_spmask:
case o_stgcyc:
break;
case o_imm:
if ( !isload )
goto badTouch;
/* no break */
case o_displ:
doImmdValue(x.n);
if ( op_adds_xrefs(uFlag, x.n) )
{
int outf = x.type != o_imm ? OOF_ADDR : 0;
if ( x.dtyp == dt_word )
outf |= OOF_SIGNED;
ua_add_off_drefs2(x, dr_O, outf);
}
break;
case o_near:
{
ea_t ea = toEA(cmd.cs,x.addr);
ea_t ref = find_first_insn_in_packet(ea);
ua_add_cref(x.offb, ref, fl_JN);
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x, int use)
{
switch ( x.type )
{
case o_reg:
return;
case o_near:
{
if (cmd.itype != TMS320C3X_RPTB )
{
cref_t ftype = fl_JN;
ea_t ea = calc_code_mem(x);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
else // evaluate RPTB loops as dref
ua_add_dref(x.offb, calc_code_mem(x), dr_I);
}
break;
case o_imm:
if ( !use ) error("interr: emu");
process_imm(x);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, 0);
break;
case o_mem:
{
ea_t ea = calc_data_mem(x);
if (ea != BADADDR)
{
ua_add_dref(x.offb, ea, use ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !use )
doVar(ea);
}
}
break;
case o_phrase:
break;
case o_displ:
doImmd(cmd.ea);
break;
default:
if ( x.type == o_void )
{
if ( cmd.itype == TMS320C3X_ABSF )
break;
if ( cmd.itype == TMS320C3X_ABSI )
break;
}
warning("interr: emu2 address:%a operand:%d type:%d", cmd.ea, x.n, x.type);
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
case o_reglist:
return;
case o_imm:
QASSERT(10090, isload);
process_immediate_number(x.n);
if ( op_adds_xrefs(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, calc_opimm_flags());
break;
case o_phrase:
case o_displ:
process_immediate_number(x.n);
if ( isAlt ) break;
if ( op_adds_xrefs(uFlag, x.n) )
{
ea_t ea = ua_add_off_drefs2(x, isload ? dr_R : dr_W, calc_opdispl_flags());
if ( ea != BADADDR )
{
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
}
}
// create stack variables if required
if ( x.type == o_displ
&& may_create_stkvars()
&& !isDefArg(uFlag, x.n) )
{
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL
&& (issp(x.phrase)
|| isbp(x.phrase) && (pfn->flags & FUNC_FRAME) != 0) )
{
if ( ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
op_stkvar(cmd.ea, x.n);
}
}
break;
case o_near:
case o_far:
{
cref_t ftype = x.type == o_near ? fl_JN : fl_JF;
ea_t ea = calc_mem(x);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = x.type == o_near ? fl_CN : fl_CF;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_mem:
{
ea_t ea = calc_mem(x);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload ) doVar(ea);
}
break;
default:
INTERR(10091);
}
}
// Emulate an operand.
static void handle_operand(op_t &op, bool write) {
switch ( op.type ) {
// Code address
case o_near:
{
cref_t mode;
ea_t ea = toEA(cmd.cs, op.addr);
// call or jump ?
if ( cmd.itype == st9_call || cmd.itype == st9_calls )
{
if ( !func_does_return(ea) )
flow = false;
mode = fl_CN;
}
else
{
mode = fl_JN;
}
ua_add_cref(op.offb, ea, mode);
}
break;
// Memory address
case o_mem:
{
enum dref_t mode;
mode = write ? dr_W: dr_R;
ua_add_dref(op.offb, toEA(cmd.cs, op.addr), mode);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
break;
// Immediate value
case o_imm:
doImmd(cmd.ea);
// create a comment if this immediate is represented in the .cfg file
{
const ioport_t * port = find_sym(op.value);
if ( port != NULL && !has_cmt(uFlag) ) {
set_cmt(cmd.ea, port->cmt, false);
}
}
// 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);
break;
// Displacement
case o_displ:
doImmd(cmd.ea);
if ( isOff(uFlag, op.n) ) {
ua_add_off_drefs2(op, dr_O, OOF_ADDR);
ua_dodata2(op.offb, op.addr, op.dtyp);
}
// create stack variables if required
if ( 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.addr, STKVAR_VALID_SIZE) ) {
op_stkvar(cmd.ea, op.n);
if ( cmd.Op2.type == o_reg ) {
regvar_t *r = find_regvar(pfn, cmd.ea, ph.regNames[cmd.Op2.reg]);
if ( r != NULL ) {
struc_t *s = get_frame(pfn);
member_t *m = get_stkvar(op, op.addr, NULL);
char b[20];
qsnprintf(b, sizeof b, "%scopy", r->user);
set_member_name(s, m->soff, b);
}
}
}
}
}
break;
// Register - Phrase - Void: do nothing
case o_reg:
case o_phrase:
case o_void:
break;
default:
IDA_ERROR("Invalid op.type in handle_operand()");
}
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload) {
switch ( x.type ) {
case o_phrase:
//Добавляем в список ошибок(выводим сообщение)
//ошибку и адресс где это случилось
//QueueMark(Q_jumps, cmd.ea);
case o_void:
case o_reg:
break;
case o_sr:
case o_displ:
//Установить для данного байта признак immedia
doImmd(cmd.ea);
//Получить флаг для указанного линейного адресса
if ( !isAlt ) {
uint32 offb;
ushort addr = ushort(x.addr);
if ( x.type == o_displ ) {
addr += (ushort)cmd.ip;
addr += cmd.size;
//Получить линейный адресс
offb = (uint32)toEA(codeSeg(addr,x.n), 0);
DataSet(x, offb+addr, isload);
} else if ( isOff(uFlag, x.n) ) {
reref:
ua_add_off_drefs2(x, dr_O, x.type == o_displ ? OOF_ADDR : 0);
if ( x.type == o_displ )
//Преобразовать данные по указанному линейному адрессу в указанный тип
ua_dodata2(x.offb, calc_target(cmd.ea+x.offb, cmd.ea, x.n, x.addr), x.dtyp);
} else if ( x.type == o_displ && !x.reg && !isDefArg(uFlag, x.n ) &&
set_offset(cmd.ea, x.n, toEA(cmd.cs,0))) goto reref;
}
break;
case o_stk:
case o_imm:
{
//Установить для данного байта признак immedia
doImmd(cmd.ea);
if ( isOff(get_flags_novalue(cmd.ea), x.n) )
ua_add_off_drefs2(x, dr_O, 0);
}
break;
case o_ab:
{
if ( x.TypeOper == TAB_INDIRECTED_ABS_X )
{
ea_t ea = toEA(cmd.cs, x.addr);
ua_dodata2(x.offb, ea, dt_word);
//добавить крос референсы для текущей инструкции
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
//получить данные
uint32 Addr;
Addr = get_word(ea);
Addr = uint32( Addr | (getPG<<16));
//добавить крос референсы для текущей инструкции
ua_add_cref(2, Addr, fl_JF);
}
else
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}
break;
case o_mem:
{
// Конвертирование в данные(указан адресс) по указанному типу,
//добавить крос референсы для текущей инструкции
switch ( x.TypeOper )
{
case TDIR_DIR_Y:
case TDIR_DIR_X:
case TDIR_DIR:
case TDIR_INDIRECT_DIR:
case TDIR_INDIRECT_DIR_X:
case TDIR_INDIRECT_DIR_Y:
case TDIR_L_INDIRECT_DIR:
case TDIR_L_INDIRECT_DIR_Y:
{
if ( getDPReg == 1 )
{
uint32 d = x.addr & 0xC;
x.addr &= 0xFF3F;
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
x.addr |=d;
}
else
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}
break;
default:
DataSet(x, toEA(codeSeg(x.addr,x.n), x.addr), isload);
}//end switch
}
break;
case o_near:
{
//Получить линейный адресс
ea_t ea = toEA(cmd.cs, x.addr);
switch ( cmd.itype )
{
case m7900_jsr:
{
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_CN );
if ( !func_does_return(ea) )
flow = false;
}
break;
case m7900_jsrl:
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_CF);
if ( !func_does_return(ea) )
flow = false;
break;
case m7900_jmpl:
//добавить крос референсы для текущей инструкции
ua_add_cref(x.offb, ea, fl_JF);
break;
default:
ua_add_cref(x.offb, ea, fl_JN);
break;
}
}
break;
default:
// warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static void process_operand(op_t &x, int use)
{
switch ( x.type )
{
case o_bit:
case o_reg:
case o_cond8:
case o_cond2:
return;
case o_near:
case o_far:
{
if (cmd.itype != TMS320C54_rptb && cmd.itype != TMS320C54_rptbd)
{
cref_t ftype = fl_JN;
ea_t ea = calc_code_mem(x.addr, x.type == o_near);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
#ifndef TMS320C54_NO_NAME_NO_REF
if ( x.dtyp == dt_byte )
ua_add_dref(x.offb, ea, dr_R);
else
ua_add_cref(x.offb, ea, ftype);
#endif
}
#ifndef TMS320C54_NO_NAME_NO_REF
else // evaluate RPTB[D] loops as dref
ua_add_dref(x.offb, calc_code_mem(x.addr), dr_I);
#endif
}
break;
case o_imm:
if ( !use ) error("interr: emu");
process_imm(x);
#ifndef TMS320C54_NO_NAME_NO_REF
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, x.Signed ? OOF_SIGNED : 0);
#endif
break;
case o_mem:
case o_farmem:
case o_mmr:
{
ea_t ea = calc_data_mem(x.addr, x.type == o_mem);
if (ea != BADADDR)
{
#ifndef TMS320C54_NO_NAME_NO_REF
ua_add_dref(x.offb, ea, use ? dr_R : dr_W);
#endif
ua_dodata2(x.offb, ea, x.dtyp);
if ( !use )
doVar(ea);
}
}
break;
case o_local: // local variables
if ( may_create_stkvars()
&& (get_func(cmd.ea) != NULL)
&& ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
{
op_stkvar(cmd.ea, x.n);
}
break;
case o_displ:
doImmd(cmd.ea);
break;
default:
warning("interr: emu2 address:%a operand:%d type:%d", cmd.ea, x.n, x.type);
}
}
//------------------------------------------------------------------------
static void TouchArg(op_t &x,int isAlt,int isload) {
ea_t jmpa;
switch ( x.type ) {
case o_near: // Jcc/ [jmp/call 37/67]
case o_mem: // 37/67/77
case o_far:
jmpa = toEA(x.type == o_far ? x.segval : codeSeg(x.addr16,x.n), x.addr16);
if ( x.phrase == 0) { ua_add_cref(x.offb,jmpa,fl_JN ); break; } //Jcc
extxref:
if ( (x.phrase & 070) == 070 ) goto xrefset;
if ( cmd.itype == pdp_jmp) ua_add_cref(x.offb,jmpa,fl_JF );
else if ( cmd.itype == pdp_jsr || cmd.itype == pdp_call ) {
ua_add_cref(x.offb,jmpa,fl_CF);
if ( !func_does_return(jmpa) )
flow = false;
} else {
xrefset:
ua_dodata2(x.offb, jmpa, x.dtyp);
ua_add_dref(x.offb, jmpa, isload ? dr_R : dr_W);
}
break;
case o_displ: // 6x/7x (!67/!77)
doImmdValue();
if ( !isload && x.phrase == (060 + rR0) && x.addr16 <= 1 )
loadR0data(&x, x.addr16);
if ( !isAlt && isOff(emuFlg,x.n ) &&
(jmpa = get_offbase(cmd.ea, x.n)) != BADADDR) {
jmpa += x.addr16;
goto extxref;
}
break;
case o_imm: // 27
if ( !x.ill_imm )
{
doImmdValue();
if ( op_adds_xrefs(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOF_SIGNED);
}
break;
case o_number: // EMT/TRAP/MARK/SPL
if ( cmd.itype == pdp_emt && get_cmt(cmd.ea, false, NULL, 0) <= 0 ) {
if ( x.value >= 0374 && x.value <= 0375 ) {
cmd.Op2.value = (x.value == 0375) ? emuR0data.b[1] : (emuR0 >> 8);
cmd.Op2.type = o_imm;
}
char buf[MAXSTR];
if ( get_predef_insn_cmt(cmd, buf, sizeof(buf)) > 0 )
set_cmt(cmd.ea, buf, false);
cmd.Op2.type = o_void;
}
break;
case o_reg: // 0
if ( x.reg == rR0 ) {
if ( cmd.Op2.type == o_void ) { // one operand cmd
if ( cmd.itype != pdp_clr ) {
goto undefall;
} else {
if ( cmd.bytecmd ) emuR0 &= 0xFF00;
else emuR0 = 0;
goto undefdata;
}
}
if ( &x == &cmd.Op2 ) {
if ( cmd.itype != pdp_mov ) {
if ( cmd.bytecmd ) { emuR0 |= 0xFF; goto undefdata; }
else goto undefall;
}
if ( cmd.bytecmd ) goto undefall;
if ( cmd.Op1.type == o_imm ) {
if ( (emuR0 = (ushort)cmd.Op1.value) & 1 ) goto undefdata;
emuR0data.w = get_word(toEA(cmd.cs, emuR0));
} else {
undefall:
emuR0 = 0xFFFF;
undefdata:
emuR0data.w = 0xFFFF;
}
}
}
break;
case o_phrase: // 1x/2x/3x/4x/5x (!27/!37)
if ( (x.phrase & 7) == rR0 )
{
if ( !isload && x.phrase == (010 + rR0)) loadR0data(&x, 0 );
else if ( cmd.Op2.type == o_void || &x == &cmd.Op2 ) goto undefall;
}
case o_fpreg: // FPP
break;
default:
warning("%" FMT_EA "o (%s): bad optype %d", cmd.ip, cmd.get_canon_mnem(), x.type);
break;
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int isAlt,int isload)
{
switch ( x.type )
{
case o_reg:
case o_phrase:
case o_reglist:
return;
case o_imm:
QASSERT(10094, isload);
process_immediate_number(x.n);
if ( op_adds_xrefs(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOFS_IFSIGN|OOFW_IMM);
break;
case o_displ:
process_immediate_number(x.n);
if ( isAlt )
break;
if ( op_adds_xrefs(uFlag, x.n) )
{
ea_t ea = ua_add_off_drefs2(x, isload ? dr_R : dr_W, get_displ_outf(x));
if ( ea != BADADDR )
{
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
}
}
// create stack variables if required
if ( may_create_stkvars() && !isDefArg(uFlag, x.n) )
{
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL
&& (issp(x.phrase)
|| isbp(x.phrase) && (pfn->flags & FUNC_FRAME) != 0) )
{
if ( ua_stkvar2(x, x.addr, STKVAR_VALID_SIZE) )
op_stkvar(cmd.ea, x.n);
}
}
break;
case o_near:
add_code_xref(x, calc_mem(x.addr));
break;
case o_mem:
case o_memind:
{
ea_t ea = calc_mem(x.addr);
if ( !isEnabled(ea) && find_sym(ea) ) break; // address not here
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( x.type == o_memind )
{
ssize_t size = get_dtyp_size(x.dtyp);
flags_t F = getFlags(ea);
if ( (isWord(F) || isDwrd(F))
&& (!isDefArg0(F) || isOff0(F)) )
{
ea_t target = calc_mem(size == 2
? get_word(ea)
: (get_long(ea) & 0xFFFFFFL));
if ( isEnabled(target) ) add_code_xref(x, target);
if ( !isOff0(F) )
set_offset(ea, 0, calc_mem(0));
}
break;
}
if ( !isload ) doVar(ea);
}
break;
default:
INTERR(10095);
}
}
// 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);
}
}
// emulate operand
static void handle_operand(op_t &op, bool loading) {
switch ( op.type ) {
// Address
case o_near:
// branch label - create code reference (call or jump
// according to the instruction)
{
ea_t ea = toEA(cmd.cs, op.addr);
cref_t ftype = fl_JN;
if ( cmd.itype == m32r_bl )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
ua_add_cref(op.offb, ea, ftype);
}
break;
// Immediate
case o_imm:
if ( !loading ) {
interr1("handle_operand(): o_imm with CF_CHG");
}
handle_imm();
// if the value was converted to an offset, then create a data xref:
if ( op_adds_xrefs(uFlag, op.n) )
ua_add_off_drefs2(op, dr_O, OOFW_IMM|OOF_SIGNED);
// create a comment if this immediate is represented in the .cfg file
{
const ioport_t * port = find_sym(op.value);
if ( port != NULL && !has_cmt(uFlag) )
set_cmt(cmd.ea, port->cmt, false);
}
break;
// Displ
case o_displ:
handle_imm();
// if the value was converted to an offset, then create a data xref:
if ( op_adds_xrefs(uFlag, op.n) )
ua_add_off_drefs2(op, loading ? dr_R : dr_W, OOF_SIGNED|OOF_ADDR|OOFW_32);
// create stack variables if required
if ( may_create_stkvars() && !isDefArg(uFlag, op.n) ) {
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && (op.reg == rFP || op.reg == rSP) && pfn->flags & FUNC_FRAME ) {
if ( ua_stkvar2(op, op.addr, STKVAR_VALID_SIZE) ) {
op_stkvar(cmd.ea, op.n);
}
}
}
break;
case o_phrase:
/* create stack variables if required */
if ( op.specflag1 == fRI && may_create_stkvars() && !isDefArg(uFlag, op.n) ) {
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && (op.reg == rFP || op.reg == rSP) && pfn->flags & FUNC_FRAME ) {
if ( ua_stkvar2(op, 0, STKVAR_VALID_SIZE) ) {
op_stkvar(cmd.ea, op.n);
}
}
}
break;
// Phrase - register - void : do nothing
case o_reg:
case o_void:
break;
// Others types should never be called
default:
interr2("handle_operand(): unknown type %d", op.type);
break;
}
}
/*
#<pydoc>
def ua_add_off_drefs2(op, type, outf):
"""
Add xrefs for offset operand of the current instruction
Please check ua.hpp / ua_add_off_drefs2()
@return: ea_t
"""
pass
#</pydoc>
*/
ea_t py_ua_add_off_drefs2(PyObject *py_op, dref_t type, int outf)
{
PYW_GIL_CHECK_LOCKED_SCOPE();
op_t *op = op_t_get_clink(py_op);
return op == NULL ? BADADDR : ua_add_off_drefs2(*op, type, outf);
}
//----------------------------------------------------------------------
static void TouchArg(op_t &x,int isload)
{
ea_t ea;
switch ( x.type )
{
case o_phrase: // 2 registers or indirect addressing
if ( cmd.itype != TMS_mar && cmd.itype != TMS2_mar
&& find_ar(&ea) ) goto set_dref;
case o_reg:
case o_bit:
case o_cond:
break;
case o_imm:
if ( ! isload ) goto badTouch;
doImmdValue();
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, is_mpy() ? OOF_SIGNED : 0);
break;
case o_mem:
ea = toEA(dataSeg_op(x.n),x.addr);
set_dref:
ua_dodata2(x.offb, ea, x.dtyp);
if ( ! isload )
doVar(ea);
ua_add_dref(x.offb,ea,isload ? dr_R : dr_W);
if ( x.type == o_mem )
if ( cmd.itype == TMS_dmov ||
cmd.itype == TMS_ltd ||
cmd.itype == TMS_macd ||
cmd.itype == TMS_madd ||
cmd.itype == TMS2_dmov ||
cmd.itype == TMS2_macd ) ua_add_dref(x.offb,ea+1,dr_W);
break;
case o_near:
{
ea_t segbase = codeSeg(x.addr, x.n);
ea = toEA(segbase, x.addr);
if ( cmd.itype == TMS_blpd ||
cmd.itype == TMS_mac ||
cmd.itype == TMS_macd ||
cmd.itype == TMS2_blkp ||
cmd.itype == TMS2_mac ||
cmd.itype == TMS2_macd
) goto set_dref;
uval_t thisseg = cmd.cs;
int iscall = InstrIsSet(cmd.itype,CF_CALL);
if ( cmd.itype == TMS_rptb && isTail(get_flags_novalue(ea)) )
{
// small hack to display end_loop-1 instead of before_end_loop+1
ea++;
}
ua_add_cref(x.offb,
ea,
iscall ? ((segbase == thisseg) ? fl_CN : fl_CF)
: ((segbase == thisseg) ? fl_JN : fl_JF));
if ( iscall )
{
if ( !func_does_return(ea) )
flow = false;
}
}
break;
default:
badTouch:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
static void handle_operand(op_t &x,int loading)
{
switch ( x.type )
{
case o_phrase: // no special hanlding for these types
case o_reg:
break;
case o_imm: // an immediate number as an operand
if ( !loading ) goto BAD_LOGIC; // this can't happen!
doImmdValue(); // handle immediate number
// if the value was converted to an offset, then create a data xref:
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, OOFS_IFSIGN);
break;
case o_displ:
doImmdValue(); // handle immediate number
// if the value was converted to an offset, then create a data xref:
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, loading?dr_R:dr_W, OOFS_IFSIGN|OOF_ADDR);
break;
case o_bit: // 8051 specific operand types - bits
case o_bitnot:
x.addr = (x.reg & 0xF8);
if( (x.addr & 0x80) == 0 ) x.addr = x.addr/8 + 0x20;
attach_bit_comment(x.addr, x.reg & 7); // attach a comment if necessary
goto MEM_XREF;
case o_bit251:
attach_bit_comment(x.addr, x.b251_bit);
/* no break */
case o_mem: // an ordinary memory data reference
MEM_XREF:
{
ea_t dea = map_addr(x.addr, x.n, true);
ua_dodata2(x.offb, dea, x.dtyp);
if ( !loading )
doVar(dea); // write access
ua_add_dref(x.offb, dea, loading ? dr_R : dr_W);
}
break;
case o_near: // a code reference
{
ea_t ea = map_addr(x.addr, x.n, false);
int iscall = InstrIsSet(cmd.itype, CF_CALL);
ua_add_cref(x.offb, ea, iscall ? fl_CN : fl_JN);
if ( flow && iscall )
flow = func_does_return(ea);
}
break;
default:
BAD_LOGIC:
warning("%a: %s,%d: bad optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
}
//----------------------------------------------------------------------
static int LoadArg(op_t &x)
{
dref_t xreftype;
switch ( x.type ) {
case o_reg:
{
if ( x.reg == R_sp ) goto Undefined;
// AbstractRegister *in = &i5_getreg(x.reg);
// if ( ! in->isDef() ) goto Undefined;
// r.doInt(in->value());
return 1;
}
case o_imm:
// r.doInt(unsigned(x.value));
xreftype = dr_O;
MakeImm:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, xreftype, 0);
return 1;
case o_displ:
// r.undef();
xreftype = dr_R;
goto MakeImm;
case o_mem:
{
ea_t ea = toEA(dataSeg_op(x.n),x.addr);
ua_add_dref(x.offb,ea,dr_R);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isVar(get_flags_novalue(ea)) && isLoaded(ea) )
{
// r.doInt( x.dtyp != dt_byte ? get_word(ea) : char(get_byte(ea)) );
return 1;
}
}
case o_phrase:
Undefined:
// r.undef();
break;
case o_near:
{
ea_t segbase = codeSeg(x.addr,x.n);
ea_t ea = toEA(segbase,x.addr);
ea_t thisseg = cmd.cs;
int iscall = InstrIsSet(cmd.itype,CF_CALL);
ua_add_cref(x.offb,
ea,
iscall ? ((segbase == thisseg) ? fl_CN : fl_CF)
: ((segbase == thisseg) ? fl_JN : fl_JF));
if ( iscall && !func_does_return(ea) )
flow = false;
// r.doInt(unsigned(x.addr));
}
return 1;
default:
// warning("%a: %s,%d: bad load optype %d", cmd.ea, cmd.get_canon_mnem(), x.n, x.type);
break;
}
return 0;
}
//----------------------------------------------------------------------
static void process_operand(op_t &x,int ,int isload)
{
if ( cmd.Op2.type == o_reg && cmd.Op2.reg == F || cmd.itype == PIC_swapf ) isload = 0;
switch ( x.type )
{
case o_reg:
return;
case o_imm:
if ( !isload ) error("interr: emu");
process_immediate_number(x.n);
if ( isOff(uFlag, x.n) )
ua_add_off_drefs2(x, dr_O, calc_outf(x));
break;
case o_near:
{
cref_t ftype = fl_JN;
ea_t ea = calc_code_mem(x.addr);
if ( InstrIsSet(cmd.itype, CF_CALL) )
{
if ( !func_does_return(ea) )
flow = false;
ftype = fl_CN;
}
ua_add_cref(x.offb, ea, ftype);
}
break;
case o_mem:
{
ea_t ea = calc_data_mem(x.addr);
destroy_if_unnamed_array(ea);
ua_add_dref(x.offb, ea, isload ? dr_R : dr_W);
ua_dodata2(x.offb, ea, x.dtyp);
if ( !isload )
doVar(ea);
if ( may_create_stkvars())
{
if ( x.addr == PIC16_INDF2 )
{
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && (pfn->flags & FUNC_FRAME) != 0 )
{
ua_stkvar2(cmd.Op1, 0, STKVAR_VALID_SIZE);
}
}
else if ( x.addr == PIC16_PLUSW2 )
{
insn_t saved = cmd;
if ( decode_prev_insn(cmd.ea) != BADADDR && cmd.itype == PIC_movlw )
{
func_t *pfn = get_func(cmd.ea);
if ( pfn != NULL && (pfn->flags & FUNC_FRAME) != 0 )
{
if ( ua_stkvar2(cmd.Op1, cmd.Op1.value, STKVAR_VALID_SIZE) )
op_stkvar(cmd.ea, cmd.Op1.n);
}
}
cmd = saved;
}
}
}
break;
default:
warning("interr: emu2 %a", cmd.ea);
}
}