From 4aa701906d478d7fa132beb56bfc65738f85ade2 Mon Sep 17 00:00:00 2001 From: Florian Krohm Date: Sun, 7 Oct 2012 15:42:37 +0000 Subject: [PATCH] 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 . Part of fixing #307113. git-svn-id: svn://svn.valgrind.org/vex/trunk@2547 --- VEX/priv/guest_s390_helpers.c | 50 +++++++-------- VEX/priv/guest_s390_toIR.c | 115 +++++++++++++++++----------------- VEX/priv/host_s390_defs.c | 39 ++++++------ VEX/priv/host_s390_defs.h | 40 ++++++------ VEX/priv/host_s390_isel.c | 28 ++++----- 5 files changed, 138 insertions(+), 134 deletions(-) diff --git a/VEX/priv/guest_s390_helpers.c b/VEX/priv/guest_s390_helpers.c index 247d3abbed..75f4021984 100644 --- 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 09b09b3f5e..114f8bf765 100644 --- 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 01056ef0c8..3ffe0eb58c 100644 --- 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 7ce0793759..6034b48dce 100644 --- 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 1c14749d8a..afa5df8961 100644 --- 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: -- 2.47.2