s390: This is a pre-patch for DFP support. It renames certain

identifiers to explicitly refer to BFP, as there will be counterparts
in the future for DFP.
Patch by Maran <maranp@linux.vnet.ibm.com>.
Part of fixing #307113.

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

diff --git a/VEX/priv/guest_s390_helpers.c b/VEX/priv/guest_s390_helpers.c
index 247d3abbed79b7cfa93aac77a66cce4a8fd2d8ca..75f40219842aa5e5b026de632d07aff07ed0be11 100644 (file)
--- a/VEX/priv/guest_s390_helpers.c
+++ b/VEX/priv/guest_s390_helpers.c
@@ -874,14 +874,14 @@ ULong s390_do_ecag(ULong op2addr) { return 0; }
 
 /* Convert an IRRoundingMode value to s390_round_t */
 #if defined(VGA_s390x)
-static s390_round_t
+static s390_bfp_round_t
 decode_bfp_rounding_mode(UInt irrm)
 {
    switch (irrm) {
-   case Irrm_NEAREST: return S390_ROUND_NEAREST_EVEN;
-   case Irrm_NegINF:  return S390_ROUND_NEGINF;
-   case Irrm_PosINF:  return S390_ROUND_POSINF;
-   case Irrm_ZERO:    return S390_ROUND_ZERO;
+   case Irrm_NEAREST: return S390_BFP_ROUND_NEAREST_EVEN;
+   case Irrm_NegINF:  return S390_BFP_ROUND_NEGINF;
+   case Irrm_PosINF:  return S390_BFP_ROUND_POSINF;
+   case Irrm_ZERO:    return S390_BFP_ROUND_ZERO;
    }
    vpanic("decode_bfp_rounding_mode");
 }
@@ -965,20 +965,20 @@ decode_bfp_rounding_mode(UInt irrm)
 ({                                                        \
    UInt cc;                                               \
    switch (decode_bfp_rounding_mode(cc_dep2)) {           \
-   case S390_ROUND_NEAREST_EVEN:                          \
+   case S390_BFP_ROUND_NEAREST_EVEN:                      \
       cc = S390_CC_FOR_BFP_CONVERT_AUX(opcode,cc_dep1,4); \
       break;                                              \
-   case S390_ROUND_ZERO:                                  \
+   case S390_BFP_ROUND_ZERO:                              \
       cc = S390_CC_FOR_BFP_CONVERT_AUX(opcode,cc_dep1,5); \
       break;                                              \
-   case S390_ROUND_POSINF:                                \
+   case S390_BFP_ROUND_POSINF:                            \
       cc = S390_CC_FOR_BFP_CONVERT_AUX(opcode,cc_dep1,6); \
       break;                                              \
-   case S390_ROUND_NEGINF:                                \
+   case S390_BFP_ROUND_NEGINF:                            \
       cc = S390_CC_FOR_BFP_CONVERT_AUX(opcode,cc_dep1,7); \
       break;                                              \
    default:                                               \
-      vpanic("unexpected rounding mode");                 \
+      vpanic("unexpected bfp rounding mode");             \
    }                                                      \
    cc;                                                    \
 })
@@ -997,20 +997,20 @@ decode_bfp_rounding_mode(UInt irrm)
 ({                                                         \
    UInt cc;                                                \
    switch (decode_bfp_rounding_mode(cc_dep2)) {            \
-   case S390_ROUND_NEAREST_EVEN:                           \
+   case S390_BFP_ROUND_NEAREST_EVEN:                       \
       cc = S390_CC_FOR_BFP_UCONVERT_AUX(opcode,cc_dep1,4); \
       break;                                               \
-   case S390_ROUND_ZERO:                                   \
+   case S390_BFP_ROUND_ZERO:                               \
       cc = S390_CC_FOR_BFP_UCONVERT_AUX(opcode,cc_dep1,5); \
       break;                                               \
-   case S390_ROUND_POSINF:                                 \
+   case S390_BFP_ROUND_POSINF:                             \
       cc = S390_CC_FOR_BFP_UCONVERT_AUX(opcode,cc_dep1,6); \
       break;                                               \
-   case S390_ROUND_NEGINF:                                 \
+   case S390_BFP_ROUND_NEGINF:                             \
       cc = S390_CC_FOR_BFP_UCONVERT_AUX(opcode,cc_dep1,7); \
       break;                                               \
    default:                                                \
-      vpanic("unexpected rounding mode");                  \
+      vpanic("unexpected bfp rounding mode");              \
    }                                                       \
    cc;                                                     \
 })
@@ -1034,20 +1034,20 @@ decode_bfp_rounding_mode(UInt irrm)
       s390_cc_thunk_put3 for rationale. */                           \
    cc_dep2 = cc_dep2 ^ cc_ndep;                                      \
    switch (decode_bfp_rounding_mode(cc_ndep)) {                      \
-   case S390_ROUND_NEAREST_EVEN:                                     \
+   case S390_BFP_ROUND_NEAREST_EVEN:                                 \
       cc = S390_CC_FOR_BFP128_CONVERT_AUX(opcode,cc_dep1,cc_dep2,4); \
       break;                                                         \
-   case S390_ROUND_ZERO:                                             \
+   case S390_BFP_ROUND_ZERO:                                         \
       cc = S390_CC_FOR_BFP128_CONVERT_AUX(opcode,cc_dep1,cc_dep2,5); \
       break;                                                         \
-   case S390_ROUND_POSINF:                                           \
+   case S390_BFP_ROUND_POSINF:                                       \
       cc = S390_CC_FOR_BFP128_CONVERT_AUX(opcode,cc_dep1,cc_dep2,6); \
       break;                                                         \
-   case S390_ROUND_NEGINF:                                           \
+   case S390_BFP_ROUND_NEGINF:                                       \
       cc = S390_CC_FOR_BFP128_CONVERT_AUX(opcode,cc_dep1,cc_dep2,7); \
       break;                                                         \
    default:                                                          \
-      vpanic("unexpected rounding mode");                            \
+      vpanic("unexpected bfp rounding mode");                        \
    }                                                                 \
    cc;                                                               \
 })
@@ -1071,20 +1071,20 @@ decode_bfp_rounding_mode(UInt irrm)
       s390_cc_thunk_put3 for rationale. */                            \
    cc_dep2 = cc_dep2 ^ cc_ndep;                                       \
    switch (decode_bfp_rounding_mode(cc_ndep)) {                       \
-   case S390_ROUND_NEAREST_EVEN:                                      \
+   case S390_BFP_ROUND_NEAREST_EVEN:                                  \
       cc = S390_CC_FOR_BFP128_UCONVERT_AUX(opcode,cc_dep1,cc_dep2,4); \
       break;                                                          \
-   case S390_ROUND_ZERO:                                              \
+   case S390_BFP_ROUND_ZERO:                                          \
       cc = S390_CC_FOR_BFP128_UCONVERT_AUX(opcode,cc_dep1,cc_dep2,5); \
       break;                                                          \
-   case S390_ROUND_POSINF:                                            \
+   case S390_BFP_ROUND_POSINF:                                        \
       cc = S390_CC_FOR_BFP128_UCONVERT_AUX(opcode,cc_dep1,cc_dep2,6); \
       break;                                                          \
-   case S390_ROUND_NEGINF:                                            \
+   case S390_BFP_ROUND_NEGINF:                                        \
       cc = S390_CC_FOR_BFP128_UCONVERT_AUX(opcode,cc_dep1,cc_dep2,7); \
       break;                                                          \
    default:                                                           \
-      vpanic("unexpected rounding mode");                             \
+      vpanic("unexpected bfp rounding mode");                         \
    }                                                                  \
    cc;                                                                \
 })

diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c
index 09b09b3f5e9e8d6a61a13e0bf19403dd72699ea4..114f8bf765fd5cd81ee502f06062b11d0a78f585 100644 (file)
--- a/VEX/priv/guest_s390_toIR.c
+++ b/VEX/priv/guest_s390_toIR.c
@@ -1397,7 +1397,7 @@ get_fpc_w0(void)
 /*--- Rounding modes                                       ---*/
 /*------------------------------------------------------------*/
 
-/* Extract the rounding mode from the guest FPC reg and encode it as an
+/* Extract the bfp rounding mode from the guest FPC reg and encode it as an
    IRRoundingMode:
 
    rounding mode | s390 | IR
@@ -1410,7 +1410,7 @@ get_fpc_w0(void)
    So:  IR = (4 - s390) & 3
 */
 static IRExpr *
-get_rounding_mode_from_fpc(void)
+get_bfp_rounding_mode_from_fpc(void)
 {
    IRTemp fpc_bits = newTemp(Ity_I32);
 
@@ -1432,7 +1432,7 @@ get_rounding_mode_from_fpc(void)
    /* For now silently adjust an unsupported rounding mode to "nearest" */
    IRExpr *rm_s390 = mkite(binop(Iop_CmpLE32S, mkexpr(fpc_bits), mkU32(3)),
                            mkexpr(fpc_bits),
-                           mkU32(S390_FPC_ROUND_NEAREST_EVEN));
+                           mkU32(S390_FPC_BFP_ROUND_NEAREST_EVEN));
 
    // rm_IR = (4 - rm_s390) & 3;
    return binop(Iop_And32, binop(Iop_Sub32, mkU32(4), rm_s390), mkU32(3));
@@ -1449,13 +1449,15 @@ encode_bfp_rounding_mode(UChar mode)
    IRExpr *rm;
 
    switch (mode) {
-   case S390_ROUND_PER_FPC:       rm = get_rounding_mode_from_fpc(); break;
-   case S390_ROUND_NEAREST_AWAY:  /* not supported */
-   case S390_ROUND_PREPARE_SHORT: /* not supported */
-   case S390_ROUND_NEAREST_EVEN:  rm = mkU32(Irrm_NEAREST); break;
-   case S390_ROUND_ZERO:          rm = mkU32(Irrm_ZERO);    break;
-   case S390_ROUND_POSINF:        rm = mkU32(Irrm_PosINF);  break;
-   case S390_ROUND_NEGINF:        rm = mkU32(Irrm_NegINF);  break;
+   case S390_BFP_ROUND_PER_FPC:
+      rm = get_bfp_rounding_mode_from_fpc();
+      break;
+   case S390_BFP_ROUND_NEAREST_AWAY:  /* not supported */
+   case S390_BFP_ROUND_PREPARE_SHORT: /* not supported */
+   case S390_BFP_ROUND_NEAREST_EVEN:  rm = mkU32(Irrm_NEAREST); break;
+   case S390_BFP_ROUND_ZERO:          rm = mkU32(Irrm_ZERO);    break;
+   case S390_BFP_ROUND_POSINF:        rm = mkU32(Irrm_PosINF);  break;
+   case S390_BFP_ROUND_NEGINF:        rm = mkU32(Irrm_NegINF);  break;
    default:
       vpanic("encode_bfp_rounding_mode");
    }
@@ -8210,7 +8212,7 @@ s390_irgen_srnmb_wrapper(UChar b2, UShort d2)
             /* ok */
          } else {
             emulation_warning(EmWarn_S390X_invalid_rounding);
-            d2 = S390_FPC_ROUND_NEAREST_EVEN;
+            d2 = S390_FPC_BFP_ROUND_NEAREST_EVEN;
          }
       }
    }
@@ -8273,7 +8275,7 @@ s390_irgen_AEBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, get_fpr_w0(r2));
@@ -8291,7 +8293,7 @@ s390_irgen_ADBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, get_fpr_dw0(r2));
@@ -8309,7 +8311,7 @@ s390_irgen_AEB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, load(Ity_F32, mkexpr(op2addr)));
@@ -8327,7 +8329,7 @@ s390_irgen_ADB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, load(Ity_F64, mkexpr(op2addr)));
@@ -8343,9 +8345,9 @@ static HChar *
 s390_irgen_CEFBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp op2 = newTemp(Ity_I32);
 
@@ -8372,9 +8374,9 @@ static HChar *
 s390_irgen_CEGBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp op2 = newTemp(Ity_I64);
 
@@ -8389,9 +8391,9 @@ static HChar *
 s390_irgen_CDGBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp op2 = newTemp(Ity_I64);
 
@@ -8620,7 +8622,7 @@ s390_irgen_DEBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, get_fpr_w0(r2));
@@ -8637,7 +8639,7 @@ s390_irgen_DDBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, get_fpr_dw0(r2));
@@ -8654,7 +8656,7 @@ s390_irgen_DEB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, load(Ity_F32, mkexpr(op2addr)));
@@ -8671,7 +8673,7 @@ s390_irgen_DDB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, load(Ity_F64, mkexpr(op2addr)));
@@ -8756,9 +8758,9 @@ static HChar *
 s390_irgen_LEDBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp op = newTemp(Ity_F64);
 
@@ -8775,7 +8777,8 @@ s390_irgen_MEEBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRRoundingMode rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRRoundingMode rounding_mode =
+      encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, get_fpr_w0(r2));
@@ -8792,7 +8795,7 @@ s390_irgen_MDBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, get_fpr_dw0(r2));
@@ -8809,7 +8812,7 @@ s390_irgen_MEEB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, load(Ity_F32, mkexpr(op2addr)));
@@ -8826,7 +8829,7 @@ s390_irgen_MDB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, load(Ity_F64, mkexpr(op2addr)));
@@ -8843,7 +8846,7 @@ s390_irgen_SEBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, get_fpr_w0(r2));
@@ -8861,7 +8864,7 @@ s390_irgen_SDBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, get_fpr_dw0(r2));
@@ -8879,7 +8882,7 @@ s390_irgen_SEB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F32);
    IRTemp op2 = newTemp(Ity_F32);
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_w0(r1));
    assign(op2, load(Ity_F32, mkexpr(op2addr)));
@@ -8897,7 +8900,7 @@ s390_irgen_SDB(UChar r1, IRTemp op2addr)
    IRTemp op1 = newTemp(Ity_F64);
    IRTemp op2 = newTemp(Ity_F64);
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_dw0(r1));
    assign(op2, load(Ity_F64, mkexpr(op2addr)));
@@ -10309,7 +10312,7 @@ s390_irgen_AXBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F128);
    IRTemp op2 = newTemp(Ity_F128);
    IRTemp result = newTemp(Ity_F128);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_pair(r1));
    assign(op2, get_fpr_pair(r2));
@@ -10594,7 +10597,7 @@ s390_irgen_DXBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F128);
    IRTemp op2 = newTemp(Ity_F128);
    IRTemp result = newTemp(Ity_F128);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_pair(r1));
    assign(op2, get_fpr_pair(r2));
@@ -10749,9 +10752,9 @@ static HChar *
 s390_irgen_LDXBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp result = newTemp(Ity_F64);
 
@@ -10766,9 +10769,9 @@ static HChar *
 s390_irgen_LEXBR(UChar m3, UChar m4 __attribute__((unused)),
                  UChar r1, UChar r2)
 {
-   if (! s390_host_has_fpext && m3 != S390_ROUND_PER_FPC) {
+   if (! s390_host_has_fpext && m3 != S390_BFP_ROUND_PER_FPC) {
       emulation_warning(EmWarn_S390X_fpext_rounding);
-      m3 = S390_ROUND_PER_FPC;
+      m3 = S390_BFP_ROUND_PER_FPC;
    }
    IRTemp result = newTemp(Ity_F32);
 
@@ -10785,7 +10788,7 @@ s390_irgen_MXBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F128);
    IRTemp op2 = newTemp(Ity_F128);
    IRTemp result = newTemp(Ity_F128);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_pair(r1));
    assign(op2, get_fpr_pair(r2));
@@ -10799,7 +10802,7 @@ s390_irgen_MXBR(UChar r1, UChar r2)
 static HChar *
 s390_irgen_MAEBR(UChar r1, UChar r3, UChar r2)
 {
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_w0(r1, qop(Iop_MAddF32, mkexpr(rounding_mode),
                       get_fpr_w0(r1), get_fpr_w0(r2), get_fpr_w0(r3)));
@@ -10810,7 +10813,7 @@ s390_irgen_MAEBR(UChar r1, UChar r3, UChar r2)
 static HChar *
 s390_irgen_MADBR(UChar r1, UChar r3, UChar r2)
 {
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_dw0(r1, qop(Iop_MAddF64, mkexpr(rounding_mode),
                        get_fpr_dw0(r1), get_fpr_dw0(r2), get_fpr_dw0(r3)));
@@ -10822,7 +10825,7 @@ static HChar *
 s390_irgen_MAEB(UChar r3, IRTemp op2addr, UChar r1)
 {
    IRExpr *op2 = load(Ity_F32, mkexpr(op2addr));
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_w0(r1, qop(Iop_MAddF32, mkexpr(rounding_mode),
                       get_fpr_w0(r1), op2, get_fpr_w0(r3)));
@@ -10834,7 +10837,7 @@ static HChar *
 s390_irgen_MADB(UChar r3, IRTemp op2addr, UChar r1)
 {
    IRExpr *op2 = load(Ity_F64, mkexpr(op2addr));
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_dw0(r1, qop(Iop_MAddF64, mkexpr(rounding_mode),
                        get_fpr_dw0(r1), op2, get_fpr_dw0(r3)));
@@ -10845,7 +10848,7 @@ s390_irgen_MADB(UChar r3, IRTemp op2addr, UChar r1)
 static HChar *
 s390_irgen_MSEBR(UChar r1, UChar r3, UChar r2)
 {
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_w0(r1, qop(Iop_MSubF32, mkexpr(rounding_mode),
                       get_fpr_w0(r1), get_fpr_w0(r2), get_fpr_w0(r3)));
@@ -10856,7 +10859,7 @@ s390_irgen_MSEBR(UChar r1, UChar r3, UChar r2)
 static HChar *
 s390_irgen_MSDBR(UChar r1, UChar r3, UChar r2)
 {
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_dw0(r1, qop(Iop_MSubF64, mkexpr(rounding_mode),
                        get_fpr_dw0(r1), get_fpr_dw0(r2), get_fpr_dw0(r3)));
@@ -10868,7 +10871,7 @@ static HChar *
 s390_irgen_MSEB(UChar r3, IRTemp op2addr, UChar r1)
 {
    IRExpr *op2 = load(Ity_F32, mkexpr(op2addr));
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_w0(r1, qop(Iop_MSubF32, mkexpr(rounding_mode),
                       get_fpr_w0(r1), op2, get_fpr_w0(r3)));
@@ -10880,7 +10883,7 @@ static HChar *
 s390_irgen_MSDB(UChar r3, IRTemp op2addr, UChar r1)
 {
    IRExpr *op2 = load(Ity_F64, mkexpr(op2addr));
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    put_fpr_dw0(r1, qop(Iop_MSubF64, mkexpr(rounding_mode),
                        get_fpr_dw0(r1), op2, get_fpr_dw0(r3)));
@@ -10892,7 +10895,7 @@ static HChar *
 s390_irgen_SQEBR(UChar r1, UChar r2)
 {
    IRTemp result = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(result, binop(Iop_SqrtF32, mkexpr(rounding_mode), get_fpr_w0(r2)));
    put_fpr_w0(r1, mkexpr(result));
@@ -10904,7 +10907,7 @@ static HChar *
 s390_irgen_SQDBR(UChar r1, UChar r2)
 {
    IRTemp result = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(result, binop(Iop_SqrtF64, mkexpr(rounding_mode), get_fpr_dw0(r2)));
    put_fpr_dw0(r1, mkexpr(result));
@@ -10916,7 +10919,7 @@ static HChar *
 s390_irgen_SQXBR(UChar r1, UChar r2)
 {
    IRTemp result = newTemp(Ity_F128);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(result, binop(Iop_SqrtF128, mkexpr(rounding_mode),
                         get_fpr_pair(r2)));
@@ -10929,7 +10932,7 @@ static HChar *
 s390_irgen_SQEB(UChar r1, IRTemp op2addr)
 {
    IRTemp op = newTemp(Ity_F32);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op, load(Ity_F32, mkexpr(op2addr)));
    put_fpr_w0(r1, binop(Iop_SqrtF32, mkexpr(rounding_mode), mkexpr(op)));
@@ -10941,7 +10944,7 @@ static HChar *
 s390_irgen_SQDB(UChar r1, IRTemp op2addr)
 {
    IRTemp op = newTemp(Ity_F64);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op, load(Ity_F64, mkexpr(op2addr)));
    put_fpr_dw0(r1, binop(Iop_SqrtF64, mkexpr(rounding_mode), mkexpr(op)));
@@ -10955,7 +10958,7 @@ s390_irgen_SXBR(UChar r1, UChar r2)
    IRTemp op1 = newTemp(Ity_F128);
    IRTemp op2 = newTemp(Ity_F128);
    IRTemp result = newTemp(Ity_F128);
-   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_ROUND_PER_FPC);
+   IRTemp rounding_mode = encode_bfp_rounding_mode(S390_BFP_ROUND_PER_FPC);
 
    assign(op1, get_fpr_pair(r1));
    assign(op2, get_fpr_pair(r2));

diff --git a/VEX/priv/host_s390_defs.c b/VEX/priv/host_s390_defs.c
index 01056ef0c8cc75608f3df87d284c01797c1d3050..3ffe0eb58c5e94b24eb638dc3712e73667e0c985 100644 (file)
--- a/VEX/priv/host_s390_defs.c
+++ b/VEX/priv/host_s390_defs.c
@@ -708,8 +708,8 @@ s390_insn_get_reg_usage(HRegUsage *u, const s390_insn *insn)
    case S390_INSN_GADD:
       break;
 
-   case S390_INSN_SET_FPCRM:
-      addHRegUse(u, HRmRead,  insn->variant.set_fpcrm.mode);
+   case S390_INSN_SET_FPC_BFPRM:
+      addHRegUse(u, HRmRead,  insn->variant.set_fpc_bfprm.mode);
       break;
 
    case S390_INSN_EVCHECK:
@@ -936,9 +936,9 @@ s390_insn_map_regs(HRegRemap *m, s390_insn *insn)
    case S390_INSN_GADD:
       break;
 
-   case S390_INSN_SET_FPCRM:
-      insn->variant.set_fpcrm.mode =
-         lookupHRegRemap(m, insn->variant.set_fpcrm.mode);
+   case S390_INSN_SET_FPC_BFPRM:
+      insn->variant.set_fpc_bfprm.mode =
+         lookupHRegRemap(m, insn->variant.set_fpc_bfprm.mode);
       break;
 
    case S390_INSN_EVCHECK:
@@ -4738,7 +4738,7 @@ s390_insn_bfp_compare(UChar size, HReg dst, HReg op1, HReg op2)
 
 s390_insn *
 s390_insn_bfp_convert(UChar size, s390_conv_t tag, HReg dst, HReg op,
-                      s390_round_t rounding_mode)
+                      s390_bfp_round_t rounding_mode)
 {
    s390_insn *insn = LibVEX_Alloc(sizeof(s390_insn));
 
@@ -4841,7 +4841,7 @@ s390_insn_bfp128_compare(UChar size, HReg dst, HReg op1_hi, HReg op1_lo,
 static s390_insn *
 s390_insn_bfp128_convert(UChar size, s390_conv_t tag, HReg dst_hi,
                          HReg dst_lo, HReg op_hi, HReg op_lo,
-                         s390_round_t rounding_mode)
+                         s390_bfp_round_t rounding_mode)
 {
    s390_insn *insn = LibVEX_Alloc(sizeof(s390_insn));
 
@@ -4874,7 +4874,7 @@ s390_insn_bfp128_convert_to(UChar size, s390_conv_t tag, HReg dst_hi,
 {
    /* Conversion to bfp128 never requires a rounding mode. Provide default
       rounding mode. It will not be used when emitting insns. */
-   s390_round_t rounding_mode = S390_ROUND_NEAREST_EVEN;
+   s390_bfp_round_t rounding_mode = S390_BFP_ROUND_NEAREST_EVEN;
 
    return s390_insn_bfp128_convert(size, tag, dst_hi, dst_lo, op,
                                    INVALID_HREG, rounding_mode);
@@ -4884,7 +4884,7 @@ s390_insn_bfp128_convert_to(UChar size, s390_conv_t tag, HReg dst_hi,
 s390_insn *
 s390_insn_bfp128_convert_from(UChar size, s390_conv_t tag, HReg dst,
                               HReg op_hi, HReg op_lo,
-                              s390_round_t rounding_mode)
+                              s390_bfp_round_t rounding_mode)
 {
    return s390_insn_bfp128_convert(size, tag, dst, INVALID_HREG, op_hi, op_lo,
                                    rounding_mode);
@@ -4932,15 +4932,15 @@ s390_insn_gadd(UChar size, UInt offset, UChar delta, ULong value)
 
 
 s390_insn *
-s390_insn_set_fpcrm(UChar size, HReg mode)
+s390_insn_set_fpc_bfprm(UChar size, HReg mode)
 {
    vassert(size == 4);
 
    s390_insn *insn = LibVEX_Alloc(sizeof(s390_insn));
 
-   insn->tag  = S390_INSN_SET_FPCRM;
+   insn->tag  = S390_INSN_SET_FPC_BFPRM;
    insn->size = size;
-   insn->variant.set_fpcrm.mode = mode;
+   insn->variant.set_fpc_bfprm.mode = mode;
 
    return insn;
 }
@@ -5451,8 +5451,9 @@ s390_insn_as_string(const s390_insn *insn)
                    insn->variant.gadd.value);
       break;
 
-   case S390_INSN_SET_FPCRM:
-      s390_sprintf(buf, "%M %R", "v-set-fpcrm", insn->variant.set_fpcrm.mode);
+   case S390_INSN_SET_FPC_BFPRM:
+      s390_sprintf(buf, "%M %R", "v-set-fpc-bfprm",
+                   insn->variant.set_fpc_bfprm.mode);
       break;
 
    case S390_INSN_EVCHECK:
@@ -7415,7 +7416,7 @@ s390_insn_bfp_convert_emit(UChar *buf, const s390_insn *insn)
 {
    UInt  r1 = hregNumber(insn->variant.bfp_convert.dst_hi);
    UInt  r2 = hregNumber(insn->variant.bfp_convert.op_hi);
-   s390_round_t m3 = insn->variant.bfp_convert.rounding_mode;
+   s390_bfp_round_t m3 = insn->variant.bfp_convert.rounding_mode;
    /* The IEEE-inexact-exception control is not modelled. So the
       m4 field is 0 (which is what GCC does, too) */
    const UInt m4 = 0;
@@ -7518,9 +7519,9 @@ s390_insn_gadd_emit(UChar *buf, const s390_insn *insn)
 
 
 static UChar *
-s390_insn_set_fpcrm_emit(UChar *buf, const s390_insn *insn)
+s390_insn_set_fpc_bfprm_emit(UChar *buf, const s390_insn *insn)
 {
-   UInt mode = hregNumber(insn->variant.set_fpcrm.mode);
+   UInt mode = hregNumber(insn->variant.set_fpc_bfprm.mode);
 
    /* Copy FPC from guest state to R0 and OR in the new rounding mode */
    buf = s390_emit_L(buf, R0, 0, S390_REGNO_GUEST_STATE_POINTER,
@@ -8074,8 +8075,8 @@ emit_S390Instr(Bool *is_profinc, UChar *buf, Int nbuf, s390_insn *insn,
       end = s390_insn_gadd_emit(buf, insn);
       break;
 
-   case S390_INSN_SET_FPCRM:
-      end = s390_insn_set_fpcrm_emit(buf, insn);
+   case S390_INSN_SET_FPC_BFPRM:
+      end = s390_insn_set_fpc_bfprm_emit(buf, insn);
       break;
 
    case S390_INSN_PROFINC:

diff --git a/VEX/priv/host_s390_defs.h b/VEX/priv/host_s390_defs.h
index 7ce079375983d74f914233b4ec8888532eba7c57..6034b48dce5633becbbd60c0dbe0f6e41aca1b48 100644 (file)
--- a/VEX/priv/host_s390_defs.h
+++ b/VEX/priv/host_s390_defs.h
@@ -140,7 +140,7 @@ typedef enum {
    S390_INSN_MFENCE,
    S390_INSN_GZERO,   /* Assign zero to a guest register */
    S390_INSN_GADD,    /* Add a value to a guest register */
-   S390_INSN_SET_FPCRM, /* Set the rounding mode in the FPC */
+   S390_INSN_SET_FPC_BFPRM, /* Set the bfp rounding mode in the FPC */
    /* The following 5 insns are mandated by translation chaining */
    S390_INSN_XDIRECT,     /* direct transfer to guest address */
    S390_INSN_XINDIR,      /* indirect transfer to guest address */
@@ -257,28 +257,28 @@ typedef enum {
 /* Rounding mode as it is encoded in the m3 field of certain
    instructions (e.g. CFEBR) */
 typedef enum {
-   S390_ROUND_PER_FPC       = 0,
-   S390_ROUND_NEAREST_AWAY  = 1,
+   S390_BFP_ROUND_PER_FPC       = 0,
+   S390_BFP_ROUND_NEAREST_AWAY  = 1,
    /* 2 is not allowed */
-   S390_ROUND_PREPARE_SHORT = 3,
-   S390_ROUND_NEAREST_EVEN  = 4,
-   S390_ROUND_ZERO          = 5,
-   S390_ROUND_POSINF        = 6,
-   S390_ROUND_NEGINF        = 7
-} s390_round_t;
+   S390_BFP_ROUND_PREPARE_SHORT = 3,
+   S390_BFP_ROUND_NEAREST_EVEN  = 4,
+   S390_BFP_ROUND_ZERO          = 5,
+   S390_BFP_ROUND_POSINF        = 6,
+   S390_BFP_ROUND_NEGINF        = 7
+} s390_bfp_round_t;
 
 
 /* Rounding mode as it is encoded in bits [29:31] of the FPC register.
    Only rounding modes 0..3 are universally supported. Others require
    additional hardware facilities. */
 typedef enum {
-   S390_FPC_ROUND_NEAREST_EVEN  = 0,
-   S390_FPC_ROUND_ZERO          = 1,
-   S390_FPC_ROUND_POSINF        = 2,
-   S390_FPC_ROUND_NEGINF        = 3,
+   S390_FPC_BFP_ROUND_NEAREST_EVEN  = 0,
+   S390_FPC_BFP_ROUND_ZERO          = 1,
+   S390_FPC_BFP_ROUND_POSINF        = 2,
+   S390_FPC_BFP_ROUND_NEGINF        = 3,
    /* 4,5,6 are not allowed */
-   S390_FPC_ROUND_PREPARE_SHORT = 7
-} s390_fpc_round_t;
+   S390_FPC_BFP_ROUND_PREPARE_SHORT = 7
+} s390_fpc_bfp_round_t;
 
 
 /* Invert the condition code */
@@ -438,7 +438,7 @@ typedef struct {
       } bfp_unop;
       struct {
          s390_conv_t  tag;
-         s390_round_t rounding_mode;
+         s390_bfp_round_t rounding_mode;
          HReg         dst_hi; /* 128-bit result high part; 32/64-bit result */
          HReg         dst_lo; /* 128-bit result low part */
          HReg         op_hi;  /* 128-bit operand high part; 32/64-bit opnd */
@@ -463,7 +463,7 @@ typedef struct {
       } gadd;
       struct {
          HReg             mode;
-      } set_fpcrm;
+      } set_fpc_bfprm;
 
       /* The next 5 entries are generic to support translation chaining */
 
@@ -541,7 +541,7 @@ s390_insn *s390_insn_bfp_unop(UChar size, s390_bfp_unop_t tag, HReg dst,
                               HReg op);
 s390_insn *s390_insn_bfp_compare(UChar size, HReg dst, HReg op1, HReg op2);
 s390_insn *s390_insn_bfp_convert(UChar size, s390_conv_t tag, HReg dst,
-                                 HReg op, s390_round_t);
+                                 HReg op, s390_bfp_round_t);
 s390_insn *s390_insn_bfp128_binop(UChar size, s390_bfp_binop_t, HReg dst_hi,
                                   HReg dst_lo, HReg op2_hi, HReg op2_lo);
 s390_insn *s390_insn_bfp128_unop(UChar size, s390_bfp_unop_t, HReg dst_hi,
@@ -552,11 +552,11 @@ s390_insn *s390_insn_bfp128_convert_to(UChar size, s390_conv_t,
                                        HReg dst_hi, HReg dst_lo, HReg op);
 s390_insn *s390_insn_bfp128_convert_from(UChar size, s390_conv_t,
                                          HReg dst, HReg op_hi, HReg op_lo,
-                                         s390_round_t);
+                                         s390_bfp_round_t);
 s390_insn *s390_insn_mfence(void);
 s390_insn *s390_insn_gzero(UChar size, UInt offset);
 s390_insn *s390_insn_gadd(UChar size, UInt offset, UChar delta, ULong value);
-s390_insn *s390_insn_set_fpcrm(UChar size, HReg mode);
+s390_insn *s390_insn_set_fpc_bfprm(UChar size, HReg mode);
 
 /* Five for translation chaining */
 s390_insn *s390_insn_xdirect(s390_cc_t cond, Addr64 dst, s390_amode *guest_IA,

diff --git a/VEX/priv/host_s390_isel.c b/VEX/priv/host_s390_isel.c
index 1c14749d8a907d4f6cd2d324d36cefc58b72d1e4..afa5df8961644750a1b8e4e16de01ad1013fa718 100644 (file)
--- a/VEX/priv/host_s390_isel.c
+++ b/VEX/priv/host_s390_isel.c
@@ -577,7 +577,7 @@ set_bfp_rounding_mode_in_fpc(ISelEnv *env, IRExpr *irrm)
    addInstr(env, s390_insn_alu(4, S390_ALU_SUB, mode, s390_opnd_reg(ir)));
    addInstr(env, s390_insn_alu(4, S390_ALU_AND, mode, s390_opnd_imm(3)));
 
-   addInstr(env, s390_insn_set_fpcrm(4, mode));
+   addInstr(env, s390_insn_set_fpc_bfprm(4, mode));
 }
 
 
@@ -585,7 +585,7 @@ set_bfp_rounding_mode_in_fpc(ISelEnv *env, IRExpr *irrm)
    a rounding mode in the insn itself. In that case there is no need to
    stick the rounding mode into the FPC -- a good thing. However, the
    rounding mode must be known. */
-static s390_round_t
+static s390_bfp_round_t
 get_bfp_rounding_mode(ISelEnv *env, IRExpr *irrm)
 {
    if (irrm->tag == Iex_Const) {          /* rounding mode is known */
@@ -593,17 +593,17 @@ get_bfp_rounding_mode(ISelEnv *env, IRExpr *irrm)
       IRRoundingMode mode = irrm->Iex.Const.con->Ico.U32;
 
       switch (mode) {
-      case Irrm_NEAREST:  return S390_ROUND_NEAREST_EVEN;
-      case Irrm_ZERO:     return S390_ROUND_ZERO;
-      case Irrm_PosINF:   return S390_ROUND_POSINF;
-      case Irrm_NegINF:   return S390_ROUND_NEGINF;
+      case Irrm_NEAREST:  return S390_BFP_ROUND_NEAREST_EVEN;
+      case Irrm_ZERO:     return S390_BFP_ROUND_ZERO;
+      case Irrm_PosINF:   return S390_BFP_ROUND_POSINF;
+      case Irrm_NegINF:   return S390_BFP_ROUND_NEGINF;
       default:
          vpanic("get_bfp_rounding_mode");
       }
    }
 
    set_bfp_rounding_mode_in_fpc(env, irrm);
-   return S390_ROUND_PER_FPC;
+   return S390_BFP_ROUND_PER_FPC;
 }
 
 
@@ -981,7 +981,7 @@ s390_isel_int_expr_wrk(ISelEnv *env, IRExpr *expr)
       case Iop_F128toI64U: conv = S390_BFP_F128_TO_U64; goto do_convert_128;
 
       do_convert: {
-         s390_round_t rounding_mode;
+         s390_bfp_round_t rounding_mode;
 
          res  = newVRegI(env);
          h1   = s390_isel_float_expr(env, arg2);   /* Process operand */
@@ -993,7 +993,7 @@ s390_isel_int_expr_wrk(ISelEnv *env, IRExpr *expr)
       }
 
       do_convert_128: {
-         s390_round_t rounding_mode;
+         s390_bfp_round_t rounding_mode;
          HReg op_hi, op_lo, f13, f15;
 
          res = newVRegI(env);
@@ -1956,7 +1956,7 @@ s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
          goto convert;
 
       convert: {
-         s390_round_t rounding_mode;
+         s390_bfp_round_t rounding_mode;
          /* convert-from-fixed and load-rounded have a rounding mode field
             when the floating point extension facility is installed. */
          dst = newVRegF(env);
@@ -1964,7 +1964,7 @@ s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
             rounding_mode = get_bfp_rounding_mode(env, irrm);
          } else {
             set_bfp_rounding_mode_in_fpc(env, irrm);
-            rounding_mode = S390_ROUND_PER_FPC;
+            rounding_mode = S390_BFP_ROUND_PER_FPC;
          }
          addInstr(env, s390_insn_bfp_convert(size, conv, dst, h1,
                                              rounding_mode));
@@ -1977,7 +1977,7 @@ s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
       case Iop_F128toF64:
       case Iop_F128toF32: {
          HReg op_hi, op_lo, f13, f15;
-         s390_round_t rounding_mode;
+         s390_bfp_round_t rounding_mode;
 
          conv = op == Iop_F128toF32 ? S390_BFP_F128_TO_F32
                                     : S390_BFP_F128_TO_F64;
@@ -1999,7 +1999,7 @@ s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
             rounding_mode = get_bfp_rounding_mode(env, irrm);
          } else {
             set_bfp_rounding_mode_in_fpc(env, irrm);
-            rounding_mode = S390_ROUND_PER_FPC;
+            rounding_mode = S390_BFP_ROUND_PER_FPC;
          }
          addInstr(env, s390_insn_bfp128_convert_from(size, conv, dst, f13, f15,
                                                      rounding_mode));
@@ -2064,7 +2064,7 @@ s390_isel_float_expr_wrk(ISelEnv *env, IRExpr *expr)
          /* No rounding mode is needed for these conversions. Just stick
             one in. It won't be used later on. */
          addInstr(env, s390_insn_bfp_convert(size, conv, dst, h1,
-                                             S390_ROUND_NEAREST_EVEN));
+                                             S390_BFP_ROUND_NEAREST_EVEN));
          return dst;
 
       default: