//----------------------------------------------------------------------
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 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 TouchArg(op_t &x,int isload)
{
switch ( x.type )
{
case o_regpair:
case o_reg:
case o_phrase:
break;
case o_imm:
if ( !isload ) goto badTouch;
/* no break */
case o_displ:
doImmdValue(x.n);
if ( isOff(uFlag, x.n) ) ua_add_off_drefs(x, dr_O);
break;
case o_near:
ua_add_cref(x.offb,toEA(cmd.cs,x.addr),fl_JN);
break;
default:
badTouch:
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 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 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 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 void handle_operand(op_t &x, bool read_access)
{
ea_t ea;
dref_t dreftype;
switch ( x.type )
{
case o_void:
case o_reg:
break;
case o_imm:
QASSERT(557, read_access);
dreftype = dr_O;
MAKE_IMMD:
doImmdValue();
if ( isOff(uFlag, x.n) )
ua_add_off_drefs(x, dreftype);
break;
case o_displ:
dreftype = read_access ? dr_R : dr_W;
switch ( x.phrase )
{
case rD: // "dp"
case rDX: // "dp, X"
case rDY: // "dp, Y"
case riDX: // "(dp, X)"
case rDi: // "(dp,n)"
case rDiL: // "long(dp,n)"
case rDiY: // "(dp,n), Y"
case rDiLY: // "long(dp,n), Y"
{
sel_t dp = get_segreg(cmd.ea, rD);
if ( dp != BADSEL )
{
ea_t orig_ea = dp + x.addr;
ea = xlat(orig_ea);
goto MAKE_DREF;
}
else
{
goto MAKE_IMMD;
}
}
case rAbsi: // "(abs)"
case rAbsX: // "abs, X"
case rAbsY: // "abs, Y"
case rAbsiL: // "long(abs)"
ea = toEA(dataSeg_op(x.n), x.addr);
goto MAKE_DREF;
case rAbsXi: // "(abs,X)"
ea = toEA(codeSeg(cmd.ea, x.n), x.addr); // jmp, jsr
goto MAKE_DREF;
case rAbsLX: // "long abs, X"
ea = x.addr;
goto MAKE_DREF;
default:
goto MAKE_IMMD;
}
case o_mem:
case o_mem_far:
ea = calc_addr(x);
MAKE_DREF:
ua_dodata2(x.offb, ea, x.dtyp);
if ( !read_access )
doVar(ea);
ua_add_dref(x.offb, ea, read_access ? dr_R : dr_W);
break;
case o_near:
case o_far:
{
ea_t orig_ea;
ea = calc_addr(x, &orig_ea);
if ( cmd.itype == M65816_per )
{
ua_add_dref(x.offb, ea, dr_O);
}
else
{
bool iscall = InstrIsSet(cmd.itype, CF_CALL);
cref_t creftype = x.type == o_near
? iscall ? fl_CN : fl_JN
: iscall ? fl_CF : fl_JF;
ua_add_cref(x.offb, ea, creftype);
if ( flow && iscall )
flow = func_does_return(ea);
}
}
break;
default:
INTERR(558);
}
}
