Add a few cases arising from testing on amd64.

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3544

diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c
index b46178f82340dc77dd7f6ddef8fe06f2b4409d20..dd11f6ed942d43281d2e82976e9a6ebf08a00c25 100644 (file)
--- a/memcheck/mc_translate.c
+++ b/memcheck/mc_translate.c
@@ -507,7 +507,18 @@ static IRAtom* mkPCastTo( MCEnv* mce, IRType dst_ty, IRAtom* vbits )
       case Ity_I64: 
          tmp1 = assignNew(mce, Ity_I1, binop(Iop_CmpNE64, vbits, mkU64(0)));
          break;
+      case Ity_I128: {
+         /* Gah.  Chop it in half, OR the halves together, and compare
+            that with zero. */
+         IRAtom* tmp2 = assignNew(mce, Ity_I64, unop(Iop_128HIto64, vbits));
+         IRAtom* tmp3 = assignNew(mce, Ity_I64, unop(Iop_128to64, vbits));
+         IRAtom* tmp4 = assignNew(mce, Ity_I64, binop(Iop_Or64, tmp2, tmp3));
+         tmp1         = assignNew(mce, Ity_I1, 
+                                       binop(Iop_CmpNE64, tmp4, mkU64(0)));
+         break;
+      }
       default:
+         ppIRType(ty);
          VG_(tool_panic)("mkPCastTo(1)");
    }
    tl_assert(tmp1);
@@ -527,6 +538,10 @@ static IRAtom* mkPCastTo( MCEnv* mce, IRType dst_ty, IRAtom* vbits )
          tmp1 = assignNew(mce, Ity_I64,  unop(Iop_1Sto64, tmp1));
          tmp1 = assignNew(mce, Ity_V128, binop(Iop_64HLtoV128, tmp1, tmp1));
          return tmp1;
+      case Ity_I128:
+         tmp1 = assignNew(mce, Ity_I64,  unop(Iop_1Sto64, tmp1));
+         tmp1 = assignNew(mce, Ity_I128, binop(Iop_64HLto128, tmp1, tmp1));
+         return tmp1;
       default: 
          ppIRType(dst_ty);
          VG_(tool_panic)("mkPCastTo(2)");
@@ -1509,6 +1524,10 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_InterleaveHI8x16:
          return assignNew(mce, Ity_V128, binop(op, vatom1, vatom2));
 
+      /* I128-bit data-steering */
+      case Iop_64HLto128:
+         return assignNew(mce, Ity_I128, binop(op, vatom1, vatom2));
+
       /* Scalar floating point */
 
       case Iop_RoundF64:
@@ -1550,6 +1569,10 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_DivModS64to32:
          return mkLazy2(mce, Ity_I64, vatom1, vatom2);
 
+      case Iop_DivModU128to64:
+      case Iop_DivModS128to64:
+         return mkLazy2(mce, Ity_I128, vatom1, vatom2);
+
       case Iop_16HLto32:
          return assignNew(mce, Ity_I32, binop(op, vatom1, vatom2));
       case Iop_32HLto64:
@@ -1601,6 +1624,7 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
          return mkLeft32(mce, mkUifU32(mce, vatom1,vatom2));
 
       /* could do better: Add64, Sub64 */
+      case Iop_Mul64:
       case Iop_Add64:
       case Iop_Sub64:
          return mkLeft64(mce, mkUifU64(mce, vatom1,vatom2));
@@ -1614,12 +1638,22 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_Add8:
          return mkLeft8(mce, mkUifU8(mce, vatom1,vatom2));
 
+      case Iop_CmpEQ64: 
+         if (mce->bogusLiterals)
+            return expensiveCmpEQorNE(mce,Ity_I64, vatom1,vatom2, atom1,atom2 );
+         else
+            goto cheap_cmp64;
+      cheap_cmp64:
+        //      case Iop_CmpLE64S: case Iop_CmpLE64U: 
+        //      case Iop_CmpLT64U: case Iop_CmpLT64S:
+        //      case Iop_CmpNE64:
+         return mkPCastTo(mce, Ity_I1, mkUifU64(mce, vatom1,vatom2));
+
       case Iop_CmpEQ32: 
          if (mce->bogusLiterals)
             return expensiveCmpEQorNE(mce,Ity_I32, vatom1,vatom2, atom1,atom2 );
          else
             goto cheap_cmp32;
-
       cheap_cmp32:
       case Iop_CmpLE32S: case Iop_CmpLE32U: 
       case Iop_CmpLT32U: case Iop_CmpLT32S:
@@ -1648,7 +1682,7 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
          complainIfUndefined(mce, atom2);
          return assignNew(mce, Ity_I8, binop(op, vatom1, atom2));
 
-      case Iop_Shl64: case Iop_Shr64: 
+      case Iop_Shl64: case Iop_Shr64: case Iop_Sar64:
          /* Same scheme as with 32-bit shifts. */
          complainIfUndefined(mce, atom2);
          return assignNew(mce, Ity_I64, binop(op, vatom1, atom2));
@@ -1991,6 +2025,10 @@ IRExpr* zwidenToHostWord ( MCEnv* mce, IRAtom* vatom )
    if (tyH == Ity_I64) {
       switch (ty) {
          case Ity_I32: return assignNew(mce, tyH, unop(Iop_32Uto64, vatom));
+         case Ity_I16: return assignNew(mce, tyH, unop(Iop_32Uto64, 
+                              assignNew(mce, Ity_I32, unop(Iop_16Uto32, vatom))));
+         case Ity_I8:  return assignNew(mce, tyH, unop(Iop_32Uto64, 
+                              assignNew(mce, Ity_I32, unop(Iop_8Uto32, vatom))));
          default:      goto unhandled;
       }
    } else {