From 48e9546efc61f458da9fbf69784f2f37252c7d87 Mon Sep 17 00:00:00 2001 From: Peter Maydell Date: Mon, 12 Feb 2018 13:36:34 -0500 Subject: [PATCH] softfloat: expand out STATUS_VAR Expand out and remove the STATUS_VAR macro. Backports commit ff32e16e865c78fb54187723f3fd09650cd9b962 from qemu --- qemu/fpu/softfloat-specialize.h | 50 +- qemu/fpu/softfloat.c | 995 +++++++++++++++++--------------- qemu/include/fpu/softfloat.h | 9 +- qemu/target-mips/msa_helper.c | 56 +- 4 files changed, 607 insertions(+), 503 deletions(-) diff --git a/qemu/fpu/softfloat-specialize.h b/qemu/fpu/softfloat-specialize.h index e343dcd9..fe8edd08 100644 --- a/qemu/fpu/softfloat-specialize.h +++ b/qemu/fpu/softfloat-specialize.h @@ -257,7 +257,9 @@ static commonNaNT float16ToCommonNaN( float16 a, float_status *status) { commonNaNT z; - if ( float16_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR ); + if (float16_is_signaling_nan(a)) { + float_raise(float_flag_invalid, status); + } z.sign = float16_val(a) >> 15; z.low = 0; z.high = ((uint64_t) float16_val(a))<<54; @@ -360,7 +362,9 @@ static commonNaNT float32ToCommonNaN( float32 a, float_status *status) { commonNaNT z; - if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR ); + if (float32_is_signaling_nan(a)) { + float_raise(float_flag_invalid, status); + } z.sign = float32_val(a)>>31; z.low = 0; z.high = ( (uint64_t) float32_val(a) )<<41; @@ -513,7 +517,7 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN, * the default NaN */ if (infzero && cIsQNaN) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 3; } @@ -542,7 +546,7 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN, * the default NaN */ if (infzero) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 3; } @@ -570,7 +574,7 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN, * a default NaN */ if (infzero) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 2; } @@ -621,7 +625,9 @@ static float32 propagateFloat32NaN( float32 a, float32 b, float_status *status) av = float32_val(a); bv = float32_val(b); - if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); + if (aIsSignalingNaN | bIsSignalingNaN) { + float_raise(float_flag_invalid, status); + } if ( STATUS(default_nan_mode) ) return float32_default_nan; @@ -666,12 +672,12 @@ static float32 propagateFloat32MulAddNaN(float32 a, float32 b, cIsSignalingNaN = float32_is_signaling_nan(c); if (aIsSignalingNaN | bIsSignalingNaN | cIsSignalingNaN) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } which = pickNaNMulAdd(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN, - cIsQuietNaN, cIsSignalingNaN, infzero STATUS_VAR); + cIsQuietNaN, cIsSignalingNaN, infzero, status); if (STATUS(default_nan_mode)) { /* Note that this check is after pickNaNMulAdd so that function @@ -771,7 +777,9 @@ static commonNaNT float64ToCommonNaN( float64 a, float_status *status) { commonNaNT z; - if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); + if (float64_is_signaling_nan(a)) { + float_raise(float_flag_invalid, status); + } z.sign = float64_val(a)>>63; z.low = 0; z.high = float64_val(a)<<12; @@ -819,7 +827,9 @@ static float64 propagateFloat64NaN( float64 a, float64 b, float_status *status) av = float64_val(a); bv = float64_val(b); - if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); + if (aIsSignalingNaN | bIsSignalingNaN) { + float_raise(float_flag_invalid, status); + } if ( STATUS(default_nan_mode) ) return float64_default_nan; @@ -864,12 +874,12 @@ static float64 propagateFloat64MulAddNaN(float64 a, float64 b, cIsSignalingNaN = float64_is_signaling_nan(c); if (aIsSignalingNaN | bIsSignalingNaN | cIsSignalingNaN) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } which = pickNaNMulAdd(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN, - cIsQuietNaN, cIsSignalingNaN, infzero STATUS_VAR); + cIsQuietNaN, cIsSignalingNaN, infzero, status); if (STATUS(default_nan_mode)) { /* Note that this check is after pickNaNMulAdd so that function @@ -979,7 +989,9 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a, float_status *status) { commonNaNT z; - if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); + if (floatx80_is_signaling_nan(a)) { + float_raise(float_flag_invalid, status); + } if ( a.low >> 63 ) { z.sign = a.high >> 15; z.low = 0; @@ -1034,7 +1046,9 @@ static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b, float_status *stat bIsQuietNaN = floatx80_is_quiet_nan( b ); bIsSignalingNaN = floatx80_is_signaling_nan( b ); - if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); + if (aIsSignalingNaN | bIsSignalingNaN) { + float_raise(float_flag_invalid, status); + } if ( STATUS(default_nan_mode) ) { a.low = floatx80_default_nan_low; @@ -1138,7 +1152,9 @@ static commonNaNT float128ToCommonNaN( float128 a, float_status *status) { commonNaNT z; - if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); + if (float128_is_signaling_nan(a)) { + float_raise(float_flag_invalid, status); + } z.sign = a.high>>63; shortShift128Left( a.high, a.low, 16, &z.high, &z.low ); return z; @@ -1180,7 +1196,9 @@ static float128 propagateFloat128NaN( float128 a, float128 b, float_status *stat bIsQuietNaN = float128_is_quiet_nan( b ); bIsSignalingNaN = float128_is_signaling_nan( b ); - if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); + if (aIsSignalingNaN | bIsSignalingNaN) { + float_raise(float_flag_invalid, status); + } if ( STATUS(default_nan_mode) ) { a.low = float128_default_nan_low; diff --git a/qemu/fpu/softfloat.c b/qemu/fpu/softfloat.c index 7e9dd0f2..21a7cdc5 100644 --- a/qemu/fpu/softfloat.c +++ b/qemu/fpu/softfloat.c @@ -176,7 +176,7 @@ static int32 roundAndPackInt32( flag zSign, uint64_t absZ, float_status *status) z = (int32_t)absZ; if ( zSign ) z = - z; if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact; @@ -230,7 +230,7 @@ static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1, floa if ( zSign ) z = - z; if ( z && ( ( z < 0 ) ^ zSign ) ) { overflow: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return zSign ? (int64_t) LIT64( 0x8000000000000000 ) : LIT64( 0x7FFFFFFFFFFFFFFF ); @@ -278,14 +278,14 @@ static int64 roundAndPackUint64(flag zSign, uint64_t absZ0, if (increment) { ++absZ0; if (absZ0 == 0) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return LIT64(0xFFFFFFFFFFFFFFFF); } absZ0 &= ~(((uint64_t)(absZ1<<1) == 0) & roundNearestEven); } if (zSign && absZ0) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } @@ -336,7 +336,7 @@ float32 float32_squash_input_denormal(float32 a, float_status *status) { if (STATUS(flush_inputs_to_zero)) { if (extractFloat32Exp(a) == 0 && extractFloat32Frac(a) != 0) { - float_raise(float_flag_input_denormal STATUS_VAR); + float_raise(float_flag_input_denormal, status); return make_float32(float32_val(a) & 0x80000000); } } @@ -435,12 +435,12 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, || ( ( zExp == 0xFD ) && ( (int32_t) ( zSig + roundIncrement ) < 0 ) ) ) { - float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise( float_flag_overflow | float_flag_inexact, status); return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 )); } if ( zExp < 0 ) { if (STATUS(flush_to_zero)) { - float_raise(float_flag_output_denormal STATUS_VAR); + float_raise(float_flag_output_denormal, status); return packFloat32(zSign, 0, 0); } isTiny = @@ -450,7 +450,9 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, shift32RightJamming( zSig, - zExp, &zSig ); zExp = 0; roundBits = zSig & 0x7F; - if ( isTiny && roundBits ) float_raise( float_flag_underflow STATUS_VAR); + if (isTiny && roundBits) { + float_raise(float_flag_underflow, status); + } } } if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact; @@ -476,7 +478,7 @@ static float32 int8 shiftCount; shiftCount = countLeadingZeros32( zSig ) - 1; - return roundAndPackFloat32( zSign, zExp - shiftCount, zSig< 126)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); if (float32_is_any_nan(a)) { return LIT64(0xFFFFFFFFFFFFFFFF); } else { @@ -1691,14 +1701,14 @@ uint64 float32_to_uint64(float32 a, float_status *status) aSig |= 0x00800000; } if (shiftCount < 0) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return LIT64(0xFFFFFFFFFFFFFFFF); } aSig64 = aSig; aSig64 <<= 40; shift64ExtraRightJamming(aSig64, 0, shiftCount, &aSig64, &aSigExtra); - return roundAndPackUint64(aSign, aSig64, aSigExtra STATUS_VAR); + return roundAndPackUint64(aSign, aSig64, aSigExtra, status); } /*---------------------------------------------------------------------------- @@ -1716,9 +1726,9 @@ uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status) { int64_t v; signed char current_rounding_mode = STATUS(float_rounding_mode); - set_float_rounding_mode(float_round_to_zero STATUS_VAR); - v = float32_to_uint64(a STATUS_VAR); - set_float_rounding_mode(current_rounding_mode STATUS_VAR); + set_float_rounding_mode(float_round_to_zero, status); + v = float32_to_uint64(a, status); + set_float_rounding_mode(current_rounding_mode, status); return v; } @@ -1739,7 +1749,7 @@ int64 float32_to_int64_round_to_zero( float32 a, float_status *status) uint32_t aSig; uint64_t aSig64; int64 z; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); @@ -1747,7 +1757,7 @@ int64 float32_to_int64_round_to_zero( float32 a, float_status *status) shiftCount = aExp - 0xBE; if ( 0 <= shiftCount ) { if ( float32_val(a) != 0xDF000000 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) { return LIT64( 0x7FFFFFFFFFFFFFFF ); } @@ -1781,13 +1791,15 @@ float64 float32_to_float64( float32 a, float_status *status) flag aSign; int_fast16_t aExp; uint32_t aSig; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF ) { - if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloat64(float32ToCommonNaN(a, status), status); + } return packFloat64( aSign, 0x7FF, 0 ); } if ( aExp == 0 ) { @@ -1812,12 +1824,14 @@ floatx80 float32_to_floatx80( float32 a, float_status *status) int_fast16_t aExp; uint32_t aSig; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF ) { - if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloatx80(float32ToCommonNaN(a, status), status); + } return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( aExp == 0 ) { @@ -1842,12 +1856,14 @@ float128 float32_to_float128( float32 a, float_status *status) int_fast16_t aExp; uint32_t aSig; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF ) { - if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloat128(float32ToCommonNaN(a, status), status); + } return packFloat128( aSign, 0x7FFF, 0, 0 ); } if ( aExp == 0 ) { @@ -1872,12 +1888,12 @@ float32 float32_round_to_int( float32 a, float_status *status) int_fast16_t aExp; uint32_t lastBitMask, roundBitsMask; uint32_t z; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aExp = extractFloat32Exp( a ); if ( 0x96 <= aExp ) { if ( ( aExp == 0xFF ) && extractFloat32Frac( a ) ) { - return propagateFloat32NaN( a, a STATUS_VAR ); + return propagateFloat32NaN( a, a, status ); } return a; } @@ -1961,7 +1977,9 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s bSig <<= 6; if ( 0 < expDiff ) { if ( aExp == 0xFF ) { - if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (aSig) { + return propagateFloat32NaN(a, b, status); + } return a; } if ( bExp == 0 ) { @@ -1975,7 +1993,9 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s } else if ( expDiff < 0 ) { if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } return packFloat32( zSign, 0xFF, 0 ); } if ( aExp == 0 ) { @@ -1989,13 +2009,15 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s } else { if ( aExp == 0xFF ) { - if ( aSig | bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (aSig | bSig) { + return propagateFloat32NaN(a, b, status); + } return a; } if ( aExp == 0 ) { if (STATUS(flush_to_zero)) { if (aSig | bSig) { - float_raise(float_flag_output_denormal STATUS_VAR); + float_raise(float_flag_output_denormal, status); } return packFloat32(zSign, 0, 0); } @@ -2013,7 +2035,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s ++zExp; } roundAndPack: - return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); + return roundAndPackFloat32( zSign, zExp, zSig, status ); } @@ -2041,8 +2063,10 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s if ( 0 < expDiff ) goto aExpBigger; if ( expDiff < 0 ) goto bExpBigger; if ( aExp == 0xFF ) { - if ( aSig | bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); - float_raise( float_flag_invalid STATUS_VAR); + if (aSig | bSig) { + return propagateFloat32NaN(a, b, status); + } + float_raise( float_flag_invalid, status); return float32_default_nan; } if ( aExp == 0 ) { @@ -2054,7 +2078,9 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s return packFloat32( STATUS(float_rounding_mode) == float_round_down, 0, 0 ); bExpBigger: if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } return packFloat32( zSign ^ 1, 0xFF, 0 ); } if ( aExp == 0 ) { @@ -2072,7 +2098,9 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s goto normalizeRoundAndPack; aExpBigger: if ( aExp == 0xFF ) { - if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (aSig) { + return propagateFloat32NaN(a, b, status); + } return a; } if ( bExp == 0 ) { @@ -2088,7 +2116,7 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s zExp = aExp; normalizeRoundAndPack: --zExp; - return normalizeRoundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); + return normalizeRoundAndPackFloat32( zSign, zExp, zSig, status ); } @@ -2101,16 +2129,16 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s float32 float32_add( float32 a, float32 b, float_status *status) { flag aSign, bSign; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); aSign = extractFloat32Sign( a ); bSign = extractFloat32Sign( b ); if ( aSign == bSign ) { - return addFloat32Sigs( a, b, aSign STATUS_VAR); + return addFloat32Sigs( a, b, aSign, status); } else { - return subFloat32Sigs( a, b, aSign STATUS_VAR ); + return subFloat32Sigs( a, b, aSign, status ); } } @@ -2124,16 +2152,16 @@ float32 float32_add( float32 a, float32 b, float_status *status) float32 float32_sub( float32 a, float32 b, float_status *status) { flag aSign, bSign; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); aSign = extractFloat32Sign( a ); bSign = extractFloat32Sign( b ); if ( aSign == bSign ) { - return subFloat32Sigs( a, b, aSign STATUS_VAR ); + return subFloat32Sigs( a, b, aSign, status ); } else { - return addFloat32Sigs( a, b, aSign STATUS_VAR ); + return addFloat32Sigs( a, b, aSign, status ); } } @@ -2152,8 +2180,8 @@ float32 float32_mul( float32 a, float32 b, float_status *status) uint64_t zSig64; uint32_t zSig; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); @@ -2164,18 +2192,20 @@ float32 float32_mul( float32 a, float32 b, float_status *status) zSign = aSign ^ bSign; if ( aExp == 0xFF ) { if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) { - return propagateFloat32NaN( a, b STATUS_VAR ); + return propagateFloat32NaN( a, b, status ); } if ( ( bExp | bSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } return packFloat32( zSign, 0xFF, 0 ); } if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } if ( ( aExp | aSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } return packFloat32( zSign, 0xFF, 0 ); @@ -2197,7 +2227,7 @@ float32 float32_mul( float32 a, float32 b, float_status *status) zSig <<= 1; --zExp; } - return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); + return roundAndPackFloat32( zSign, zExp, zSig, status ); } @@ -2212,8 +2242,8 @@ float32 float32_div( float32 a, float32 b, float_status *status) flag aSign, bSign, zSign; int_fast16_t aExp, bExp, zExp; uint32_t aSig, bSig, zSig; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); @@ -2223,25 +2253,29 @@ float32 float32_div( float32 a, float32 b, float_status *status) bSign = extractFloat32Sign( b ); zSign = aSign ^ bSign; if ( aExp == 0xFF ) { - if ( aSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if ( aSig ) return propagateFloat32NaN(a, b, status); if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); - float_raise( float_flag_invalid STATUS_VAR); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } + float_raise( float_flag_invalid, status); return float32_default_nan; } return packFloat32( zSign, 0xFF, 0 ); } if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } return packFloat32( zSign, 0, 0 ); } if ( bExp == 0 ) { if ( bSig == 0 ) { if ( ( aExp | aSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } - float_raise( float_flag_divbyzero STATUS_VAR); + float_raise( float_flag_divbyzero, status); return packFloat32( zSign, 0xFF, 0 ); } normalizeFloat32Subnormal( bSig, &bExp, &bSig ); @@ -2261,7 +2295,7 @@ float32 float32_div( float32 a, float32 b, float_status *status) if ( ( zSig & 0x3F ) == 0 ) { zSig |= ( (uint64_t) bSig * zSig != ( (uint64_t) aSig )<<32 ); } - return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); + return roundAndPackFloat32( zSign, zExp, zSig, status ); } @@ -2280,8 +2314,8 @@ float32 float32_rem( float32 a, float32 b, float_status *status) uint64_t aSig64, bSig64, q64; uint32_t alternateASig; int32_t sigMean; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); @@ -2290,18 +2324,20 @@ float32 float32_rem( float32 a, float32 b, float_status *status) bExp = extractFloat32Exp( b ); if ( aExp == 0xFF ) { if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) { - return propagateFloat32NaN( a, b STATUS_VAR ); + return propagateFloat32NaN(a, b, status); } - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } if ( bExp == 0xFF ) { - if ( bSig ) return propagateFloat32NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat32NaN(a, b, status); + } return a; } if ( bExp == 0 ) { if ( bSig == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } normalizeFloat32Subnormal( bSig, &bExp, &bSig ); @@ -2362,7 +2398,7 @@ float32 float32_rem( float32 a, float32 b, float_status *status) } zSign = ( (int32_t) aSig < 0 ); if ( zSign ) aSig = 0- aSig; - return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR ); + return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig, status ); } @@ -2388,9 +2424,9 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status int shiftcount; flag signflip, infzero; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); - c = float32_squash_input_denormal(c STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); + c = float32_squash_input_denormal(c, status); aSig = extractFloat32Frac(a); aExp = extractFloat32Exp(a); aSign = extractFloat32Sign(a); @@ -2412,11 +2448,11 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status if (((aExp == 0xff) && aSig) || ((bExp == 0xff) && bSig) || ((cExp == 0xff) && cSig)) { - return propagateFloat32MulAddNaN(a, b, c, infzero STATUS_VAR); + return propagateFloat32MulAddNaN(a, b, c, infzero, status); } if (infzero) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float32_default_nan; } @@ -2437,7 +2473,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status if (cExp == 0xff) { if (pInf && (pSign ^ cSign)) { /* addition of opposite-signed infinities => InvalidOperation */ - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float32_default_nan; } /* Otherwise generate an infinity of the same sign */ @@ -2463,7 +2499,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status } /* Exact zero plus a denorm */ if (STATUS(flush_to_zero)) { - float_raise(float_flag_output_denormal STATUS_VAR); + float_raise(float_flag_output_denormal, status); return packFloat32(cSign ^ signflip, 0, 0); } } @@ -2477,7 +2513,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status */ cExp -= 2; cSig = (cSig | 0x00800000) << 7; - return roundAndPackFloat32(cSign ^ signflip, cExp, cSig STATUS_VAR); + return roundAndPackFloat32(cSign ^ signflip, cExp, cSig, status); } return packFloat32(cSign ^ signflip, cExp, cSig); } @@ -2519,7 +2555,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status pExp--; } return roundAndPackFloat32(zSign, pExp - 1, - pSig STATUS_VAR); + pSig, status); } normalizeFloat32Subnormal(cSig, &cExp, &cSig); } @@ -2587,7 +2623,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status } shift64RightJamming(zSig64, 32, &zSig64); - return roundAndPackFloat32(zSign, zExp, (uint32_t)zSig64 STATUS_VAR); + return roundAndPackFloat32(zSign, zExp, (uint32_t)zSig64, status); } @@ -2603,20 +2639,22 @@ float32 float32_sqrt( float32 a, float_status *status) int_fast16_t aExp, zExp; uint32_t aSig, zSig; uint64_t rem, term; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF ) { - if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR ); + if (aSig) { + return propagateFloat32NaN(a, float32_zero, status); + } if ( ! aSign ) return a; - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } if ( aSign ) { if ( ( aExp | aSig ) == 0 ) return a; - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } if ( aExp == 0 ) { @@ -2642,7 +2680,7 @@ float32 float32_sqrt( float32 a, float_status *status) } shift32RightJamming( zSig, 1, &zSig ); roundAndPack: - return roundAndPackFloat32( 0, zExp, zSig STATUS_VAR ); + return roundAndPackFloat32( 0, zExp, zSig, status ); } @@ -2690,37 +2728,39 @@ float32 float32_exp2( float32 a, float_status *status) uint32_t aSig; float64 r, x, xn; int i; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF) { - if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR ); + if (aSig) { + return propagateFloat32NaN(a, float32_zero, status); + } return (aSign) ? float32_zero : a; } if (aExp == 0) { if (aSig == 0) return float32_one; } - float_raise( float_flag_inexact STATUS_VAR); + float_raise( float_flag_inexact, status); /* ******************************* */ /* using float64 for approximation */ /* ******************************* */ - x = float32_to_float64(a STATUS_VAR); - x = float64_mul(x, float64_ln2 STATUS_VAR); + x = float32_to_float64(a, status); + x = float64_mul(x, float64_ln2, status); xn = x; r = float64_one; for (i = 0 ; i < 15 ; i++) { float64 f; - f = float64_mul(xn, float32_exp2_coefficients[i] STATUS_VAR); - r = float64_add(r, f STATUS_VAR); + f = float64_mul(xn, float32_exp2_coefficients[i], status); + r = float64_add(r, f, status); - xn = float64_mul(xn, x STATUS_VAR); + xn = float64_mul(xn, x, status); } return float64_to_float32(r, status); @@ -2737,7 +2777,7 @@ float32 float32_log2( float32 a, float_status *status) int_fast16_t aExp; uint32_t aSig, zSig, i; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); @@ -2747,11 +2787,13 @@ float32 float32_log2( float32 a, float_status *status) normalizeFloat32Subnormal( aSig, &aExp, &aSig ); } if ( aSign ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float32_default_nan; } if ( aExp == 0xFF ) { - if ( aSig ) return propagateFloat32NaN( a, float32_zero STATUS_VAR ); + if (aSig) { + return propagateFloat32NaN(a, float32_zero, status); + } return a; } @@ -2771,7 +2813,7 @@ float32 float32_log2( float32 a, float_status *status) if ( zSign ) zSig = 0-zSig; - return normalizeRoundAndPackFloat32( zSign, 0x85, zSig STATUS_VAR ); + return normalizeRoundAndPackFloat32( zSign, 0x85, zSig, status ); } /*---------------------------------------------------------------------------- @@ -2784,13 +2826,13 @@ float32 float32_log2( float32 a, float_status *status) int float32_eq( float32 a, float32 b, float_status *status) { uint32_t av, bv; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } av = float32_val(a); @@ -2809,13 +2851,13 @@ int float32_le( float32 a, float32 b, float_status *status) { flag aSign, bSign; uint32_t av, bv; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } aSign = extractFloat32Sign( a ); @@ -2838,13 +2880,13 @@ int float32_lt( float32 a, float32 b, float_status *status ) { flag aSign, bSign; uint32_t av, bv; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } aSign = extractFloat32Sign( a ); @@ -2865,13 +2907,13 @@ int float32_lt( float32 a, float32 b, float_status *status ) int float32_unordered( float32 a, float32 b, float_status *status ) { - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 1; } return 0; @@ -2886,14 +2928,14 @@ int float32_unordered( float32 a, float32 b, float_status *status ) int float32_eq_quiet( float32 a, float32 b, float_status *status ) { - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } return 0; } @@ -2912,14 +2954,14 @@ int float32_le_quiet( float32 a, float32 b, float_status *status ) { flag aSign, bSign; uint32_t av, bv; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } return 0; } @@ -2943,14 +2985,14 @@ int float32_lt_quiet( float32 a, float32 b, float_status *status ) { flag aSign, bSign; uint32_t av, bv; - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } return 0; } @@ -2972,14 +3014,14 @@ int float32_lt_quiet( float32 a, float32 b, float_status *status ) int float32_unordered_quiet( float32 a, float32 b, float_status *status ) { - a = float32_squash_input_denormal(a STATUS_VAR); - b = float32_squash_input_denormal(b STATUS_VAR); + a = float32_squash_input_denormal(a, status); + b = float32_squash_input_denormal(b, status); if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) ) { if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); } return 1; } @@ -3001,7 +3043,7 @@ int32 float64_to_int32( float64 a, float_status *status ) flag aSign; int_fast16_t aExp, shiftCount; uint64_t aSig; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); @@ -3010,7 +3052,7 @@ int32 float64_to_int32( float64 a, float_status *status ) if ( aExp ) aSig |= LIT64( 0x0010000000000000 ); shiftCount = 0x42C - aExp; if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig ); - return roundAndPackInt32( aSign, aSig STATUS_VAR ); + return roundAndPackInt32( aSign, aSig, status ); } @@ -3030,7 +3072,7 @@ int32 float64_to_int32_round_to_zero( float64 a, float_status *status ) int_fast16_t aExp, shiftCount; uint64_t aSig, savedASig; int32_t z; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); @@ -3040,7 +3082,9 @@ int32 float64_to_int32_round_to_zero( float64 a, float_status *status ) goto invalid; } else if ( aExp < 0x3FF ) { - if ( aExp || aSig ) STATUS(float_exception_flags) |= float_flag_inexact; + if (aExp || aSig) { + STATUS(float_exception_flags) |= float_flag_inexact; + } return 0; } aSig |= LIT64( 0x0010000000000000 ); @@ -3051,7 +3095,7 @@ int32 float64_to_int32_round_to_zero( float64 a, float_status *status ) if ( aSign ) z = - z; if ( ( z < 0 ) ^ aSign ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig<>( - shiftCount ); @@ -3221,13 +3267,15 @@ float32 float64_to_float32( float64 a, float_status *status ) int_fast16_t aExp; uint64_t aSig; uint32_t zSig; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { - if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloat32(float64ToCommonNaN(a, status), status); + } return packFloat32( aSign, 0xFF, 0 ); } shift64RightJamming( aSig, 22, &aSig ); @@ -3236,7 +3284,7 @@ float32 float64_to_float32( float64 a, float_status *status ) zSig |= 0x40000000; aExp -= 0x381; } - return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR ); + return roundAndPackFloat32(aSign, aExp, zSig, status); } @@ -3333,10 +3381,10 @@ static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp, if (zExp > maxexp || (zExp == maxexp && rounding_bumps_exp)) { if (ieee) { - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise(float_flag_overflow | float_flag_inexact, status); return packFloat16(zSign, 0x1f, 0); } else { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return packFloat16(zSign, 0x1f, 0x3ff); } } @@ -3349,9 +3397,9 @@ static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp, || (!rounding_bumps_exp); } if (zSig & mask) { - float_raise(float_flag_inexact STATUS_VAR); + float_raise(float_flag_inexact, status); if (is_tiny) { - float_raise(float_flag_underflow STATUS_VAR); + float_raise(float_flag_underflow, status); } } @@ -3394,7 +3442,7 @@ float32 float16_to_float32(float16 a, flag ieee, float_status *status) if (aExp == 0x1f && ieee) { if (aSig) { - return commonNaNToFloat32(float16ToCommonNaN(a STATUS_VAR) STATUS_VAR); + return commonNaNToFloat32(float16ToCommonNaN(a, status), status); } return packFloat32(aSign, 0xff, 0); } @@ -3415,7 +3463,7 @@ float16 float32_to_float16(float32 a, flag ieee, float_status *status) int_fast16_t aExp; uint32_t aSig; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); @@ -3424,15 +3472,15 @@ float16 float32_to_float16(float32 a, flag ieee, float_status *status) if (aSig) { /* Input is a NaN */ if (!ieee) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return packFloat16(aSign, 0, 0); } return commonNaNToFloat16( - float32ToCommonNaN(a STATUS_VAR) STATUS_VAR); + float32ToCommonNaN(a, status), status); } /* Infinity */ if (!ieee) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return packFloat16(aSign, 0x1f, 0x3ff); } return packFloat16(aSign, 0x1f, 0); @@ -3450,7 +3498,7 @@ float16 float32_to_float16(float32 a, flag ieee, float_status *status) aSig |= 0x00800000; aExp -= 0x71; - return roundAndPackFloat16(aSign, aExp, aSig, ieee STATUS_VAR); + return roundAndPackFloat16(aSign, aExp, aSig, ieee, status); } float64 float16_to_float64(float16 a, flag ieee, float_status *status) @@ -3466,7 +3514,7 @@ float64 float16_to_float64(float16 a, flag ieee, float_status *status) if (aExp == 0x1f && ieee) { if (aSig) { return commonNaNToFloat64( - float16ToCommonNaN(a STATUS_VAR) STATUS_VAR); + float16ToCommonNaN(a, status), status); } return packFloat64(aSign, 0x7ff, 0); } @@ -3488,7 +3536,7 @@ float16 float64_to_float16(float64 a, flag ieee, float_status *status) uint64_t aSig; uint32_t zSig; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac(a); aExp = extractFloat64Exp(a); @@ -3497,15 +3545,15 @@ float16 float64_to_float16(float64 a, flag ieee, float_status *status) if (aSig) { /* Input is a NaN */ if (!ieee) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return packFloat16(aSign, 0, 0); } return commonNaNToFloat16( - float64ToCommonNaN(a STATUS_VAR) STATUS_VAR); + float64ToCommonNaN(a, status), status); } /* Infinity */ if (!ieee) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return packFloat16(aSign, 0x1f, 0x3ff); } return packFloat16(aSign, 0x1f, 0); @@ -3525,7 +3573,7 @@ float16 float64_to_float16(float64 a, flag ieee, float_status *status) zSig |= 0x00800000; aExp -= 0x3F1; - return roundAndPackFloat16(aSign, aExp, zSig, ieee STATUS_VAR); + return roundAndPackFloat16(aSign, aExp, zSig, ieee, status); } /*---------------------------------------------------------------------------- @@ -3541,12 +3589,14 @@ floatx80 float64_to_floatx80( float64 a, float_status *status ) int_fast16_t aExp; uint64_t aSig; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { - if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloatx80( float64ToCommonNaN(a, status), status); + } return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( aExp == 0 ) { @@ -3572,12 +3622,14 @@ float128 float64_to_float128( float64 a, float_status *status ) int_fast16_t aExp; uint64_t aSig, zSig0, zSig1; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { - if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + if (aSig) { + return commonNaNToFloat128(float64ToCommonNaN(a, status), status); + } return packFloat128( aSign, 0x7FFF, 0, 0 ); } if ( aExp == 0 ) { @@ -3603,12 +3655,12 @@ float64 float64_round_to_int( float64 a, float_status *status ) int_fast16_t aExp; uint64_t lastBitMask, roundBitsMask; uint64_t z; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aExp = extractFloat64Exp( a ); if ( 0x433 <= aExp ) { if ( ( aExp == 0x7FF ) && extractFloat64Frac( a ) ) { - return propagateFloat64NaN( a, a STATUS_VAR ); + return propagateFloat64NaN( a, a, status ); } return a; } @@ -3665,8 +3717,9 @@ float64 float64_round_to_int( float64 a, float_status *status ) abort(); } z &= ~ roundBitsMask; - if ( z != float64_val(a) ) + if ( z != float64_val(a) ) { STATUS(float_exception_flags) |= float_flag_inexact; + } return make_float64(z); } @@ -3677,7 +3730,7 @@ float64 float64_trunc_to_int( float64 a, float_status *status) float64 res; oldmode = STATUS(float_rounding_mode); STATUS(float_rounding_mode) = float_round_to_zero; - res = float64_round_to_int(a STATUS_VAR); + res = float64_round_to_int(a, status); STATUS(float_rounding_mode) = oldmode; return res; } @@ -3705,7 +3758,9 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s bSig <<= 9; if ( 0 < expDiff ) { if ( aExp == 0x7FF ) { - if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (aSig) { + return propagateFloat64NaN(a, b, status); + } return a; } if ( bExp == 0 ) { @@ -3719,7 +3774,9 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s } else if ( expDiff < 0 ) { if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } return packFloat64( zSign, 0x7FF, 0 ); } if ( aExp == 0 ) { @@ -3733,13 +3790,15 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s } else { if ( aExp == 0x7FF ) { - if ( aSig | bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (aSig | bSig) { + return propagateFloat64NaN(a, b, status); + } return a; } if ( aExp == 0 ) { if (STATUS(flush_to_zero)) { if (aSig | bSig) { - float_raise(float_flag_output_denormal STATUS_VAR); + float_raise(float_flag_output_denormal, status); } return packFloat64(zSign, 0, 0); } @@ -3757,7 +3816,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s ++zExp; } roundAndPack: - return roundAndPackFloat64( zSign, zExp, zSig STATUS_VAR ); + return roundAndPackFloat64( zSign, zExp, zSig, status ); } @@ -3785,8 +3844,10 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s if ( 0 < expDiff ) goto aExpBigger; if ( expDiff < 0 ) goto bExpBigger; if ( aExp == 0x7FF ) { - if ( aSig | bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); - float_raise( float_flag_invalid STATUS_VAR); + if (aSig | bSig) { + return propagateFloat64NaN(a, b, status); + } + float_raise(float_flag_invalid, status); return float64_default_nan; } if ( aExp == 0 ) { @@ -3798,7 +3859,9 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s return packFloat64( STATUS(float_rounding_mode) == float_round_down, 0, 0 ); bExpBigger: if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } return packFloat64( zSign ^ 1, 0x7FF, 0 ); } if ( aExp == 0 ) { @@ -3816,7 +3879,9 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s goto normalizeRoundAndPack; aExpBigger: if ( aExp == 0x7FF ) { - if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (aSig) { + return propagateFloat64NaN(a, b, status); + } return a; } if ( bExp == 0 ) { @@ -3832,7 +3897,7 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s zExp = aExp; normalizeRoundAndPack: --zExp; - return normalizeRoundAndPackFloat64( zSign, zExp, zSig STATUS_VAR ); + return normalizeRoundAndPackFloat64( zSign, zExp, zSig, status ); } @@ -3845,16 +3910,16 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s float64 float64_add( float64 a, float64 b, float_status *status ) { flag aSign, bSign; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); aSign = extractFloat64Sign( a ); bSign = extractFloat64Sign( b ); if ( aSign == bSign ) { - return addFloat64Sigs( a, b, aSign STATUS_VAR ); + return addFloat64Sigs( a, b, aSign, status ); } else { - return subFloat64Sigs( a, b, aSign STATUS_VAR ); + return subFloat64Sigs( a, b, aSign, status ); } } @@ -3868,16 +3933,16 @@ float64 float64_add( float64 a, float64 b, float_status *status ) float64 float64_sub( float64 a, float64 b, float_status *status ) { flag aSign, bSign; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); aSign = extractFloat64Sign( a ); bSign = extractFloat64Sign( b ); if ( aSign == bSign ) { - return subFloat64Sigs( a, b, aSign STATUS_VAR ); + return subFloat64Sigs( a, b, aSign, status ); } else { - return addFloat64Sigs( a, b, aSign STATUS_VAR ); + return addFloat64Sigs( a, b, aSign, status ); } } @@ -3894,8 +3959,8 @@ float64 float64_mul( float64 a, float64 b, float_status *status ) int_fast16_t aExp, bExp, zExp; uint64_t aSig, bSig, zSig0, zSig1; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); @@ -3906,18 +3971,20 @@ float64 float64_mul( float64 a, float64 b, float_status *status ) zSign = aSign ^ bSign; if ( aExp == 0x7FF ) { if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) { - return propagateFloat64NaN( a, b STATUS_VAR ); + return propagateFloat64NaN(a, b, status); } if ( ( bExp | bSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } return packFloat64( zSign, 0x7FF, 0 ); } if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } if ( ( aExp | aSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } return packFloat64( zSign, 0x7FF, 0 ); @@ -3939,7 +4006,7 @@ float64 float64_mul( float64 a, float64 b, float_status *status ) zSig0 <<= 1; --zExp; } - return roundAndPackFloat64( zSign, zExp, zSig0 STATUS_VAR ); + return roundAndPackFloat64( zSign, zExp, zSig0, status ); } @@ -3956,8 +4023,8 @@ float64 float64_div( float64 a, float64 b, float_status *status ) uint64_t aSig, bSig, zSig; uint64_t rem0, rem1; uint64_t term0, term1; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); @@ -3967,25 +4034,31 @@ float64 float64_div( float64 a, float64 b, float_status *status ) bSign = extractFloat64Sign( b ); zSign = aSign ^ bSign; if ( aExp == 0x7FF ) { - if ( aSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (aSig) { + return propagateFloat64NaN(a, b, status); + } if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); - float_raise( float_flag_invalid STATUS_VAR); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } + float_raise(float_flag_invalid, status); return float64_default_nan; } return packFloat64( zSign, 0x7FF, 0 ); } if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } return packFloat64( zSign, 0, 0 ); } if ( bExp == 0 ) { if ( bSig == 0 ) { if ( ( aExp | aSig ) == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } - float_raise( float_flag_divbyzero STATUS_VAR); + float_raise(float_flag_divbyzero, status); return packFloat64( zSign, 0x7FF, 0 ); } normalizeFloat64Subnormal( bSig, &bExp, &bSig ); @@ -4011,7 +4084,7 @@ float64 float64_div( float64 a, float64 b, float_status *status ) } zSig |= ( rem1 != 0 ); } - return roundAndPackFloat64( zSign, zExp, zSig STATUS_VAR ); + return roundAndPackFloat64( zSign, zExp, zSig, status ); } @@ -4029,8 +4102,8 @@ float64 float64_rem( float64 a, float64 b, float_status *status ) uint64_t q, alternateASig; int64_t sigMean; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); @@ -4038,18 +4111,20 @@ float64 float64_rem( float64 a, float64 b, float_status *status ) bExp = extractFloat64Exp( b ); if ( aExp == 0x7FF ) { if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) { - return propagateFloat64NaN( a, b STATUS_VAR ); + return propagateFloat64NaN(a, b, status); } - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float64_default_nan; } if ( bExp == 0x7FF ) { - if ( bSig ) return propagateFloat64NaN( a, b STATUS_VAR ); + if (bSig) { + return propagateFloat64NaN(a, b, status); + } return a; } if ( bExp == 0 ) { if ( bSig == 0 ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } normalizeFloat64Subnormal( bSig, &bExp, &bSig ); @@ -4097,7 +4172,7 @@ float64 float64_rem( float64 a, float64 b, float_status *status ) } zSign = ( (int64_t) aSig < 0 ); if ( zSign ) aSig = 0- aSig; - return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR ); + return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig, status ); } @@ -4122,9 +4197,9 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status int shiftcount; flag signflip, infzero; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); - c = float64_squash_input_denormal(c STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); + c = float64_squash_input_denormal(c, status); aSig = extractFloat64Frac(a); aExp = extractFloat64Exp(a); aSign = extractFloat64Sign(a); @@ -4146,11 +4221,11 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status if (((aExp == 0x7ff) && aSig) || ((bExp == 0x7ff) && bSig) || ((cExp == 0x7ff) && cSig)) { - return propagateFloat64MulAddNaN(a, b, c, infzero STATUS_VAR); + return propagateFloat64MulAddNaN(a, b, c, infzero, status); } if (infzero) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } @@ -4171,7 +4246,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status if (cExp == 0x7ff) { if (pInf && (pSign ^ cSign)) { /* addition of opposite-signed infinities => InvalidOperation */ - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } /* Otherwise generate an infinity of the same sign */ @@ -4197,7 +4272,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status } /* Exact zero plus a denorm */ if (STATUS(flush_to_zero)) { - float_raise(float_flag_output_denormal STATUS_VAR); + float_raise(float_flag_output_denormal, status); return packFloat64(cSign ^ signflip, 0, 0); } } @@ -4211,7 +4286,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status */ cExp -= 2; cSig = (cSig | 0x0010000000000000ULL) << 10; - return roundAndPackFloat64(cSign ^ signflip, cExp, cSig STATUS_VAR); + return roundAndPackFloat64(cSign ^ signflip, cExp, cSig, status); } return packFloat64(cSign ^ signflip, cExp, cSig); } @@ -4252,7 +4327,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status pExp--; } return roundAndPackFloat64(zSign, pExp - 1, - pSig1 STATUS_VAR); + pSig1, status); } normalizeFloat64Subnormal(cSig, &cExp, &cSig); } @@ -4290,7 +4365,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status if (flags & float_muladd_halve_result) { zExp--; } - return roundAndPackFloat64(zSign, zExp, zSig1 STATUS_VAR); + return roundAndPackFloat64(zSign, zExp, zSig1, status); } else { /* Subtraction */ if (expDiff > 0) { @@ -4343,7 +4418,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status if (flags & float_muladd_halve_result) { zExp--; } - return roundAndPackFloat64(zSign, zExp, zSig0 STATUS_VAR); + return roundAndPackFloat64(zSign, zExp, zSig0, status); } } @@ -4359,20 +4434,22 @@ float64 float64_sqrt( float64 a, float_status *status ) int_fast16_t aExp, zExp; uint64_t aSig, zSig, doubleZSig; uint64_t rem0, rem1, term0, term1; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { - if ( aSig ) return propagateFloat64NaN( a, a STATUS_VAR ); + if (aSig) { + return propagateFloat64NaN(a, a, status); + } if ( ! aSign ) return a; - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float64_default_nan; } if ( aSign ) { if ( ( aExp | aSig ) == 0 ) return a; - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float64_default_nan; } if ( aExp == 0 ) { @@ -4395,7 +4472,7 @@ float64 float64_sqrt( float64 a, float_status *status ) } zSig |= ( ( rem0 | rem1 ) != 0 ); } - return roundAndPackFloat64( 0, zExp, zSig STATUS_VAR ); + return roundAndPackFloat64( 0, zExp, zSig, status ); } @@ -4409,7 +4486,7 @@ float64 float64_log2( float64 a, float_status *status ) flag aSign, zSign; int_fast16_t aExp; uint64_t aSig, aSig0, aSig1, zSig, i; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); @@ -4420,11 +4497,13 @@ float64 float64_log2( float64 a, float_status *status ) normalizeFloat64Subnormal( aSig, &aExp, &aSig ); } if ( aSign ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return float64_default_nan; } if ( aExp == 0x7FF ) { - if ( aSig ) return propagateFloat64NaN( a, float64_zero STATUS_VAR ); + if (aSig) { + return propagateFloat64NaN(a, float64_zero, status); + } return a; } @@ -4443,7 +4522,7 @@ float64 float64_log2( float64 a, float_status *status ) if ( zSign ) zSig = 0-zSig; - return normalizeRoundAndPackFloat64( zSign, 0x408, zSig STATUS_VAR ); + return normalizeRoundAndPackFloat64( zSign, 0x408, zSig, status ); } /*---------------------------------------------------------------------------- @@ -4456,13 +4535,13 @@ float64 float64_log2( float64 a, float_status *status ) int float64_eq( float64 a, float64 b, float_status *status ) { uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } av = float64_val(a); @@ -4482,13 +4561,13 @@ int float64_le( float64 a, float64 b, float_status *status ) { flag aSign, bSign; uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } aSign = extractFloat64Sign( a ); @@ -4512,12 +4591,12 @@ int float64_lt( float64 a, float64 b, float_status *status ) flag aSign, bSign; uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } aSign = extractFloat64Sign( a ); @@ -4538,13 +4617,13 @@ int float64_lt( float64 a, float64 b, float_status *status ) int float64_unordered( float64 a, float64 b, float_status *status ) { - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 1; } return 0; @@ -4560,14 +4639,14 @@ int float64_unordered( float64 a, float64 b, float_status *status ) int float64_eq_quiet( float64 a, float64 b, float_status *status ) { uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -4588,14 +4667,14 @@ int float64_le_quiet( float64 a, float64 b, float_status *status ) { flag aSign, bSign; uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -4619,14 +4698,14 @@ int float64_lt_quiet( float64 a, float64 b, float_status *status ) { flag aSign, bSign; uint64_t av, bv; - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -4648,14 +4727,14 @@ int float64_lt_quiet( float64 a, float64 b, float_status *status ) int float64_unordered_quiet( float64 a, float64 b, float_status *status ) { - a = float64_squash_input_denormal(a STATUS_VAR); - b = float64_squash_input_denormal(b STATUS_VAR); + a = float64_squash_input_denormal(a, status); + b = float64_squash_input_denormal(b, status); if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) ) { if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 1; } @@ -4679,7 +4758,7 @@ int32 floatx80_to_int32( floatx80 a, float_status *status ) uint64_t aSig; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 1 << 31; } aSig = extractFloatx80Frac( a ); @@ -4689,7 +4768,7 @@ int32 floatx80_to_int32( floatx80 a, float_status *status ) shiftCount = 0x4037 - aExp; if ( shiftCount <= 0 ) shiftCount = 1; shift64RightJamming( aSig, shiftCount, &aSig ); - return roundAndPackInt32( aSign, aSig STATUS_VAR ); + return roundAndPackInt32( aSign, aSig, status ); } @@ -4711,7 +4790,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a, float_status *status ) int32_t z; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 1 << 31; } aSig = extractFloatx80Frac( a ); @@ -4722,7 +4801,9 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a, float_status *status ) goto invalid; } else if ( aExp < 0x3FFF ) { - if ( aExp || aSig ) STATUS(float_exception_flags) |= float_flag_inexact; + if (aExp || aSig) { + STATUS(float_exception_flags) |= float_flag_inexact; + } return 0; } shiftCount = 0x403E - aExp; @@ -4732,7 +4813,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a, float_status *status ) if ( aSign ) z = - z; if ( ( z < 0 ) ^ aSign ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig<>( - shiftCount ); @@ -4848,7 +4931,7 @@ float32 floatx80_to_float32( floatx80 a, float_status *status ) uint64_t aSig; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float32_default_nan; } aSig = extractFloatx80Frac( a ); @@ -4856,13 +4939,13 @@ float32 floatx80_to_float32( floatx80 a, float_status *status ) aSign = extractFloatx80Sign( a ); if ( aExp == 0x7FFF ) { if ( (uint64_t) ( aSig<<1 ) ) { - return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + return commonNaNToFloat32(floatx80ToCommonNaN(a, status), status); } return packFloat32( aSign, 0xFF, 0 ); } shift64RightJamming( aSig, 33, &aSig ); if ( aExp || aSig ) aExp -= 0x3F81; - return roundAndPackFloat32( aSign, aExp, (uint32_t)aSig STATUS_VAR ); + return roundAndPackFloat32( aSign, aExp, (uint32_t)aSig, status); } @@ -4880,7 +4963,7 @@ float64 floatx80_to_float64( floatx80 a, float_status *status ) uint64_t aSig, zSig; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float64_default_nan; } aSig = extractFloatx80Frac( a ); @@ -4888,13 +4971,13 @@ float64 floatx80_to_float64( floatx80 a, float_status *status ) aSign = extractFloatx80Sign( a ); if ( aExp == 0x7FFF ) { if ( (uint64_t) ( aSig<<1 ) ) { - return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + return commonNaNToFloat64(floatx80ToCommonNaN(a, status), status); } return packFloat64( aSign, 0x7FF, 0 ); } shift64RightJamming( aSig, 1, &zSig ); if ( aExp || aSig ) aExp -= 0x3C01; - return roundAndPackFloat64( aSign, aExp, zSig STATUS_VAR ); + return roundAndPackFloat64(aSign, aExp, zSig, status); } @@ -4912,14 +4995,14 @@ float128 floatx80_to_float128( floatx80 a, float_status *status ) uint64_t aSig, zSig0, zSig1; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float128_default_nan; } aSig = extractFloatx80Frac( a ); aExp = extractFloatx80Exp( a ); aSign = extractFloatx80Sign( a ); if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) { - return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); + return commonNaNToFloat128(floatx80ToCommonNaN(a, status), status); } shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 ); return packFloat128( aSign, aExp, zSig0, zSig1 ); @@ -4941,13 +5024,13 @@ floatx80 floatx80_round_to_int( floatx80 a, float_status *status ) floatx80 z; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aExp = extractFloatx80Exp( a ); if ( 0x403E <= aExp ) { if ( ( aExp == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) { - return propagateFloatx80NaN( a, a STATUS_VAR ); + return propagateFloatx80NaN( a, a, status ); } return a; } @@ -5017,7 +5100,9 @@ floatx80 floatx80_round_to_int( floatx80 a, float_status *status ) ++z.high; z.low = LIT64( 0x8000000000000000 ); } - if ( z.low != a.low ) STATUS(float_exception_flags) |= float_flag_inexact; + if (z.low != a.low) { + STATUS(float_exception_flags) |= float_flag_inexact; + } return z; } @@ -5043,7 +5128,9 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu expDiff = aExp - bExp; if ( 0 < expDiff ) { if ( aExp == 0x7FFF ) { - if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ((uint64_t) (aSig << 1)) { + return propagateFloatx80NaN(a, b, status); + } return a; } if ( bExp == 0 ) --expDiff; @@ -5052,7 +5139,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu } else if ( expDiff < 0 ) { if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN(a, b, status); return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( aExp == 0 ) ++expDiff; @@ -5062,7 +5149,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu else { if ( aExp == 0x7FFF ) { if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) { - return propagateFloatx80NaN( a, b STATUS_VAR ); + return propagateFloatx80NaN( a, b, status ); } return a; } @@ -5084,7 +5171,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu roundAndPack: return roundAndPackFloatx80( - STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR ); + STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1, status ); } @@ -5112,9 +5199,9 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu if ( expDiff < 0 ) goto bExpBigger; if ( aExp == 0x7FFF ) { if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) { - return propagateFloatx80NaN( a, b STATUS_VAR ); + return propagateFloatx80NaN( a, b, status ); } - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); z.low = floatx80_default_nan_low; z.high = floatx80_default_nan_high; return z; @@ -5129,7 +5216,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu return packFloatx80( STATUS(float_rounding_mode) == float_round_down, 0, 0 ); bExpBigger: if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( aExp == 0 ) ++expDiff; @@ -5141,7 +5228,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu goto normalizeRoundAndPack; aExpBigger: if ( aExp == 0x7FFF ) { - if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); return a; } if ( bExp == 0 ) --expDiff; @@ -5152,7 +5239,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign, float_statu normalizeRoundAndPack: return normalizeRoundAndPackFloatx80( - STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR ); + STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1, status ); } @@ -5167,16 +5254,16 @@ floatx80 floatx80_add( floatx80 a, floatx80 b, float_status *status ) flag aSign, bSign; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSign = extractFloatx80Sign( a ); bSign = extractFloatx80Sign( b ); if ( aSign == bSign ) { - return addFloatx80Sigs( a, b, aSign STATUS_VAR ); + return addFloatx80Sigs( a, b, aSign, status ); } else { - return subFloatx80Sigs( a, b, aSign STATUS_VAR ); + return subFloatx80Sigs( a, b, aSign, status ); } } @@ -5192,16 +5279,16 @@ floatx80 floatx80_sub( floatx80 a, floatx80 b, float_status *status ) flag aSign, bSign; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSign = extractFloatx80Sign( a ); bSign = extractFloatx80Sign( b ); if ( aSign == bSign ) { - return subFloatx80Sigs( a, b, aSign STATUS_VAR ); + return subFloatx80Sigs( a, b, aSign, status ); } else { - return addFloatx80Sigs( a, b, aSign STATUS_VAR ); + return addFloatx80Sigs( a, b, aSign, status ); } } @@ -5220,7 +5307,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b, float_status *status ) floatx80 z; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSig = extractFloatx80Frac( a ); @@ -5233,16 +5320,16 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b, float_status *status ) if ( aExp == 0x7FFF ) { if ( (uint64_t) ( aSig<<1 ) || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) { - return propagateFloatx80NaN( a, b STATUS_VAR ); + return propagateFloatx80NaN( a, b, status ); } if ( ( bExp | bSig ) == 0 ) goto invalid; return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); if ( ( aExp | aSig ) == 0 ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); z.low = floatx80_default_nan_low; z.high = floatx80_default_nan_high; return z; @@ -5265,7 +5352,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b, float_status *status ) } return roundAndPackFloatx80( - STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR ); + STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1, status ); } @@ -5284,7 +5371,7 @@ floatx80 floatx80_div( floatx80 a, floatx80 b, float_status *status ) floatx80 z; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSig = extractFloatx80Frac( a ); @@ -5295,27 +5382,27 @@ floatx80 floatx80_div( floatx80 a, floatx80 b, float_status *status ) bSign = extractFloatx80Sign( b ); zSign = aSign ^ bSign; if ( aExp == 0x7FFF ) { - if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); goto invalid; } return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); return packFloatx80( zSign, 0, 0 ); } if ( bExp == 0 ) { if ( bSig == 0 ) { if ( ( aExp | aSig ) == 0 ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); z.low = floatx80_default_nan_low; z.high = floatx80_default_nan_high; return z; } - float_raise( float_flag_divbyzero STATUS_VAR); + float_raise( float_flag_divbyzero, status); return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); } normalizeFloatx80Subnormal( bSig, &bExp, &bSig ); @@ -5349,7 +5436,7 @@ floatx80 floatx80_div( floatx80 a, floatx80 b, float_status *status ) } return roundAndPackFloatx80( - STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR ); + STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1, status ); } @@ -5368,7 +5455,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b, float_status *status ) floatx80 z; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSig0 = extractFloatx80Frac( a ); @@ -5379,18 +5466,18 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b, float_status *status ) if ( aExp == 0x7FFF ) { if ( (uint64_t) ( aSig0<<1 ) || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) { - return propagateFloatx80NaN( a, b STATUS_VAR ); + return propagateFloatx80NaN( a, b, status ); } goto invalid; } if ( bExp == 0x7FFF ) { - if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status ); return a; } if ( bExp == 0 ) { if ( bSig == 0 ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); z.low = floatx80_default_nan_low; z.high = floatx80_default_nan_high; return z; @@ -5449,7 +5536,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b, float_status *status ) } return normalizeRoundAndPackFloatx80( - 80, zSign, bExp + expDiff, aSig0, aSig1 STATUS_VAR ); + 80, zSign, bExp + expDiff, aSig0, aSig1, status ); } @@ -5468,21 +5555,21 @@ floatx80 floatx80_sqrt( floatx80 a, float_status *status ) floatx80 z; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSig0 = extractFloatx80Frac( a ); aExp = extractFloatx80Exp( a ); aSign = extractFloatx80Sign( a ); if ( aExp == 0x7FFF ) { - if ( (uint64_t) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a STATUS_VAR ); + if ( (uint64_t) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a, status ); if ( ! aSign ) return a; goto invalid; } if ( aSign ) { if ( ( aExp | aSig0 ) == 0 ) return a; invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); z.low = floatx80_default_nan_low; z.high = floatx80_default_nan_high; return z; @@ -5523,7 +5610,7 @@ floatx80 floatx80_sqrt( floatx80 a, float_status *status ) zSig0 |= doubleZSig0; return roundAndPackFloatx80( - STATUS(floatx80_rounding_precision), 0, zExp, zSig0, zSig1 STATUS_VAR ); + STATUS(floatx80_rounding_precision), 0, zExp, zSig0, zSig1, status ); } @@ -5543,7 +5630,7 @@ int floatx80_eq( floatx80 a, floatx80 b, float_status *status ) || (extractFloatx80Exp(b) == 0x7FFF && (uint64_t) (extractFloatx80Frac(b) << 1)) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } return @@ -5573,7 +5660,7 @@ int floatx80_le( floatx80 a, floatx80 b, float_status *status ) || (extractFloatx80Exp(b) == 0x7FFF && (uint64_t) (extractFloatx80Frac(b) << 1)) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } aSign = extractFloatx80Sign( a ); @@ -5607,7 +5694,7 @@ int floatx80_lt( floatx80 a, floatx80 b, float_status *status ) || (extractFloatx80Exp(b) == 0x7FFF && (uint64_t) (extractFloatx80Frac(b) << 1)) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 0; } aSign = extractFloatx80Sign( a ); @@ -5638,7 +5725,7 @@ int floatx80_unordered( floatx80 a, floatx80 b, float_status *status ) || (extractFloatx80Exp(b) == 0x7FFF && (uint64_t) (extractFloatx80Frac(b) << 1)) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return 1; } return 0; @@ -5655,7 +5742,7 @@ int floatx80_eq_quiet( floatx80 a, floatx80 b, float_status *status ) { if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) @@ -5665,7 +5752,7 @@ int floatx80_eq_quiet( floatx80 a, floatx80 b, float_status *status ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -5690,7 +5777,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b, float_status *status ) flag aSign, bSign; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) @@ -5700,7 +5787,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b, float_status *status ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -5730,7 +5817,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b, float_status *status ) flag aSign, bSign; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) @@ -5740,7 +5827,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b, float_status *status ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 0; } @@ -5767,7 +5854,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b, float_status *status ) int floatx80_unordered_quiet( floatx80 a, floatx80 b, float_status *status ) { if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 1; } if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) @@ -5777,7 +5864,7 @@ int floatx80_unordered_quiet( floatx80 a, floatx80 b, float_status *status ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return 1; } @@ -5809,7 +5896,7 @@ int32 float128_to_int32( float128 a, float_status *status ) aSig0 |= ( aSig1 != 0 ); shiftCount = 0x4028 - aExp; if ( 0 < shiftCount ) shift64RightJamming( aSig0, shiftCount, &aSig0 ); - return roundAndPackInt32( aSign, aSig0 STATUS_VAR ); + return roundAndPackInt32( aSign, aSig0, status ); } @@ -5851,7 +5938,7 @@ int32 float128_to_int32_round_to_zero( float128 a, float_status *status ) if ( aSign ) z = - z; if ( ( z < 0 ) ^ aSign ) { invalid: - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig0< 0xffffffff) { @@ -7007,8 +7094,8 @@ uint32 float32_to_uint32( float32 a, float_status *status ) } else { return (uint32)v; } - set_float_exception_flags(old_exc_flags STATUS_VAR); - float_raise(float_flag_invalid STATUS_VAR); + set_float_exception_flags(old_exc_flags, status); + float_raise(float_flag_invalid, status); return res; } @@ -7018,7 +7105,7 @@ uint32 float32_to_uint32_round_to_zero( float32 a, float_status *status ) uint32 res; int old_exc_flags = get_float_exception_flags(status); - v = float32_to_int64_round_to_zero(a STATUS_VAR); + v = float32_to_int64_round_to_zero(a, status); if (v < 0) { res = 0; } else if (v > 0xffffffff) { @@ -7027,7 +7114,7 @@ uint32 float32_to_uint32_round_to_zero( float32 a, float_status *status ) return (uint32)v; } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7037,7 +7124,7 @@ int_fast16_t float32_to_int16(float32 a, float_status *status) int_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float32_to_int32(a STATUS_VAR); + v = float32_to_int32(a, status); if (v < -0x8000) { res = -0x8000; } else if (v > 0x7fff) { @@ -7047,7 +7134,7 @@ int_fast16_t float32_to_int16(float32 a, float_status *status) } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7057,7 +7144,7 @@ uint_fast16_t float32_to_uint16(float32 a, float_status *status) uint_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float32_to_int32(a STATUS_VAR); + v = float32_to_int32(a, status); if (v < 0) { res = 0; } else if (v > 0xffff) { @@ -7067,7 +7154,7 @@ uint_fast16_t float32_to_uint16(float32 a, float_status *status) } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7077,7 +7164,7 @@ uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status) uint_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float32_to_int64_round_to_zero(a STATUS_VAR); + v = float32_to_int64_round_to_zero(a, status); if (v < 0) { res = 0; } else if (v > 0xffff) { @@ -7086,7 +7173,7 @@ uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status) return (uint_fast16_t)v; } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7096,14 +7183,14 @@ uint32 float64_to_uint32( float64 a, float_status *status ) uint32 res; int old_exc_flags = get_float_exception_flags(status); - v = float64_to_uint64(a STATUS_VAR); + v = float64_to_uint64(a, status); if (v > 0xffffffff) { res = 0xffffffff; } else { return (uint32)v; } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7113,14 +7200,14 @@ uint32 float64_to_uint32_round_to_zero( float64 a, float_status *status ) uint32 res; int old_exc_flags = get_float_exception_flags(status); - v = float64_to_uint64_round_to_zero(a STATUS_VAR); + v = float64_to_uint64_round_to_zero(a, status); if (v > 0xffffffff) { res = 0xffffffff; } else { return (uint32)v; } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7130,7 +7217,7 @@ int_fast16_t float64_to_int16(float64 a, float_status *status) int_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float64_to_int32(a STATUS_VAR); + v = float64_to_int32(a, status); if (v < -0x8000) { res = -0x8000; } else if (v > 0x7fff) { @@ -7140,7 +7227,7 @@ int_fast16_t float64_to_int16(float64 a, float_status *status) } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7150,7 +7237,7 @@ uint_fast16_t float64_to_uint16(float64 a, float_status *status) uint_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float64_to_int32(a STATUS_VAR); + v = float64_to_int32(a, status); if (v < 0) { res = 0; } else if (v > 0xffff) { @@ -7160,7 +7247,7 @@ uint_fast16_t float64_to_uint16(float64 a, float_status *status) } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7170,7 +7257,7 @@ uint_fast16_t float64_to_uint16_round_to_zero(float64 a, float_status *status) uint_fast16_t res; int old_exc_flags = get_float_exception_flags(status); - v = float64_to_int64_round_to_zero(a STATUS_VAR); + v = float64_to_int64_round_to_zero(a, status); if (v < 0) { res = 0; } else if (v > 0xffff) { @@ -7179,7 +7266,7 @@ uint_fast16_t float64_to_uint16_round_to_zero(float64 a, float_status *status) return (uint_fast16_t)v; } set_float_exception_flags(old_exc_flags, status); - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return res; } @@ -7200,13 +7287,13 @@ uint64_t float64_to_uint64(float64 a, float_status *status) flag aSign; int_fast16_t aExp, shiftCount; uint64_t aSig, aSigExtra; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac(a); aExp = extractFloat64Exp(a); aSign = extractFloat64Sign(a); if (aSign && (aExp > 1022)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); if (float64_is_any_nan(a)) { return LIT64(0xFFFFFFFFFFFFFFFF); } else { @@ -7219,7 +7306,7 @@ uint64_t float64_to_uint64(float64 a, float_status *status) shiftCount = 0x433 - aExp; if (shiftCount <= 0) { if (0x43E < aExp) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return LIT64(0xFFFFFFFFFFFFFFFF); } aSigExtra = 0; @@ -7227,16 +7314,16 @@ uint64_t float64_to_uint64(float64 a, float_status *status) } else { shift64ExtraRightJamming(aSig, 0, shiftCount, &aSig, &aSigExtra); } - return roundAndPackUint64(aSign, aSig, aSigExtra STATUS_VAR); + return roundAndPackUint64(aSign, aSig, aSigExtra, status); } uint64_t float64_to_uint64_round_to_zero (float64 a, float_status *status) { int64_t v; signed char current_rounding_mode = STATUS(float_rounding_mode); - set_float_rounding_mode(float_round_to_zero STATUS_VAR); - v = float64_to_uint64(a STATUS_VAR); - set_float_rounding_mode(current_rounding_mode STATUS_VAR); + set_float_rounding_mode(float_round_to_zero, status); + v = float64_to_uint64(a, status); + set_float_rounding_mode(current_rounding_mode, status); return v; } @@ -7246,8 +7333,8 @@ static inline int float ## s ## _compare_internal( float ## s a, float ## s b, { \ flag aSign, bSign; \ uint ## s ## _t av, bv; \ - a = float ## s ## _squash_input_denormal(a STATUS_VAR); \ - b = float ## s ## _squash_input_denormal(b STATUS_VAR); \ + a = float ## s ## _squash_input_denormal(a, status); \ + b = float ## s ## _squash_input_denormal(b, status); \ \ if (( ( extractFloat ## s ## Exp( a ) == nan_exp ) && \ extractFloat ## s ## Frac( a ) ) || \ @@ -7256,7 +7343,7 @@ static inline int float ## s ## _compare_internal( float ## s a, float ## s b, if (!is_quiet || \ float ## s ## _is_signaling_nan( a ) || \ float ## s ## _is_signaling_nan( b ) ) { \ - float_raise( float_flag_invalid STATUS_VAR); \ + float_raise( float_flag_invalid, status); \ } \ return float_relation_unordered; \ } \ @@ -7282,12 +7369,12 @@ static inline int float ## s ## _compare_internal( float ## s a, float ## s b, \ int float ## s ## _compare( float ## s a, float ## s b, float_status *status ) \ { \ - return float ## s ## _compare_internal(a, b, 0 STATUS_VAR); \ + return float ## s ## _compare_internal(a, b, 0, status); \ } \ \ int float ## s ## _compare_quiet( float ## s a, float ## s b, float_status *status ) \ { \ - return float ## s ## _compare_internal(a, b, 1 STATUS_VAR); \ + return float ## s ## _compare_internal(a, b, 1, status); \ } COMPARE(32, 0xff) @@ -7299,7 +7386,7 @@ static inline int floatx80_compare_internal( floatx80 a, floatx80 b, flag aSign, bSign; if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return float_relation_unordered; } if (( ( extractFloatx80Exp( a ) == 0x7fff ) && @@ -7309,7 +7396,7 @@ static inline int floatx80_compare_internal( floatx80 a, floatx80 b, if (!is_quiet || floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return float_relation_unordered; } @@ -7335,12 +7422,12 @@ static inline int floatx80_compare_internal( floatx80 a, floatx80 b, int floatx80_compare( floatx80 a, floatx80 b, float_status *status ) { - return floatx80_compare_internal(a, b, 0 STATUS_VAR); + return floatx80_compare_internal(a, b, 0, status); } int floatx80_compare_quiet( floatx80 a, floatx80 b, float_status *status ) { - return floatx80_compare_internal(a, b, 1 STATUS_VAR); + return floatx80_compare_internal(a, b, 1, status); } static inline int float128_compare_internal( float128 a, float128 b, @@ -7355,7 +7442,7 @@ static inline int float128_compare_internal( float128 a, float128 b, if (!is_quiet || float128_is_signaling_nan( a ) || float128_is_signaling_nan( b ) ) { - float_raise( float_flag_invalid STATUS_VAR); + float_raise( float_flag_invalid, status); } return float_relation_unordered; } @@ -7379,12 +7466,12 @@ static inline int float128_compare_internal( float128 a, float128 b, int float128_compare( float128 a, float128 b, float_status *status ) { - return float128_compare_internal(a, b, 0 STATUS_VAR); + return float128_compare_internal(a, b, 0, status); } int float128_compare_quiet( float128 a, float128 b, float_status *status ) { - return float128_compare_internal(a, b, 1 STATUS_VAR); + return float128_compare_internal(a, b, 1, status); } /* min() and max() functions. These can't be implemented as @@ -7408,8 +7495,8 @@ static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \ { \ flag aSign, bSign; \ uint ## s ## _t av, bv, aav, abv; \ - a = float ## s ## _squash_input_denormal(a STATUS_VAR); \ - b = float ## s ## _squash_input_denormal(b STATUS_VAR); \ + a = float ## s ## _squash_input_denormal(a, status); \ + b = float ## s ## _squash_input_denormal(b, status); \ if (float ## s ## _is_any_nan(a) || \ float ## s ## _is_any_nan(b)) { \ if (isieee) { \ @@ -7421,7 +7508,7 @@ static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \ return a; \ } \ } \ - return propagateFloat ## s ## NaN(a, b STATUS_VAR); \ + return propagateFloat ## s ## NaN(a, b, status); \ } \ aSign = extractFloat ## s ## Sign(a); \ bSign = extractFloat ## s ## Sign(b); \ @@ -7455,32 +7542,32 @@ static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \ \ float ## s float ## s ## _min(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 1, 0, 0 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 1, 0, 0, status); \ } \ \ float ## s float ## s ## _max(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 0, 0, 0 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 0, 0, 0, status); \ } \ \ float ## s float ## s ## _minnum(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 1, 1, 0 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 1, 1, 0, status); \ } \ \ float ## s float ## s ## _maxnum(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 0, 1, 0 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 0, 1, 0, status); \ } \ \ float ## s float ## s ## _minnummag(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 1, 1, 1 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 1, 1, 1, status); \ } \ \ float ## s float ## s ## _maxnummag(float ## s a, float ## s b, float_status *status) \ { \ - return float ## s ## _minmax(a, b, 0, 1, 1 STATUS_VAR); \ + return float ## s ## _minmax(a, b, 0, 1, 1, status); \ } MINMAX(32) @@ -7494,14 +7581,14 @@ float32 float32_scalbn( float32 a, int n, float_status *status ) int16_t aExp; uint32_t aSig; - a = float32_squash_input_denormal(a STATUS_VAR); + a = float32_squash_input_denormal(a, status); aSig = extractFloat32Frac( a ); aExp = extractFloat32Exp( a ); aSign = extractFloat32Sign( a ); if ( aExp == 0xFF ) { if ( aSig ) { - return propagateFloat32NaN( a, a STATUS_VAR ); + return propagateFloat32NaN( a, a, status ); } return a; } @@ -7521,7 +7608,7 @@ float32 float32_scalbn( float32 a, int n, float_status *status ) aExp += n - 1; aSig <<= 7; - return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR ); + return normalizeRoundAndPackFloat32( aSign, aExp, aSig, status ); } float64 float64_scalbn( float64 a, int n, float_status *status ) @@ -7530,14 +7617,14 @@ float64 float64_scalbn( float64 a, int n, float_status *status ) int16_t aExp; uint64_t aSig; - a = float64_squash_input_denormal(a STATUS_VAR); + a = float64_squash_input_denormal(a, status); aSig = extractFloat64Frac( a ); aExp = extractFloat64Exp( a ); aSign = extractFloat64Sign( a ); if ( aExp == 0x7FF ) { if ( aSig ) { - return propagateFloat64NaN( a, a STATUS_VAR ); + return propagateFloat64NaN( a, a, status ); } return a; } @@ -7557,7 +7644,7 @@ float64 float64_scalbn( float64 a, int n, float_status *status ) aExp += n - 1; aSig <<= 10; - return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR ); + return normalizeRoundAndPackFloat64( aSign, aExp, aSig, status ); } floatx80 floatx80_scalbn( floatx80 a, int n, float_status *status ) @@ -7567,7 +7654,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n, float_status *status ) uint64_t aSig; if (floatx80_invalid_encoding(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return floatx80_default_nan; } aSig = extractFloatx80Frac( a ); @@ -7576,7 +7663,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n, float_status *status ) if ( aExp == 0x7FFF ) { if ( aSig<<1 ) { - return propagateFloatx80NaN( a, a STATUS_VAR ); + return propagateFloatx80NaN( a, a, status ); } return a; } @@ -7596,7 +7683,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n, float_status *status ) aExp += n; return normalizeRoundAndPackFloatx80( STATUS(floatx80_rounding_precision), - aSign, aExp, aSig, 0 STATUS_VAR ); + aSign, aExp, aSig, 0, status ); } float128 float128_scalbn( float128 a, int n, float_status *status ) @@ -7611,7 +7698,7 @@ float128 float128_scalbn( float128 a, int n, float_status *status ) aSign = extractFloat128Sign( a ); if ( aExp == 0x7FFF ) { if ( aSig0 | aSig1 ) { - return propagateFloat128NaN( a, a STATUS_VAR ); + return propagateFloat128NaN( a, a, status ); } return a; } @@ -7631,6 +7718,6 @@ float128 float128_scalbn( float128 a, int n, float_status *status ) aExp += n - 1; return normalizeRoundAndPackFloat128( aSign, aExp, aSig0, aSig1 - STATUS_VAR ); + , status ); } diff --git a/qemu/include/fpu/softfloat.h b/qemu/include/fpu/softfloat.h index a4552382..40c3b345 100644 --- a/qemu/include/fpu/softfloat.h +++ b/qemu/include/fpu/softfloat.h @@ -109,7 +109,6 @@ typedef int64_t int64; #define LIT64( a ) a##LL #define STATUS(field) status->field -#define STATUS_VAR , status /*---------------------------------------------------------------------------- | Software IEC/IEEE floating-point ordering relations @@ -333,22 +332,22 @@ float128 uint64_to_float128(uint64_t, float_status *status); /* We provide the int16 versions for symmetry of API with float-to-int */ static inline float32 int16_to_float32(int16_t v, float_status *status) { - return int32_to_float32(v STATUS_VAR); + return int32_to_float32(v, status); } static inline float32 uint16_to_float32(uint16_t v, float_status *status) { - return uint32_to_float32(v STATUS_VAR); + return uint32_to_float32(v, status); } static inline float64 int16_to_float64(int16_t v, float_status *status) { - return int32_to_float64(v STATUS_VAR); + return int32_to_float64(v, status); } static inline float64 uint16_to_float64(uint16_t v, float_status *status) { - return uint32_to_float64(v STATUS_VAR); + return uint32_to_float64(v, status); } /*---------------------------------------------------------------------------- diff --git a/qemu/target-mips/msa_helper.c b/qemu/target-mips/msa_helper.c index d1a456c1..af1c7e34 100644 --- a/qemu/target-mips/msa_helper.c +++ b/qemu/target-mips/msa_helper.c @@ -1618,7 +1618,7 @@ static inline float16 float16_from_float32(int32 a, flag ieee, float_status *sta { float16 f_val; - f_val = float32_to_float16((float32)a, ieee STATUS_VAR); + f_val = float32_to_float16((float32)a, ieee , status); f_val = float16_maybe_silence_nan(f_val); return a < 0 ? (f_val | (1 << 15)) : f_val; @@ -1628,7 +1628,7 @@ static inline float32 float32_from_float64(int64 a, float_status *status) { float32 f_val; - f_val = float64_to_float32((float64)a STATUS_VAR); + f_val = float64_to_float32((float64)a, status); f_val = float32_maybe_silence_nan(f_val); return a < 0 ? (f_val | (1 << 31)) : f_val; @@ -1638,7 +1638,7 @@ static inline float32 float32_from_float16(int16_t a, flag ieee, float_status *s { float32 f_val; - f_val = float16_to_float32((float16)a, ieee STATUS_VAR); + f_val = float16_to_float32((float16)a, ieee, status); f_val = float32_maybe_silence_nan(f_val); return a < 0 ? (f_val | (1 << 31)) : f_val; @@ -1648,7 +1648,7 @@ static inline float64 float64_from_float32(int32 a, float_status *status) { float64 f_val; - f_val = float32_to_float64((float64)a STATUS_VAR); + f_val = float32_to_float64((float64)a, status); f_val = float64_maybe_silence_nan(f_val); return a < 0 ? (f_val | (1ULL << 63)) : f_val; @@ -1659,8 +1659,8 @@ static inline float32 float32_from_q16(int16_t a, float_status *status) float32 f_val; /* conversion as integer and scaling */ - f_val = int32_to_float32(a STATUS_VAR); - f_val = float32_scalbn(f_val, -15 STATUS_VAR); + f_val = int32_to_float32(a, status); + f_val = float32_scalbn(f_val, -15, status); return f_val; } @@ -1670,8 +1670,8 @@ static inline float64 float64_from_q32(int32 a, float_status *status) float64 f_val; /* conversion as integer and scaling */ - f_val = int32_to_float64(a STATUS_VAR); - f_val = float64_scalbn(f_val, -31 STATUS_VAR); + f_val = int32_to_float64(a, status); + f_val = float64_scalbn(f_val, -31, status); return f_val; } @@ -1685,43 +1685,43 @@ static inline int16_t float32_to_q16(float32 a, float_status *status) int ieee_ex; if (float32_is_any_nan(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } /* scaling */ - a = float32_scalbn(a, 15 STATUS_VAR); + a = float32_scalbn(a, 15, status); ieee_ex = get_float_exception_flags(status); set_float_exception_flags(ieee_ex & (~float_flag_underflow) - STATUS_VAR); + , status); if (ieee_ex & float_flag_overflow) { - float_raise(float_flag_inexact STATUS_VAR); + float_raise(float_flag_inexact, status); return (int32)a < 0 ? q_min : q_max; } /* conversion to int */ - q_val = float32_to_int32(a STATUS_VAR); + q_val = float32_to_int32(a, status); ieee_ex = get_float_exception_flags(status); set_float_exception_flags(ieee_ex & (~float_flag_underflow) - STATUS_VAR); + , status); if (ieee_ex & float_flag_invalid) { set_float_exception_flags(ieee_ex & (~float_flag_invalid) - STATUS_VAR); - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + , status); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int32)a < 0 ? q_min : q_max; } if (q_val < q_min) { - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int16_t)q_min; } if (q_max < q_val) { - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int16_t)q_max; } @@ -1737,43 +1737,43 @@ static inline int32 float64_to_q32(float64 a, float_status *status) int ieee_ex; if (float64_is_any_nan(a)) { - float_raise(float_flag_invalid STATUS_VAR); + float_raise(float_flag_invalid, status); return 0; } /* scaling */ - a = float64_scalbn(a, 31 STATUS_VAR); + a = float64_scalbn(a, 31, status); ieee_ex = get_float_exception_flags(status); set_float_exception_flags(ieee_ex & (~float_flag_underflow) - STATUS_VAR); + , status); if (ieee_ex & float_flag_overflow) { - float_raise(float_flag_inexact STATUS_VAR); + float_raise(float_flag_inexact, status); return (int64)a < 0 ? q_min : q_max; } /* conversion to integer */ - q_val = float64_to_int64(a STATUS_VAR); + q_val = float64_to_int64(a, status); ieee_ex = get_float_exception_flags(status); set_float_exception_flags(ieee_ex & (~float_flag_underflow) - STATUS_VAR); + , status); if (ieee_ex & float_flag_invalid) { set_float_exception_flags(ieee_ex & (~float_flag_invalid) - STATUS_VAR); - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + , status); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int64)a < 0 ? q_min : q_max; } if (q_val < q_min) { - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int32)q_min; } if (q_max < q_val) { - float_raise(float_flag_overflow | float_flag_inexact STATUS_VAR); + float_raise(float_flag_overflow | float_flag_inexact, status); return (int32)q_max; }