Get rid of guards on IR Puts, and instead have an IR Mux expression.

Adjust everything else accordingly.

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

diff --git a/VEX/priv/guest-x86/x86toIR.c b/VEX/priv/guest-x86/x86toIR.c
index aa8412f4180d5ba6c8ba88db4cc060ad296cf302..64e616786e95d0544947efc02d1d6f779b2b5454 100644 (file)
--- a/VEX/priv/guest-x86/x86toIR.c
+++ b/VEX/priv/guest-x86/x86toIR.c
@@ -261,7 +261,7 @@ static void putIReg ( Int sz, UInt archreg, IRExpr* e )
 {
    vassert(sz == 1 || sz == 2 || sz == 4);
    vassert(archreg < 8);
-   stmt( IRStmt_Put(NULL, integerGuestRegOffset(sz,archreg), e) );
+   stmt( IRStmt_Put(integerGuestRegOffset(sz,archreg), e) );
 }
 
 static void assign ( IRTemp dst, IRExpr* e )
@@ -397,9 +397,8 @@ static void setFlags_SRC_DST1 ( IROp    op8,
                                 IRTemp  dst1,
                                 IRType  ty )
 {
-   Bool    logic = False;
-   Int     ccOp  = ty==Ity_I8 ? 0 : (ty==Ity_I16 ? 1 : 2);
-   IRExpr* guard = NULL;
+   Bool logic = False;
+   Int  ccOp  = ty==Ity_I8 ? 0 : (ty==Ity_I16 ? 1 : 2);
 
    vassert(ty == Ity_I8 || ty == Ity_I16 || ty == Ity_I32);
 
@@ -412,10 +411,10 @@ static void setFlags_SRC_DST1 ( IROp    op8,
       default:       ppIROp(op8);
                      vpanic("setFlags_SRC_DST1(x86)");
    }
-   stmt( IRStmt_Put(guard, OFFB_CC_OP,  mkU32(ccOp)) );
-   stmt( IRStmt_Put(guard, OFFB_CC_SRC, logic ? mkU32(0) 
+   stmt( IRStmt_Put( OFFB_CC_OP,  mkU32(ccOp)) );
+   stmt( IRStmt_Put( OFFB_CC_SRC, logic ? mkU32(0) 
                                               : mkexpr(src)) );
-   stmt( IRStmt_Put(guard, OFFB_CC_DST, mkexpr(dst1)) );
+   stmt( IRStmt_Put( OFFB_CC_DST, mkexpr(dst1)) );
 }
 
 
@@ -443,9 +442,18 @@ static void setFlags_DSTus_DST1 ( IROp    op8,
    }
 
    /* CC_SRC = undershifted %d after, CC_DST = %d afterwards */
-   stmt( IRStmt_Put(mkexpr(guard), OFFB_CC_OP,  mkU32(ccOp)) );
-   stmt( IRStmt_Put(mkexpr(guard), OFFB_CC_SRC, mkexpr(dstUS)) );
-   stmt( IRStmt_Put(mkexpr(guard), OFFB_CC_DST, mkexpr(dst1)) );
+   stmt( IRStmt_Put( OFFB_CC_OP,
+                     IRExpr_Mux10( mkexpr(guard),
+                                   mkU32(ccOp),
+                                   IRExpr_Get(OFFB_CC_OP,Ity_I32))) );
+   stmt( IRStmt_Put( OFFB_CC_SRC, 
+                     IRExpr_Mux10( mkexpr(guard),
+                                   mkexpr(dstUS),
+                                   IRExpr_Get(OFFB_CC_SRC,Ity_I32))) );
+   stmt( IRStmt_Put( OFFB_CC_DST,
+                     IRExpr_Mux10( mkexpr(guard),
+                                   mkexpr(dst1),
+                                   IRExpr_Get(OFFB_CC_DST,Ity_I32))) );
 }
 
 
@@ -454,17 +462,16 @@ static void setFlags_DSTus_DST1 ( IROp    op8,
 
 static void setFlags_INC_DEC ( Bool inc, IRTemp dst, IRType ty )
 {
-   IRExpr* guard = NULL;
-   Int     ccOp  = inc ? CC_OP_INCB : CC_OP_DECB;
+   Int ccOp  = inc ? CC_OP_INCB : CC_OP_DECB;
    
    ccOp += ty==Ity_I8 ? 0 : (ty==Ity_I16 ? 1 : 2);
    vassert(ty == Ity_I8 || ty == Ity_I16 || ty == Ity_I32);
 
    /* This has to come first, because calculating the C flag 
       may require reading all three OFFB_CC fields. */
-   stmt( IRStmt_Put(guard, OFFB_CC_SRC, mk_calculate_eflags_c()) );
-   stmt( IRStmt_Put(guard, OFFB_CC_OP,  mkU32(ccOp)) );
-   stmt( IRStmt_Put(guard, OFFB_CC_DST, mkexpr(dst)) );
+   stmt( IRStmt_Put( OFFB_CC_SRC, mk_calculate_eflags_c()) );
+   stmt( IRStmt_Put( OFFB_CC_OP,  mkU32(ccOp)) );
+   stmt( IRStmt_Put( OFFB_CC_DST, mkexpr(dst)) );
 }
 
 
@@ -476,19 +483,19 @@ void setFlags_MUL ( IRType ty, IRTemp src1, IRTemp src2, UInt base_op )
 {
    switch (ty) {
    case Ity_I8:
-      stmt( IRStmt_Put( NULL, OFFB_CC_OP,  mkU32(base_op+0) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_SRC, unop(Iop_8Uto32,mkexpr(src1)) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_DST, unop(Iop_8Uto32,mkexpr(src2)) ) );
+      stmt( IRStmt_Put( OFFB_CC_OP,  mkU32(base_op+0) ) );
+      stmt( IRStmt_Put( OFFB_CC_SRC, unop(Iop_8Uto32,mkexpr(src1)) ) );
+      stmt( IRStmt_Put( OFFB_CC_DST, unop(Iop_8Uto32,mkexpr(src2)) ) );
       break;
    case Ity_I16:
-      stmt( IRStmt_Put( NULL, OFFB_CC_OP,  mkU32(base_op+1) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_SRC, unop(Iop_16Uto32,mkexpr(src1)) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_DST, unop(Iop_16Uto32,mkexpr(src2)) ) );
+      stmt( IRStmt_Put( OFFB_CC_OP,  mkU32(base_op+1) ) );
+      stmt( IRStmt_Put( OFFB_CC_SRC, unop(Iop_16Uto32,mkexpr(src1)) ) );
+      stmt( IRStmt_Put( OFFB_CC_DST, unop(Iop_16Uto32,mkexpr(src2)) ) );
       break;
    case Ity_I32:
-      stmt( IRStmt_Put( NULL, OFFB_CC_OP,  mkU32(base_op+2) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_SRC, mkexpr(src1) ) );
-      stmt( IRStmt_Put( NULL, OFFB_CC_DST, mkexpr(src2) ) );
+      stmt( IRStmt_Put( OFFB_CC_OP,  mkU32(base_op+2) ) );
+      stmt( IRStmt_Put( OFFB_CC_SRC, mkexpr(src1) ) );
+      stmt( IRStmt_Put( OFFB_CC_DST, mkexpr(src2) ) );
       break;
    default:
       vpanic("setFlags_MUL(x86)");
@@ -684,9 +691,9 @@ static void helper_ADC ( Int sz,
                      mkU32(thunkOp),
                     binop(Iop_Mul32, mkexpr(oldc), mkU32(3)));
 
-   stmt( IRStmt_Put( NULL, OFFB_CC_OP,  thunkExpr ) );
-   stmt( IRStmt_Put( NULL, OFFB_CC_SRC, mkexpr(ta2) ) );
-   stmt( IRStmt_Put( NULL, OFFB_CC_DST, mkexpr(tdst) ) );
+   stmt( IRStmt_Put( OFFB_CC_OP,  thunkExpr ) );
+   stmt( IRStmt_Put( OFFB_CC_SRC, mkexpr(ta2) ) );
+   stmt( IRStmt_Put( OFFB_CC_DST, mkexpr(tdst) ) );
 }
 
 
@@ -6753,7 +6760,7 @@ static UInt disInstr ( UInt delta, Bool* isEnd )
 
 
    case 0xFC: /* CLD */
-      stmt( IRStmt_Put( NULL, OFFB_DFLAG, mkU32(1)) );
+      stmt( IRStmt_Put( OFFB_DFLAG, mkU32(1)) );
       DIP("cld\n");
       break;
 

diff --git a/VEX/priv/ir/ir_defs.c b/VEX/priv/ir/ir_defs.c
index 0a38f972c33f3b0e0c03858c97e7544e4b5f5078..3794dbb23ad9b27ee35ef118967f6bdb32d6059f 100644 (file)
--- a/VEX/priv/ir/ir_defs.c
+++ b/VEX/priv/ir/ir_defs.c
@@ -162,6 +162,15 @@ void ppIRExpr ( IRExpr* e )
       vex_printf("):");
       ppIRType(e->Iex.CCall.retty);
       break;
+    case Iex_Mux10:
+      vex_printf("Mux10(");
+      ppIRExpr(e->Iex.Mux10.cond);
+      vex_printf(",");
+      ppIRExpr(e->Iex.Mux10.expr1);
+      vex_printf(",");
+      ppIRExpr(e->Iex.Mux10.expr0);
+      vex_printf(")");
+      break;
     default:
       vpanic("ppIExpr");
   }
@@ -171,15 +180,8 @@ void ppIRStmt ( IRStmt* s )
 {
   switch (s->tag) {
     case Ist_Put:
-      if (s->Ist.Put.guard) {
-         vex_printf("if (");
-         ppIRExpr(s->Ist.Put.guard);
-         vex_printf( ") PUT(%d) = ", s->Ist.Put.offset);
-         ppIRExpr(s->Ist.Put.expr);
-      } else {
-         vex_printf( "PUT(%d) = ", s->Ist.Put.offset);
-         ppIRExpr(s->Ist.Put.expr);
-      }
+      vex_printf( "PUT(%d) = ", s->Ist.Put.offset);
+      ppIRExpr(s->Ist.Put.expr);
       break;
     case Ist_Tmp:
       ppIRTemp(s->Ist.Tmp.tmp);
@@ -341,15 +343,22 @@ IRExpr* IRExpr_CCall ( Char* name, IRType retty, IRExpr** args ) {
    e->Iex.CCall.args  = args;
    return e;
 }
+IRExpr* IRExpr_Mux10 ( IRExpr* cond, IRExpr* expr1, IRExpr* expr0 ) {
+   IRExpr* e          = LibVEX_Alloc(sizeof(IRExpr));
+   e->tag             = Iex_Mux10;
+   e->Iex.Mux10.cond  = cond;
+   e->Iex.Mux10.expr1 = expr1;
+   e->Iex.Mux10.expr0 = expr0;
+   return e;
+}
 
 
 /* Constructors -- IRStmt */
 
-IRStmt* IRStmt_Put ( IRExpr* guard, Int off, IRExpr* value ) {
+IRStmt* IRStmt_Put ( Int off, IRExpr* value ) {
    IRStmt* s         = LibVEX_Alloc(sizeof(IRStmt));
    s->tag            = Ist_Put;
    s->link           = NULL;
-   s->Ist.Put.guard  = guard;
    s->Ist.Put.offset = off;
    s->Ist.Put.expr   = value;
    return s;
@@ -555,6 +564,8 @@ IRType typeOfIRExpr ( IRTypeEnv* tyenv, IRExpr* e )
          return t_dst;
       case Iex_CCall:
          return e->Iex.CCall.retty;
+      case Iex_Mux10:
+         return typeOfIRExpr(tyenv, e->Iex.Mux10.expr1);
       default:
          ppIRExpr(e);
          vpanic("typeOfIRExpr");
@@ -635,6 +646,13 @@ void useBeforeDef_Expr ( IRBB* bb, IRStmt* stmt, IRExpr* expr, Int* def_counts )
          for (i = 0; expr->Iex.CCall.args[i]; i++)
             useBeforeDef_Expr(bb,stmt,expr->Iex.CCall.args[i],def_counts);
          break;
+      case Iex_Mux10:
+         useBeforeDef_Expr(bb,stmt,expr->Iex.Mux10.cond,def_counts);
+         useBeforeDef_Expr(bb,stmt,expr->Iex.Mux10.expr1,def_counts);
+         useBeforeDef_Expr(bb,stmt,expr->Iex.Mux10.expr0,def_counts);
+         break;
+      default:
+         vpanic("useBeforeDef_Expr");
    }
 }
 
@@ -643,8 +661,6 @@ void useBeforeDef_Stmt ( IRBB* bb, IRStmt* stmt, Int* def_counts )
 {
    switch (stmt->tag) {
       case Ist_Put:
-         if (stmt->Ist.Put.guard)
-            useBeforeDef_Expr(bb,stmt,stmt->Ist.Put.guard,def_counts);
          useBeforeDef_Expr(bb,stmt,stmt->Ist.Put.expr,def_counts);
          break;
       case Ist_Tmp:
@@ -726,7 +742,17 @@ void tcExpr ( IRBB* bb, IRStmt* stmt, IRExpr* expr, IRType gWordTy )
          break;
       case Iex_Const:
          break;
-      default: 
+      case Iex_Mux10:
+         tcExpr(bb,stmt, expr->Iex.Mux10.cond, gWordTy);
+         tcExpr(bb,stmt, expr->Iex.Mux10.expr1, gWordTy);
+         tcExpr(bb,stmt, expr->Iex.Mux10.expr0, gWordTy);
+         if (typeOfIRExpr(tyenv, expr->Iex.Mux10.cond) != Ity_Bit)
+            sanityCheckFail(bb,stmt,"Iex.Mux10.cond: cond :: Ity_Bit");
+         if (typeOfIRExpr(tyenv, expr->Iex.Mux10.expr1)
+             != typeOfIRExpr(tyenv, expr->Iex.Mux10.expr0))
+            sanityCheckFail(bb,stmt,"Iex.Mux10: expr1/expr0 mismatch");
+         break;
+       default: 
          vpanic("tcExpr");
    }
 }
@@ -738,11 +764,6 @@ void tcStmt ( IRBB* bb, IRStmt* stmt, IRType gWordTy )
    IRTypeEnv* tyenv = bb->tyenv;
    switch (stmt->tag) {
       case Ist_Put:
-         if (stmt->Ist.Put.guard) {
-            tcExpr( bb, stmt, stmt->Ist.Put.guard, gWordTy );
-            if (typeOfIRExpr(tyenv,stmt->Ist.Put.guard) != Ity_Bit)
-               sanityCheckFail(bb,stmt,"IRStmt.Put.guard: not :: Ity_Bit");
-          }
           tcExpr( bb, stmt, stmt->Ist.Put.expr, gWordTy );
           if (typeOfIRExpr(tyenv,stmt->Ist.Put.expr) == Ity_Bit)
              sanityCheckFail(bb,stmt,"IRStmt.Put.expr: cannot Put :: Ity_Bit");

diff --git a/VEX/pub/libvex_ir.h b/VEX/pub/libvex_ir.h
index 85b61e7ee3bb74b21bc03eb4ac4265124485dbb7..b908c1700ff95559c2a04b08257dee9fec9bf97a 100644 (file)
--- a/VEX/pub/libvex_ir.h
+++ b/VEX/pub/libvex_ir.h
@@ -123,7 +123,7 @@ data Expr
 */
 typedef
    enum { Iex_Get, Iex_Tmp, Iex_Binop, Iex_Unop, Iex_LDle, 
-          Iex_Const, Iex_CCall }
+          Iex_Const, Iex_CCall, Iex_Mux10 }
    IRExprTag;
 
 typedef 
@@ -158,6 +158,11 @@ typedef
             IRType retty;
             struct _IRExpr** args;
          }  CCall;
+         struct {
+            struct _IRExpr* cond;
+            struct _IRExpr* expr1;
+            struct _IRExpr* expr0;
+         } Mux10;
       } Iex;
    }
    IRExpr;
@@ -169,6 +174,7 @@ extern IRExpr* IRExpr_Unop  ( IROp op, IRExpr* arg );
 extern IRExpr* IRExpr_LDle  ( IRType ty, IRExpr* addr );
 extern IRExpr* IRExpr_Const ( IRConst* con );
 extern IRExpr* IRExpr_CCall ( Char* name, IRType retty, IRExpr** args );
+extern IRExpr* IRExpr_Mux10 ( IRExpr* cond, IRExpr* expr1, IRExpr* expr0 );
 
 extern void ppIRExpr ( IRExpr* );
 
@@ -207,7 +213,6 @@ typedef
       IRStmtTag tag;
       union {
          struct {
-            IRExpr* guard;
             Int     offset;
             IRExpr* expr;
          } Put;
@@ -228,7 +233,7 @@ typedef
    }
    IRStmt;
 
-extern IRStmt* IRStmt_Put  ( IRExpr* guard, Int off, IRExpr* value );
+extern IRStmt* IRStmt_Put  ( Int off, IRExpr* value );
 extern IRStmt* IRStmt_Tmp  ( IRTemp tmp, IRExpr* expr );
 extern IRStmt* IRStmt_STle ( IRExpr* addr, IRExpr* value );
 extern IRStmt* IRStmt_Exit ( IRExpr* cond, IRConst* dst );