自学教程：C++ unsafeIRDirty_0_N函数代码示例

/* instruments a Binary Operation Expression in a Ist_WrTmp statement */static void instrument_Triop(IRSB* sb, IRStmt* st, Addr64 cia) {  Char thisFct[]="instrument_Triop";  IRDirty* di;  IRExpr** argv;  IRExpr *op = st->Ist.WrTmp.data;  IRExpr* oa_event_expr;  IROp irop=op->Iex.Triop.details->op;  void* f=callbackFromIROp(irop);  if (f == NULL) return;  OA_InstrumentContext inscon=contextFor(cia, irop);  if (not_worth_watching(inscon))    return;  // filter events that can't be attached to source-code location  updateStats(inscon->op);  oa_event_expr = mkIRExpr_HWord( (HWord)inscon );  IRExpr * args1[2];  packToI32orI64(sb, op->Iex.Triop.details->arg2, args1, irop);  IRExpr * args2[2];  packToI32orI64(sb, op->Iex.Triop.details->arg3, args2, irop);  argv = mkIRExprVec_3(args1[0], args2[0], oa_event_expr);  di = unsafeIRDirty_0_N( 3, thisFct, VG_(fnptr_to_fnentry)( f ), argv);  addStmtToIRSB( sb, IRStmt_Dirty(di) );  if (args1[1] != NULL) {    // we need a second callback for 64bit types    argv = mkIRExprVec_3(args1[1], args2[1], oa_event_expr);    di = unsafeIRDirty_0_N( 3, thisFct, VG_(fnptr_to_fnentry)( f ), argv);    addStmtToIRSB( sb, IRStmt_Dirty(di) );  }}

static void instrument_store(IRSB* const bb,                             IRExpr* const addr_expr,                             const HWord size){    IRExpr* size_expr;    IRExpr** argv;    IRDirty* di;    switch (size)    {    case 1:        argv = mkIRExprVec_1(addr_expr);        di = unsafeIRDirty_0_N(/*regparms*/1,                                           "drd_trace_store_1",                                           VG_(fnptr_to_fnentry)(drd_trace_store_1),                                           argv);        break;    case 2:        argv = mkIRExprVec_1(addr_expr);        di = unsafeIRDirty_0_N(/*regparms*/1,                                           "drd_trace_store_2",                                           VG_(fnptr_to_fnentry)(drd_trace_store_2),                                           argv);        break;    case 4:        argv = mkIRExprVec_1(addr_expr);        di = unsafeIRDirty_0_N(/*regparms*/1,                                           "drd_trace_store_4",                                           VG_(fnptr_to_fnentry)(drd_trace_store_4),                                           argv);        break;    case 8:        argv = mkIRExprVec_1(addr_expr);        di = unsafeIRDirty_0_N(/*regparms*/1,                                           "drd_trace_store_8",                                           VG_(fnptr_to_fnentry)(drd_trace_store_8),                                           argv);        break;    default:        size_expr = mkIRExpr_HWord(size);        argv = mkIRExprVec_2(addr_expr, size_expr);        di = unsafeIRDirty_0_N(/*regparms*/2,                                           "drd_trace_store",                                           VG_(fnptr_to_fnentry)(drd_trace_store),                                           argv);        break;    }    addStmtToIRSB(bb, IRStmt_Dirty(di));}

static void VG_(add_stmt_call_invalidate_if_not_gdbserved)     ( IRSB* sb_in,       VexGuestLayout* layout,        VexGuestExtents* vge,       IRTemp jmp,        IRSB* irsb){      void*    fn;   const HChar*   nm;   IRExpr** args;   Int      nargs;   IRDirty* di;   fn    = &VG_(helperc_invalidate_if_not_gdbserved);   nm    = "VG_(helperc_invalidate_if_not_gdbserved)";   args  = mkIRExprVec_1(IRExpr_RdTmp (jmp));   nargs = 1;      di = unsafeIRDirty_0_N( nargs/*regparms*/, nm,                            VG_(fnptr_to_fnentry)( fn ), args );   di->nFxState = 0;   addStmtToIRSB(irsb, IRStmt_Dirty(di));}

void instrument_WrTmp_Mux0X(IRStmt* st, IRSB* sb_out){    IRTemp tmp = st->Ist.WrTmp.tmp;    IRExpr* data = st->Ist.WrTmp.data;    IRExpr* cond = data->Iex.Mux0X.cond;    IRExpr* expr0 = data->Iex.Mux0X.expr0;    IRExpr* exprX = data->Iex.Mux0X.exprX;    Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, expr0));    IRDirty* di;    tl_assert(cond->tag == Iex_RdTmp);    tl_assert(isIRAtom(expr0));    tl_assert(isIRAtom(exprX));    tl_assert(typeOfIRTemp(sb_out->tyenv, tmp) == typeOfIRExpr(sb_out->tyenv, expr0));    tl_assert(typeOfIRTemp(sb_out->tyenv, tmp) == typeOfIRExpr(sb_out->tyenv, exprX));    di = unsafeIRDirty_0_N(0,                           "helper_instrument_WrTmp_Mux0X",                           VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_Mux0X),                           mkIRExprVec_5(mkIRExpr_HWord(tmp),                                         assignNew_HWord(sb_out, cond),                                         mkIRExpr_HWord((expr0->tag == Iex_RdTmp) ? expr0->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord((exprX->tag == Iex_RdTmp) ? exprX->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord(size))                            );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

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 AddStoreHelper(IRSB* sb, IRExpr* addr, IRExpr* data){  IRDirty* d;  HWord tmpname;  switch (addr->tag)    {    case (Iex_RdTmp):      switch (data->tag)	{	case (Iex_RdTmp):	  tmpname = (HWord) data->Iex.RdTmp.tmp; 		  d = unsafeIRDirty_0_N(0,			    "EmitStoreAddr2TmpHelper",			    &EmitStoreAddr2TmpHelper,			    mkIRExprVec_3(addr,					  mkIRExpr_HWord(tmpname),					  mkIRExpr_HWord(counter)					  )			    );	  setHelperAnns(d);	  addStmtToIRSB(sb, IRStmt_Dirty(d)); 	  break; 	case (Iex_Const):	  /* add code to emit new tyvar for memory address */ 	  d = unsafeIRDirty_0_N(0,				"EmitStoreAddr2ConstHelper",				&EmitStoreAddr2ConstHelper,				mkIRExprVec_1(addr					      )				);	  setHelperAnns(d);	  addStmtToIRSB(sb,IRStmt_Dirty(d)); 	  break;        default:	  /* Should not reach here. */	  ppIRExpr(data); 	  vpanic("Bad store address!/n"); 	  break; 	}      break;     default:      break;     }  return;} 

/*    cc_op        add/sub/mul        adc/sbb        shl/Shl/sar            tmp = cond(cc_op(cc_dep1, cc_dep2))        and/or/xor        inc/dec        rol/ror            tmp = cond(cc_op(cc_dep1, 0))    The taintness of tmp depends on taintness of both args. (we can't handle and(cc_dep1, 0) which gives an untainted result)    cf. valgrind guest_x86_defs.h*/void instrument_WrTmp_CCall(IRStmt* st, IRSB* sb_out){    IRTemp tmp = st->Ist.WrTmp.tmp;    IRExpr* data = st->Ist.WrTmp.data;    IRCallee* cee = data->Iex.CCall.cee;    IRExpr** args = data->Iex.CCall.args;    IRDirty* di;    if (VG_(strcmp)(cee->name, "x86g_calculate_condition") == 0)    {        IRExpr* cond = args[0];        IRExpr* cc_op = args[1];        IRExpr* cc_dep1 = args[2];        IRExpr* cc_dep2 = args[3];        tl_assert(cond->tag == Iex_Const && cond->Iex.Const.con->tag == Ico_U32);        tl_assert(isIRAtom(cc_op));        tl_assert(isIRAtom(cc_dep1));        tl_assert(isIRAtom(cc_dep2));        if (cc_op->tag == Iex_Const) tl_assert(cc_op->Iex.Const.con->tag == Ico_U32);        if (cc_dep1->tag == Iex_Const) tl_assert(cc_dep1->Iex.Const.con->tag == Ico_U32);        if (cc_dep2->tag == Iex_Const) tl_assert(cc_dep2->Iex.Const.con->tag == Ico_U32);        // typeOf(x86g_calculate_condition) == typeOf(tmp) == I32        di = unsafeIRDirty_0_N(0,                               "helper_instrument_WrTmp_CCall_x86g_calculate_condition",                               VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_CCall_x86g_calculate_condition),                               mkIRExprVec_7(mkIRExpr_HWord(tmp),                                             mkIRExpr_HWord((cc_dep1->tag == Iex_RdTmp) ? cc_dep1->Iex.RdTmp.tmp : IRTemp_INVALID),                                             mkIRExpr_HWord((cc_dep2->tag == Iex_RdTmp) ? cc_dep2->Iex.RdTmp.tmp : IRTemp_INVALID),                                             mkIRExpr_HWord(cond->Iex.Const.con->Ico.U32),                                             (cc_op->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, cc_op) : mkIRExpr_HWord(cc_op->Iex.Const.con->Ico.U32),                                             (cc_dep1->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, cc_dep1) : mkIRExpr_HWord(cc_dep1->Iex.Const.con->Ico.U32),                                             (cc_dep2->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, cc_dep2) : mkIRExpr_HWord(cc_dep2->Iex.Const.con->Ico.U32))                               );        addStmtToIRSB(sb_out, IRStmt_Dirty(di));    }    else {        di = unsafeIRDirty_0_N(0,                               "helper_instrument_WrTmp_CCall_else",                               VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_CCall_else),                               mkIRExprVec_0()                               );        addStmtToIRSB(sb_out, IRStmt_Dirty(di));    }}

void instrument_WrTmp_Binop(IRStmt* st, IRSB* sb_out){    IRTemp tmp = st->Ist.WrTmp.tmp;    IRExpr* data = st->Ist.WrTmp.data;    IROp op = data->Iex.Binop.op;    IRExpr* arg1 = data->Iex.Binop.arg1;    IRExpr* arg2 = data->Iex.Binop.arg2;    UInt arg1_value = 0, arg2_value = 0;    IRExpr* expr = IRExpr_Binop(op, arg1, arg2);    Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, expr));    IRDirty* di;    // we don't care about floating point and SIMD operations    if (op > Iop_AddF64)        return;    tl_assert(isIRAtom(arg1));    tl_assert(isIRAtom(arg2));    tl_assert(typeOfIRTemp(sb_out->tyenv, tmp) == typeOfIRExpr(sb_out->tyenv, expr));    if (arg1->tag == Iex_Const)    {        switch (arg1->Iex.Const.con->tag)        {            case Ico_U1: arg1_value = arg1->Iex.Const.con->Ico.U1; break;            case Ico_U8: arg1_value = arg1->Iex.Const.con->Ico.U8; break;            case Ico_U16: arg1_value = arg1->Iex.Const.con->Ico.U16; break;            case Ico_U32: arg1_value = arg1->Iex.Const.con->Ico.U32; break;            case Ico_U64: arg1_value = arg1->Iex.Const.con->Ico.U64; break;            default: VG_(tool_panic)("instrument_WrTmp_Binop");        }    }    if (arg2->tag == Iex_Const)    {        switch (arg2->Iex.Const.con->tag)        {            case Ico_U1: arg2_value = arg2->Iex.Const.con->Ico.U1; break;            case Ico_U8: arg2_value = arg2->Iex.Const.con->Ico.U8; break;            case Ico_U16: arg2_value = arg2->Iex.Const.con->Ico.U16; break;            case Ico_U32: arg2_value = arg2->Iex.Const.con->Ico.U32; break;            case Ico_U64: arg2_value = arg2->Iex.Const.con->Ico.U64; break;            default: VG_(tool_panic)("instrument_WrTmp_Binop");        }    }    di = unsafeIRDirty_0_N(0,                           "helper_instrument_WrTmp_Binop",                           VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_Binop),                           mkIRExprVec_7(mkIRExpr_HWord(tmp),                                         mkIRExpr_HWord((arg1->tag == Iex_RdTmp) ? arg1->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord((arg2->tag == Iex_RdTmp) ? arg2->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord(op),                                         mkIRExpr_HWord(size),                                         (arg1->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, arg1) : mkIRExpr_HWord(arg1_value),                                         (arg2->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, arg2) : mkIRExpr_HWord(arg2_value))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void addDynamicDisownNonNull(IRSB* sbOut, IRTemp idx){  IRDirty* disownDirty =    unsafeIRDirty_0_N(1, "disownShadowTempNonNullDynamic",                      VG_(fnptr_to_fnentry)(disownShadowTempNonNullDynamic),                      mkIRExprVec_1(mkU64(idx)));  disownDirty->mFx = Ifx_Modify;  disownDirty->mAddr = mkU64((uintptr_t)&(shadowTemps[idx]));  disownDirty->mSize = sizeof(ShadowTemp*);  addStmtToIRSB(sbOut, IRStmt_Dirty(disownDirty));}

void AddPutHelper(IRSB* sb, Int offset, IRExpr* data){   IRDirty * d;     HWord h_offset = (HWord)(offset);     HWord lhs_name;     switch (data->tag)    {      case(Iex_Const):              d = unsafeIRDirty_0_N(0, "EmitPutConstHelper",			       &EmitPutConstHelper,			       mkIRExprVec_2(mkIRExpr_HWord(h_offset),					     mkIRExpr_HWord(counter)					     )			       );         setHelperAnns(d);         addStmtToIRSB(sb, IRStmt_Dirty(d));          break;            case(Iex_RdTmp):           lhs_name = (HWord)data->Iex.RdTmp.tmp;          d = unsafeIRDirty_0_N(0, "EmitPutTmpHelper",			       &EmitPutTmpHelper,			       mkIRExprVec_3(mkIRExpr_HWord(h_offset),					     mkIRExpr_HWord(lhs_name),					     mkIRExpr_HWord(counter)					     )			       );         setHelperAnns(d);         addStmtToIRSB(sb, IRStmt_Dirty(d));          break;            default:          break;     }   return;    }

void instrument_WrTmp_Const(IRStmt* st, IRSB* sb_out){    IRTemp tmp = st->Ist.WrTmp.tmp;    IRDirty* di;    di = unsafeIRDirty_0_N(0,                           "helper_instrument_WrTmp_Const",                           VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_Const),                           mkIRExprVec_1(mkIRExpr_HWord(tmp))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

static void mkCall(IRSB* sb, EventKind ev, IRStmt* stmt, IRExpr* addr){   const HChar* helperName;   void*      helperAddr;   IRExpr**   argv = NULL;   IRDirty*   di = NULL;   // Decide on helper fn to call and args to pass it.   switch (ev) {      case Event_Load:  helperName = "trace_load";                        helperAddr =  trace_load;   break;      case Event_Store: helperName = "trace_store";                        helperAddr =  trace_store;  break;      case Event_Op:    helperName = "trace_op";                        helperAddr =  trace_op;                        argv = mkIRExprVec_3( mkIRExpr_HWord( (HWord) stmt),                                              mkIRExpr_HWord( 1),                                              mkIRExpr_HWord( 2));                        di   = unsafeIRDirty_0_N(3, helperName,                                   VG_(fnptr_to_fnentry)( helperAddr ), argv );                        break;      default:         tl_assert(0);   }   if (!di || !argv) {      // Add the helper.      argv = mkIRExprVec_3(addr, mkIRExpr_HWord( 0), mkIRExpr_HWord((HWord) stmt));      di   = unsafeIRDirty_0_N( 2, helperName,                                    VG_(fnptr_to_fnentry)( helperAddr ), argv );   }   IRStmt* a = IRStmt_Dirty(di);   addStmtToIRSB( sb, a);}

/* A helper that adds the instrumentation for a detail. */static void instrument_detail(IRSB* sb, Op op, IRType type){   IRDirty* di;   IRExpr** argv;   const UInt typeIx = type2index(type);   tl_assert(op < N_OPS);   tl_assert(typeIx < N_TYPES);   argv = mkIRExprVec_1( mkIRExpr_HWord( (HWord)&detailCounts[op][typeIx] ) );   di = unsafeIRDirty_0_N( 1, "increment_detail",                              VG_(fnptr_to_fnentry)( &increment_detail ),                               argv);   addStmtToIRSB( sb, IRStmt_Dirty(di) );}

static void flushEvents(IRSB* sb){    Int        i;    Char*      helperName;    void*      helperAddr;    IRExpr**   argv;    IRDirty*   di;    Event*     ev;    for (i = 0; i < events_used; i++) {        ev = &events[i];        // Decide on helper fn to call and args to pass it.        switch (ev->ekind) {        case Event_Ir:            helperName = "trace_instr";            helperAddr =  trace_instr;            break;        case Event_Dr:            helperName = "trace_load";            helperAddr =  trace_load;            break;        case Event_Dw:            helperName = "trace_store";            helperAddr =  trace_store;            break;        case Event_Dm:            helperName = "trace_modify";            helperAddr =  trace_modify;            break;        default:            tl_assert(0);        }        // Add the helper.        argv = mkIRExprVec_2( ev->addr, mkIRExpr_HWord( ev->size ) );        di   = unsafeIRDirty_0_N( /*regparms*/2,                                              helperName, VG_(fnptr_to_fnentry)( helperAddr ),                                              argv );        addStmtToIRSB( sb, IRStmt_Dirty(di) );    }    events_used = 0;}

staticvoid addEvent_FnEntry ( IRSB* sb, char *fnname){    IRExpr**   argv;    IRDirty*   di;    char *buf = (char *)VG_(malloc)("addEvent_FnEntry",100*sizeof(char));    tl_assert(buf!=NULL);    VG_(strcpy)(buf,fnname);    argv = mkIRExprVec_1( mkIRExpr_HWord( (HWord) buf ));    di   = unsafeIRDirty_0_N( /*regparms*/1,                               "trace_fnentry", VG_(fnptr_to_fnentry)( trace_fnentry ),                              argv );    if(events_used > 0)      flushEvents(sb);    addStmtToIRSB( sb, IRStmt_Dirty(di) );}

//-----------------------------------------------------------------static void instrument_Unop(IRSB* sb, IRStmt* st, Addr64 cia) {  Char thisFct[]="instrument_Unop";  IRExpr *op = st->Ist.WrTmp.data;  IROp irop=op->Iex.Unop.op;  void* f=callbackFromIROp(irop);  if (f == NULL) return;  OA_InstrumentContext inscon=contextFor(cia, irop);  if (not_worth_watching(inscon))    return;  // filter events that can't be attached to source-code location  updateStats(inscon->op);  IRExpr* oa_event_expr = mkIRExpr_HWord( (HWord)inscon );  IRExpr * args[2];  packToI32orI64(sb, op->Iex.Unop.arg, args, irop);  IRExpr** argv = mkIRExprVec_2(args[0], oa_event_expr); IRDirty* di = unsafeIRDirty_0_N( 2, thisFct, VG_(fnptr_to_fnentry)( f ), argv);  addStmtToIRSB( sb, IRStmt_Dirty(di) );}

staticvoid addEvent_RegW ( IRSB* sb, char *fnname, Int reg_no, IRAtom* tmp_val){    IRExpr**   argv;    IRDirty*   di;    tl_assert(clo_trace_mem);    tl_assert(isIRAtom(tmp_val));    char *buf = (char *)VG_(malloc)("addEvent_RegW",100*sizeof(char));    tl_assert(buf!=NULL);    VG_(strcpy)(buf,fnname);    argv = mkIRExprVec_3( mkIRExpr_HWord( (HWord) buf ), mkIRExpr_HWord( reg_no ), tmp_val );    di   = unsafeIRDirty_0_N( /*regparms*/3,                               "trace_regw", VG_(fnptr_to_fnentry)( trace_regw ),                              argv );    if(events_used > 0)      flushEvents(sb);    addStmtToIRSB( sb, IRStmt_Dirty(di) );}

static IRSB *bcg_instrument(VgCallbackClosure* closure,	       IRSB* bb,	       VexGuestLayout* layout,	       VexGuestExtents* vge,	       IRType gWordTy,	       IRType hWordTy){	unsigned long rip = 0;	int i;	if (bb->jumpkind != Ijk_Ret &&	    bb->next->tag != Iex_Const) {		IRTemp tmp;		for (i = bb->stmts_used - 1; i >= 0; i--) {			if (bb->stmts[i]->tag == Ist_IMark) {				rip = bb->stmts[i]->Ist.IMark.addr;				break;			}		}		tl_assert(i >= 0);		if (bb->next->tag == Iex_RdTmp) {			tmp = bb->next->Iex.RdTmp.tmp;		} else {			tmp = newIRTemp(bb->tyenv, Ity_I64);			addStmtToIRSB(bb,				      IRStmt_WrTmp(tmp, bb->next));			bb->next = IRExpr_RdTmp(tmp);		}		addStmtToIRSB(bb,			      IRStmt_Dirty(				      unsafeIRDirty_0_N(					      0,					      "log_call",					      log_call,					      mkIRExprVec_3(						      IRExpr_Const(IRConst_U64(rip)),						      IRExpr_Const(IRConst_U64(bb->jumpkind == Ijk_Call)),						      bb->next))));	}	return bb;}

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));}

void instrument_WrTmp_RdTmp(IRStmt* st, IRSB* sb_out){    IRTemp tmp_lhs = st->Ist.WrTmp.tmp;    IRExpr* data = st->Ist.WrTmp.data;    IRTemp tmp_rhs = data->Iex.RdTmp.tmp;    Int size = sizeofIRType_bits(typeOfIRTemp(sb_out->tyenv, tmp_rhs));    IRDirty* di;    tl_assert(typeOfIRTemp(sb_out->tyenv, tmp_lhs) == typeOfIRTemp(sb_out->tyenv, tmp_rhs));    di = unsafeIRDirty_0_N(0,                           "helper_instrument_WrTmp_RdTmp",                           VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_RdTmp),                           mkIRExprVec_3(mkIRExpr_HWord(tmp_lhs),                                         mkIRExpr_HWord(tmp_rhs),                                         mkIRExpr_HWord(size))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void instrument_CAS_double_element(IRStmt* st, IRSB* sb_out){    IRCAS* cas = st->Ist.CAS.details;    IRTemp oldHi = cas->oldHi, oldLo = cas->oldLo;    IREndness end = cas->end;    IRExpr* addr = cas->addr;    IRExpr *expdHi = cas->expdHi, *expdLo = cas->expdLo;    IRExpr *dataHi = cas->dataHi, *dataLo = cas->dataLo;    Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, dataLo));    IROp op;    IRExpr *expr, *expr2;    IRDirty* di;    tl_assert(isIRAtom(addr));    tl_assert(end == Iend_LE); // we assume endianness is little endian    tl_assert(isIRAtom(dataLo));    tl_assert(isIRAtom(dataHi));    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_double_element");    }    expr = assignNew(sb_out, IRExpr_Binop(op, IRExpr_RdTmp(oldLo), expdLo)); // statement has to be flat    expr2 = assignNew(sb_out, IRExpr_Binop(op, IRExpr_RdTmp(oldHi), expdHi)); // statement has to be flat    di = unsafeIRDirty_0_N(0,                           "helper_instrument_CAS_double_element",                           VG_(fnptr_to_fnentry)(helper_instrument_CAS_double_element),                           mkIRExprVec_6((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((dataHi->tag == Iex_RdTmp) ? dataHi->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord(size),                                         assignNew_HWord(sb_out, expr),                                         assignNew_HWord(sb_out, expr2))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void AddLoadHelper(IRSB* sb, IRTemp lhs, IRExpr* addr){  IRDirty * d;   ULong lhs_int;  lhs_int = (HWord)lhs;  d = unsafeIRDirty_0_N(0, "EmitLoadTmp2AddrHelper", 			&EmitRdTmpTmp2TmpHelper,			mkIRExprVec_3(				      mkIRExpr_HWord(lhs_int),				      addr,				      mkIRExpr_HWord(counter)				      )			);  setHelperAnns(d);  addStmtToIRSB(sb,IRStmt_Dirty(d));   return;}

void instrument_Put(IRStmt* st, IRSB* sb_out){    Int offset = st->Ist.Put.offset;    IRExpr* data = st->Ist.Put.data;    Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, data));    IRDirty* di;    tl_assert(isIRAtom(data));    // the data transfer type is the type of data    di = unsafeIRDirty_0_N(0,                           "helper_instrument_Put",                           VG_(fnptr_to_fnentry)(helper_instrument_Put),                           mkIRExprVec_3(mkIRExpr_HWord(offset),                                         mkIRExpr_HWord((data->tag == Iex_RdTmp) ? data->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord(size))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void instrument_LLSC_Load_Linked(IRStmt* st, IRSB* sb_out){    IRTemp result = st->Ist.LLSC.result;    IRExpr* addr = st->Ist.LLSC.addr;    Int size = sizeofIRType_bits(typeOfIRTemp(sb_out->tyenv, result));    IRDirty* di;    tl_assert(isIRAtom(addr));    if (addr->tag == Iex_Const) tl_assert(addr->Iex.Const.con->tag == Ico_U32);    // the data transfer type is the type of result    di = unsafeIRDirty_0_N(0,                           "helper_instrument_LLSC_Load_Linked",                           VG_(fnptr_to_fnentry)(helper_instrument_LLSC_Load_Linked),                           mkIRExprVec_3(mkIRExpr_HWord(result),                                         (addr->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, addr) : mkIRExpr_HWord(addr->Iex.Const.con->Ico.U32),                                         mkIRExpr_HWord(size))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void instrument_WrTmp_Load(IRStmt* st, IRSB* sb_out){    IRTemp tmp = st->Ist.WrTmp.tmp;    IRExpr* data = st->Ist.WrTmp.data;    IRExpr* addr = data->Iex.Load.addr;    Int size = sizeofIRType_bits(data->Iex.Load.ty);    IRDirty* di;    tl_assert(isIRAtom(addr));    if (addr->tag == Iex_Const) tl_assert(addr->Iex.Const.con->tag == Ico_U32);    tl_assert(typeOfIRTemp(sb_out->tyenv, tmp) == data->Iex.Load.ty);    di = unsafeIRDirty_0_N(0,                           "helper_instrument_WrTmp_Load",                           VG_(fnptr_to_fnentry)(helper_instrument_WrTmp_Load),                           mkIRExprVec_3(mkIRExpr_HWord(tmp),                                         (addr->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, addr) : mkIRExpr_HWord(addr->Iex.Const.con->Ico.U32),                                         mkIRExpr_HWord(size))                           );    addStmtToIRSB(sb_out, IRStmt_Dirty(di));}

void instrument_Store(IRStmt* st, IRSB* sb_out){    IRExpr* addr = st->Ist.Store.addr;    IRExpr* data = st->Ist.Store.data;    Int size = sizeofIRType_bits(typeOfIRExpr(sb_out->tyenv, st->Ist.Store.data));    IRDirty* di;    tl_assert(isIRAtom(addr));    tl_assert(isIRAtom(data));    if (addr->tag == Iex_Const) tl_assert(addr->Iex.Const.con->tag == Ico_U32);    // the data transfer type is the type of data    di = unsafeIRDirty_0_N(0,                           "helper_instrument_Store",                           VG_(fnptr_to_fnentry)(helper_instrument_Store),                           mkIRExprVec_3((addr->tag == Iex_RdTmp) ? assignNew_HWord(sb_out, addr) : mkIRExpr_HWord(addr->Iex.Const.con->Ico.U32),                                         mkIRExpr_HWord((data->tag == Iex_RdTmp) ? data->Iex.RdTmp.tmp : IRTemp_INVALID),                                         mkIRExpr_HWord(size))                           );    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 cleanupBlockOwnership(IRSB* sbOut, IRExpr* guard){  if (VG_(sizeXA)(tempDebt) == 0){    addStoreGC(sbOut, guard, mkU64(0), &blockStateDirty);    return;  }  IRTemp* curDebtContents =    VG_(perm_malloc)(sizeof(IRTemp) * VG_(sizeXA)(tempDebt),                     vg_alignof(IRTemp));  for(int i = 0; i < VG_(sizeXA)(tempDebt); ++i){    curDebtContents[i] = *(IRTemp*)VG_(indexXA)(tempDebt, i);  }  IRDirty* dynCleanupDirty =    unsafeIRDirty_0_N(2, "dynamicCleanup",                      VG_(fnptr_to_fnentry)(dynamicCleanup),                      mkIRExprVec_2(mkU64(VG_(sizeXA)(tempDebt)),                                    mkU64((uintptr_t)curDebtContents)));  dynCleanupDirty->mFx = Ifx_Modify;  dynCleanupDirty->guard = guard;  dynCleanupDirty->mAddr = mkU64((uintptr_t)shadowTemps);  dynCleanupDirty->mSize = sizeof(ShadowTemp) * MAX_TEMPS;  addStmtToIRSB(sbOut, IRStmt_Dirty(dynCleanupDirty));}

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_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));}