void AddOpRhsTypeHelper(IRSB* sb, IRExpr* arg, IntTyStateHint hint, Addr addr)
{
IRDirty * d;
HWord tmpname;
switch (arg->tag)
{
case(Iex_RdTmp):
tmpname = (HWord)arg->Iex.RdTmp.tmp;
d = unsafeIRDirty_0_N(0, "EmitTmpHelper",
&EmitTmpHelper,
mkIRExprVec_4(
mkIRExpr_HWord(tmpname),
mkIRExpr_HWord(hint),
mkIRExpr_HWord(counter),
mkIRExpr_HWord(addr)
)
);
setHelperAnns(d);
addStmtToIRSB(sb,IRStmt_Dirty(d));
break;
default:
break;
}
return;
}
void instrument_Exit(IRStmt* st, IRSB* sb_out)
{
IRExpr* guard = st->Ist.Exit.guard;
Int offsIP = st->Ist.Exit.offsIP;
Int size = sizeofIRType_bits(typeOfIRConst(st->Ist.Exit.dst));
IRDirty* di;
tl_assert(guard->tag == Iex_RdTmp);
di = unsafeIRDirty_0_N(0,
"helper_instrument_Exit",
VG_(fnptr_to_fnentry)(helper_instrument_Exit),
mkIRExprVec_4(assignNew_HWord(sb_out, guard),
mkIRExpr_HWord(offsIP),
mkIRExpr_HWord(size),
mkIRExpr_HWord(guard->Iex.RdTmp.tmp))
);
addStmtToIRSB(sb_out, IRStmt_Dirty(di));
}
/*
The GetI expression is used to read guest registers which identity is not known until run time,
i.e. not the registers we are shadowing (in principle), no harm in verifying though.
*/
void instrument_WrTmp_GetI(IRStmt* st, IRSB* sb_out)
{
IRExpr* data = st->Ist.WrTmp.data;
IRRegArray* descr = data->Iex.GetI.descr;
Int base = descr->base;
Int nElems = descr->nElems;
IRExpr* ix = data->Iex.GetI.ix;
Int bias = data->Iex.GetI.bias;
IRDirty* di;
tl_assert(ix->tag == Iex_RdTmp);
di = unsafeIRDirty_0_N(0,
"helper_instrument_WrTmp_GetI",
VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_GetI),
mkIRExprVec_4(mkIRExpr_HWord(base),
assignNew_HWord(sb_out, ix),
mkIRExpr_HWord(bias),
mkIRExpr_HWord(nElems))
);
addStmtToIRSB(sb_out, IRStmt_Dirty(di));
}
void instrument_WrTmp_Unop(IRStmt* st, IRSB* sb_out)
{
IRTemp tmp = st->Ist.WrTmp.tmp;
IRExpr* data = st->Ist.WrTmp.data;
IROp op = data->Iex.Unop.op;
IRExpr* arg = data->Iex.Unop.arg;
IRExpr* expr = IRExpr_Unop(op, arg);
Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, expr));
IRDirty* di;
tl_assert(isIRAtom(arg));
tl_assert(typeOfIRTemp(sb_out->tyenv, tmp) == typeOfIRExpr(sb_out->tyenv, expr));
di = unsafeIRDirty_0_N(0,
"helper_instrument_WrTmp_Unop",
VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_Unop),
mkIRExprVec_4(mkIRExpr_HWord(tmp),
mkIRExpr_HWord((arg->tag == Iex_RdTmp) ? arg->Iex.RdTmp.tmp : IRTemp_INVALID),
mkIRExpr_HWord(op),
mkIRExpr_HWord(size))
);
addStmtToIRSB(sb_out, IRStmt_Dirty(di));
}
void instrument_CAS_single_element(IRStmt* st, IRSB* sb_out)
{
IRCAS* cas = st->Ist.CAS.details;
IRTemp oldLo = cas->oldLo;
IRExpr* addr = cas->addr;
IRExpr* expdLo = cas->expdLo;
IRExpr* dataLo = cas->dataLo;
Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, dataLo));
IROp op;
IRExpr* expr;
IRDirty* di;
tl_assert(isIRAtom(addr));
tl_assert(isIRAtom(dataLo));
if (addr->tag == Iex_Const) tl_assert(addr->Iex.Const.con->tag == Ico_U32);
tl_assert(typeOfIRExpr(sb_out->tyenv, addr) == typeOfIRExpr(sb_out->tyenv, dataLo));
switch (size)
{
case 8: op = Iop_CasCmpEQ8; break;
case 16: op = Iop_CasCmpEQ16; break;
case 32: op = Iop_CasCmpEQ32; break;
default: VG_(tool_panic)("instrument_CAS_single_element");
}
expr = assignNew(sb_out, IRExpr_Binop(op, IRExpr_RdTmp(oldLo), expdLo)); // statement has to be flat
di = unsafeIRDirty_0_N(0,
"helper_instrument_CAS_single_element",
VG_(fnptr_to_fnentry)(helper_instrument_CAS_single_element),
mkIRExprVec_4((addr->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, addr) : mkIRExpr_HWord(addr->Iex.Const.con->Ico.U32),
mkIRExpr_HWord((dataLo->tag == Iex_RdTmp) ? dataLo->Iex.RdTmp.tmp : IRTemp_INVALID),
mkIRExpr_HWord(size),
assignNew_HWord(sb_out, expr))
);
addStmtToIRSB(sb_out, IRStmt_Dirty(di));
}
void instrument_LLSC_Store_Conditional(IRStmt* st, IRSB* sb_out)
{
IRTemp result = st->Ist.LLSC.result;
IRExpr* addr = st->Ist.LLSC.addr;
IRExpr* storedata = st->Ist.LLSC.storedata;
Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, storedata));
IRExpr* result_expr = IRExpr_RdTmp(result);
IRDirty* di;
tl_assert(isIRAtom(addr));
tl_assert(isIRAtom(storedata));
if (addr->tag == Iex_Const) tl_assert(addr->Iex.Const.con->tag == Ico_U32);
// the data transfer type is the type of storedata
di = unsafeIRDirty_0_N(0,
"helper_instrument_LLSC_Store_Conditional",
VG_(fnptr_to_fnentry)(helper_instrument_LLSC_Store_Conditional),
mkIRExprVec_4((addr->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, addr) : mkIRExpr_HWord(addr->Iex.Const.con->Ico.U32),
mkIRExpr_HWord((storedata->tag == Iex_RdTmp) ? storedata->Iex.RdTmp.tmp : IRTemp_INVALID),
mkIRExpr_HWord(size),
assignNew_HWord(sb_out, result_expr))
);
addStmtToIRSB(sb_out, IRStmt_Dirty(di));
}
void AddBinopHelper(IRSB* sb,IRStmt* st)
{
IROp op;
IRDirty* d1;
IRDirty* d2;
IRExpr* arg1;
IRExpr* arg2;
HWord lhs,tmpname;
// HWord cur_ctr = (HWord)counter;
vassert(st->tag = Ist_WrTmp);
op = (HWord)st->Ist.WrTmp.data->Iex.Binop.op;
arg1 = st->Ist.WrTmp.data->Iex.Binop.arg1;
arg2 = st->Ist.WrTmp.data->Iex.Binop.arg2;
lhs = (HWord)st->Ist.WrTmp.tmp;
d1 = unsafeIRDirty_0_N(0, "EmitNewTmpTyvarHelper",
&EmitNewTmpTyvarHelper,
mkIRExprVec_2(
mkIRExpr_HWord(lhs),
mkIRExpr_HWord(counter)
)
);
setHelperAnns(d1);
addStmtToIRSB(sb,IRStmt_Dirty(d1));
if (arg1->tag == Iex_RdTmp && arg2->tag == Iex_RdTmp)
{
d2 = unsafeIRDirty_0_N(0, "EmitBinopTmpTmpTypeHelper",
&EmitBinopTmpTmpTypeHelper,
mkIRExprVec_5(
mkIRExpr_HWord(lhs),
mkIRExpr_HWord(op),
mkIRExpr_HWord((HWord)arg1->Iex.RdTmp.tmp),
mkIRExpr_HWord((HWord)arg2->Iex.RdTmp.tmp),
mkIRExpr_HWord(counter)
)
);
setHelperAnns(d2);
addStmtToIRSB(sb,IRStmt_Dirty(d2));
}
if ((arg1->tag == Iex_RdTmp && arg2->tag == Iex_Const)
|| (arg1->tag == Iex_Const && arg2->tag == Iex_RdTmp))
{
if (arg1->tag == Iex_RdTmp) tmpname = (HWord)arg1->Iex.RdTmp.tmp;
else if (arg2->tag == Iex_RdTmp) tmpname = (HWord)arg2->Iex.RdTmp.tmp;
else vpanic("Neither arg1 nor arg2 is a tmp! \n");
d2 = unsafeIRDirty_0_N(0, "EmitBinopTmpConstTypeHelper",
&EmitBinopTmpConstTypeHelper,
mkIRExprVec_4(
mkIRExpr_HWord(lhs),
mkIRExpr_HWord(op),
mkIRExpr_HWord(tmpname),
mkIRExpr_HWord(counter)
)
);
setHelperAnns(d2);
addStmtToIRSB(sb,IRStmt_Dirty(d2));
}
return;
}
