[Valgrind-developers] vex: r2631: Add 12 IROps for converting betwen DFP values and signed/unsigned integers.

[<sv...@va...>]

florian	2013-01-12 22:02:07 +0000 (Sat, 12 Jan 2013)

  New Revision: 2631

  Log:
    Add 12 IROps for converting betwen DFP values and signed/unsigned integers.
    Patch by Maran Pakkirisamy (ma...@li...).
    Part of fixing BZ 307113.

  Modified files:
    trunk/priv/ir_defs.c
    trunk/pub/libvex_ir.h


  Modified: trunk/priv/ir_defs.c (+40 -0)
===================================================================
--- trunk/priv/ir_defs.c	2013-01-10 15:41:46 +00:00 (rev 2630)
+++ trunk/priv/ir_defs.c	2013-01-12 22:02:07 +00:00 (rev 2631)
@@ -965,12 +965,24 @@
       case Iop_DivD64:  vex_printf("DivD64");   return;
       case Iop_ShlD64:  vex_printf("ShlD64"); return;
       case Iop_ShrD64:  vex_printf("ShrD64"); return;
+      case Iop_D64toI32S:  vex_printf("D64toI32S");  return;
+      case Iop_D64toI32U:  vex_printf("D64toI32U");  return;
       case Iop_D64toI64S:  vex_printf("D64toI64S");  return;
+      case Iop_D64toI64U:  vex_printf("D64toI64U");  return;
+      case Iop_I32StoD64:  vex_printf("I32StoD64");  return;
+      case Iop_I32UtoD64:  vex_printf("I32UtoD64");  return;
       case Iop_I64StoD64:  vex_printf("I64StoD64");  return;
+      case Iop_I64UtoD64:  vex_printf("I64UtoD64");  return;
+      case Iop_I32StoD128: vex_printf("I32StoD128"); return;
+      case Iop_I32UtoD128: vex_printf("I32UtoD128"); return;
       case Iop_I64StoD128: vex_printf("I64StoD128"); return;
+      case Iop_I64UtoD128: vex_printf("I64UtoD128"); return;
       case Iop_D64toD128:  vex_printf("D64toD128");  return;
       case Iop_D128toD64:  vex_printf("D128toD64");  return;
+      case Iop_D128toI32S: vex_printf("D128toI32S"); return;
+      case Iop_D128toI32U: vex_printf("D128toI32U"); return;
       case Iop_D128toI64S: vex_printf("D128toI64S"); return;
+      case Iop_D128toI64U: vex_printf("D128toI64U"); return;
       case Iop_AddD128: vex_printf("AddD128");  return;
       case Iop_SubD128: vex_printf("SubD128");  return;
       case Iop_MulD128: vex_printf("MulD128");  return;
@@ -2779,9 +2791,16 @@
       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);
@@ -2793,6 +2812,13 @@
       case Iop_D128toI64S:
          BINARY(ity_RMode, Ity_D128, Ity_D64);
 
+      case Iop_D128toI64U:
+         BINARY(ity_RMode, Ity_D128, Ity_I64);
+
+      case Iop_D128toI32S:
+      case Iop_D128toI32U:
+         BINARY(ity_RMode, Ity_D128, Ity_I32);
+
       case Iop_D64HLtoD128:
          BINARY(Ity_D64, Ity_D64, Ity_D128);
 
@@ -2803,12 +2829,26 @@
       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);

  Modified: trunk/pub/libvex_ir.h (+36 -0)
===================================================================
--- trunk/pub/libvex_ir.h	2013-01-10 15:41:46 +00:00 (rev 2630)
+++ trunk/pub/libvex_ir.h	2013-01-12 22:02:07 +00:00 (rev 2631)
@@ -1039,24 +1039,60 @@
       /*   D64 -> D128 */
       Iop_D64toD128, 
 
+      /*   I32S -> D128 */
+      Iop_I32StoD128,
+
+      /*   I32U -> D128 */
+      Iop_I32UtoD128,
+
       /*   I64S -> D128 */
       Iop_I64StoD128, 
 
+      /*   I64U -> D128 */
+      Iop_I64UtoD128,
+
       /*   IRRoundingModeDFP(I32) x D64 -> D32 */
       Iop_D64toD32,
 
       /*   IRRoundingModeDFP(I32) x D128 -> D64 */
       Iop_D128toD64,
 
+      /*   I32S -> D64 */
+      Iop_I32StoD64,
+
+      /*   I32U -> D64 */
+      Iop_I32UtoD64,
+
       /*   IRRoundingModeDFP(I32) x I64 -> D64 */
       Iop_I64StoD64,
 
+      /*   IRRoundingModeDFP(I32) x I64 -> D64 */
+      Iop_I64UtoD64,
+
+      /*   IRRoundingModeDFP(I32) x D64 -> I32 */
+      Iop_D64toI32S,
+
+      /*   IRRoundingModeDFP(I32) x D64 -> I32 */
+      Iop_D64toI32U,
+
       /*   IRRoundingModeDFP(I32) x D64 -> I64 */
       Iop_D64toI64S,
 
+      /*   IRRoundingModeDFP(I32) x D64 -> I64 */
+      Iop_D64toI64U,
+
+      /*   IRRoundingModeDFP(I32) x D128 -> I32 */
+      Iop_D128toI32S,
+
+      /*   IRRoundingModeDFP(I32) x D128 -> I32 */
+      Iop_D128toI32U,
+
       /*   IRRoundingModeDFP(I32) x D128 -> I64 */
       Iop_D128toI64S,
 
+      /*   IRRoundingModeDFP(I32) x D128 -> I64 */
+      Iop_D128toI64U,
+
       /* ROUNDING INSTRUCTIONS
        * IRRoundingMode(I32) x D64 -> D64
        * The D64 operand, if a finite number, is rounded to an integer value.