Add memcheck support for the IROps added in VEX r2631.

Adapt vbit-tester.
Patch by Maran Pakkirisamy (maranp@linux.vnet.ibm.com).
Part of fixing BZ 307113.

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

diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c
index 70ad02d814b737dbd14f7e9a06d2d7dfedff4cfe..2d0d867474b42aa5d298294300acecbb0b3b327b 100644 (file)
--- a/memcheck/mc_translate.c
+++ b/memcheck/mc_translate.c
@@ -3305,8 +3305,10 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
          return mkLazy2(mce, Ity_I128, vatom1, vatom2);
 
       case Iop_D64toI64S:
+      case Iop_D64toI64U:
       case Iop_I64StoD64:
-         /* I32(DFP rm) x I64 -> D64 */
+      case Iop_I64UtoD64:
+         /* I32(DFP rm) x I64/D64 -> D64/I64 */
          return mkLazy2(mce, Ity_I64, vatom1, vatom2);
 
       case Iop_RoundF32toInt:
@@ -3328,6 +3330,8 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_F128toI32S: /* IRRoundingMode(I32) x F128 -> signed I32  */
       case Iop_F128toI32U: /* IRRoundingMode(I32) x F128 -> unsigned I32  */
       case Iop_F128toF32:  /* IRRoundingMode(I32) x F128 -> F32         */
+      case Iop_D128toI32S: /* IRRoundingModeDFP(I32) x D128 -> signed I32  */
+      case Iop_D128toI32U: /* IRRoundingModeDFP(I32) x D128 -> unsigned I32  */
          return mkLazy2(mce, Ity_I32, vatom1, vatom2);
 
       case Iop_F128toI64S: /* IRRoundingMode(I32) x F128 -> signed I64  */
@@ -3335,6 +3339,7 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_F128toF64:  /* IRRoundingMode(I32) x F128 -> F64         */
       case Iop_D128toD64:  /* IRRoundingModeDFP(I64) x D128 -> D64 */
       case Iop_D128toI64S: /* IRRoundingModeDFP(I64) x D128 -> signed I64  */
+      case Iop_D128toI64U: /* IRRoundingModeDFP(I32) x D128 -> unsigned I64  */
          return mkLazy2(mce, Ity_I64, vatom1, vatom2);
 
       case Iop_F64HLtoF128:
@@ -3346,7 +3351,9 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce,
       case Iop_F64toI32S:
       case Iop_F64toF32:
       case Iop_I64UtoF32:
-         /* First arg is I32 (rounding mode), second is F64 (data). */
+      case Iop_D64toI32U:
+      case Iop_D64toI32S:
+         /* First arg is I32 (rounding mode), second is F64/D64 (data). */
          return mkLazy2(mce, Ity_I32, vatom1, vatom2);
 
       case Iop_D64toD32:
@@ -3699,7 +3706,10 @@ IRExpr* expr2vbits_Unop ( MCEnv* mce, IROp op, IRAtom* atom )
       case Iop_I64UtoF128: /* unsigned I64 -> F128 */
       case Iop_F32toF128:  /* F32 -> F128 */
       case Iop_F64toF128:  /* F64 -> F128 */
+      case Iop_I32StoD128: /* signed I64 -> D128 */
       case Iop_I64StoD128: /* signed I64 -> D128 */
+      case Iop_I32UtoD128: /* unsigned I32 -> D128 */
+      case Iop_I64UtoD128: /* unsigned I64 -> D128 */
          return mkPCastTo(mce, Ity_I128, vatom);
 
       case Iop_F32toF64: 
@@ -3714,6 +3724,8 @@ IRExpr* expr2vbits_Unop ( MCEnv* mce, IROp op, IRAtom* atom )
       case Iop_RoundF64toF64_ZERO:
       case Iop_Clz64:
       case Iop_D32toD64:
+      case Iop_I32StoD64:
+      case Iop_I32UtoD64:
       case Iop_ExtractExpD64:    /* D64  -> I64 */
       case Iop_ExtractExpD128:   /* D128 -> I64 */
       case Iop_ExtractSigD64:    /* D64  -> I64 */

diff --git a/memcheck/tests/vbit-test/irops.c b/memcheck/tests/vbit-test/irops.c
index 210ce4479531e20c74fe9a88180ab81b18e97734..fc2be4cdf9823847fae4ef96692cf949f98e03cf 100644 (file)
--- a/memcheck/tests/vbit-test/irops.c
+++ b/memcheck/tests/vbit-test/irops.c
@@ -491,12 +491,24 @@ static irop_t irops[] = {
   { DEFOP(Iop_ShrD128,               UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
   { DEFOP(Iop_D32toD64,              UNDEF_ALL),  .s390x = 1, .ppc64 = 1, .ppc32 = 1 },
   { DEFOP(Iop_D64toD128,             UNDEF_ALL),  .s390x = 1, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_I32StoD128,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_I32UtoD128,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_I64StoD128,            UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_I64UtoD128,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_D64toD32,              UNDEF_ALL),  .s390x = 1, .ppc64 = 1, .ppc32 = 1 },
   { DEFOP(Iop_D128toD64,             UNDEF_ALL),  .s390x = 1, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_I32StoD64,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_I32UtoD64,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_I64StoD64,             UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_I64UtoD64,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_D64toI32S,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_D64toI32U,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_D64toI64S,             UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_D64toI64U,             UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_D128toI64S,            UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
+  { DEFOP(Iop_D128toI64U,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_D128toI32S,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
+  { DEFOP(Iop_D128toI32U,            UNDEF_ALL),  .s390x = 1, .ppc64 = 0, .ppc32 = 0 },
   { DEFOP(Iop_RoundD64toInt,         UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
   { DEFOP(Iop_RoundD128toInt,        UNDEF_ALL),  .s390x = 0, .ppc64 = 1, .ppc32 = 1 },
   { DEFOP(Iop_CmpD64,                UNDEF_ALL),  .s390x = 1, .ppc64 = 1, .ppc32 = 1 },
@@ -881,6 +893,18 @@ get_irop(IROp op)
 #ifdef __s390x__
 #define S390X_FEATURES "../../../tests/s390x_features"
          switch (op) {
+         case Iop_I32StoD64:    // CDFTR
+         case Iop_I32StoD128:   // CXFTR
+         case Iop_I32UtoD64:    // CDLFTR
+         case Iop_I32UtoD128:   // CXLFTR
+         case Iop_I64UtoD64:    // CDLGTR
+         case Iop_I64UtoD128:   // CXLGTR
+         case Iop_D64toI32S:    // CFDTR
+         case Iop_D128toI32S:   // CFXTR
+         case Iop_D64toI64U:    // CLGDTR
+         case Iop_D64toI32U:    // CLFDTR
+         case Iop_D128toI64U:   // CLGXTR
+         case Iop_D128toI32U:   // CLFXTR
          case Iop_I32UtoF32:
          case Iop_I32UtoF64:
          case Iop_I32UtoF128:

diff --git a/memcheck/tests/vbit-test/util.c b/memcheck/tests/vbit-test/util.c
index eda8592ff51cfa93ceb932992b1e76e52f498276..7297f4107f2e93fd5a6abb45056bdd01b8da9387 100644 (file)
--- a/memcheck/tests/vbit-test/util.c
+++ b/memcheck/tests/vbit-test/util.c
@@ -859,9 +859,16 @@ typeof_primop(IROp op, IRType *t_dst, IRType *t_arg1, IRType *t_arg2,
       case Iop_RoundD128toInt:
          BINARY(ity_RMode,Ity_D128, Ity_D128);
 
+      case Iop_I32StoD128:
+      case Iop_I32UtoD128:
+         UNARY(Ity_I32, Ity_D128);
+
       case Iop_I64StoD128:    /* I64 bit pattern stored in Float register */
          UNARY(Ity_D64, Ity_D128);
 
+      case Iop_I64UtoD128:
+         UNARY(Ity_I64, Ity_D128);
+
       case Iop_DPBtoBCD:
       case Iop_BCDtoDPB:
          UNARY(Ity_I64, Ity_I64);
@@ -870,9 +877,16 @@ typeof_primop(IROp op, IRType *t_dst, IRType *t_arg1, IRType *t_arg2,
       case Iop_D128LOtoD64:
          UNARY(Ity_D128, Ity_D64);
 
+      case Iop_D128toI32S:
+      case Iop_D128toI32U:
+         BINARY(ity_RMode, Ity_D128, Ity_I32);
+
       case Iop_D128toI64S:
          BINARY(ity_RMode, Ity_D128, Ity_D64);
 
+      case Iop_D128toI64U:
+         BINARY(ity_RMode, Ity_D128, Ity_I64);
+
       case Iop_D64HLtoD128:
          BINARY(Ity_D64, Ity_D64, Ity_D128);
 
@@ -883,12 +897,26 @@ typeof_primop(IROp op, IRType *t_dst, IRType *t_arg1, IRType *t_arg2,
       case Iop_D64toD32:  
          BINARY(ity_RMode, Ity_D64, Ity_D32);
 
+      case Iop_D64toI32S:
+      case Iop_D64toI32U:
+         BINARY(ity_RMode, Ity_D64, Ity_I32);
+
       case Iop_D64toI64S:
          BINARY(ity_RMode, Ity_D64, Ity_D64);
 
+      case Iop_D64toI64U:
+         BINARY(ity_RMode, Ity_D64, Ity_I64);
+
+      case Iop_I32StoD64:
+      case Iop_I32UtoD64:
+         UNARY(Ity_I32, Ity_D64);
+
       case Iop_I64StoD64:  /* I64 bit pattern stored in Float register */
          BINARY(ity_RMode, Ity_D64, Ity_D64);
 
+      case Iop_I64UtoD64:
+         BINARY(ity_RMode, Ity_I64, Ity_D64);
+
       case Iop_CmpD64:
       case Iop_CmpExpD64:
          BINARY(Ity_D64,Ity_D64, Ity_I32);