From: Florian Krohm Date: Sun, 21 Sep 2014 21:53:39 +0000 (+0000) Subject: Constification part 1. X-Git-Tag: svn/VALGRIND_3_11_0^2~197 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=fb5f8ce631135f38545954cbb39a934d6c4a9847;p=thirdparty%2Fvalgrind.git Constification part 1. git-svn-id: svn://svn.valgrind.org/vex/trunk@2954 --- diff --git a/VEX/priv/ir_defs.c b/VEX/priv/ir_defs.c index 80d273c1be..dc339552e2 100644 --- a/VEX/priv/ir_defs.c +++ b/VEX/priv/ir_defs.c @@ -67,7 +67,7 @@ void ppIRType ( IRType ty ) } } -void ppIRConst ( IRConst* con ) +void ppIRConst ( const IRConst* con ) { union { ULong i64; Double f64; UInt i32; Float f32; } u; vassert(sizeof(ULong) == sizeof(Double)); @@ -91,7 +91,7 @@ void ppIRConst ( IRConst* con ) } } -void ppIRCallee ( IRCallee* ce ) +void ppIRCallee ( const IRCallee* ce ) { vex_printf("%s", ce->name); if (ce->regparms > 0) @@ -101,7 +101,7 @@ void ppIRCallee ( IRCallee* ce ) vex_printf("{%p}", (void*)ce->addr); } -void ppIRRegArray ( IRRegArray* arr ) +void ppIRRegArray ( const IRRegArray* arr ) { vex_printf("(%d:%dx", arr->base, arr->nElems); ppIRType(arr->elemTy); @@ -1248,7 +1248,7 @@ void ppIROp ( IROp op ) } } -void ppIRExpr ( IRExpr* e ) +void ppIRExpr ( const IRExpr* e ) { Int i; switch (e->tag) { @@ -1271,7 +1271,7 @@ void ppIRExpr ( IRExpr* e ) ppIRTemp(e->Iex.RdTmp.tmp); break; case Iex_Qop: { - IRQop *qop = e->Iex.Qop.details; + const IRQop *qop = e->Iex.Qop.details; ppIROp(qop->op); vex_printf( "(" ); ppIRExpr(qop->arg1); @@ -1285,7 +1285,7 @@ void ppIRExpr ( IRExpr* e ) break; } case Iex_Triop: { - IRTriop *triop = e->Iex.Triop.details; + const IRTriop *triop = e->Iex.Triop.details; ppIROp(triop->op); vex_printf( "(" ); ppIRExpr(triop->arg1); @@ -1365,7 +1365,7 @@ void ppIREffect ( IREffect fx ) } } -void ppIRDirty ( IRDirty* d ) +void ppIRDirty ( const IRDirty* d ) { Int i; if (d->tmp != IRTemp_INVALID) { @@ -1406,7 +1406,7 @@ void ppIRDirty ( IRDirty* d ) vex_printf(")"); } -void ppIRCAS ( IRCAS* cas ) +void ppIRCAS ( const IRCAS* cas ) { /* Print even structurally invalid constructions, as an aid to debugging. */ @@ -1432,7 +1432,7 @@ void ppIRCAS ( IRCAS* cas ) vex_printf(")"); } -void ppIRPutI ( IRPutI* puti ) +void ppIRPutI ( const IRPutI* puti ) { vex_printf( "PUTI" ); ppIRRegArray(puti->descr); @@ -1442,7 +1442,7 @@ void ppIRPutI ( IRPutI* puti ) ppIRExpr(puti->data); } -void ppIRStoreG ( IRStoreG* sg ) +void ppIRStoreG ( const IRStoreG* sg ) { vex_printf("if ("); ppIRExpr(sg->guard); @@ -1465,7 +1465,7 @@ void ppIRLoadGOp ( IRLoadGOp cvt ) } } -void ppIRLoadG ( IRLoadG* lg ) +void ppIRLoadG ( const IRLoadG* lg ) { ppIRTemp(lg->dst); vex_printf(" = if-strict ("); @@ -1521,7 +1521,7 @@ void ppIRMBusEvent ( IRMBusEvent event ) } } -void ppIRStmt ( IRStmt* s ) +void ppIRStmt ( const IRStmt* s ) { if (!s) { vex_printf("!!! IRStmt* which is NULL !!!"); @@ -1608,7 +1608,8 @@ void ppIRStmt ( IRStmt* s ) } } -void ppIRTypeEnv ( IRTypeEnv* env ) { +void ppIRTypeEnv ( const IRTypeEnv* env ) +{ UInt i; for (i = 0; i < env->types_used; i++) { if (i % 8 == 0) @@ -1625,7 +1626,7 @@ void ppIRTypeEnv ( IRTypeEnv* env ) { vex_printf( "\n"); } -void ppIRSB ( IRSB* bb ) +void ppIRSB ( const IRSB* bb ) { Int i; vex_printf("IRSB {\n"); @@ -2207,18 +2208,22 @@ IRExpr** shallowCopyIRExprVec ( IRExpr** vec ) /* Deep copy of an IRExpr vector */ -IRExpr** deepCopyIRExprVec ( IRExpr** vec ) +IRExpr** deepCopyIRExprVec ( IRExpr *const * vec ) { Int i; - IRExpr** newvec = shallowCopyIRExprVec( vec ); - for (i = 0; newvec[i]; i++) - newvec[i] = deepCopyIRExpr(newvec[i]); + IRExpr** newvec; + for (i = 0; vec[i]; i++) + ; + newvec = LibVEX_Alloc((i+1)*sizeof(IRExpr*)); + for (i = 0; vec[i]; i++) + newvec[i] = deepCopyIRExpr(vec[i]); + newvec[i] = NULL; return newvec; } /* Deep copy constructors for all heap-allocated IR types follow. */ -IRConst* deepCopyIRConst ( IRConst* c ) +IRConst* deepCopyIRConst ( const IRConst* c ) { switch (c->tag) { case Ico_U1: return IRConst_U1(c->Ico.U1); @@ -2236,19 +2241,19 @@ IRConst* deepCopyIRConst ( IRConst* c ) } } -IRCallee* deepCopyIRCallee ( IRCallee* ce ) +IRCallee* deepCopyIRCallee ( const IRCallee* ce ) { IRCallee* ce2 = mkIRCallee(ce->regparms, ce->name, ce->addr); ce2->mcx_mask = ce->mcx_mask; return ce2; } -IRRegArray* deepCopyIRRegArray ( IRRegArray* d ) +IRRegArray* deepCopyIRRegArray ( const IRRegArray* d ) { return mkIRRegArray(d->base, d->elemTy, d->nElems); } -IRExpr* deepCopyIRExpr ( IRExpr* e ) +IRExpr* deepCopyIRExpr ( const IRExpr* e ) { switch (e->tag) { case Iex_Get: @@ -2260,7 +2265,7 @@ IRExpr* deepCopyIRExpr ( IRExpr* e ) case Iex_RdTmp: return IRExpr_RdTmp(e->Iex.RdTmp.tmp); case Iex_Qop: { - IRQop* qop = e->Iex.Qop.details; + const IRQop* qop = e->Iex.Qop.details; return IRExpr_Qop(qop->op, deepCopyIRExpr(qop->arg1), @@ -2269,7 +2274,7 @@ IRExpr* deepCopyIRExpr ( IRExpr* e ) deepCopyIRExpr(qop->arg4)); } case Iex_Triop: { - IRTriop *triop = e->Iex.Triop.details; + const IRTriop *triop = e->Iex.Triop.details; return IRExpr_Triop(triop->op, deepCopyIRExpr(triop->arg1), @@ -2312,7 +2317,7 @@ IRExpr* deepCopyIRExpr ( IRExpr* e ) } } -IRDirty* deepCopyIRDirty ( IRDirty* d ) +IRDirty* deepCopyIRDirty ( const IRDirty* d ) { Int i; IRDirty* d2 = emptyIRDirty(); @@ -2329,7 +2334,7 @@ IRDirty* deepCopyIRDirty ( IRDirty* d ) return d2; } -IRCAS* deepCopyIRCAS ( IRCAS* cas ) +IRCAS* deepCopyIRCAS ( const IRCAS* cas ) { return mkIRCAS( cas->oldHi, cas->oldLo, cas->end, deepCopyIRExpr(cas->addr), @@ -2339,7 +2344,7 @@ IRCAS* deepCopyIRCAS ( IRCAS* cas ) deepCopyIRExpr(cas->dataLo) ); } -IRPutI* deepCopyIRPutI ( IRPutI * puti ) +IRPutI* deepCopyIRPutI ( const IRPutI * puti ) { return mkIRPutI( deepCopyIRRegArray(puti->descr), deepCopyIRExpr(puti->ix), @@ -2347,7 +2352,7 @@ IRPutI* deepCopyIRPutI ( IRPutI * puti ) deepCopyIRExpr(puti->data)); } -IRStmt* deepCopyIRStmt ( IRStmt* s ) +IRStmt* deepCopyIRStmt ( const IRStmt* s ) { switch (s->tag) { case Ist_NoOp: @@ -2373,14 +2378,14 @@ IRStmt* deepCopyIRStmt ( IRStmt* s ) deepCopyIRExpr(s->Ist.Store.addr), deepCopyIRExpr(s->Ist.Store.data)); case Ist_StoreG: { - IRStoreG* sg = s->Ist.StoreG.details; + const IRStoreG* sg = s->Ist.StoreG.details; return IRStmt_StoreG(sg->end, deepCopyIRExpr(sg->addr), deepCopyIRExpr(sg->data), deepCopyIRExpr(sg->guard)); } case Ist_LoadG: { - IRLoadG* lg = s->Ist.LoadG.details; + const IRLoadG* lg = s->Ist.LoadG.details; return IRStmt_LoadG(lg->end, lg->cvt, lg->dst, deepCopyIRExpr(lg->addr), deepCopyIRExpr(lg->alt), @@ -2409,7 +2414,7 @@ IRStmt* deepCopyIRStmt ( IRStmt* s ) } } -IRTypeEnv* deepCopyIRTypeEnv ( IRTypeEnv* src ) +IRTypeEnv* deepCopyIRTypeEnv ( const IRTypeEnv* src ) { Int i; IRTypeEnv* dst = LibVEX_Alloc(sizeof(IRTypeEnv)); @@ -2421,7 +2426,7 @@ IRTypeEnv* deepCopyIRTypeEnv ( IRTypeEnv* src ) return dst; } -IRSB* deepCopyIRSB ( IRSB* bb ) +IRSB* deepCopyIRSB ( const IRSB* bb ) { Int i; IRStmt** sts2; @@ -2434,7 +2439,7 @@ IRSB* deepCopyIRSB ( IRSB* bb ) return bb2; } -IRSB* deepCopyIRSBExceptStmts ( IRSB* bb ) +IRSB* deepCopyIRSBExceptStmts ( const IRSB* bb ) { IRSB* bb2 = emptyIRSB(); bb2->tyenv = deepCopyIRTypeEnv(bb->tyenv); @@ -3461,14 +3466,14 @@ IRTemp newIRTemp ( IRTypeEnv* env, IRType ty ) /*---------------------------------------------------------------*/ inline -IRType typeOfIRTemp ( IRTypeEnv* env, IRTemp tmp ) +IRType typeOfIRTemp ( const IRTypeEnv* env, IRTemp tmp ) { vassert(tmp >= 0); vassert(tmp < env->types_used); return env->types[tmp]; } -IRType typeOfIRConst ( IRConst* con ) +IRType typeOfIRConst ( const IRConst* con ) { switch (con->tag) { case Ico_U1: return Ity_I1; @@ -3501,7 +3506,7 @@ void typeOfIRLoadGOp ( IRLoadGOp cvt, } } -IRType typeOfIRExpr ( IRTypeEnv* tyenv, IRExpr* e ) +IRType typeOfIRExpr ( const IRTypeEnv* tyenv, const IRExpr* e ) { IRType t_dst, t_arg1, t_arg2, t_arg3, t_arg4; start: @@ -3581,7 +3586,8 @@ Bool isPlausibleIRType ( IRType ty ) } */ -static inline Bool isIRAtom_or_VECRET_or_BBPTR ( IRExpr* e ) { +static inline Bool isIRAtom_or_VECRET_or_BBPTR ( const IRExpr* e ) +{ if (isIRAtom(e)) { return True; } @@ -3589,15 +3595,12 @@ static inline Bool isIRAtom_or_VECRET_or_BBPTR ( IRExpr* e ) { return UNLIKELY(is_IRExpr_VECRET_or_BBPTR(e)); } -Bool isFlatIRStmt ( IRStmt* st ) +Bool isFlatIRStmt ( const IRStmt* st ) { Int i; - IRExpr* e; - IRDirty* di; - IRCAS* cas; - IRPutI* puti; - IRQop* qop; - IRTriop* triop; + const IRExpr* e; + const IRQop* qop; + const IRTriop* triop; switch (st->tag) { case Ist_AbiHint: @@ -3605,10 +3608,11 @@ Bool isFlatIRStmt ( IRStmt* st ) && isIRAtom(st->Ist.AbiHint.nia); case Ist_Put: return isIRAtom(st->Ist.Put.data); - case Ist_PutI: - puti = st->Ist.PutI.details; + case Ist_PutI: { + const IRPutI *puti = st->Ist.PutI.details; return toBool( isIRAtom(puti->ix) && isIRAtom(puti->data) ); + } case Ist_WrTmp: /* This is the only interesting case. The RHS can be any expression, *but* all its subexpressions *must* be @@ -3652,28 +3656,29 @@ Bool isFlatIRStmt ( IRStmt* st ) return toBool( isIRAtom(st->Ist.Store.addr) && isIRAtom(st->Ist.Store.data) ); case Ist_StoreG: { - IRStoreG* sg = st->Ist.StoreG.details; + const IRStoreG* sg = st->Ist.StoreG.details; return toBool( isIRAtom(sg->addr) && isIRAtom(sg->data) && isIRAtom(sg->guard) ); } case Ist_LoadG: { - IRLoadG* lg = st->Ist.LoadG.details; + const IRLoadG* lg = st->Ist.LoadG.details; return toBool( isIRAtom(lg->addr) && isIRAtom(lg->alt) && isIRAtom(lg->guard) ); } - case Ist_CAS: - cas = st->Ist.CAS.details; + case Ist_CAS: { + const IRCAS* cas = st->Ist.CAS.details; return toBool( isIRAtom(cas->addr) && (cas->expdHi ? isIRAtom(cas->expdHi) : True) && isIRAtom(cas->expdLo) && (cas->dataHi ? isIRAtom(cas->dataHi) : True) && isIRAtom(cas->dataLo) ); + } case Ist_LLSC: return toBool( isIRAtom(st->Ist.LLSC.addr) && (st->Ist.LLSC.storedata ? isIRAtom(st->Ist.LLSC.storedata) : True) ); - case Ist_Dirty: - di = st->Ist.Dirty.details; + case Ist_Dirty: { + const IRDirty* di = st->Ist.Dirty.details; if (!isIRAtom(di->guard)) return False; for (i = 0; di->args[i]; i++) @@ -3682,6 +3687,7 @@ Bool isFlatIRStmt ( IRStmt* st ) if (di->mAddr && !isIRAtom(di->mAddr)) return False; return True; + } case Ist_NoOp: case Ist_IMark: case Ist_MBE: @@ -3717,7 +3723,7 @@ static inline Int countArgs ( IRExpr** args ) static __attribute((noreturn)) -void sanityCheckFail ( IRSB* bb, IRStmt* stmt, const HChar* what ) +void sanityCheckFail ( const IRSB* bb, const IRStmt* stmt, const HChar* what ) { vex_printf("\nIR SANITY CHECK FAILURE\n\n"); ppIRSB(bb); @@ -3729,7 +3735,7 @@ void sanityCheckFail ( IRSB* bb, IRStmt* stmt, const HChar* what ) vpanic("sanityCheckFail: exiting due to bad IR"); } -static Bool saneIRRegArray ( IRRegArray* arr ) +static Bool saneIRRegArray ( const IRRegArray* arr ) { if (arr->base < 0 || arr->base > 10000 /* somewhat arbitrary */) return False; @@ -3740,7 +3746,7 @@ static Bool saneIRRegArray ( IRRegArray* arr ) return True; } -static Bool saneIRCallee ( IRCallee* cee ) +static Bool saneIRCallee ( const IRCallee* cee ) { if (cee->name == NULL) return False; @@ -3751,7 +3757,7 @@ static Bool saneIRCallee ( IRCallee* cee ) return True; } -static Bool saneIRConst ( IRConst* con ) +static Bool saneIRConst ( const IRConst* con ) { switch (con->tag) { case Ico_U1: @@ -3768,7 +3774,8 @@ static Bool saneIRConst ( IRConst* con ) def_count is zero. */ static -void useBeforeDef_Temp ( IRSB* bb, IRStmt* stmt, IRTemp tmp, Int* def_counts ) +void useBeforeDef_Temp ( const IRSB* bb, const IRStmt* stmt, IRTemp tmp, + Int* def_counts ) { if (tmp < 0 || tmp >= bb->tyenv->types_used) sanityCheckFail(bb,stmt, "out of range Temp in IRExpr"); @@ -3777,7 +3784,8 @@ void useBeforeDef_Temp ( IRSB* bb, IRStmt* stmt, IRTemp tmp, Int* def_counts ) } static -void useBeforeDef_Expr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts ) +void useBeforeDef_Expr ( const IRSB* bb, const IRStmt* stmt, + const IRExpr* expr, Int* def_counts ) { Int i; switch (expr->tag) { @@ -3790,7 +3798,7 @@ void useBeforeDef_Expr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts ) useBeforeDef_Temp(bb,stmt,expr->Iex.RdTmp.tmp,def_counts); break; case Iex_Qop: { - IRQop* qop = expr->Iex.Qop.details; + const IRQop* qop = expr->Iex.Qop.details; useBeforeDef_Expr(bb,stmt,qop->arg1,def_counts); useBeforeDef_Expr(bb,stmt,qop->arg2,def_counts); useBeforeDef_Expr(bb,stmt,qop->arg3,def_counts); @@ -3798,7 +3806,7 @@ void useBeforeDef_Expr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts ) break; } case Iex_Triop: { - IRTriop* triop = expr->Iex.Triop.details; + const IRTriop* triop = expr->Iex.Triop.details; useBeforeDef_Expr(bb,stmt,triop->arg1,def_counts); useBeforeDef_Expr(bb,stmt,triop->arg2,def_counts); useBeforeDef_Expr(bb,stmt,triop->arg3,def_counts); @@ -3818,7 +3826,7 @@ void useBeforeDef_Expr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts ) break; case Iex_CCall: for (i = 0; expr->Iex.CCall.args[i]; i++) { - IRExpr* arg = expr->Iex.CCall.args[i]; + const IRExpr* arg = expr->Iex.CCall.args[i]; if (UNLIKELY(is_IRExpr_VECRET_or_BBPTR(arg))) { /* These aren't allowed in CCall lists. Let's detect and throw them out here, though, rather than @@ -3840,14 +3848,14 @@ void useBeforeDef_Expr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts ) } static -void useBeforeDef_Stmt ( IRSB* bb, IRStmt* stmt, Int* def_counts ) +void useBeforeDef_Stmt ( const IRSB* bb, const IRStmt* stmt, Int* def_counts ) { Int i; - IRDirty* d; - IRCAS* cas; - IRPutI* puti; - IRLoadG* lg; - IRStoreG* sg; + const IRDirty* d; + const IRCAS* cas; + const IRPutI* puti; + const IRLoadG* lg; + const IRStoreG* sg; switch (stmt->tag) { case Ist_IMark: break; @@ -3923,11 +3931,12 @@ void useBeforeDef_Stmt ( IRSB* bb, IRStmt* stmt, Int* def_counts ) } static -void tcExpr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, IRType gWordTy ) +void tcExpr ( const IRSB* bb, const IRStmt* stmt, const IRExpr* expr, + IRType gWordTy ) { Int i; IRType t_dst, t_arg1, t_arg2, t_arg3, t_arg4; - IRTypeEnv* tyenv = bb->tyenv; + const IRTypeEnv* tyenv = bb->tyenv; switch (expr->tag) { case Iex_Get: case Iex_RdTmp: @@ -3941,7 +3950,7 @@ void tcExpr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, IRType gWordTy ) break; case Iex_Qop: { IRType ttarg1, ttarg2, ttarg3, ttarg4; - IRQop* qop = expr->Iex.Qop.details; + const IRQop* qop = expr->Iex.Qop.details; tcExpr(bb,stmt, qop->arg1, gWordTy ); tcExpr(bb,stmt, qop->arg2, gWordTy ); tcExpr(bb,stmt, qop->arg3, gWordTy ); @@ -3993,7 +4002,7 @@ void tcExpr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, IRType gWordTy ) } case Iex_Triop: { IRType ttarg1, ttarg2, ttarg3; - IRTriop *triop = expr->Iex.Triop.details; + const IRTriop *triop = expr->Iex.Triop.details; tcExpr(bb,stmt, triop->arg1, gWordTy ); tcExpr(bb,stmt, triop->arg2, gWordTy ); tcExpr(bb,stmt, triop->arg3, gWordTy ); @@ -4131,14 +4140,11 @@ void tcExpr ( IRSB* bb, IRStmt* stmt, IRExpr* expr, IRType gWordTy ) static -void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) +void tcStmt ( const IRSB* bb, const IRStmt* stmt, IRType gWordTy ) { Int i; - IRDirty* d; - IRCAS* cas; - IRPutI* puti; IRType tyExpd, tyData; - IRTypeEnv* tyenv = bb->tyenv; + const IRTypeEnv* tyenv = bb->tyenv; switch (stmt->tag) { case Ist_IMark: /* Somewhat heuristic, but rule out totally implausible @@ -4161,8 +4167,8 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) if (typeOfIRExpr(tyenv,stmt->Ist.Put.data) == Ity_I1) sanityCheckFail(bb,stmt,"IRStmt.Put.data: cannot Put :: Ity_I1"); break; - case Ist_PutI: - puti = stmt->Ist.PutI.details; + case Ist_PutI:{ + const IRPutI* puti = stmt->Ist.PutI.details; tcExpr( bb, stmt, puti->data, gWordTy ); tcExpr( bb, stmt, puti->ix, gWordTy ); if (typeOfIRExpr(tyenv,puti->data) == Ity_I1) @@ -4175,6 +4181,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) if (!saneIRRegArray(puti->descr)) sanityCheckFail(bb,stmt,"IRStmt.PutI.descr: invalid descr"); break; + } case Ist_WrTmp: tcExpr( bb, stmt, stmt->Ist.WrTmp.data, gWordTy ); if (typeOfIRTemp(tyenv, stmt->Ist.WrTmp.tmp) @@ -4195,7 +4202,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) sanityCheckFail(bb,stmt,"Ist.Store.end: bogus endianness"); break; case Ist_StoreG: { - IRStoreG* sg = stmt->Ist.StoreG.details; + const IRStoreG* sg = stmt->Ist.StoreG.details; tcExpr( bb, stmt, sg->addr, gWordTy ); tcExpr( bb, stmt, sg->data, gWordTy ); tcExpr( bb, stmt, sg->guard, gWordTy ); @@ -4210,7 +4217,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) break; } case Ist_LoadG: { - IRLoadG* lg = stmt->Ist.LoadG.details; + const IRLoadG* lg = stmt->Ist.LoadG.details; tcExpr( bb, stmt, lg->addr, gWordTy ); tcExpr( bb, stmt, lg->alt, gWordTy ); tcExpr( bb, stmt, lg->guard, gWordTy ); @@ -4227,8 +4234,8 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) sanityCheckFail(bb,stmt,"IRStmt.LoadG: dst/loaded type mismatch"); break; } - case Ist_CAS: - cas = stmt->Ist.CAS.details; + case Ist_CAS: { + const IRCAS* cas = stmt->Ist.CAS.details; /* make sure it's definitely either a CAS or a DCAS */ if (cas->oldHi == IRTemp_INVALID && cas->expdHi == NULL && cas->dataHi == NULL) { @@ -4277,6 +4284,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) bad_cas: sanityCheckFail(bb,stmt,"IRStmt.CAS: ill-formed"); break; + } case Ist_LLSC: { IRType tyRes; if (typeOfIRExpr(tyenv, stmt->Ist.LLSC.addr) != gWordTy) @@ -4303,7 +4311,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) } case Ist_Dirty: { /* Mostly check for various kinds of ill-formed dirty calls. */ - d = stmt->Ist.Dirty.details; + const IRDirty* d = stmt->Ist.Dirty.details; if (d->cee == NULL) goto bad_dirty; if (!saneIRCallee(d->cee)) goto bad_dirty; if (d->cee->regparms > countArgs(d->args)) goto bad_dirty; @@ -4345,7 +4353,7 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) for (i = 0; d->args[i] != NULL; i++) { if (i >= 32) sanityCheckFail(bb,stmt,"IRStmt.Dirty: > 32 args"); - IRExpr* arg = d->args[i]; + const IRExpr* arg = d->args[i]; if (UNLIKELY(arg->tag == Iex_VECRET)) { nVECRETs++; } else if (UNLIKELY(arg->tag == Iex_BBPTR)) { @@ -4417,11 +4425,10 @@ void tcStmt ( IRSB* bb, IRStmt* stmt, IRType gWordTy ) } } -void sanityCheckIRSB ( IRSB* bb, const HChar* caller, +void sanityCheckIRSB ( const IRSB* bb, const HChar* caller, Bool require_flat, IRType guest_word_size ) { Int i; - IRStmt* stmt; Int n_temps = bb->tyenv->types_used; Int* def_counts = LibVEX_Alloc(n_temps * sizeof(Int)); @@ -4446,6 +4453,8 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, } } + const IRStmt* stmt; + /* Check for flatness, if required. */ if (require_flat) { for (i = 0; i < bb->stmts_used; i++) { @@ -4466,9 +4475,6 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, def_counts[i] = 0; for (i = 0; i < bb->stmts_used; i++) { - IRDirty* d; - IRCAS* cas; - IRLoadG* lg; stmt = bb->stmts[i]; /* Check any temps used by this statement. */ useBeforeDef_Stmt(bb,stmt,def_counts); @@ -4484,8 +4490,8 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, sanityCheckFail(bb, stmt, "IRStmt.Tmp: destination tmp is assigned more than once"); break; - case Ist_LoadG: - lg = stmt->Ist.LoadG.details; + case Ist_LoadG: { + const IRLoadG* lg = stmt->Ist.LoadG.details; if (lg->dst < 0 || lg->dst >= n_temps) sanityCheckFail(bb, stmt, "IRStmt.LoadG: destination tmp is out of range"); @@ -4494,8 +4500,9 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, sanityCheckFail(bb, stmt, "IRStmt.LoadG: destination tmp is assigned more than once"); break; - case Ist_Dirty: - d = stmt->Ist.Dirty.details; + } + case Ist_Dirty: { + const IRDirty* d = stmt->Ist.Dirty.details; if (d->tmp != IRTemp_INVALID) { if (d->tmp < 0 || d->tmp >= n_temps) sanityCheckFail(bb, stmt, @@ -4506,8 +4513,9 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, "IRStmt.Dirty: destination tmp is assigned more than once"); } break; - case Ist_CAS: - cas = stmt->Ist.CAS.details; + } + case Ist_CAS: { + const IRCAS* cas = stmt->Ist.CAS.details; if (cas->oldHi != IRTemp_INVALID) { if (cas->oldHi < 0 || cas->oldHi >= n_temps) sanityCheckFail(bb, stmt, @@ -4525,6 +4533,7 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, sanityCheckFail(bb, stmt, "IRStmt.CAS: destination tmpLo is assigned more than once"); break; + } case Ist_LLSC: if (stmt->Ist.LLSC.result < 0 || stmt->Ist.LLSC.result >= n_temps) sanityCheckFail(bb, stmt, @@ -4549,14 +4558,13 @@ void sanityCheckIRSB ( IRSB* bb, const HChar* caller, /* because it would intersect with host_EvC_* */ if (bb->offsIP < 16) sanityCheckFail(bb, NULL, "bb->offsIP: too low"); - } /*---------------------------------------------------------------*/ /*--- Misc helper functions ---*/ /*---------------------------------------------------------------*/ -Bool eqIRConst ( IRConst* c1, IRConst* c2 ) +Bool eqIRConst ( const IRConst* c1, const IRConst* c2 ) { if (c1->tag != c2->tag) return False; @@ -4577,7 +4585,7 @@ Bool eqIRConst ( IRConst* c1, IRConst* c2 ) } } -Bool eqIRRegArray ( IRRegArray* descr1, IRRegArray* descr2 ) +Bool eqIRRegArray ( const IRRegArray* descr1, const IRRegArray* descr2 ) { return toBool( descr1->base == descr2->base && descr1->elemTy == descr2->elemTy @@ -4656,7 +4664,7 @@ IRExpr* mkIRExprCCall ( IRType retty, retty, args ); } -Bool eqIRAtom ( IRExpr* a1, IRExpr* a2 ) +Bool eqIRAtom ( const IRExpr* a1, const IRExpr* a2 ) { vassert(isIRAtom(a1)); vassert(isIRAtom(a2)); diff --git a/VEX/pub/libvex_basictypes.h b/VEX/pub/libvex_basictypes.h index f10c33fca2..8ebf5aebbd 100644 --- a/VEX/pub/libvex_basictypes.h +++ b/VEX/pub/libvex_basictypes.h @@ -218,14 +218,14 @@ typedef unsigned long HWord; #if VEX_HOST_WORDSIZE == 8 - static inline ULong Ptr_to_ULong ( void* p ) { + static inline ULong Ptr_to_ULong ( const void* p ) { return (ULong)p; } static inline void* ULong_to_Ptr ( ULong n ) { return (void*)n; } #elif VEX_HOST_WORDSIZE == 4 - static inline ULong Ptr_to_ULong ( void* p ) { + static inline ULong Ptr_to_ULong ( const void* p ) { UInt w = (UInt)p; return (ULong)w; } diff --git a/VEX/pub/libvex_ir.h b/VEX/pub/libvex_ir.h index a561278006..82771768a6 100644 --- a/VEX/pub/libvex_ir.h +++ b/VEX/pub/libvex_ir.h @@ -320,13 +320,13 @@ extern IRConst* IRConst_V128 ( UShort ); extern IRConst* IRConst_V256 ( UInt ); /* Deep-copy an IRConst */ -extern IRConst* deepCopyIRConst ( IRConst* ); +extern IRConst* deepCopyIRConst ( const IRConst* ); /* Pretty-print an IRConst */ -extern void ppIRConst ( IRConst* ); +extern void ppIRConst ( const IRConst* ); /* Compare two IRConsts for equality */ -extern Bool eqIRConst ( IRConst*, IRConst* ); +extern Bool eqIRConst ( const IRConst*, const IRConst* ); /* ------------------ Call targets ------------------ */ @@ -359,10 +359,10 @@ typedef extern IRCallee* mkIRCallee ( Int regparms, const HChar* name, void* addr ); /* Deep-copy an IRCallee. */ -extern IRCallee* deepCopyIRCallee ( IRCallee* ); +extern IRCallee* deepCopyIRCallee ( const IRCallee* ); /* Pretty-print an IRCallee. */ -extern void ppIRCallee ( IRCallee* ); +extern void ppIRCallee ( const IRCallee* ); /* ------------------ Guest state arrays ------------------ */ @@ -380,10 +380,10 @@ typedef extern IRRegArray* mkIRRegArray ( Int, IRType, Int ); -extern IRRegArray* deepCopyIRRegArray ( IRRegArray* ); +extern IRRegArray* deepCopyIRRegArray ( const IRRegArray* ); -extern void ppIRRegArray ( IRRegArray* ); -extern Bool eqIRRegArray ( IRRegArray*, IRRegArray* ); +extern void ppIRRegArray ( const IRRegArray* ); +extern Bool eqIRRegArray ( const IRRegArray*, const IRRegArray* ); /* ------------------ Temporaries ------------------ */ @@ -2124,7 +2124,7 @@ struct _IRQop { only appear at most once in an argument list, and it may not appear at all in argument lists for clean helper calls. */ -static inline Bool is_IRExpr_VECRET_or_BBPTR ( IRExpr* e ) { +static inline Bool is_IRExpr_VECRET_or_BBPTR ( const IRExpr* e ) { return e->tag == Iex_VECRET || e->tag == Iex_BBPTR; } @@ -2148,10 +2148,10 @@ extern IRExpr* IRExpr_VECRET ( void ); extern IRExpr* IRExpr_BBPTR ( void ); /* Deep-copy an IRExpr. */ -extern IRExpr* deepCopyIRExpr ( IRExpr* ); +extern IRExpr* deepCopyIRExpr ( const IRExpr* ); /* Pretty-print an IRExpr. */ -extern void ppIRExpr ( IRExpr* ); +extern void ppIRExpr ( const IRExpr* ); /* NULL-terminated IRExpr vector constructors, suitable for use as arg lists in clean/dirty helper calls. */ @@ -2174,7 +2174,7 @@ extern IRExpr** mkIRExprVec_8 ( IRExpr*, IRExpr*, IRExpr*, IRExpr*, elements with the original). - deepCopy: deep-copy (ie. create a completely new vector). */ extern IRExpr** shallowCopyIRExprVec ( IRExpr** ); -extern IRExpr** deepCopyIRExprVec ( IRExpr** ); +extern IRExpr** deepCopyIRExprVec ( IRExpr *const * ); /* Make a constant expression from the given host word taking into account (of course) the host word size. */ @@ -2189,13 +2189,13 @@ IRExpr* mkIRExprCCall ( IRType retty, /* Convenience functions for atoms (IRExprs which are either Iex_Tmp or * Iex_Const). */ -static inline Bool isIRAtom ( IRExpr* e ) { +static inline Bool isIRAtom ( const IRExpr* e ) { return toBool(e->tag == Iex_RdTmp || e->tag == Iex_Const); } /* Are these two IR atoms identical? Causes an assertion failure if they are passed non-atoms. */ -extern Bool eqIRAtom ( IRExpr*, IRExpr* ); +extern Bool eqIRAtom ( const IRExpr*, const IRExpr* ); /* ------------------ Jump kinds ------------------ */ @@ -2374,13 +2374,13 @@ typedef IRDirty; /* Pretty-print a dirty call */ -extern void ppIRDirty ( IRDirty* ); +extern void ppIRDirty ( const IRDirty* ); /* Allocate an uninitialised dirty call */ extern IRDirty* emptyIRDirty ( void ); /* Deep-copy a dirty call */ -extern IRDirty* deepCopyIRDirty ( IRDirty* ); +extern IRDirty* deepCopyIRDirty ( const IRDirty* ); /* A handy function which takes some of the tedium out of constructing dirty helper calls. The called function impliedly does not return @@ -2493,14 +2493,14 @@ typedef } IRCAS; -extern void ppIRCAS ( IRCAS* cas ); +extern void ppIRCAS ( const IRCAS* cas ); extern IRCAS* mkIRCAS ( IRTemp oldHi, IRTemp oldLo, IREndness end, IRExpr* addr, IRExpr* expdHi, IRExpr* expdLo, IRExpr* dataHi, IRExpr* dataLo ); -extern IRCAS* deepCopyIRCAS ( IRCAS* ); +extern IRCAS* deepCopyIRCAS ( const IRCAS* ); /* ------------------ Circular Array Put ------------------ */ @@ -2513,12 +2513,12 @@ typedef IRExpr* data; /* The value to write */ } IRPutI; -extern void ppIRPutI ( IRPutI* puti ); +extern void ppIRPutI ( const IRPutI* puti ); extern IRPutI* mkIRPutI ( IRRegArray* descr, IRExpr* ix, Int bias, IRExpr* data ); -extern IRPutI* deepCopyIRPutI ( IRPutI* ); +extern IRPutI* deepCopyIRPutI ( const IRPutI* ); /* --------------- Guarded loads and stores --------------- */ @@ -2585,11 +2585,11 @@ typedef } IRLoadG; -extern void ppIRStoreG ( IRStoreG* sg ); +extern void ppIRStoreG ( const IRStoreG* sg ); extern void ppIRLoadGOp ( IRLoadGOp cvt ); -extern void ppIRLoadG ( IRLoadG* lg ); +extern void ppIRLoadG ( const IRLoadG* lg ); extern IRStoreG* mkIRStoreG ( IREndness end, IRExpr* addr, IRExpr* data, @@ -2893,10 +2893,10 @@ extern IRStmt* IRStmt_Exit ( IRExpr* guard, IRJumpKind jk, IRConst* dst, Int offsIP ); /* Deep-copy an IRStmt. */ -extern IRStmt* deepCopyIRStmt ( IRStmt* ); +extern IRStmt* deepCopyIRStmt ( const IRStmt* ); /* Pretty-print an IRStmt. */ -extern void ppIRStmt ( IRStmt* ); +extern void ppIRStmt ( const IRStmt* ); /* ------------------ Basic Blocks ------------------ */ @@ -2919,10 +2919,10 @@ typedef extern IRTemp newIRTemp ( IRTypeEnv*, IRType ); /* Deep-copy a type environment */ -extern IRTypeEnv* deepCopyIRTypeEnv ( IRTypeEnv* ); +extern IRTypeEnv* deepCopyIRTypeEnv ( const IRTypeEnv* ); /* Pretty-print a type environment */ -extern void ppIRTypeEnv ( IRTypeEnv* ); +extern void ppIRTypeEnv ( const IRTypeEnv* ); /* Code blocks, which in proper compiler terminology are superblocks @@ -2956,14 +2956,14 @@ typedef extern IRSB* emptyIRSB ( void ); /* Deep-copy an IRSB */ -extern IRSB* deepCopyIRSB ( IRSB* ); +extern IRSB* deepCopyIRSB ( const IRSB* ); /* Deep-copy an IRSB, except for the statements list, which set to be a new, empty, list of statements. */ -extern IRSB* deepCopyIRSBExceptStmts ( IRSB* ); +extern IRSB* deepCopyIRSBExceptStmts ( const IRSB* ); /* Pretty-print an IRSB */ -extern void ppIRSB ( IRSB* ); +extern void ppIRSB ( const IRSB* ); /* Append an IRStmt to an IRSB */ extern void addStmtToIRSB ( IRSB*, IRStmt* ); @@ -2977,9 +2977,9 @@ extern void addStmtToIRSB ( IRSB*, IRStmt* ); extern IRTypeEnv* emptyIRTypeEnv ( void ); /* What is the type of this expression? */ -extern IRType typeOfIRConst ( IRConst* ); -extern IRType typeOfIRTemp ( IRTypeEnv*, IRTemp ); -extern IRType typeOfIRExpr ( IRTypeEnv*, IRExpr* ); +extern IRType typeOfIRConst ( const IRConst* ); +extern IRType typeOfIRTemp ( const IRTypeEnv*, IRTemp ); +extern IRType typeOfIRExpr ( const IRTypeEnv*, const IRExpr* ); /* What are the arg and result type for this IRLoadGOp? */ extern void typeOfIRLoadGOp ( IRLoadGOp cvt, @@ -2987,11 +2987,11 @@ extern void typeOfIRLoadGOp ( IRLoadGOp cvt, /*OUT*/IRType* t_arg ); /* Sanity check a BB of IR */ -extern void sanityCheckIRSB ( IRSB* bb, +extern void sanityCheckIRSB ( const IRSB* bb, const HChar* caller, Bool require_flatness, IRType guest_word_size ); -extern Bool isFlatIRStmt ( IRStmt* ); +extern Bool isFlatIRStmt ( const IRStmt* ); /* Is this any value actually in the enumeration 'IRType' ? */ extern Bool isPlausibleIRType ( IRType ty );