const IRExpr arguments for matchIRExpr()

Fixes BZ#373938

Gist of the changes is really just:
- Bool matchIRExpr ( MatchInfo* mi, IRExpr* p, IRExpr* e );
+ Bool matchIRExpr ( MatchInfo* mi, const IRExpr* p, const IRExpr* e );

git-svn-id: svn://svn.valgrind.org/vex/trunk@3288

diff --git a/VEX/priv/host_amd64_isel.c b/VEX/priv/host_amd64_isel.c
index 262c7f8bb3ee498148780f2a0a6ed9127201ce98..2d5fb42e762bd79fef4fa2117787871f10576e5d 100644 (file)
--- a/VEX/priv/host_amd64_isel.c
+++ b/VEX/priv/host_amd64_isel.c
@@ -216,42 +216,42 @@ static HReg newVRegV ( ISelEnv* env )
    checks that all returned registers are virtual.  You should not
    call the _wrk version directly.
 */
-static AMD64RMI*     iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e );
-static AMD64RMI*     iselIntExpr_RMI     ( ISelEnv* env, IRExpr* e );
+static AMD64RMI*     iselIntExpr_RMI_wrk ( ISelEnv* env, const IRExpr* e );
+static AMD64RMI*     iselIntExpr_RMI     ( ISelEnv* env, const IRExpr* e );
 
-static AMD64RI*      iselIntExpr_RI_wrk  ( ISelEnv* env, IRExpr* e );
-static AMD64RI*      iselIntExpr_RI      ( ISelEnv* env, IRExpr* e );
+static AMD64RI*      iselIntExpr_RI_wrk  ( ISelEnv* env, const IRExpr* e );
+static AMD64RI*      iselIntExpr_RI      ( ISelEnv* env, const IRExpr* e );
 
-static AMD64RM*      iselIntExpr_RM_wrk  ( ISelEnv* env, IRExpr* e );
-static AMD64RM*      iselIntExpr_RM      ( ISelEnv* env, IRExpr* e );
+static AMD64RM*      iselIntExpr_RM_wrk  ( ISelEnv* env, const IRExpr* e );
+static AMD64RM*      iselIntExpr_RM      ( ISelEnv* env, const IRExpr* e );
 
-static HReg          iselIntExpr_R_wrk   ( ISelEnv* env, IRExpr* e );
-static HReg          iselIntExpr_R       ( ISelEnv* env, IRExpr* e );
+static HReg          iselIntExpr_R_wrk   ( ISelEnv* env, const IRExpr* e );
+static HReg          iselIntExpr_R       ( ISelEnv* env, const IRExpr* e );
 
-static AMD64AMode*   iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e );
-static AMD64AMode*   iselIntExpr_AMode     ( ISelEnv* env, IRExpr* e );
+static AMD64AMode*   iselIntExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e );
+static AMD64AMode*   iselIntExpr_AMode     ( ISelEnv* env, const IRExpr* e );
 
 static void          iselInt128Expr_wrk ( /*OUT*/HReg* rHi, HReg* rLo, 
-                                          ISelEnv* env, IRExpr* e );
+                                          ISelEnv* env, const IRExpr* e );
 static void          iselInt128Expr     ( /*OUT*/HReg* rHi, HReg* rLo, 
-                                          ISelEnv* env, IRExpr* e );
+                                          ISelEnv* env, const IRExpr* e );
 
-static AMD64CondCode iselCondCode_wrk    ( ISelEnv* env, IRExpr* e );
-static AMD64CondCode iselCondCode        ( ISelEnv* env, IRExpr* e );
+static AMD64CondCode iselCondCode_wrk    ( ISelEnv* env, const IRExpr* e );
+static AMD64CondCode iselCondCode        ( ISelEnv* env, const IRExpr* e );
 
-static HReg          iselDblExpr_wrk     ( ISelEnv* env, IRExpr* e );
-static HReg          iselDblExpr         ( ISelEnv* env, IRExpr* e );
+static HReg          iselDblExpr_wrk     ( ISelEnv* env, const IRExpr* e );
+static HReg          iselDblExpr         ( ISelEnv* env, const IRExpr* e );
 
-static HReg          iselFltExpr_wrk     ( ISelEnv* env, IRExpr* e );
-static HReg          iselFltExpr         ( ISelEnv* env, IRExpr* e );
+static HReg          iselFltExpr_wrk     ( ISelEnv* env, const IRExpr* e );
+static HReg          iselFltExpr         ( ISelEnv* env, const IRExpr* e );
 
-static HReg          iselVecExpr_wrk     ( ISelEnv* env, IRExpr* e );
-static HReg          iselVecExpr         ( ISelEnv* env, IRExpr* e );
+static HReg          iselVecExpr_wrk     ( ISelEnv* env, const IRExpr* e );
+static HReg          iselVecExpr         ( ISelEnv* env, const IRExpr* e );
 
 static void          iselDVecExpr_wrk ( /*OUT*/HReg* rHi, HReg* rLo, 
-                                        ISelEnv* env, IRExpr* e );
+                                        ISelEnv* env, const IRExpr* e );
 static void          iselDVecExpr     ( /*OUT*/HReg* rHi, HReg* rLo, 
-                                        ISelEnv* env, IRExpr* e );
+                                        ISelEnv* env, const IRExpr* e );
 
 
 /*---------------------------------------------------------*/
@@ -896,7 +896,7 @@ static ULong bitmask8_to_bytemask64 ( UShort w8 )
    mask or sign extend partial values if necessary.
 */
 
-static HReg iselIntExpr_R ( ISelEnv* env, IRExpr* e )
+static HReg iselIntExpr_R ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselIntExpr_R_wrk(env, e);
    /* sanity checks ... */
@@ -909,7 +909,7 @@ static HReg iselIntExpr_R ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselIntExpr_R_wrk ( ISelEnv* env, const IRExpr* e )
 {
    /* Used for unary/binary SIMD64 ops. */
    HWord fn = 0;
@@ -1379,7 +1379,7 @@ static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
          DEFINE_PATTERN( p_1Uto8_64to1,
                          unop(Iop_1Uto8, unop(Iop_64to1, bind(0))) );
          if (matchIRExpr(&mi,p_1Uto8_64to1,e)) {
-            IRExpr* expr64 = mi.bindee[0];
+            const IRExpr* expr64 = mi.bindee[0];
             HReg    dst    = newVRegI(env);
             HReg    src    = iselIntExpr_R(env, expr64);
             addInstr(env, mk_iMOVsd_RR(src,dst) );
@@ -1934,7 +1934,7 @@ static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
    result.  The expression may only be a 32-bit one.
 */
 
-static AMD64AMode* iselIntExpr_AMode ( ISelEnv* env, IRExpr* e )
+static AMD64AMode* iselIntExpr_AMode ( ISelEnv* env, const IRExpr* e )
 {
    AMD64AMode* am = iselIntExpr_AMode_wrk(env, e);
    vassert(sane_AMode(am));
@@ -1942,7 +1942,7 @@ static AMD64AMode* iselIntExpr_AMode ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static AMD64AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e )
+static AMD64AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e )
 {
    MatchInfo mi;
    DECLARE_PATTERN(p_complex);
@@ -1961,10 +1961,10 @@ static AMD64AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e )
            )
    );
    if (matchIRExpr(&mi, p_complex, e)) {
-      IRExpr* expr1  = mi.bindee[0];
-      IRExpr* expr2  = mi.bindee[1];
-      IRExpr* imm8   = mi.bindee[2];
-      IRExpr* simm32 = mi.bindee[3];
+      const IRExpr* expr1  = mi.bindee[0];
+      const IRExpr* expr2  = mi.bindee[1];
+      const IRExpr* imm8   = mi.bindee[2];
+      const IRExpr* simm32 = mi.bindee[3];
       if (imm8->tag == Iex_Const 
           && imm8->Iex.Const.con->tag == Ico_U8
           && imm8->Iex.Const.con->Ico.U8 < 4
@@ -2023,7 +2023,7 @@ static AMD64AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e )
 /* Similarly, calculate an expression into an X86RMI operand.  As with
    iselIntExpr_R, the expression can have type 32, 16 or 8 bits.  */
 
-static AMD64RMI* iselIntExpr_RMI ( ISelEnv* env, IRExpr* e )
+static AMD64RMI* iselIntExpr_RMI ( ISelEnv* env, const IRExpr* e )
 {
    AMD64RMI* rmi = iselIntExpr_RMI_wrk(env, e);
    /* sanity checks ... */
@@ -2043,7 +2043,7 @@ static AMD64RMI* iselIntExpr_RMI ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static AMD64RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e )
+static AMD64RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I64 || ty == Ity_I32 
@@ -2095,7 +2095,7 @@ static AMD64RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e )
    iselIntExpr_R, the expression can have type 64, 32, 16 or 8
    bits. */
 
-static AMD64RI* iselIntExpr_RI ( ISelEnv* env, IRExpr* e )
+static AMD64RI* iselIntExpr_RI ( ISelEnv* env, const IRExpr* e )
 {
    AMD64RI* ri = iselIntExpr_RI_wrk(env, e);
    /* sanity checks ... */
@@ -2112,7 +2112,7 @@ static AMD64RI* iselIntExpr_RI ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static AMD64RI* iselIntExpr_RI_wrk ( ISelEnv* env, IRExpr* e )
+static AMD64RI* iselIntExpr_RI_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I64 || ty == Ity_I32 
@@ -2151,7 +2151,7 @@ static AMD64RI* iselIntExpr_RI_wrk ( ISelEnv* env, IRExpr* e )
    with iselIntExpr_R, the expression can have type 64, 32, 16 or 8
    bits.  */
 
-static AMD64RM* iselIntExpr_RM ( ISelEnv* env, IRExpr* e )
+static AMD64RM* iselIntExpr_RM ( ISelEnv* env, const IRExpr* e )
 {
    AMD64RM* rm = iselIntExpr_RM_wrk(env, e);
    /* sanity checks ... */
@@ -2169,7 +2169,7 @@ static AMD64RM* iselIntExpr_RM ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static AMD64RM* iselIntExpr_RM_wrk ( ISelEnv* env, IRExpr* e )
+static AMD64RM* iselIntExpr_RM_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I64 || ty == Ity_I32 || ty == Ity_I16 || ty == Ity_I8);
@@ -2196,14 +2196,14 @@ static AMD64RM* iselIntExpr_RM_wrk ( ISelEnv* env, IRExpr* e )
    condition code which would correspond when the expression would
    notionally have returned 1. */
 
-static AMD64CondCode iselCondCode ( ISelEnv* env, IRExpr* e )
+static AMD64CondCode iselCondCode ( ISelEnv* env, const IRExpr* e )
 {
    /* Uh, there's nothing we can sanity check here, unfortunately. */
    return iselCondCode_wrk(env,e);
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static AMD64CondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e )
+static AMD64CondCode iselCondCode_wrk ( ISelEnv* env, const IRExpr* e )
 {
    MatchInfo mi;
 
@@ -2457,7 +2457,7 @@ static AMD64CondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e )
    by subsequent code emitted by the caller.  */
 
 static void iselInt128Expr ( HReg* rHi, HReg* rLo, 
-                             ISelEnv* env, IRExpr* e )
+                             ISelEnv* env, const IRExpr* e )
 {
    iselInt128Expr_wrk(rHi, rLo, env, e);
 #  if 0
@@ -2471,7 +2471,7 @@ static void iselInt128Expr ( HReg* rHi, HReg* rLo,
 
 /* DO NOT CALL THIS DIRECTLY ! */
 static void iselInt128Expr_wrk ( HReg* rHi, HReg* rLo, 
-                                 ISelEnv* env, IRExpr* e )
+                                 ISelEnv* env, const IRExpr* e )
 {
    vassert(e);
    vassert(typeOfIRExpr(env->type_env,e) == Ity_I128);
@@ -2550,7 +2550,7 @@ static void iselInt128Expr_wrk ( HReg* rHi, HReg* rLo,
 /* Nothing interesting here; really just wrappers for
    64-bit stuff. */
 
-static HReg iselFltExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselFltExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselFltExpr_wrk( env, e );
 #  if 0
@@ -2562,7 +2562,7 @@ static HReg iselFltExpr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselFltExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_F32);
@@ -2737,7 +2737,7 @@ static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e )
     positive zero         0           0             .000000---0
 */
 
-static HReg iselDblExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselDblExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselDblExpr_wrk( env, e );
 #  if 0
@@ -2749,7 +2749,7 @@ static HReg iselDblExpr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselDblExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(e);
@@ -3104,7 +3104,7 @@ static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e )
 /*--- ISEL: SIMD (Vector) expressions, 128 bit.         ---*/
 /*---------------------------------------------------------*/
 
-static HReg iselVecExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselVecExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselVecExpr_wrk( env, e );
 #  if 0
@@ -3117,7 +3117,7 @@ static HReg iselVecExpr ( ISelEnv* env, IRExpr* e )
 
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselVecExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselVecExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    HWord      fn = 0; /* address of helper fn, if required */
    Bool       arg1isEReg = False;
@@ -3719,7 +3719,7 @@ static HReg iselVecExpr_wrk ( ISelEnv* env, IRExpr* e )
 /*---------------------------------------------------------*/
 
 static void iselDVecExpr ( /*OUT*/HReg* rHi, /*OUT*/HReg* rLo, 
-                           ISelEnv* env, IRExpr* e )
+                           ISelEnv* env, const IRExpr* e )
 {
    iselDVecExpr_wrk( rHi, rLo, env, e );
 #  if 0
@@ -3734,7 +3734,7 @@ static void iselDVecExpr ( /*OUT*/HReg* rHi, /*OUT*/HReg* rLo,
 
 /* DO NOT CALL THIS DIRECTLY */
 static void iselDVecExpr_wrk ( /*OUT*/HReg* rHi, /*OUT*/HReg* rLo, 
-                               ISelEnv* env, IRExpr* e )
+                               ISelEnv* env, const IRExpr* e )
 {
    HWord fn = 0; /* address of helper fn, if required */
    vassert(e);

diff --git a/VEX/priv/host_arm_isel.c b/VEX/priv/host_arm_isel.c
index 8385e7b5b6b192854c6848ba9fce77176eaca233..3b093701a4942f17294e1f0d73ea0856e18ad47f 100644 (file)
--- a/VEX/priv/host_arm_isel.c
+++ b/VEX/priv/host_arm_isel.c
@@ -233,9 +233,9 @@ static HReg        iselIntExpr_R_wrk      ( ISelEnv* env, IRExpr* e );
 static HReg        iselIntExpr_R          ( ISelEnv* env, IRExpr* e );
 
 static void        iselInt64Expr_wrk      ( HReg* rHi, HReg* rLo, 
-                                            ISelEnv* env, IRExpr* e );
+                                            ISelEnv* env, const IRExpr* e );
 static void        iselInt64Expr          ( HReg* rHi, HReg* rLo, 
-                                            ISelEnv* env, IRExpr* e );
+                                            ISelEnv* env, const IRExpr* e );
 
 static HReg        iselDblExpr_wrk        ( ISelEnv* env, IRExpr* e );
 static HReg        iselDblExpr            ( ISelEnv* env, IRExpr* e );
@@ -243,11 +243,11 @@ static HReg        iselDblExpr            ( ISelEnv* env, IRExpr* e );
 static HReg        iselFltExpr_wrk        ( ISelEnv* env, IRExpr* e );
 static HReg        iselFltExpr            ( ISelEnv* env, IRExpr* e );
 
-static HReg        iselNeon64Expr_wrk     ( ISelEnv* env, IRExpr* e );
-static HReg        iselNeon64Expr         ( ISelEnv* env, IRExpr* e );
+static HReg        iselNeon64Expr_wrk     ( ISelEnv* env, const IRExpr* e );
+static HReg        iselNeon64Expr         ( ISelEnv* env, const IRExpr* e );
 
-static HReg        iselNeonExpr_wrk       ( ISelEnv* env, IRExpr* e );
-static HReg        iselNeonExpr           ( ISelEnv* env, IRExpr* e );
+static HReg        iselNeonExpr_wrk       ( ISelEnv* env, const IRExpr* e );
+static HReg        iselNeonExpr           ( ISelEnv* env, const IRExpr* e );
 
 /*---------------------------------------------------------*/
 /*--- ISEL: Misc helpers                                ---*/
@@ -1655,7 +1655,7 @@ static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
 //zz         DEFINE_PATTERN(p_32to1_then_1Uto8,
 //zz                        unop(Iop_1Uto8,unop(Iop_32to1,bind(0))));
 //zz         if (matchIRExpr(&mi,p_32to1_then_1Uto8,e)) {
-//zz            IRExpr* expr32 = mi.bindee[0];
+//zz            const IRExpr* expr32 = mi.bindee[0];
 //zz            HReg dst = newVRegI(env);
 //zz            HReg src = iselIntExpr_R(env, expr32);
 //zz            addInstr(env, mk_iMOVsd_RR(src,dst) );
@@ -2053,7 +2053,8 @@ static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
    either real or virtual regs; in any case they must not be changed
    by subsequent code emitted by the caller.  */
 
-static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
+static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                            const IRExpr* e )
 {
    iselInt64Expr_wrk(rHi, rLo, env, e);
 #  if 0
@@ -2066,7 +2067,8 @@ static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
+static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                                const IRExpr* e )
 {
    vassert(e);
    vassert(typeOfIRExpr(env->type_env,e) == Ity_I64);
@@ -2317,7 +2319,7 @@ static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
 /*--- ISEL: Vector (NEON) expressions (64 or 128 bit)   ---*/
 /*---------------------------------------------------------*/
 
-static HReg iselNeon64Expr ( ISelEnv* env, IRExpr* e )
+static HReg iselNeon64Expr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r;
    vassert(env->hwcaps & VEX_HWCAPS_ARM_NEON);
@@ -2328,7 +2330,7 @@ static HReg iselNeon64Expr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselNeon64Expr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselNeon64Expr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env, e);
    MatchInfo mi;
@@ -3938,7 +3940,7 @@ static HReg iselNeon64Expr_wrk ( ISelEnv* env, IRExpr* e )
 }
 
 
-static HReg iselNeonExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselNeonExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r;
    vassert(env->hwcaps & VEX_HWCAPS_ARM_NEON);
@@ -3949,7 +3951,7 @@ static HReg iselNeonExpr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselNeonExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselNeonExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env, e);
    MatchInfo mi;

diff --git a/VEX/priv/host_ppc_isel.c b/VEX/priv/host_ppc_isel.c
index aa35febafa23a259eed446677186758d7d3c5efa..d43030a841d39145ee3e3f2928a6396ca02647ae 100644 (file)
--- a/VEX/priv/host_ppc_isel.c
+++ b/VEX/priv/host_ppc_isel.c
@@ -379,9 +379,9 @@ static HReg newVRegV ( ISelEnv* env )
 */
 /* 32-bit mode: compute an I8/I16/I32 into a GPR.
    64-bit mode: compute an I8/I16/I32/I64 into a GPR. */
-static HReg          iselWordExpr_R_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselWordExpr_R_wrk ( ISelEnv* env, const IRExpr* e,
                                           IREndness IEndianess );
-static HReg          iselWordExpr_R     ( ISelEnv* env, IRExpr* e,
+static HReg          iselWordExpr_R     ( ISelEnv* env, const IRExpr* e,
                                           IREndness IEndianess );
 
 /* 32-bit mode: Compute an I8/I16/I32 into a RH
@@ -394,33 +394,33 @@ static HReg          iselWordExpr_R     ( ISelEnv* env, IRExpr* e,
    return can have their sign inverted if need be. 
 */
 static PPCRH*        iselWordExpr_RH_wrk ( ISelEnv* env, 
-                                           Bool syned, IRExpr* e,
+                                           Bool syned, const IRExpr* e,
                                            IREndness IEndianess );
 static PPCRH*        iselWordExpr_RH     ( ISelEnv* env, 
-                                           Bool syned, IRExpr* e,
+                                           Bool syned, const IRExpr* e,
                                            IREndness IEndianess );
 
 /* 32-bit mode: compute an I32 into a RI (reg or 32-bit immediate).
    64-bit mode: compute an I64 into a RI (reg or 64-bit immediate). */
-static PPCRI*        iselWordExpr_RI_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRI*        iselWordExpr_RI_wrk ( ISelEnv* env, const IRExpr* e,
                                            IREndness IEndianess );
-static PPCRI*        iselWordExpr_RI     ( ISelEnv* env, IRExpr* e,
+static PPCRI*        iselWordExpr_RI     ( ISelEnv* env, const IRExpr* e,
                                            IREndness IEndianess );
 
 /* In 32 bit mode ONLY, compute an I8 into a
    reg-or-5-bit-unsigned-immediate, the latter being an immediate in
    the range 1 .. 31 inclusive.  Used for doing shift amounts. */
-static PPCRH*        iselWordExpr_RH5u_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRH*        iselWordExpr_RH5u_wrk ( ISelEnv* env, const IRExpr* e,
                                              IREndness IEndianess );
-static PPCRH*        iselWordExpr_RH5u     ( ISelEnv* env, IRExpr* e,
+static PPCRH*        iselWordExpr_RH5u     ( ISelEnv* env, const IRExpr* e,
                                              IREndness IEndianess );
 
 /* In 64-bit mode ONLY, compute an I8 into a
    reg-or-6-bit-unsigned-immediate, the latter being an immediate in
    the range 1 .. 63 inclusive.  Used for doing shift amounts. */
-static PPCRH*        iselWordExpr_RH6u_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRH*        iselWordExpr_RH6u_wrk ( ISelEnv* env, const IRExpr* e,
                                              IREndness IEndianess );
-static PPCRH*        iselWordExpr_RH6u     ( ISelEnv* env, IRExpr* e,
+static PPCRH*        iselWordExpr_RH6u     ( ISelEnv* env, const IRExpr* e,
                                              IREndness IEndianess );
 
 /* 32-bit mode: compute an I32 into an AMode.
@@ -434,77 +434,79 @@ static PPCRH*        iselWordExpr_RH6u     ( ISelEnv* env, IRExpr* e,
 
    Since there are no such restrictions on 32-bit insns, xferTy is
    ignored for 32-bit code generation. */
-static PPCAMode*     iselWordExpr_AMode_wrk ( ISelEnv* env, IRExpr* e,
+static PPCAMode*     iselWordExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e,
                                               IRType xferTy,
                                               IREndness IEndianess );
-static PPCAMode*     iselWordExpr_AMode     ( ISelEnv* env, IRExpr* e,
+static PPCAMode*     iselWordExpr_AMode     ( ISelEnv* env, const IRExpr* e,
                                               IRType xferTy,
                                               IREndness IEndianess );
 
 static void iselInt128Expr_to_32x4_wrk ( HReg* rHi, HReg* rMedHi,
                                          HReg* rMedLo, HReg* rLo,
-                                         ISelEnv* env, IRExpr* e,
+                                         ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
 static void iselInt128Expr_to_32x4     ( HReg* rHi, HReg* rMedHi,
                                          HReg* rMedLo, HReg* rLo,
-                                         ISelEnv* env, IRExpr* e,
+                                         ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
 
 
 /* 32-bit mode ONLY: compute an I64 into a GPR pair. */
 static void          iselInt64Expr_wrk ( HReg* rHi, HReg* rLo,
-                                         ISelEnv* env, IRExpr* e,
+                                         ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
 static void          iselInt64Expr     ( HReg* rHi, HReg* rLo,
-                                         ISelEnv* env, IRExpr* e,
+                                         ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
 
 /* 64-bit mode ONLY: compute an I128 into a GPR64 pair. */
 static void          iselInt128Expr_wrk ( HReg* rHi, HReg* rLo, 
-                                          ISelEnv* env, IRExpr* e,
+                                          ISelEnv* env, const IRExpr* e,
                                           IREndness IEndianess );
 
 static void          iselInt128Expr     ( HReg* rHi, HReg* rLo, 
-                                          ISelEnv* env, IRExpr* e,
+                                          ISelEnv* env, const IRExpr* e,
                                           IREndness IEndianess );
 
-static PPCCondCode   iselCondCode_wrk ( ISelEnv* env, IRExpr* e,
+static PPCCondCode   iselCondCode_wrk ( ISelEnv* env, const IRExpr* e,
                                         IREndness IEndianess );
-static PPCCondCode   iselCondCode     ( ISelEnv* env, IRExpr* e,
+static PPCCondCode   iselCondCode     ( ISelEnv* env, const IRExpr* e,
                                         IREndness IEndianess );
 
-static HReg          iselDblExpr_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselDblExpr_wrk ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
-static HReg          iselDblExpr     ( ISelEnv* env, IRExpr* e,
+static HReg          iselDblExpr     ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
 
-static HReg          iselFltExpr_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselFltExpr_wrk ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
-static HReg          iselFltExpr     ( ISelEnv* env, IRExpr* e,
+static HReg          iselFltExpr     ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
 
-static HReg          iselVecExpr_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselVecExpr_wrk ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
-static HReg          iselVecExpr     ( ISelEnv* env, IRExpr* e,
+static HReg          iselVecExpr     ( ISelEnv* env, const IRExpr* e,
                                        IREndness IEndianess );
 
 /* 64-bit mode ONLY. */
-static HReg          iselDfp32Expr_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselDfp32Expr_wrk ( ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
-static HReg          iselDfp32Expr     ( ISelEnv* env, IRExpr* e,
+static HReg          iselDfp32Expr     ( ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
-static HReg          iselDfp64Expr_wrk ( ISelEnv* env, IRExpr* e,
+static HReg          iselDfp64Expr_wrk ( ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
-static HReg          iselDfp64Expr     ( ISelEnv* env, IRExpr* e,
+static HReg          iselDfp64Expr     ( ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess );
-static HReg iselFp128Expr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess);
-static HReg iselFp128Expr     ( ISelEnv* env, IRExpr* e, IREndness IEndianess);
+static HReg iselFp128Expr_wrk ( ISelEnv* env, const IRExpr* e,
+                                IREndness IEndianess);
+static HReg iselFp128Expr     ( ISelEnv* env, const IRExpr* e,
+                                IREndness IEndianess);
 
 /* 64-bit mode ONLY: compute an D128 into a GPR64 pair. */
 static void iselDfp128Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env,
-                                 IRExpr* e, IREndness IEndianess );
+                                 const IRExpr* e, IREndness IEndianess );
 static void iselDfp128Expr     ( HReg* rHi, HReg* rLo, ISelEnv* env,
-                                 IRExpr* e, IREndness IEndianess );
+                                 const IRExpr* e, IREndness IEndianess );
 
 /*---------------------------------------------------------*/
 /*--- ISEL: Misc helpers                                ---*/
@@ -1396,7 +1398,8 @@ static HReg isNan ( ISelEnv* env, HReg vSrc, IREndness IEndianess )
    if necessary.
 */
 
-static HReg iselWordExpr_R ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselWordExpr_R ( ISelEnv* env, const IRExpr* e,
+                             IREndness IEndianess )
 {
    HReg r = iselWordExpr_R_wrk(env, e, IEndianess);
    /* sanity checks ... */
@@ -1410,7 +1413,7 @@ static HReg iselWordExpr_R ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static HReg iselWordExpr_R_wrk ( ISelEnv* env, IRExpr* e,
+static HReg iselWordExpr_R_wrk ( ISelEnv* env, const IRExpr* e,
                                  IREndness IEndianess )
 {
    Bool mode64 = env->mode64;
@@ -1871,7 +1874,7 @@ static HReg iselWordExpr_R_wrk ( ISelEnv* env, IRExpr* e,
       DEFINE_PATTERN(p_32to1_then_1Uto8,
                      unop(Iop_1Uto8,unop(Iop_32to1,bind(0))));
       if (matchIRExpr(&mi,p_32to1_then_1Uto8,e)) {
-         IRExpr* expr32 = mi.bindee[0];
+         const IRExpr* expr32 = mi.bindee[0];
          HReg r_dst = newVRegI(env);
          HReg r_src = iselWordExpr_R(env, expr32, IEndianess);
          addInstr(env, PPCInstr_Alu(Palu_AND, r_dst,
@@ -2604,7 +2607,7 @@ static Bool sane_AMode ( ISelEnv* env, PPCAMode* am )
 }
 
 static 
-PPCAMode* iselWordExpr_AMode ( ISelEnv* env, IRExpr* e, IRType xferTy,
+PPCAMode* iselWordExpr_AMode ( ISelEnv* env, const IRExpr* e, IRType xferTy,
                                IREndness IEndianess )
 {
    PPCAMode* am = iselWordExpr_AMode_wrk(env, e, xferTy, IEndianess);
@@ -2613,7 +2616,7 @@ PPCAMode* iselWordExpr_AMode ( ISelEnv* env, IRExpr* e, IRType xferTy,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCAMode* iselWordExpr_AMode_wrk ( ISelEnv* env, IRExpr* e,
+static PPCAMode* iselWordExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e,
                                           IRType xferTy, IREndness IEndianess )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
@@ -2695,7 +2698,7 @@ static PPCAMode* iselWordExpr_AMode_wrk ( ISelEnv* env, IRExpr* e,
    signed immediates that are return can have their sign inverted if
    need be. */
 
-static PPCRH* iselWordExpr_RH ( ISelEnv* env, Bool syned, IRExpr* e,
+static PPCRH* iselWordExpr_RH ( ISelEnv* env, Bool syned, const IRExpr* e,
                                 IREndness IEndianess )
 {
   PPCRH* ri = iselWordExpr_RH_wrk(env, syned, e, IEndianess);
@@ -2716,7 +2719,7 @@ static PPCRH* iselWordExpr_RH ( ISelEnv* env, Bool syned, IRExpr* e,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCRH* iselWordExpr_RH_wrk ( ISelEnv* env, Bool syned, IRExpr* e,
+static PPCRH* iselWordExpr_RH_wrk ( ISelEnv* env, Bool syned, const IRExpr* e,
                                     IREndness IEndianess )
 {
    ULong u;
@@ -2760,7 +2763,8 @@ static PPCRH* iselWordExpr_RH_wrk ( ISelEnv* env, Bool syned, IRExpr* e,
    iselIntExpr_R, the expression can have type 32, 16 or 8 bits, or,
    in 64-bit mode, 64 bits. */
 
-static PPCRI* iselWordExpr_RI ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static PPCRI* iselWordExpr_RI ( ISelEnv* env, const IRExpr* e,
+                                IREndness IEndianess )
 {
    PPCRI* ri = iselWordExpr_RI_wrk(env, e, IEndianess);
    /* sanity checks ... */
@@ -2777,7 +2781,7 @@ static PPCRI* iselWordExpr_RI ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCRI* iselWordExpr_RI_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRI* iselWordExpr_RI_wrk ( ISelEnv* env, const IRExpr* e,
                                     IREndness IEndianess )
 {
    Long  l;
@@ -2810,7 +2814,7 @@ static PPCRI* iselWordExpr_RI_wrk ( ISelEnv* env, IRExpr* e,
    being an immediate in the range 1 .. 31 inclusive.  Used for doing
    shift amounts.  Only used in 32-bit mode. */
 
-static PPCRH* iselWordExpr_RH5u ( ISelEnv* env, IRExpr* e,
+static PPCRH* iselWordExpr_RH5u ( ISelEnv* env, const IRExpr* e,
                                   IREndness IEndianess )
 {
    PPCRH* ri;
@@ -2832,7 +2836,7 @@ static PPCRH* iselWordExpr_RH5u ( ISelEnv* env, IRExpr* e,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCRH* iselWordExpr_RH5u_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRH* iselWordExpr_RH5u_wrk ( ISelEnv* env, const IRExpr* e,
                                       IREndness IEndianess )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
@@ -2857,7 +2861,7 @@ static PPCRH* iselWordExpr_RH5u_wrk ( ISelEnv* env, IRExpr* e,
    being an immediate in the range 1 .. 63 inclusive.  Used for doing
    shift amounts.  Only used in 64-bit mode. */
 
-static PPCRH* iselWordExpr_RH6u ( ISelEnv* env, IRExpr* e,
+static PPCRH* iselWordExpr_RH6u ( ISelEnv* env, const IRExpr* e,
                                   IREndness IEndianess )
 {
    PPCRH* ri; 
@@ -2879,7 +2883,7 @@ static PPCRH* iselWordExpr_RH6u ( ISelEnv* env, IRExpr* e,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCRH* iselWordExpr_RH6u_wrk ( ISelEnv* env, IRExpr* e,
+static PPCRH* iselWordExpr_RH6u_wrk ( ISelEnv* env, const IRExpr* e,
                                       IREndness IEndianess )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
@@ -2904,7 +2908,7 @@ static PPCRH* iselWordExpr_RH6u_wrk ( ISelEnv* env, IRExpr* e,
    condition code which would correspond when the expression would
    notionally have returned 1. */
 
-static PPCCondCode iselCondCode ( ISelEnv* env, IRExpr* e,
+static PPCCondCode iselCondCode ( ISelEnv* env, const IRExpr* e,
                                   IREndness IEndianess )
 {
    /* Uh, there's nothing we can sanity check here, unfortunately. */
@@ -2912,7 +2916,7 @@ static PPCCondCode iselCondCode ( ISelEnv* env, IRExpr* e,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static PPCCondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e,
+static PPCCondCode iselCondCode_wrk ( ISelEnv* env, const IRExpr* e,
                                       IREndness IEndianess )
 {
    vassert(e);
@@ -3100,8 +3104,8 @@ static PPCCondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e,
    case they must not be changed by subsequent code emitted by the
    caller.  */
 
-static void iselInt128Expr ( HReg* rHi, HReg* rLo,
-                             ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static void iselInt128Expr ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                             const IRExpr* e, IREndness IEndianess )
 {
    vassert(env->mode64);
    iselInt128Expr_wrk(rHi, rLo, env, e, IEndianess);
@@ -3115,8 +3119,8 @@ static void iselInt128Expr ( HReg* rHi, HReg* rLo,
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static void iselInt128Expr_wrk ( HReg* rHi, HReg* rLo,
-                                 ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static void iselInt128Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                                 const IRExpr* e, IREndness IEndianess )
 {
    Bool mode64 = env->mode64;
 
@@ -3197,7 +3201,7 @@ static void iselInt128Expr_wrk ( HReg* rHi, HReg* rLo,
 
 /* 32-bit mode ONLY: compute a 128-bit value into a register quad */
 static void iselInt128Expr_to_32x4 ( HReg* rHi, HReg* rMedHi, HReg* rMedLo,
-                                     HReg* rLo, ISelEnv* env, IRExpr* e,
+                                     HReg* rLo, ISelEnv* env, const IRExpr* e,
                                      IREndness IEndianess )
 {
    vassert(!env->mode64);
@@ -3217,7 +3221,7 @@ static void iselInt128Expr_to_32x4 ( HReg* rHi, HReg* rMedHi, HReg* rMedLo,
 
 static void iselInt128Expr_to_32x4_wrk ( HReg* rHi, HReg* rMedHi,
                                          HReg* rMedLo, HReg* rLo,
-                                         ISelEnv* env, IRExpr* e,
+                                         ISelEnv* env, const IRExpr* e,
                                          IREndness IEndianess )
 {
    vassert(e);
@@ -3255,7 +3259,7 @@ static void iselInt128Expr_to_32x4_wrk ( HReg* rHi, HReg* rMedHi,
    caller.  */
 
 static void iselInt64Expr ( HReg* rHi, HReg* rLo,
-                            ISelEnv* env, IRExpr* e,
+                            ISelEnv* env, const IRExpr* e,
                             IREndness IEndianess )
 {
    vassert(!env->mode64);
@@ -3271,7 +3275,7 @@ static void iselInt64Expr ( HReg* rHi, HReg* rLo,
 
 /* DO NOT CALL THIS DIRECTLY ! */
 static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo,
-                                ISelEnv* env, IRExpr* e,
+                                ISelEnv* env, const IRExpr* e,
                                 IREndness IEndianess )
 {
    vassert(e);
@@ -3893,7 +3897,7 @@ static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo,
 /* Nothing interesting here; really just wrappers for
    64-bit stuff. */
 
-static HReg iselFltExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselFltExpr ( ISelEnv* env, const IRExpr* e, IREndness IEndianess )
 {
   HReg r = iselFltExpr_wrk( env, e, IEndianess );
 #  if 0
@@ -3905,7 +3909,8 @@ static HReg iselFltExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselFltExpr_wrk ( ISelEnv* env, const IRExpr* e,
+                              IREndness IEndianess )
 {
    Bool        mode64 = env->mode64;
 
@@ -4065,7 +4070,7 @@ static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
     positive zero         0           0             .000000---0
 */
 
-static HReg iselDblExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselDblExpr ( ISelEnv* env, const IRExpr* e, IREndness IEndianess )
 {
    HReg r = iselDblExpr_wrk( env, e, IEndianess );
 #  if 0
@@ -4077,7 +4082,8 @@ static HReg iselDblExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselDblExpr_wrk ( ISelEnv* env, const IRExpr* e,
+                              IREndness IEndianess )
 {
    Bool mode64 = env->mode64;
    IRType ty = typeOfIRExpr(env->type_env,e);
@@ -4431,7 +4437,7 @@ static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
    vpanic("iselDblExpr_wrk(ppc)");
 }
 
-static HReg iselDfp32Expr(ISelEnv* env, IRExpr* e, IREndness IEndianess)
+static HReg iselDfp32Expr(ISelEnv* env, const IRExpr* e, IREndness IEndianess)
 {
    HReg r = iselDfp32Expr_wrk( env, e, IEndianess );
    vassert(hregClass(r) == HRcFlt64);
@@ -4440,7 +4446,8 @@ static HReg iselDfp32Expr(ISelEnv* env, IRExpr* e, IREndness IEndianess)
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselDfp32Expr_wrk(ISelEnv* env, IRExpr* e, IREndness IEndianess)
+static HReg iselDfp32Expr_wrk(ISelEnv* env, const IRExpr* e,
+                              IREndness IEndianess)
 {
    Bool mode64 = env->mode64;
    IRType ty = typeOfIRExpr( env->type_env, e );
@@ -4483,7 +4490,7 @@ static HReg iselDfp32Expr_wrk(ISelEnv* env, IRExpr* e, IREndness IEndianess)
    vpanic( "iselDfp32Expr_wrk(ppc)" );
 }
 
-static HReg iselFp128Expr( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselFp128Expr( ISelEnv* env, const IRExpr* e, IREndness IEndianess )
 {
    HReg r = iselFp128Expr_wrk( env, e, IEndianess );
    vassert(hregClass(r) == HRcVec128);
@@ -4492,7 +4499,8 @@ static HReg iselFp128Expr( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselFp128Expr_wrk( ISelEnv* env, IRExpr* e, IREndness IEndianess)
+static HReg iselFp128Expr_wrk( ISelEnv* env, const IRExpr* e,
+                               IREndness IEndianess)
 {
    Bool mode64 = env->mode64;
    PPCFpOp fpop = Pfp_INVALID;
@@ -4799,7 +4807,7 @@ static HReg iselFp128Expr_wrk( ISelEnv* env, IRExpr* e, IREndness IEndianess)
    vpanic( "iselFp128Expr(ppc64)" );
 }
 
-static HReg iselDfp64Expr(ISelEnv* env, IRExpr* e, IREndness IEndianess)
+static HReg iselDfp64Expr(ISelEnv* env, const IRExpr* e, IREndness IEndianess)
 {
    HReg r = iselDfp64Expr_wrk( env, e, IEndianess );
    vassert(hregClass(r) == HRcFlt64);
@@ -4808,7 +4816,8 @@ static HReg iselDfp64Expr(ISelEnv* env, IRExpr* e, IREndness IEndianess)
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselDfp64Expr_wrk(ISelEnv* env, IRExpr* e, IREndness IEndianess)
+static HReg iselDfp64Expr_wrk(ISelEnv* env, const IRExpr* e,
+                              IREndness IEndianess)
 {
    Bool mode64 = env->mode64;
    IRType ty = typeOfIRExpr( env->type_env, e );
@@ -5082,7 +5091,7 @@ static HReg iselDfp64Expr_wrk(ISelEnv* env, IRExpr* e, IREndness IEndianess)
    vpanic( "iselDfp64Expr_wrk(ppc)" );
 }
 
-static void iselDfp128Expr(HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e,
+static void iselDfp128Expr(HReg* rHi, HReg* rLo, ISelEnv* env, const IRExpr* e,
                            IREndness IEndianess)
 {
    iselDfp128Expr_wrk( rHi, rLo, env, e, IEndianess );
@@ -5091,8 +5100,8 @@ static void iselDfp128Expr(HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e,
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static void iselDfp128Expr_wrk(HReg* rHi, HReg *rLo, ISelEnv* env, IRExpr* e,
-                               IREndness IEndianess)
+static void iselDfp128Expr_wrk(HReg* rHi, HReg *rLo, ISelEnv* env,
+                               const IRExpr* e, IREndness IEndianess)
 {
    vassert( e );
    vassert( typeOfIRExpr(env->type_env,e) == Ity_D128 );
@@ -5359,7 +5368,7 @@ static void iselDfp128Expr_wrk(HReg* rHi, HReg *rLo, ISelEnv* env, IRExpr* e,
 /*--- ISEL: SIMD (Vector) expressions, 128 bit.         ---*/
 /*---------------------------------------------------------*/
 
-static HReg iselVecExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselVecExpr ( ISelEnv* env, const IRExpr* e, IREndness IEndianess )
 {
    HReg r = iselVecExpr_wrk( env, e, IEndianess );
 #  if 0
@@ -5371,7 +5380,8 @@ static HReg iselVecExpr ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselVecExpr_wrk ( ISelEnv* env, IRExpr* e, IREndness IEndianess )
+static HReg iselVecExpr_wrk ( ISelEnv* env, const IRExpr* e,
+                              IREndness IEndianess )
 {
    Bool mode64 = env->mode64;
    PPCAvOp op = Pav_INVALID;

diff --git a/VEX/priv/host_x86_isel.c b/VEX/priv/host_x86_isel.c
index 0c9f582d245b335be240f8f7ed4354070115b4b8..7481fdaeb781e2fc8eecf766f61afa24aa810c0e 100644 (file)
--- a/VEX/priv/host_x86_isel.c
+++ b/VEX/priv/host_x86_isel.c
@@ -247,37 +247,37 @@ static HReg newVRegV ( ISelEnv* env )
    checks that all returned registers are virtual.  You should not
    call the _wrk version directly.
 */
-static X86RMI*     iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e );
-static X86RMI*     iselIntExpr_RMI     ( ISelEnv* env, IRExpr* e );
+static X86RMI*     iselIntExpr_RMI_wrk ( ISelEnv* env, const IRExpr* e );
+static X86RMI*     iselIntExpr_RMI     ( ISelEnv* env, const IRExpr* e );
 
-static X86RI*      iselIntExpr_RI_wrk ( ISelEnv* env, IRExpr* e );
-static X86RI*      iselIntExpr_RI     ( ISelEnv* env, IRExpr* e );
+static X86RI*      iselIntExpr_RI_wrk ( ISelEnv* env, const IRExpr* e );
+static X86RI*      iselIntExpr_RI     ( ISelEnv* env, const IRExpr* e );
 
-static X86RM*      iselIntExpr_RM_wrk ( ISelEnv* env, IRExpr* e );
-static X86RM*      iselIntExpr_RM     ( ISelEnv* env, IRExpr* e );
+static X86RM*      iselIntExpr_RM_wrk ( ISelEnv* env, const IRExpr* e );
+static X86RM*      iselIntExpr_RM     ( ISelEnv* env, const IRExpr* e );
 
-static HReg        iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e );
-static HReg        iselIntExpr_R     ( ISelEnv* env, IRExpr* e );
+static HReg        iselIntExpr_R_wrk ( ISelEnv* env, const IRExpr* e );
+static HReg        iselIntExpr_R     ( ISelEnv* env, const IRExpr* e );
 
-static X86AMode*   iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e );
-static X86AMode*   iselIntExpr_AMode     ( ISelEnv* env, IRExpr* e );
+static X86AMode*   iselIntExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e );
+static X86AMode*   iselIntExpr_AMode     ( ISelEnv* env, const IRExpr* e );
 
 static void        iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, 
-                                       ISelEnv* env, IRExpr* e );
+                                       ISelEnv* env, const IRExpr* e );
 static void        iselInt64Expr     ( HReg* rHi, HReg* rLo, 
-                                       ISelEnv* env, IRExpr* e );
+                                       ISelEnv* env, const IRExpr* e );
 
-static X86CondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e );
-static X86CondCode iselCondCode     ( ISelEnv* env, IRExpr* e );
+static X86CondCode iselCondCode_wrk ( ISelEnv* env, const IRExpr* e );
+static X86CondCode iselCondCode     ( ISelEnv* env, const IRExpr* e );
 
-static HReg        iselDblExpr_wrk ( ISelEnv* env, IRExpr* e );
-static HReg        iselDblExpr     ( ISelEnv* env, IRExpr* e );
+static HReg        iselDblExpr_wrk ( ISelEnv* env, const IRExpr* e );
+static HReg        iselDblExpr     ( ISelEnv* env, const IRExpr* e );
 
-static HReg        iselFltExpr_wrk ( ISelEnv* env, IRExpr* e );
-static HReg        iselFltExpr     ( ISelEnv* env, IRExpr* e );
+static HReg        iselFltExpr_wrk ( ISelEnv* env, const IRExpr* e );
+static HReg        iselFltExpr     ( ISelEnv* env, const IRExpr* e );
 
-static HReg        iselVecExpr_wrk ( ISelEnv* env, IRExpr* e );
-static HReg        iselVecExpr     ( ISelEnv* env, IRExpr* e );
+static HReg        iselVecExpr_wrk ( ISelEnv* env, const IRExpr* e );
+static HReg        iselVecExpr     ( ISelEnv* env, const IRExpr* e );
 
 
 /*---------------------------------------------------------*/
@@ -835,7 +835,7 @@ static void roundToF64 ( ISelEnv* env, HReg reg )
    or sign extend partial values if necessary.
 */
 
-static HReg iselIntExpr_R ( ISelEnv* env, IRExpr* e )
+static HReg iselIntExpr_R ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselIntExpr_R_wrk(env, e);
    /* sanity checks ... */
@@ -848,7 +848,7 @@ static HReg iselIntExpr_R ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselIntExpr_R_wrk ( ISelEnv* env, const IRExpr* e )
 {
    MatchInfo mi;
 
@@ -1161,7 +1161,7 @@ static HReg iselIntExpr_R_wrk ( ISelEnv* env, IRExpr* e )
          DEFINE_PATTERN(p_32to1_then_1Uto8,
                         unop(Iop_1Uto8,unop(Iop_32to1,bind(0))));
          if (matchIRExpr(&mi,p_32to1_then_1Uto8,e)) {
-            IRExpr* expr32 = mi.bindee[0];
+            const IRExpr* expr32 = mi.bindee[0];
             HReg dst = newVRegI(env);
             HReg src = iselIntExpr_R(env, expr32);
             addInstr(env, mk_iMOVsd_RR(src,dst) );
@@ -1546,7 +1546,7 @@ static Bool sane_AMode ( X86AMode* am )
    }
 }
 
-static X86AMode* iselIntExpr_AMode ( ISelEnv* env, IRExpr* e )
+static X86AMode* iselIntExpr_AMode ( ISelEnv* env, const IRExpr* e )
 {
    X86AMode* am = iselIntExpr_AMode_wrk(env, e);
    vassert(sane_AMode(am));
@@ -1554,7 +1554,7 @@ static X86AMode* iselIntExpr_AMode ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static X86AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e )
+static X86AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I32);
@@ -1621,7 +1621,7 @@ static X86AMode* iselIntExpr_AMode_wrk ( ISelEnv* env, IRExpr* e )
 /* Similarly, calculate an expression into an X86RMI operand.  As with
    iselIntExpr_R, the expression can have type 32, 16 or 8 bits.  */
 
-static X86RMI* iselIntExpr_RMI ( ISelEnv* env, IRExpr* e )
+static X86RMI* iselIntExpr_RMI ( ISelEnv* env, const IRExpr* e )
 {
    X86RMI* rmi = iselIntExpr_RMI_wrk(env, e);
    /* sanity checks ... */
@@ -1641,7 +1641,7 @@ static X86RMI* iselIntExpr_RMI ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static X86RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e )
+static X86RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I32 || ty == Ity_I16 || ty == Ity_I8);
@@ -1684,7 +1684,7 @@ static X86RMI* iselIntExpr_RMI_wrk ( ISelEnv* env, IRExpr* e )
 /* Calculate an expression into an X86RI operand.  As with
    iselIntExpr_R, the expression can have type 32, 16 or 8 bits. */
 
-static X86RI* iselIntExpr_RI ( ISelEnv* env, IRExpr* e )
+static X86RI* iselIntExpr_RI ( ISelEnv* env, const IRExpr* e )
 {
    X86RI* ri = iselIntExpr_RI_wrk(env, e);
    /* sanity checks ... */
@@ -1701,7 +1701,7 @@ static X86RI* iselIntExpr_RI ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static X86RI* iselIntExpr_RI_wrk ( ISelEnv* env, IRExpr* e )
+static X86RI* iselIntExpr_RI_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I32 || ty == Ity_I16 || ty == Ity_I8);
@@ -1731,7 +1731,7 @@ static X86RI* iselIntExpr_RI_wrk ( ISelEnv* env, IRExpr* e )
 /* Similarly, calculate an expression into an X86RM operand.  As with
    iselIntExpr_R, the expression can have type 32, 16 or 8 bits.  */
 
-static X86RM* iselIntExpr_RM ( ISelEnv* env, IRExpr* e )
+static X86RM* iselIntExpr_RM ( ISelEnv* env, const IRExpr* e )
 {
    X86RM* rm = iselIntExpr_RM_wrk(env, e);
    /* sanity checks ... */
@@ -1749,7 +1749,7 @@ static X86RM* iselIntExpr_RM ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static X86RM* iselIntExpr_RM_wrk ( ISelEnv* env, IRExpr* e )
+static X86RM* iselIntExpr_RM_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_I32 || ty == Ity_I16 || ty == Ity_I8);
@@ -1776,14 +1776,14 @@ static X86RM* iselIntExpr_RM_wrk ( ISelEnv* env, IRExpr* e )
    condition code which would correspond when the expression would
    notionally have returned 1. */
 
-static X86CondCode iselCondCode ( ISelEnv* env, IRExpr* e )
+static X86CondCode iselCondCode ( ISelEnv* env, const IRExpr* e )
 {
    /* Uh, there's nothing we can sanity check here, unfortunately. */
    return iselCondCode_wrk(env,e);
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static X86CondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e )
+static X86CondCode iselCondCode_wrk ( ISelEnv* env, const IRExpr* e )
 {
    MatchInfo mi;
 
@@ -2069,7 +2069,8 @@ static X86CondCode iselCondCode_wrk ( ISelEnv* env, IRExpr* e )
    either real or virtual regs; in any case they must not be changed
    by subsequent code emitted by the caller.  */
 
-static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
+static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                            const IRExpr* e )
 {
    iselInt64Expr_wrk(rHi, rLo, env, e);
 #  if 0
@@ -2082,7 +2083,8 @@ static void iselInt64Expr ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY ! */
-static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
+static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env,
+                                const IRExpr* e )
 {
    MatchInfo mi;
    HWord fn = 0; /* helper fn for most SIMD64 stuff */
@@ -2871,7 +2873,7 @@ static void iselInt64Expr_wrk ( HReg* rHi, HReg* rLo, ISelEnv* env, IRExpr* e )
 /* Nothing interesting here; really just wrappers for
    64-bit stuff. */
 
-static HReg iselFltExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselFltExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselFltExpr_wrk( env, e );
 #  if 0
@@ -2883,7 +2885,7 @@ static HReg iselFltExpr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselFltExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(ty == Ity_F32);
@@ -2988,7 +2990,7 @@ static HReg iselFltExpr_wrk ( ISelEnv* env, IRExpr* e )
     positive zero         0           0             .000000---0
 */
 
-static HReg iselDblExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselDblExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselDblExpr_wrk( env, e );
 #  if 0
@@ -3000,7 +3002,7 @@ static HReg iselDblExpr ( ISelEnv* env, IRExpr* e )
 }
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselDblExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
    IRType ty = typeOfIRExpr(env->type_env,e);
    vassert(e);
@@ -3239,7 +3241,7 @@ static HReg iselDblExpr_wrk ( ISelEnv* env, IRExpr* e )
 /*--- ISEL: SIMD (Vector) expressions, 128 bit.         ---*/
 /*---------------------------------------------------------*/
 
-static HReg iselVecExpr ( ISelEnv* env, IRExpr* e )
+static HReg iselVecExpr ( ISelEnv* env, const IRExpr* e )
 {
    HReg r = iselVecExpr_wrk( env, e );
 #  if 0
@@ -3252,7 +3254,7 @@ static HReg iselVecExpr ( ISelEnv* env, IRExpr* e )
 
 
 /* DO NOT CALL THIS DIRECTLY */
-static HReg iselVecExpr_wrk ( ISelEnv* env, IRExpr* e )
+static HReg iselVecExpr_wrk ( ISelEnv* env, const IRExpr* e )
 {
 
 #  define REQUIRE_SSE1                                    \

diff --git a/VEX/priv/ir_match.c b/VEX/priv/ir_match.c
index 40fd46f854e2a87342f49fa5330125e40c390a87..7f6b5753b378e18ea9251583ebef2944a0f1cfed 100644 (file)
--- a/VEX/priv/ir_match.c
+++ b/VEX/priv/ir_match.c
@@ -42,7 +42,7 @@
 /* Assign a value to a binder.  Checks for obvious stupidities. */
 
 static 
-void setBindee ( MatchInfo* mi, Int n, IRExpr* bindee )
+void setBindee ( MatchInfo* mi, Int n, const IRExpr* bindee )
 {
    if (n < 0 || n >= N_IRMATCH_BINDERS)
       vpanic("setBindee: out of range index");
@@ -57,7 +57,8 @@ void setBindee ( MatchInfo* mi, Int n, IRExpr* bindee )
    found into 'mi'. */
 
 static 
-Bool matchWrk ( MatchInfo* mi, IRExpr* p/*attern*/, IRExpr* e/*xpr*/ )
+Bool matchWrk ( MatchInfo* mi, const IRExpr* p/*attern*/,
+                const IRExpr* e/*xpr*/ )
 {
    switch (p->tag) {
       case Iex_Binder: /* aha, what we were looking for. */
@@ -96,7 +97,8 @@ Bool matchWrk ( MatchInfo* mi, IRExpr* p/*attern*/, IRExpr* e/*xpr*/ )
 
 /* Top level entry point to the matcher. */
 
-Bool matchIRExpr ( MatchInfo* mi, IRExpr* p/*attern*/, IRExpr* e/*xpr*/ )
+Bool matchIRExpr ( MatchInfo* mi, const IRExpr* p/*attern*/,
+                   const IRExpr* e/*xpr*/ )
 {
    Int i;
    for (i = 0; i < N_IRMATCH_BINDERS; i++)

diff --git a/VEX/priv/ir_match.h b/VEX/priv/ir_match.h
index f339426c69c3fecccd6b9f4c64520cfed49ab82d..7f238fc28160d175194dd889942f8fd15cf49a1f 100644 (file)
--- a/VEX/priv/ir_match.h
+++ b/VEX/priv/ir_match.h
@@ -68,7 +68,7 @@
 
 typedef
    struct {
-      IRExpr* bindee[N_IRMATCH_BINDERS];
+      const IRExpr* bindee[N_IRMATCH_BINDERS];
    }
    MatchInfo;
 
@@ -78,7 +78,8 @@ typedef
    succeeded. */
 
 extern
-Bool matchIRExpr ( MatchInfo* mi, IRExpr* p/*attern*/, IRExpr* e/*xpr*/ );
+Bool matchIRExpr ( MatchInfo* mi, const IRExpr* p/*attern*/,
+                   const IRExpr* e/*xpr*/ );
 
 
 #endif /* ndef __VEX_IR_MATCH_H */