* [Qemu-devel] [PATCH 1/3] softfloat: Expand out the STATUS_PARAM macro
2015-02-02 20:31 [Qemu-devel] [PATCH 0/3] softfloat: Remove STATUS macros Peter Maydell
@ 2015-02-02 20:31 ` Peter Maydell
2015-02-02 21:37 ` Richard Henderson
2015-02-02 20:31 ` [Qemu-devel] [PATCH 2/3] softfloat: expand out STATUS_VAR Peter Maydell
` (2 subsequent siblings)
3 siblings, 1 reply; 8+ messages in thread
From: Peter Maydell @ 2015-02-02 20:31 UTC (permalink / raw)
To: qemu-devel; +Cc: Richard Henderson, Maciej W. Rozycki, patches
Expand out STATUS_PARAM wherever it is used and delete the definition.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
fpu/softfloat-specialize.h | 50 +++---
fpu/softfloat.c | 387 ++++++++++++++++++++++++---------------------
include/fpu/softfloat.h | 332 +++++++++++++++++++-------------------
target-mips/msa_helper.c | 18 ++-
4 files changed, 410 insertions(+), 377 deletions(-)
diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
index 23d7378..264f6c0 100644
--- a/fpu/softfloat-specialize.h
+++ b/fpu/softfloat-specialize.h
@@ -170,7 +170,7 @@ const float128 float128_default_nan
| should be simply `float_exception_flags |= flags;'.
*----------------------------------------------------------------------------*/
-void float_raise( int8 flags STATUS_PARAM )
+void float_raise(int8 flags , float_status *status)
{
STATUS(float_exception_flags) |= flags;
}
@@ -253,7 +253,7 @@ float16 float16_maybe_silence_nan(float16 a_)
| exception is raised.
*----------------------------------------------------------------------------*/
-static commonNaNT float16ToCommonNaN( float16 a STATUS_PARAM )
+static commonNaNT float16ToCommonNaN(float16 a, float_status *status)
{
commonNaNT z;
@@ -269,7 +269,7 @@ static commonNaNT float16ToCommonNaN( float16 a STATUS_PARAM )
| precision floating-point format.
*----------------------------------------------------------------------------*/
-static float16 commonNaNToFloat16(commonNaNT a STATUS_PARAM)
+static float16 commonNaNToFloat16(commonNaNT a, float_status *status)
{
uint16_t mantissa = a.high>>54;
@@ -356,7 +356,7 @@ float32 float32_maybe_silence_nan( float32 a_ )
| exception is raised.
*----------------------------------------------------------------------------*/
-static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
+static commonNaNT float32ToCommonNaN(float32 a, float_status *status)
{
commonNaNT z;
@@ -372,7 +372,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
| precision floating-point format.
*----------------------------------------------------------------------------*/
-static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM)
+static float32 commonNaNToFloat32(commonNaNT a, float_status *status)
{
uint32_t mantissa = a.high>>41;
@@ -507,7 +507,8 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
*----------------------------------------------------------------------------*/
#if defined(TARGET_ARM)
static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
- flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+ flag cIsQNaN, flag cIsSNaN, flag infzero,
+ float_status *status)
{
/* For ARM, the (inf,zero,qnan) case sets InvalidOp and returns
* the default NaN
@@ -536,7 +537,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
}
#elif defined(TARGET_MIPS)
static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
- flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+ flag cIsQNaN, flag cIsSNaN, flag infzero,
+ float_status *status)
{
/* For MIPS, the (inf,zero,qnan) case sets InvalidOp and returns
* the default NaN
@@ -563,7 +565,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
}
#elif defined(TARGET_PPC)
static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
- flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+ flag cIsQNaN, flag cIsSNaN, flag infzero,
+ float_status *status)
{
/* For PPC, the (inf,zero,qnan) case sets InvalidOp, but we prefer
* to return an input NaN if we have one (ie c) rather than generating
@@ -590,7 +593,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
* This is unlikely to actually match any real implementation.
*/
static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
- flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+ flag cIsQNaN, flag cIsSNaN, flag infzero,
+ float_status *status)
{
if (aIsSNaN || aIsQNaN) {
return 0;
@@ -608,7 +612,7 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
| signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
-static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
+static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand;
@@ -652,7 +656,8 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
*----------------------------------------------------------------------------*/
static float32 propagateFloat32MulAddNaN(float32 a, float32 b,
- float32 c, flag infzero STATUS_PARAM)
+ float32 c, flag infzero,
+ float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
cIsQuietNaN, cIsSignalingNaN;
@@ -767,7 +772,7 @@ float64 float64_maybe_silence_nan( float64 a_ )
| exception is raised.
*----------------------------------------------------------------------------*/
-static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
+static commonNaNT float64ToCommonNaN(float64 a, float_status *status)
{
commonNaNT z;
@@ -783,7 +788,7 @@ static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
| precision floating-point format.
*----------------------------------------------------------------------------*/
-static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
+static float64 commonNaNToFloat64(commonNaNT a, float_status *status)
{
uint64_t mantissa = a.high>>12;
@@ -806,7 +811,7 @@ static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
| signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
-static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
+static float64 propagateFloat64NaN(float64 a, float64 b, float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand;
@@ -850,7 +855,8 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
*----------------------------------------------------------------------------*/
static float64 propagateFloat64MulAddNaN(float64 a, float64 b,
- float64 c, flag infzero STATUS_PARAM)
+ float64 c, flag infzero,
+ float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
cIsQuietNaN, cIsSignalingNaN;
@@ -975,7 +981,7 @@ floatx80 floatx80_maybe_silence_nan( floatx80 a )
| invalid exception is raised.
*----------------------------------------------------------------------------*/
-static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
+static commonNaNT floatx80ToCommonNaN(floatx80 a, float_status *status)
{
commonNaNT z;
@@ -997,7 +1003,7 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
| double-precision floating-point format.
*----------------------------------------------------------------------------*/
-static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM)
+static floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
{
floatx80 z;
@@ -1024,7 +1030,8 @@ static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM)
| `b' is a signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
-static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
+static floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b,
+ float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand;
@@ -1134,7 +1141,7 @@ float128 float128_maybe_silence_nan( float128 a )
| exception is raised.
*----------------------------------------------------------------------------*/
-static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
+static commonNaNT float128ToCommonNaN(float128 a, float_status *status)
{
commonNaNT z;
@@ -1149,7 +1156,7 @@ static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
| precision floating-point format.
*----------------------------------------------------------------------------*/
-static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM)
+static float128 commonNaNToFloat128(commonNaNT a, float_status *status)
{
float128 z;
@@ -1170,7 +1177,8 @@ static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM)
| `b' is a signaling NaN, the invalid exception is raised.
*----------------------------------------------------------------------------*/
-static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
+static float128 propagateFloat128NaN(float128 a, float128 b,
+ float_status *status)
{
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand;
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index a1f1cb3..6437b17 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -144,7 +144,7 @@ static inline flag extractFloat16Sign(float16 a)
| positive or negative integer is returned.
*----------------------------------------------------------------------------*/
-static int32 roundAndPackInt32( flag zSign, uint64_t absZ STATUS_PARAM)
+static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
{
int8 roundingMode;
flag roundNearestEven;
@@ -196,7 +196,8 @@ static int32 roundAndPackInt32( flag zSign, uint64_t absZ STATUS_PARAM)
| returned.
*----------------------------------------------------------------------------*/
-static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1 STATUS_PARAM)
+static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
+ float_status *status)
{
int8 roundingMode;
flag roundNearestEven, increment;
@@ -251,7 +252,7 @@ static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1 STATU
*----------------------------------------------------------------------------*/
static int64 roundAndPackUint64(flag zSign, uint64_t absZ0,
- uint64_t absZ1 STATUS_PARAM)
+ uint64_t absZ1, float_status *status)
{
int8 roundingMode;
flag roundNearestEven, increment;
@@ -332,7 +333,7 @@ static inline flag extractFloat32Sign( float32 a )
| If `a' is denormal and we are in flush-to-zero mode then set the
| input-denormal exception and return zero. Otherwise just return the value.
*----------------------------------------------------------------------------*/
-float32 float32_squash_input_denormal(float32 a STATUS_PARAM)
+float32 float32_squash_input_denormal(float32 a, float_status *status)
{
if (STATUS(flush_inputs_to_zero)) {
if (extractFloat32Exp(a) == 0 && extractFloat32Frac(a) != 0) {
@@ -402,7 +403,8 @@ static inline float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig STATUS_PARAM)
+static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
+ float_status *status)
{
int8 roundingMode;
flag roundNearestEven;
@@ -471,7 +473,8 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig
*----------------------------------------------------------------------------*/
static float32
- normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig STATUS_PARAM)
+ normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
+ float_status *status)
{
int8 shiftCount;
@@ -517,7 +520,7 @@ static inline flag extractFloat64Sign( float64 a )
| If `a' is denormal and we are in flush-to-zero mode then set the
| input-denormal exception and return zero. Otherwise just return the value.
*----------------------------------------------------------------------------*/
-float64 float64_squash_input_denormal(float64 a STATUS_PARAM)
+float64 float64_squash_input_denormal(float64 a, float_status *status)
{
if (STATUS(flush_inputs_to_zero)) {
if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
@@ -587,7 +590,8 @@ static inline float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig STATUS_PARAM)
+static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
+ float_status *status)
{
int8 roundingMode;
flag roundNearestEven;
@@ -655,7 +659,8 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig
*----------------------------------------------------------------------------*/
static float64
- normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig STATUS_PARAM)
+ normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
+ float_status *status)
{
int8 shiftCount;
@@ -757,10 +762,9 @@ static inline floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static floatx80
- roundAndPackFloatx80(
- int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1
- STATUS_PARAM)
+static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
+ int32 zExp, uint64_t zSig0, uint64_t zSig1,
+ float_status *status)
{
int8 roundingMode;
flag roundNearestEven, increment, isTiny;
@@ -940,10 +944,10 @@ static floatx80
| normalized.
*----------------------------------------------------------------------------*/
-static floatx80
- normalizeRoundAndPackFloatx80(
- int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1
- STATUS_PARAM)
+static floatx80 normalizeRoundAndPackFloatx80(int8 roundingPrecision,
+ flag zSign, int32 zExp,
+ uint64_t zSig0, uint64_t zSig1,
+ float_status *status)
{
int8 shiftCount;
@@ -1093,9 +1097,9 @@ static inline float128
| overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float128
- roundAndPackFloat128(
- flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1, uint64_t zSig2 STATUS_PARAM)
+static float128 roundAndPackFloat128(flag zSign, int32 zExp,
+ uint64_t zSig0, uint64_t zSig1,
+ uint64_t zSig2, float_status *status)
{
int8 roundingMode;
flag roundNearestEven, increment, isTiny;
@@ -1206,9 +1210,9 @@ static float128
| point exponent.
*----------------------------------------------------------------------------*/
-static float128
- normalizeRoundAndPackFloat128(
- flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 STATUS_PARAM)
+static float128 normalizeRoundAndPackFloat128(flag zSign, int32 zExp,
+ uint64_t zSig0, uint64_t zSig1,
+ float_status *status)
{
int8 shiftCount;
uint64_t zSig2;
@@ -1238,7 +1242,7 @@ static float128
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 int32_to_float32(int32_t a STATUS_PARAM)
+float32 int32_to_float32(int32_t a, float_status *status)
{
flag zSign;
@@ -1255,7 +1259,7 @@ float32 int32_to_float32(int32_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 int32_to_float64(int32_t a STATUS_PARAM)
+float64 int32_to_float64(int32_t a, float_status *status)
{
flag zSign;
uint32 absA;
@@ -1278,7 +1282,7 @@ float64 int32_to_float64(int32_t a STATUS_PARAM)
| Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 int32_to_floatx80(int32_t a STATUS_PARAM)
+floatx80 int32_to_floatx80(int32_t a, float_status *status)
{
flag zSign;
uint32 absA;
@@ -1300,7 +1304,7 @@ floatx80 int32_to_floatx80(int32_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 int32_to_float128(int32_t a STATUS_PARAM)
+float128 int32_to_float128(int32_t a, float_status *status)
{
flag zSign;
uint32 absA;
@@ -1322,7 +1326,7 @@ float128 int32_to_float128(int32_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 int64_to_float32(int64_t a STATUS_PARAM)
+float32 int64_to_float32(int64_t a, float_status *status)
{
flag zSign;
uint64 absA;
@@ -1354,7 +1358,7 @@ float32 int64_to_float32(int64_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 int64_to_float64(int64_t a STATUS_PARAM)
+float64 int64_to_float64(int64_t a, float_status *status)
{
flag zSign;
@@ -1374,7 +1378,7 @@ float64 int64_to_float64(int64_t a STATUS_PARAM)
| Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 int64_to_floatx80(int64_t a STATUS_PARAM)
+floatx80 int64_to_floatx80(int64_t a, float_status *status)
{
flag zSign;
uint64 absA;
@@ -1394,7 +1398,7 @@ floatx80 int64_to_floatx80(int64_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 int64_to_float128(int64_t a STATUS_PARAM)
+float128 int64_to_float128(int64_t a, float_status *status)
{
flag zSign;
uint64 absA;
@@ -1427,7 +1431,7 @@ float128 int64_to_float128(int64_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 uint64_to_float32(uint64_t a STATUS_PARAM)
+float32 uint64_to_float32(uint64_t a, float_status *status)
{
int shiftcount;
@@ -1462,7 +1466,7 @@ float32 uint64_to_float32(uint64_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 uint64_to_float64(uint64_t a STATUS_PARAM)
+float64 uint64_to_float64(uint64_t a, float_status *status)
{
int exp = 0x43C;
int shiftcount;
@@ -1486,7 +1490,7 @@ float64 uint64_to_float64(uint64_t a STATUS_PARAM)
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 uint64_to_float128(uint64_t a STATUS_PARAM)
+float128 uint64_to_float128(uint64_t a, float_status *status)
{
if (a == 0) {
return float128_zero;
@@ -1504,7 +1508,7 @@ float128 uint64_to_float128(uint64_t a STATUS_PARAM)
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int32 float32_to_int32( float32 a STATUS_PARAM )
+int32 float32_to_int32(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1535,7 +1539,7 @@ int32 float32_to_int32( float32 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
+int32 float32_to_int32_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1578,7 +1582,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int_fast16_t float32_to_int16_round_to_zero(float32 a STATUS_PARAM)
+int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1627,7 +1631,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a STATUS_PARAM)
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int64 float32_to_int64( float32 a STATUS_PARAM )
+int64 float32_to_int64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1666,7 +1670,7 @@ int64 float32_to_int64( float32 a STATUS_PARAM )
| raise the inexact exception flag.
*----------------------------------------------------------------------------*/
-uint64 float32_to_uint64(float32 a STATUS_PARAM)
+uint64 float32_to_uint64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1711,7 +1715,7 @@ uint64 float32_to_uint64(float32 a STATUS_PARAM)
| not round to zero will raise the inexact flag.
*----------------------------------------------------------------------------*/
-uint64 float32_to_uint64_round_to_zero(float32 a STATUS_PARAM)
+uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status)
{
signed char current_rounding_mode = STATUS(float_rounding_mode);
set_float_rounding_mode(float_round_to_zero STATUS_VAR);
@@ -1730,7 +1734,7 @@ uint64 float32_to_uint64_round_to_zero(float32 a STATUS_PARAM)
| returned.
*----------------------------------------------------------------------------*/
-int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM )
+int64 float32_to_int64_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -1774,7 +1778,7 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float32_to_float64( float32 a STATUS_PARAM )
+float64 float32_to_float64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -1804,7 +1808,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
+floatx80 float32_to_floatx80(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -1834,7 +1838,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float32_to_float128( float32 a STATUS_PARAM )
+float128 float32_to_float128(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -1864,7 +1868,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_round_to_int( float32 a STATUS_PARAM)
+float32 float32_round_to_int(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -1944,7 +1948,8 @@ float32 float32_round_to_int( float32 a STATUS_PARAM)
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
+static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
+ float_status *status)
{
int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
@@ -2023,7 +2028,8 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
+static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
+ float_status *status)
{
int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
@@ -2096,7 +2102,7 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_add( float32 a, float32 b STATUS_PARAM )
+float32 float32_add(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
a = float32_squash_input_denormal(a STATUS_VAR);
@@ -2119,7 +2125,7 @@ float32 float32_add( float32 a, float32 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_sub( float32 a, float32 b STATUS_PARAM )
+float32 float32_sub(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
a = float32_squash_input_denormal(a STATUS_VAR);
@@ -2142,7 +2148,7 @@ float32 float32_sub( float32 a, float32 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_mul( float32 a, float32 b STATUS_PARAM )
+float32 float32_mul(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
@@ -2205,7 +2211,7 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_div( float32 a, float32 b STATUS_PARAM )
+float32 float32_div(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
@@ -2269,7 +2275,7 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_rem( float32 a, float32 b STATUS_PARAM )
+float32 float32_rem(float32 a, float32 b, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp, bExp, expDiff;
@@ -2375,7 +2381,8 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
| externally will flip the sign bit on NaNs.)
*----------------------------------------------------------------------------*/
-float32 float32_muladd(float32 a, float32 b, float32 c, int flags STATUS_PARAM)
+float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
+ float_status *status)
{
flag aSign, bSign, cSign, zSign;
int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
@@ -2595,7 +2602,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags STATUS_PARAM)
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_sqrt( float32 a STATUS_PARAM )
+float32 float32_sqrt(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, zExp;
@@ -2681,7 +2688,7 @@ static const float64 float32_exp2_coefficients[15] =
const_float64( 0x3d6ae7f3e733b81fll ), /* 15 */
};
-float32 float32_exp2( float32 a STATUS_PARAM )
+float32 float32_exp2(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -2729,7 +2736,7 @@ float32 float32_exp2( float32 a STATUS_PARAM )
| The operation is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float32_log2( float32 a STATUS_PARAM )
+float32 float32_log2(float32 a, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp;
@@ -2779,7 +2786,7 @@ float32 float32_log2( float32 a STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_eq( float32 a, float32 b STATUS_PARAM )
+int float32_eq(float32 a, float32 b, float_status *status)
{
uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR);
@@ -2803,7 +2810,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_le( float32 a, float32 b STATUS_PARAM )
+int float32_le(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
uint32_t av, bv;
@@ -2832,7 +2839,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM )
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_lt( float32 a, float32 b STATUS_PARAM )
+int float32_lt(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
uint32_t av, bv;
@@ -2861,7 +2868,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_unordered( float32 a, float32 b STATUS_PARAM )
+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);
@@ -2882,7 +2889,7 @@ int float32_unordered( float32 a, float32 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_eq_quiet( float32 a, float32 b STATUS_PARAM )
+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);
@@ -2906,7 +2913,7 @@ int float32_eq_quiet( float32 a, float32 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
+int float32_le_quiet(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
uint32_t av, bv;
@@ -2937,7 +2944,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
+int float32_lt_quiet(float32 a, float32 b, float_status *status)
{
flag aSign, bSign;
uint32_t av, bv;
@@ -2968,7 +2975,7 @@ int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float32_unordered_quiet( float32 a, float32 b STATUS_PARAM )
+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);
@@ -2994,7 +3001,7 @@ int float32_unordered_quiet( float32 a, float32 b STATUS_PARAM )
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int32 float64_to_int32( float64 a STATUS_PARAM )
+int32 float64_to_int32(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -3022,7 +3029,7 @@ int32 float64_to_int32( float64 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
+int32 float64_to_int32_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -3069,7 +3076,7 @@ int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int_fast16_t float64_to_int16_round_to_zero(float64 a STATUS_PARAM)
+int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -3120,7 +3127,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a STATUS_PARAM)
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int64 float64_to_int64( float64 a STATUS_PARAM )
+int64 float64_to_int64(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -3163,7 +3170,7 @@ int64 float64_to_int64( float64 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM )
+int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -3213,7 +3220,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float64_to_float32( float64 a STATUS_PARAM )
+float32 float64_to_float32(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3284,7 +3291,8 @@ static float16 packFloat16(flag zSign, int_fast16_t zExp, uint16_t zSig)
*----------------------------------------------------------------------------*/
static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
- uint32_t zSig, flag ieee STATUS_PARAM)
+ uint32_t zSig, flag ieee,
+ float_status *status)
{
int maxexp = ieee ? 29 : 30;
uint32_t mask;
@@ -3380,7 +3388,7 @@ static void normalizeFloat16Subnormal(uint32_t aSig, int_fast16_t *zExpPtr,
/* Half precision floats come in two formats: standard IEEE and "ARM" format.
The latter gains extra exponent range by omitting the NaN/Inf encodings. */
-float32 float16_to_float32(float16 a, flag ieee STATUS_PARAM)
+float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3407,7 +3415,7 @@ float32 float16_to_float32(float16 a, flag ieee STATUS_PARAM)
return packFloat32( aSign, aExp + 0x70, aSig << 13);
}
-float16 float32_to_float16(float32 a, flag ieee STATUS_PARAM)
+float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3451,7 +3459,7 @@ float16 float32_to_float16(float32 a, flag ieee STATUS_PARAM)
return roundAndPackFloat16(aSign, aExp, aSig, ieee STATUS_VAR);
}
-float64 float16_to_float64(float16 a, flag ieee STATUS_PARAM)
+float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3479,7 +3487,7 @@ float64 float16_to_float64(float16 a, flag ieee STATUS_PARAM)
return packFloat64(aSign, aExp + 0x3f0, ((uint64_t)aSig) << 42);
}
-float16 float64_to_float16(float64 a, flag ieee STATUS_PARAM)
+float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3533,7 +3541,7 @@ float16 float64_to_float16(float64 a, flag ieee STATUS_PARAM)
| Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
+floatx80 float64_to_floatx80(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3564,7 +3572,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float64_to_float128( float64 a STATUS_PARAM )
+float128 float64_to_float128(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3595,7 +3603,7 @@ float128 float64_to_float128( float64 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_round_to_int( float64 a STATUS_PARAM )
+float64 float64_round_to_int(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -3669,7 +3677,7 @@ float64 float64_round_to_int( float64 a STATUS_PARAM )
}
-float64 float64_trunc_to_int( float64 a STATUS_PARAM)
+float64 float64_trunc_to_int(float64 a, float_status *status)
{
int oldmode;
float64 res;
@@ -3688,7 +3696,8 @@ float64 float64_trunc_to_int( float64 a STATUS_PARAM)
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
+static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
+ float_status *status)
{
int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
@@ -3767,7 +3776,8 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
+static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
+ float_status *status)
{
int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
@@ -3840,7 +3850,7 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_add( float64 a, float64 b STATUS_PARAM )
+float64 float64_add(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
a = float64_squash_input_denormal(a STATUS_VAR);
@@ -3863,7 +3873,7 @@ float64 float64_add( float64 a, float64 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_sub( float64 a, float64 b STATUS_PARAM )
+float64 float64_sub(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
a = float64_squash_input_denormal(a STATUS_VAR);
@@ -3886,7 +3896,7 @@ float64 float64_sub( float64 a, float64 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_mul( float64 a, float64 b STATUS_PARAM )
+float64 float64_mul(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
@@ -3947,7 +3957,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM )
| the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_div( float64 a, float64 b STATUS_PARAM )
+float64 float64_div(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
@@ -4019,7 +4029,7 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_rem( float64 a, float64 b STATUS_PARAM )
+float64 float64_rem(float64 a, float64 b, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp, bExp, expDiff;
@@ -4110,7 +4120,8 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM )
| externally will flip the sign bit on NaNs.)
*----------------------------------------------------------------------------*/
-float64 float64_muladd(float64 a, float64 b, float64 c, int flags STATUS_PARAM)
+float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
+ float_status *status)
{
flag aSign, bSign, cSign, zSign;
int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
@@ -4351,7 +4362,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags STATUS_PARAM)
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_sqrt( float64 a STATUS_PARAM )
+float64 float64_sqrt(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, zExp;
@@ -4402,7 +4413,7 @@ float64 float64_sqrt( float64 a STATUS_PARAM )
| The operation is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float64_log2( float64 a STATUS_PARAM )
+float64 float64_log2(float64 a, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp;
@@ -4451,7 +4462,7 @@ float64 float64_log2( float64 a STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_eq( float64 a, float64 b STATUS_PARAM )
+int float64_eq(float64 a, float64 b, float_status *status)
{
uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR);
@@ -4476,7 +4487,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_le( float64 a, float64 b STATUS_PARAM )
+int float64_le(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
uint64_t av, bv;
@@ -4505,7 +4516,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM )
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_lt( float64 a, float64 b STATUS_PARAM )
+int float64_lt(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
uint64_t av, bv;
@@ -4534,7 +4545,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_unordered( float64 a, float64 b STATUS_PARAM )
+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);
@@ -4555,7 +4566,7 @@ int float64_unordered( float64 a, float64 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
+int float64_eq_quiet(float64 a, float64 b, float_status *status)
{
uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR);
@@ -4582,7 +4593,7 @@ int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
+int float64_le_quiet(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
uint64_t av, bv;
@@ -4613,7 +4624,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_lt_quiet( float64 a, float64 b STATUS_PARAM )
+int float64_lt_quiet(float64 a, float64 b, float_status *status)
{
flag aSign, bSign;
uint64_t av, bv;
@@ -4644,7 +4655,7 @@ int float64_lt_quiet( float64 a, float64 b STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float64_unordered_quiet( float64 a, float64 b STATUS_PARAM )
+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);
@@ -4670,7 +4681,7 @@ int float64_unordered_quiet( float64 a, float64 b STATUS_PARAM )
| overflows, the largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int32 floatx80_to_int32( floatx80 a STATUS_PARAM )
+int32 floatx80_to_int32(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -4697,7 +4708,7 @@ int32 floatx80_to_int32( floatx80 a STATUS_PARAM )
| sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM )
+int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -4742,7 +4753,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM )
| overflows, the largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
+int64 floatx80_to_int64(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -4782,7 +4793,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
| sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM )
+int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -4823,7 +4834,7 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
+float32 floatx80_to_float32(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -4851,7 +4862,7 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
+float64 floatx80_to_float64(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -4879,7 +4890,7 @@ float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
+float128 floatx80_to_float128(floatx80 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
@@ -4903,7 +4914,7 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
+floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -4996,7 +5007,8 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM)
+static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
+ float_status *status)
{
int32 aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1;
@@ -5062,7 +5074,8 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM )
+static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
+ float_status *status)
{
int32 aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1;
@@ -5128,7 +5141,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_add( floatx80 a, floatx80 b STATUS_PARAM )
+floatx80 floatx80_add(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5149,7 +5162,7 @@ floatx80 floatx80_add( floatx80 a, floatx80 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_sub( floatx80 a, floatx80 b STATUS_PARAM )
+floatx80 floatx80_sub(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5170,7 +5183,7 @@ floatx80 floatx80_sub( floatx80 a, floatx80 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
+floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign, zSign;
int32 aExp, bExp, zExp;
@@ -5229,7 +5242,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
+floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign, zSign;
int32 aExp, bExp, zExp;
@@ -5309,7 +5322,7 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
+floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, zSign;
int32 aExp, bExp, expDiff;
@@ -5405,7 +5418,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
+floatx80 floatx80_sqrt(floatx80 a, float_status *status)
{
flag aSign;
int32 aExp, zExp;
@@ -5476,7 +5489,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_eq(floatx80 a, floatx80 b, float_status *status)
{
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
@@ -5504,7 +5517,7 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_le(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5537,7 +5550,7 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_lt(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5569,7 +5582,7 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
| either operand is a NaN. The comparison is performed according to the
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_unordered(floatx80 a, floatx80 b, float_status *status)
{
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5589,7 +5602,7 @@ int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *status)
{
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
@@ -5619,7 +5632,7 @@ int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM )
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_le_quiet(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5655,7 +5668,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *status)
{
flag aSign, bSign;
@@ -5690,7 +5703,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM )
| The comparison is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int floatx80_unordered_quiet( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_unordered_quiet(floatx80 a, floatx80 b, float_status *status)
{
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5716,7 +5729,7 @@ int floatx80_unordered_quiet( floatx80 a, floatx80 b STATUS_PARAM )
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int32 float128_to_int32( float128 a STATUS_PARAM )
+int32 float128_to_int32(float128 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -5745,7 +5758,7 @@ int32 float128_to_int32( float128 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM )
+int32 float128_to_int32_round_to_zero(float128 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -5793,7 +5806,7 @@ int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM )
| largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/
-int64 float128_to_int64( float128 a STATUS_PARAM )
+int64 float128_to_int64(float128 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -5836,7 +5849,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM )
| returned.
*----------------------------------------------------------------------------*/
-int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
+int64 float128_to_int64_round_to_zero(float128 a, float_status *status)
{
flag aSign;
int32 aExp, shiftCount;
@@ -5894,7 +5907,7 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float32 float128_to_float32( float128 a STATUS_PARAM )
+float32 float128_to_float32(float128 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -5929,7 +5942,7 @@ float32 float128_to_float32( float128 a STATUS_PARAM )
| Arithmetic.
*----------------------------------------------------------------------------*/
-float64 float128_to_float64( float128 a STATUS_PARAM )
+float64 float128_to_float64(float128 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -5962,7 +5975,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
+floatx80 float128_to_floatx80(float128 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -5997,7 +6010,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_round_to_int( float128 a STATUS_PARAM )
+float128 float128_round_to_int(float128 a, float_status *status)
{
flag aSign;
int32 aExp;
@@ -6136,7 +6149,8 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM)
+static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
+ float_status *status)
{
int32 aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
@@ -6222,7 +6236,8 @@ static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float128 subFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM)
+static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
+ float_status *status)
{
int32 aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
@@ -6304,7 +6319,7 @@ static float128 subFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_add( float128 a, float128 b STATUS_PARAM )
+float128 float128_add(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6325,7 +6340,7 @@ float128 float128_add( float128 a, float128 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_sub( float128 a, float128 b STATUS_PARAM )
+float128 float128_sub(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6346,7 +6361,7 @@ float128 float128_sub( float128 a, float128 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_mul( float128 a, float128 b STATUS_PARAM )
+float128 float128_mul(float128 a, float128 b, float_status *status)
{
flag aSign, bSign, zSign;
int32 aExp, bExp, zExp;
@@ -6410,7 +6425,7 @@ float128 float128_mul( float128 a, float128 b STATUS_PARAM )
| the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_div( float128 a, float128 b STATUS_PARAM )
+float128 float128_div(float128 a, float128 b, float_status *status)
{
flag aSign, bSign, zSign;
int32 aExp, bExp, zExp;
@@ -6494,7 +6509,7 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_rem( float128 a, float128 b STATUS_PARAM )
+float128 float128_rem(float128 a, float128 b, float_status *status)
{
flag aSign, zSign;
int32 aExp, bExp, expDiff;
@@ -6603,7 +6618,7 @@ float128 float128_rem( float128 a, float128 b STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-float128 float128_sqrt( float128 a STATUS_PARAM )
+float128 float128_sqrt(float128 a, float_status *status)
{
flag aSign;
int32 aExp, zExp;
@@ -6673,7 +6688,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_eq( float128 a, float128 b STATUS_PARAM )
+int float128_eq(float128 a, float128 b, float_status *status)
{
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
@@ -6700,7 +6715,7 @@ int float128_eq( float128 a, float128 b STATUS_PARAM )
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_le( float128 a, float128 b STATUS_PARAM )
+int float128_le(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6733,7 +6748,7 @@ int float128_le( float128 a, float128 b STATUS_PARAM )
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_lt( float128 a, float128 b STATUS_PARAM )
+int float128_lt(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6766,7 +6781,7 @@ int float128_lt( float128 a, float128 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_unordered( float128 a, float128 b STATUS_PARAM )
+int float128_unordered(float128 a, float128 b, float_status *status)
{
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6786,7 +6801,7 @@ int float128_unordered( float128 a, float128 b STATUS_PARAM )
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_eq_quiet( float128 a, float128 b STATUS_PARAM )
+int float128_eq_quiet(float128 a, float128 b, float_status *status)
{
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
@@ -6816,7 +6831,7 @@ int float128_eq_quiet( float128 a, float128 b STATUS_PARAM )
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_le_quiet( float128 a, float128 b STATUS_PARAM )
+int float128_le_quiet(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6852,7 +6867,7 @@ int float128_le_quiet( float128 a, float128 b STATUS_PARAM )
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_lt_quiet( float128 a, float128 b STATUS_PARAM )
+int float128_lt_quiet(float128 a, float128 b, float_status *status)
{
flag aSign, bSign;
@@ -6888,7 +6903,7 @@ int float128_lt_quiet( float128 a, float128 b STATUS_PARAM )
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-int float128_unordered_quiet( float128 a, float128 b STATUS_PARAM )
+int float128_unordered_quiet(float128 a, float128 b, float_status *status)
{
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6905,17 +6920,17 @@ int float128_unordered_quiet( float128 a, float128 b STATUS_PARAM )
}
/* misc functions */
-float32 uint32_to_float32(uint32_t a STATUS_PARAM)
+float32 uint32_to_float32(uint32_t a, float_status *status)
{
return int64_to_float32(a STATUS_VAR);
}
-float64 uint32_to_float64(uint32_t a STATUS_PARAM)
+float64 uint32_to_float64(uint32_t a, float_status *status)
{
return int64_to_float64(a STATUS_VAR);
}
-uint32 float32_to_uint32( float32 a STATUS_PARAM )
+uint32 float32_to_uint32(float32 a, float_status *status)
{
int64_t v;
uint32 res;
@@ -6934,7 +6949,7 @@ uint32 float32_to_uint32( float32 a STATUS_PARAM )
return res;
}
-uint32 float32_to_uint32_round_to_zero( float32 a STATUS_PARAM )
+uint32 float32_to_uint32_round_to_zero(float32 a, float_status *status)
{
int64_t v;
uint32 res;
@@ -6953,7 +6968,7 @@ uint32 float32_to_uint32_round_to_zero( float32 a STATUS_PARAM )
return res;
}
-int_fast16_t float32_to_int16(float32 a STATUS_PARAM)
+int_fast16_t float32_to_int16(float32 a, float_status *status)
{
int32_t v;
int_fast16_t res;
@@ -6973,7 +6988,7 @@ int_fast16_t float32_to_int16(float32 a STATUS_PARAM)
return res;
}
-uint_fast16_t float32_to_uint16(float32 a STATUS_PARAM)
+uint_fast16_t float32_to_uint16(float32 a, float_status *status)
{
int32_t v;
uint_fast16_t res;
@@ -6993,7 +7008,7 @@ uint_fast16_t float32_to_uint16(float32 a STATUS_PARAM)
return res;
}
-uint_fast16_t float32_to_uint16_round_to_zero(float32 a STATUS_PARAM)
+uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status)
{
int64_t v;
uint_fast16_t res;
@@ -7012,7 +7027,7 @@ uint_fast16_t float32_to_uint16_round_to_zero(float32 a STATUS_PARAM)
return res;
}
-uint32 float64_to_uint32( float64 a STATUS_PARAM )
+uint32 float64_to_uint32(float64 a, float_status *status)
{
uint64_t v;
uint32 res;
@@ -7029,7 +7044,7 @@ uint32 float64_to_uint32( float64 a STATUS_PARAM )
return res;
}
-uint32 float64_to_uint32_round_to_zero( float64 a STATUS_PARAM )
+uint32 float64_to_uint32_round_to_zero(float64 a, float_status *status)
{
uint64_t v;
uint32 res;
@@ -7046,7 +7061,7 @@ uint32 float64_to_uint32_round_to_zero( float64 a STATUS_PARAM )
return res;
}
-int_fast16_t float64_to_int16(float64 a STATUS_PARAM)
+int_fast16_t float64_to_int16(float64 a, float_status *status)
{
int64_t v;
int_fast16_t res;
@@ -7066,7 +7081,7 @@ int_fast16_t float64_to_int16(float64 a STATUS_PARAM)
return res;
}
-uint_fast16_t float64_to_uint16(float64 a STATUS_PARAM)
+uint_fast16_t float64_to_uint16(float64 a, float_status *status)
{
int64_t v;
uint_fast16_t res;
@@ -7086,7 +7101,7 @@ uint_fast16_t float64_to_uint16(float64 a STATUS_PARAM)
return res;
}
-uint_fast16_t float64_to_uint16_round_to_zero(float64 a STATUS_PARAM)
+uint_fast16_t float64_to_uint16_round_to_zero(float64 a, float_status *status)
{
int64_t v;
uint_fast16_t res;
@@ -7117,7 +7132,7 @@ uint_fast16_t float64_to_uint16_round_to_zero(float64 a STATUS_PARAM)
| will raise the inexact exception.
*----------------------------------------------------------------------------*/
-uint64_t float64_to_uint64(float64 a STATUS_PARAM)
+uint64_t float64_to_uint64(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, shiftCount;
@@ -7152,7 +7167,7 @@ uint64_t float64_to_uint64(float64 a STATUS_PARAM)
return roundAndPackUint64(aSign, aSig, aSigExtra STATUS_VAR);
}
-uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)
+uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status)
{
signed char current_rounding_mode = STATUS(float_rounding_mode);
set_float_rounding_mode(float_round_to_zero STATUS_VAR);
@@ -7162,8 +7177,8 @@ uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)
}
#define COMPARE(s, nan_exp) \
-static inline int float ## s ## _compare_internal( float ## s a, float ## s b, \
- int is_quiet STATUS_PARAM ) \
+static inline int float ## s ## _compare_internal(float ## s a, float ## s b,\
+ int is_quiet, float_status *status) \
{ \
flag aSign, bSign; \
uint ## s ## _t av, bv; \
@@ -7201,12 +7216,13 @@ static inline int float ## s ## _compare_internal( float ## s a, float ## s b,
} \
} \
\
-int float ## s ## _compare( float ## s a, float ## s b STATUS_PARAM ) \
+int float ## s ## _compare(float ## s a, float ## s b, float_status *status) \
{ \
return float ## s ## _compare_internal(a, b, 0 STATUS_VAR); \
} \
\
-int float ## s ## _compare_quiet( float ## s a, float ## s b STATUS_PARAM ) \
+int float ## s ## _compare_quiet(float ## s a, float ## s b, \
+ float_status *status) \
{ \
return float ## s ## _compare_internal(a, b, 1 STATUS_VAR); \
}
@@ -7214,8 +7230,8 @@ int float ## s ## _compare_quiet( float ## s a, float ## s b STATUS_PARAM ) \
COMPARE(32, 0xff)
COMPARE(64, 0x7ff)
-static inline int floatx80_compare_internal( floatx80 a, floatx80 b,
- int is_quiet STATUS_PARAM )
+static inline int floatx80_compare_internal(floatx80 a, floatx80 b,
+ int is_quiet, float_status *status)
{
flag aSign, bSign;
@@ -7250,18 +7266,18 @@ static inline int floatx80_compare_internal( floatx80 a, floatx80 b,
}
}
-int floatx80_compare( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_compare(floatx80 a, floatx80 b, float_status *status)
{
return floatx80_compare_internal(a, b, 0 STATUS_VAR);
}
-int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )
+int floatx80_compare_quiet(floatx80 a, floatx80 b, float_status *status)
{
return floatx80_compare_internal(a, b, 1 STATUS_VAR);
}
-static inline int float128_compare_internal( float128 a, float128 b,
- int is_quiet STATUS_PARAM )
+static inline int float128_compare_internal(float128 a, float128 b,
+ int is_quiet, float_status *status)
{
flag aSign, bSign;
@@ -7294,12 +7310,12 @@ static inline int float128_compare_internal( float128 a, float128 b,
}
}
-int float128_compare( float128 a, float128 b STATUS_PARAM )
+int float128_compare(float128 a, float128 b, float_status *status)
{
return float128_compare_internal(a, b, 0 STATUS_VAR);
}
-int float128_compare_quiet( float128 a, float128 b STATUS_PARAM )
+int float128_compare_quiet(float128 a, float128 b, float_status *status)
{
return float128_compare_internal(a, b, 1 STATUS_VAR);
}
@@ -7321,7 +7337,8 @@ int float128_compare_quiet( float128 a, float128 b STATUS_PARAM )
#define MINMAX(s) \
static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \
int ismin, int isieee, \
- int ismag STATUS_PARAM) \
+ int ismag, \
+ float_status *status) \
{ \
flag aSign, bSign; \
uint ## s ## _t av, bv, aav, abv; \
@@ -7370,32 +7387,38 @@ static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \
} \
} \
\
-float ## s float ## s ## _min(float ## s a, float ## s b STATUS_PARAM) \
+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); \
} \
\
-float ## s float ## s ## _max(float ## s a, float ## s b STATUS_PARAM) \
+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); \
} \
\
-float ## s float ## s ## _minnum(float ## s a, float ## s b STATUS_PARAM) \
+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); \
} \
\
-float ## s float ## s ## _maxnum(float ## s a, float ## s b STATUS_PARAM) \
+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); \
} \
\
-float ## s float ## s ## _minnummag(float ## s a, float ## s b STATUS_PARAM) \
+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); \
} \
\
-float ## s float ## s ## _maxnummag(float ## s a, float ## s b STATUS_PARAM) \
+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); \
}
@@ -7405,7 +7428,7 @@ MINMAX(64)
/* Multiply A by 2 raised to the power N. */
-float32 float32_scalbn( float32 a, int n STATUS_PARAM )
+float32 float32_scalbn(float32 a, int n, float_status *status)
{
flag aSign;
int16_t aExp;
@@ -7441,7 +7464,7 @@ float32 float32_scalbn( float32 a, int n STATUS_PARAM )
return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
}
-float64 float64_scalbn( float64 a, int n STATUS_PARAM )
+float64 float64_scalbn(float64 a, int n, float_status *status)
{
flag aSign;
int16_t aExp;
@@ -7477,7 +7500,7 @@ float64 float64_scalbn( float64 a, int n STATUS_PARAM )
return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR );
}
-floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM )
+floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
{
flag aSign;
int32_t aExp;
@@ -7512,7 +7535,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM )
aSign, aExp, aSig, 0 STATUS_VAR );
}
-float128 float128_scalbn( float128 a, int n STATUS_PARAM )
+float128 float128_scalbn(float128 a, int n, float_status *status)
{
flag aSign;
int32_t aExp;
diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
index 35019c9..fab2aee 100644
--- a/include/fpu/softfloat.h
+++ b/include/fpu/softfloat.h
@@ -108,7 +108,6 @@ typedef int64_t int64;
#define LIT64( a ) a##LL
-#define STATUS_PARAM , float_status *status
#define STATUS(field) status->field
#define STATUS_VAR , status
@@ -224,31 +223,32 @@ typedef struct float_status {
flag default_nan_mode;
} float_status;
-static inline void set_float_detect_tininess(int val STATUS_PARAM)
+static inline void set_float_detect_tininess(int val, float_status *status)
{
STATUS(float_detect_tininess) = val;
}
-static inline void set_float_rounding_mode(int val STATUS_PARAM)
+static inline void set_float_rounding_mode(int val, float_status *status)
{
STATUS(float_rounding_mode) = val;
}
-static inline void set_float_exception_flags(int val STATUS_PARAM)
+static inline void set_float_exception_flags(int val, float_status *status)
{
STATUS(float_exception_flags) = val;
}
-static inline void set_floatx80_rounding_precision(int val STATUS_PARAM)
+static inline void set_floatx80_rounding_precision(int val,
+ float_status *status)
{
STATUS(floatx80_rounding_precision) = val;
}
-static inline void set_flush_to_zero(flag val STATUS_PARAM)
+static inline void set_flush_to_zero(flag val, float_status *status)
{
STATUS(flush_to_zero) = val;
}
-static inline void set_flush_inputs_to_zero(flag val STATUS_PARAM)
+static inline void set_flush_inputs_to_zero(flag val, float_status *status)
{
STATUS(flush_inputs_to_zero) = val;
}
-static inline void set_default_nan_mode(flag val STATUS_PARAM)
+static inline void set_default_nan_mode(flag val, float_status *status)
{
STATUS(default_nan_mode) = val;
}
@@ -285,14 +285,14 @@ static inline flag get_default_nan_mode(float_status *status)
| Routine to raise any or all of the software IEC/IEEE floating-point
| exception flags.
*----------------------------------------------------------------------------*/
-void float_raise( int8 flags STATUS_PARAM);
+void float_raise(int8 flags, float_status *status);
/*----------------------------------------------------------------------------
| If `a' is denormal and we are in flush-to-zero mode then set the
| input-denormal exception and return zero. Otherwise just return the value.
*----------------------------------------------------------------------------*/
-float32 float32_squash_input_denormal(float32 a STATUS_PARAM);
-float64 float64_squash_input_denormal(float64 a STATUS_PARAM);
+float32 float32_squash_input_denormal(float32 a, float_status *status);
+float64 float64_squash_input_denormal(float64 a, float_status *status);
/*----------------------------------------------------------------------------
| Options to indicate which negations to perform in float*_muladd()
@@ -312,37 +312,37 @@ enum {
/*----------------------------------------------------------------------------
| Software IEC/IEEE integer-to-floating-point conversion routines.
*----------------------------------------------------------------------------*/
-float32 int32_to_float32(int32_t STATUS_PARAM);
-float64 int32_to_float64(int32_t STATUS_PARAM);
-float32 uint32_to_float32(uint32_t STATUS_PARAM);
-float64 uint32_to_float64(uint32_t STATUS_PARAM);
-floatx80 int32_to_floatx80(int32_t STATUS_PARAM);
-float128 int32_to_float128(int32_t STATUS_PARAM);
-float32 int64_to_float32(int64_t STATUS_PARAM);
-float64 int64_to_float64(int64_t STATUS_PARAM);
-floatx80 int64_to_floatx80(int64_t STATUS_PARAM);
-float128 int64_to_float128(int64_t STATUS_PARAM);
-float32 uint64_to_float32(uint64_t STATUS_PARAM);
-float64 uint64_to_float64(uint64_t STATUS_PARAM);
-float128 uint64_to_float128(uint64_t STATUS_PARAM);
+float32 int32_to_float32(int32_t, float_status *status);
+float64 int32_to_float64(int32_t, float_status *status);
+float32 uint32_to_float32(uint32_t, float_status *status);
+float64 uint32_to_float64(uint32_t, float_status *status);
+floatx80 int32_to_floatx80(int32_t, float_status *status);
+float128 int32_to_float128(int32_t, float_status *status);
+float32 int64_to_float32(int64_t, float_status *status);
+float64 int64_to_float64(int64_t, float_status *status);
+floatx80 int64_to_floatx80(int64_t, float_status *status);
+float128 int64_to_float128(int64_t, float_status *status);
+float32 uint64_to_float32(uint64_t, float_status *status);
+float64 uint64_to_float64(uint64_t, float_status *status);
+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 STATUS_PARAM)
+static inline float32 int16_to_float32(int16_t v, float_status *status)
{
return int32_to_float32(v STATUS_VAR);
}
-static inline float32 uint16_to_float32(uint16_t v STATUS_PARAM)
+static inline float32 uint16_to_float32(uint16_t v, float_status *status)
{
return uint32_to_float32(v STATUS_VAR);
}
-static inline float64 int16_to_float64(int16_t v STATUS_PARAM)
+static inline float64 int16_to_float64(int16_t v, float_status *status)
{
return int32_to_float64(v STATUS_VAR);
}
-static inline float64 uint16_to_float64(uint16_t v STATUS_PARAM)
+static inline float64 uint16_to_float64(uint16_t v, float_status *status)
{
return uint32_to_float64(v STATUS_VAR);
}
@@ -350,10 +350,10 @@ static inline float64 uint16_to_float64(uint16_t v STATUS_PARAM)
/*----------------------------------------------------------------------------
| Software half-precision conversion routines.
*----------------------------------------------------------------------------*/
-float16 float32_to_float16( float32, flag STATUS_PARAM );
-float32 float16_to_float32( float16, flag STATUS_PARAM );
-float16 float64_to_float16(float64 a, flag ieee STATUS_PARAM);
-float64 float16_to_float64(float16 a, flag ieee STATUS_PARAM);
+float16 float32_to_float16(float32, flag, float_status *status);
+float32 float16_to_float32(float16, flag, float_status *status);
+float16 float64_to_float16(float64 a, flag ieee, float_status *status);
+float64 float16_to_float64(float16 a, flag ieee, float_status *status);
/*----------------------------------------------------------------------------
| Software half-precision operations.
@@ -375,55 +375,55 @@ extern const float16 float16_default_nan;
/*----------------------------------------------------------------------------
| Software IEC/IEEE single-precision conversion routines.
*----------------------------------------------------------------------------*/
-int_fast16_t float32_to_int16(float32 STATUS_PARAM);
-uint_fast16_t float32_to_uint16(float32 STATUS_PARAM);
-int_fast16_t float32_to_int16_round_to_zero(float32 STATUS_PARAM);
-uint_fast16_t float32_to_uint16_round_to_zero(float32 STATUS_PARAM);
-int32 float32_to_int32( float32 STATUS_PARAM );
-int32 float32_to_int32_round_to_zero( float32 STATUS_PARAM );
-uint32 float32_to_uint32( float32 STATUS_PARAM );
-uint32 float32_to_uint32_round_to_zero( float32 STATUS_PARAM );
-int64 float32_to_int64( float32 STATUS_PARAM );
-uint64 float32_to_uint64(float32 STATUS_PARAM);
-uint64 float32_to_uint64_round_to_zero(float32 STATUS_PARAM);
-int64 float32_to_int64_round_to_zero( float32 STATUS_PARAM );
-float64 float32_to_float64( float32 STATUS_PARAM );
-floatx80 float32_to_floatx80( float32 STATUS_PARAM );
-float128 float32_to_float128( float32 STATUS_PARAM );
+int_fast16_t float32_to_int16(float32, float_status *status);
+uint_fast16_t float32_to_uint16(float32, float_status *status);
+int_fast16_t float32_to_int16_round_to_zero(float32, float_status *status);
+uint_fast16_t float32_to_uint16_round_to_zero(float32, float_status *status);
+int32 float32_to_int32(float32, float_status *status);
+int32 float32_to_int32_round_to_zero(float32, float_status *status);
+uint32 float32_to_uint32(float32, float_status *status);
+uint32 float32_to_uint32_round_to_zero(float32, float_status *status);
+int64 float32_to_int64(float32, float_status *status);
+uint64 float32_to_uint64(float32, float_status *status);
+uint64 float32_to_uint64_round_to_zero(float32, float_status *status);
+int64 float32_to_int64_round_to_zero(float32, float_status *status);
+float64 float32_to_float64(float32, float_status *status);
+floatx80 float32_to_floatx80(float32, float_status *status);
+float128 float32_to_float128(float32, float_status *status);
/*----------------------------------------------------------------------------
| Software IEC/IEEE single-precision operations.
*----------------------------------------------------------------------------*/
-float32 float32_round_to_int( float32 STATUS_PARAM );
-float32 float32_add( float32, float32 STATUS_PARAM );
-float32 float32_sub( float32, float32 STATUS_PARAM );
-float32 float32_mul( float32, float32 STATUS_PARAM );
-float32 float32_div( float32, float32 STATUS_PARAM );
-float32 float32_rem( float32, float32 STATUS_PARAM );
-float32 float32_muladd(float32, float32, float32, int STATUS_PARAM);
-float32 float32_sqrt( float32 STATUS_PARAM );
-float32 float32_exp2( float32 STATUS_PARAM );
-float32 float32_log2( float32 STATUS_PARAM );
-int float32_eq( float32, float32 STATUS_PARAM );
-int float32_le( float32, float32 STATUS_PARAM );
-int float32_lt( float32, float32 STATUS_PARAM );
-int float32_unordered( float32, float32 STATUS_PARAM );
-int float32_eq_quiet( float32, float32 STATUS_PARAM );
-int float32_le_quiet( float32, float32 STATUS_PARAM );
-int float32_lt_quiet( float32, float32 STATUS_PARAM );
-int float32_unordered_quiet( float32, float32 STATUS_PARAM );
-int float32_compare( float32, float32 STATUS_PARAM );
-int float32_compare_quiet( float32, float32 STATUS_PARAM );
-float32 float32_min(float32, float32 STATUS_PARAM);
-float32 float32_max(float32, float32 STATUS_PARAM);
-float32 float32_minnum(float32, float32 STATUS_PARAM);
-float32 float32_maxnum(float32, float32 STATUS_PARAM);
-float32 float32_minnummag(float32, float32 STATUS_PARAM);
-float32 float32_maxnummag(float32, float32 STATUS_PARAM);
+float32 float32_round_to_int(float32, float_status *status);
+float32 float32_add(float32, float32, float_status *status);
+float32 float32_sub(float32, float32, float_status *status);
+float32 float32_mul(float32, float32, float_status *status);
+float32 float32_div(float32, float32, float_status *status);
+float32 float32_rem(float32, float32, float_status *status);
+float32 float32_muladd(float32, float32, float32, int, float_status *status);
+float32 float32_sqrt(float32, float_status *status);
+float32 float32_exp2(float32, float_status *status);
+float32 float32_log2(float32, float_status *status);
+int float32_eq(float32, float32, float_status *status);
+int float32_le(float32, float32, float_status *status);
+int float32_lt(float32, float32, float_status *status);
+int float32_unordered(float32, float32, float_status *status);
+int float32_eq_quiet(float32, float32, float_status *status);
+int float32_le_quiet(float32, float32, float_status *status);
+int float32_lt_quiet(float32, float32, float_status *status);
+int float32_unordered_quiet(float32, float32, float_status *status);
+int float32_compare(float32, float32, float_status *status);
+int float32_compare_quiet(float32, float32, float_status *status);
+float32 float32_min(float32, float32, float_status *status);
+float32 float32_max(float32, float32, float_status *status);
+float32 float32_minnum(float32, float32, float_status *status);
+float32 float32_maxnum(float32, float32, float_status *status);
+float32 float32_minnummag(float32, float32, float_status *status);
+float32 float32_maxnummag(float32, float32, float_status *status);
int float32_is_quiet_nan( float32 );
int float32_is_signaling_nan( float32 );
float32 float32_maybe_silence_nan( float32 );
-float32 float32_scalbn( float32, int STATUS_PARAM );
+float32 float32_scalbn(float32, int, float_status *status);
static inline float32 float32_abs(float32 a)
{
@@ -487,55 +487,55 @@ extern const float32 float32_default_nan;
/*----------------------------------------------------------------------------
| Software IEC/IEEE double-precision conversion routines.
*----------------------------------------------------------------------------*/
-int_fast16_t float64_to_int16(float64 STATUS_PARAM);
-uint_fast16_t float64_to_uint16(float64 STATUS_PARAM);
-int_fast16_t float64_to_int16_round_to_zero(float64 STATUS_PARAM);
-uint_fast16_t float64_to_uint16_round_to_zero(float64 STATUS_PARAM);
-int32 float64_to_int32( float64 STATUS_PARAM );
-int32 float64_to_int32_round_to_zero( float64 STATUS_PARAM );
-uint32 float64_to_uint32( float64 STATUS_PARAM );
-uint32 float64_to_uint32_round_to_zero( float64 STATUS_PARAM );
-int64 float64_to_int64( float64 STATUS_PARAM );
-int64 float64_to_int64_round_to_zero( float64 STATUS_PARAM );
-uint64 float64_to_uint64 (float64 a STATUS_PARAM);
-uint64 float64_to_uint64_round_to_zero (float64 a STATUS_PARAM);
-float32 float64_to_float32( float64 STATUS_PARAM );
-floatx80 float64_to_floatx80( float64 STATUS_PARAM );
-float128 float64_to_float128( float64 STATUS_PARAM );
+int_fast16_t float64_to_int16(float64, float_status *status);
+uint_fast16_t float64_to_uint16(float64, float_status *status);
+int_fast16_t float64_to_int16_round_to_zero(float64, float_status *status);
+uint_fast16_t float64_to_uint16_round_to_zero(float64, float_status *status);
+int32 float64_to_int32(float64, float_status *status);
+int32 float64_to_int32_round_to_zero(float64, float_status *status);
+uint32 float64_to_uint32(float64, float_status *status);
+uint32 float64_to_uint32_round_to_zero(float64, float_status *status);
+int64 float64_to_int64(float64, float_status *status);
+int64 float64_to_int64_round_to_zero(float64, float_status *status);
+uint64 float64_to_uint64(float64 a, float_status *status);
+uint64 float64_to_uint64_round_to_zero(float64 a, float_status *status);
+float32 float64_to_float32(float64, float_status *status);
+floatx80 float64_to_floatx80(float64, float_status *status);
+float128 float64_to_float128(float64, float_status *status);
/*----------------------------------------------------------------------------
| Software IEC/IEEE double-precision operations.
*----------------------------------------------------------------------------*/
-float64 float64_round_to_int( float64 STATUS_PARAM );
-float64 float64_trunc_to_int( float64 STATUS_PARAM );
-float64 float64_add( float64, float64 STATUS_PARAM );
-float64 float64_sub( float64, float64 STATUS_PARAM );
-float64 float64_mul( float64, float64 STATUS_PARAM );
-float64 float64_div( float64, float64 STATUS_PARAM );
-float64 float64_rem( float64, float64 STATUS_PARAM );
-float64 float64_muladd(float64, float64, float64, int STATUS_PARAM);
-float64 float64_sqrt( float64 STATUS_PARAM );
-float64 float64_log2( float64 STATUS_PARAM );
-int float64_eq( float64, float64 STATUS_PARAM );
-int float64_le( float64, float64 STATUS_PARAM );
-int float64_lt( float64, float64 STATUS_PARAM );
-int float64_unordered( float64, float64 STATUS_PARAM );
-int float64_eq_quiet( float64, float64 STATUS_PARAM );
-int float64_le_quiet( float64, float64 STATUS_PARAM );
-int float64_lt_quiet( float64, float64 STATUS_PARAM );
-int float64_unordered_quiet( float64, float64 STATUS_PARAM );
-int float64_compare( float64, float64 STATUS_PARAM );
-int float64_compare_quiet( float64, float64 STATUS_PARAM );
-float64 float64_min(float64, float64 STATUS_PARAM);
-float64 float64_max(float64, float64 STATUS_PARAM);
-float64 float64_minnum(float64, float64 STATUS_PARAM);
-float64 float64_maxnum(float64, float64 STATUS_PARAM);
-float64 float64_minnummag(float64, float64 STATUS_PARAM);
-float64 float64_maxnummag(float64, float64 STATUS_PARAM);
+float64 float64_round_to_int(float64, float_status *status);
+float64 float64_trunc_to_int(float64, float_status *status);
+float64 float64_add(float64, float64, float_status *status);
+float64 float64_sub(float64, float64, float_status *status);
+float64 float64_mul(float64, float64, float_status *status);
+float64 float64_div(float64, float64, float_status *status);
+float64 float64_rem(float64, float64, float_status *status);
+float64 float64_muladd(float64, float64, float64, int, float_status *status);
+float64 float64_sqrt(float64, float_status *status);
+float64 float64_log2(float64, float_status *status);
+int float64_eq(float64, float64, float_status *status);
+int float64_le(float64, float64, float_status *status);
+int float64_lt(float64, float64, float_status *status);
+int float64_unordered(float64, float64, float_status *status);
+int float64_eq_quiet(float64, float64, float_status *status);
+int float64_le_quiet(float64, float64, float_status *status);
+int float64_lt_quiet(float64, float64, float_status *status);
+int float64_unordered_quiet(float64, float64, float_status *status);
+int float64_compare(float64, float64, float_status *status);
+int float64_compare_quiet(float64, float64, float_status *status);
+float64 float64_min(float64, float64, float_status *status);
+float64 float64_max(float64, float64, float_status *status);
+float64 float64_minnum(float64, float64, float_status *status);
+float64 float64_maxnum(float64, float64, float_status *status);
+float64 float64_minnummag(float64, float64, float_status *status);
+float64 float64_maxnummag(float64, float64, float_status *status);
int float64_is_quiet_nan( float64 a );
int float64_is_signaling_nan( float64 );
float64 float64_maybe_silence_nan( float64 );
-float64 float64_scalbn( float64, int STATUS_PARAM );
+float64 float64_scalbn(float64, int, float_status *status);
static inline float64 float64_abs(float64 a)
{
@@ -599,38 +599,38 @@ extern const float64 float64_default_nan;
/*----------------------------------------------------------------------------
| Software IEC/IEEE extended double-precision conversion routines.
*----------------------------------------------------------------------------*/
-int32 floatx80_to_int32( floatx80 STATUS_PARAM );
-int32 floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );
-int64 floatx80_to_int64( floatx80 STATUS_PARAM );
-int64 floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM );
-float32 floatx80_to_float32( floatx80 STATUS_PARAM );
-float64 floatx80_to_float64( floatx80 STATUS_PARAM );
-float128 floatx80_to_float128( floatx80 STATUS_PARAM );
+int32 floatx80_to_int32(floatx80, float_status *status);
+int32 floatx80_to_int32_round_to_zero(floatx80, float_status *status);
+int64 floatx80_to_int64(floatx80, float_status *status);
+int64 floatx80_to_int64_round_to_zero(floatx80, float_status *status);
+float32 floatx80_to_float32(floatx80, float_status *status);
+float64 floatx80_to_float64(floatx80, float_status *status);
+float128 floatx80_to_float128(floatx80, float_status *status);
/*----------------------------------------------------------------------------
| Software IEC/IEEE extended double-precision operations.
*----------------------------------------------------------------------------*/
-floatx80 floatx80_round_to_int( floatx80 STATUS_PARAM );
-floatx80 floatx80_add( floatx80, floatx80 STATUS_PARAM );
-floatx80 floatx80_sub( floatx80, floatx80 STATUS_PARAM );
-floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM );
-floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM );
-floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );
-floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );
-int floatx80_eq( floatx80, floatx80 STATUS_PARAM );
-int floatx80_le( floatx80, floatx80 STATUS_PARAM );
-int floatx80_lt( floatx80, floatx80 STATUS_PARAM );
-int floatx80_unordered( floatx80, floatx80 STATUS_PARAM );
-int floatx80_eq_quiet( floatx80, floatx80 STATUS_PARAM );
-int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM );
-int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM );
-int floatx80_unordered_quiet( floatx80, floatx80 STATUS_PARAM );
-int floatx80_compare( floatx80, floatx80 STATUS_PARAM );
-int floatx80_compare_quiet( floatx80, floatx80 STATUS_PARAM );
+floatx80 floatx80_round_to_int(floatx80, float_status *status);
+floatx80 floatx80_add(floatx80, floatx80, float_status *status);
+floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
+floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
+floatx80 floatx80_div(floatx80, floatx80, float_status *status);
+floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
+floatx80 floatx80_sqrt(floatx80, float_status *status);
+int floatx80_eq(floatx80, floatx80, float_status *status);
+int floatx80_le(floatx80, floatx80, float_status *status);
+int floatx80_lt(floatx80, floatx80, float_status *status);
+int floatx80_unordered(floatx80, floatx80, float_status *status);
+int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
+int floatx80_le_quiet(floatx80, floatx80, float_status *status);
+int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
+int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
+int floatx80_compare(floatx80, floatx80, float_status *status);
+int floatx80_compare_quiet(floatx80, floatx80, float_status *status);
int floatx80_is_quiet_nan( floatx80 );
int floatx80_is_signaling_nan( floatx80 );
floatx80 floatx80_maybe_silence_nan( floatx80 );
-floatx80 floatx80_scalbn( floatx80, int STATUS_PARAM );
+floatx80 floatx80_scalbn(floatx80, int, float_status *status);
static inline floatx80 floatx80_abs(floatx80 a)
{
@@ -684,38 +684,38 @@ extern const floatx80 floatx80_default_nan;
/*----------------------------------------------------------------------------
| Software IEC/IEEE quadruple-precision conversion routines.
*----------------------------------------------------------------------------*/
-int32 float128_to_int32( float128 STATUS_PARAM );
-int32 float128_to_int32_round_to_zero( float128 STATUS_PARAM );
-int64 float128_to_int64( float128 STATUS_PARAM );
-int64 float128_to_int64_round_to_zero( float128 STATUS_PARAM );
-float32 float128_to_float32( float128 STATUS_PARAM );
-float64 float128_to_float64( float128 STATUS_PARAM );
-floatx80 float128_to_floatx80( float128 STATUS_PARAM );
+int32 float128_to_int32(float128, float_status *status);
+int32 float128_to_int32_round_to_zero(float128, float_status *status);
+int64 float128_to_int64(float128, float_status *status);
+int64 float128_to_int64_round_to_zero(float128, float_status *status);
+float32 float128_to_float32(float128, float_status *status);
+float64 float128_to_float64(float128, float_status *status);
+floatx80 float128_to_floatx80(float128, float_status *status);
/*----------------------------------------------------------------------------
| Software IEC/IEEE quadruple-precision operations.
*----------------------------------------------------------------------------*/
-float128 float128_round_to_int( float128 STATUS_PARAM );
-float128 float128_add( float128, float128 STATUS_PARAM );
-float128 float128_sub( float128, float128 STATUS_PARAM );
-float128 float128_mul( float128, float128 STATUS_PARAM );
-float128 float128_div( float128, float128 STATUS_PARAM );
-float128 float128_rem( float128, float128 STATUS_PARAM );
-float128 float128_sqrt( float128 STATUS_PARAM );
-int float128_eq( float128, float128 STATUS_PARAM );
-int float128_le( float128, float128 STATUS_PARAM );
-int float128_lt( float128, float128 STATUS_PARAM );
-int float128_unordered( float128, float128 STATUS_PARAM );
-int float128_eq_quiet( float128, float128 STATUS_PARAM );
-int float128_le_quiet( float128, float128 STATUS_PARAM );
-int float128_lt_quiet( float128, float128 STATUS_PARAM );
-int float128_unordered_quiet( float128, float128 STATUS_PARAM );
-int float128_compare( float128, float128 STATUS_PARAM );
-int float128_compare_quiet( float128, float128 STATUS_PARAM );
+float128 float128_round_to_int(float128, float_status *status);
+float128 float128_add(float128, float128, float_status *status);
+float128 float128_sub(float128, float128, float_status *status);
+float128 float128_mul(float128, float128, float_status *status);
+float128 float128_div(float128, float128, float_status *status);
+float128 float128_rem(float128, float128, float_status *status);
+float128 float128_sqrt(float128, float_status *status);
+int float128_eq(float128, float128, float_status *status);
+int float128_le(float128, float128, float_status *status);
+int float128_lt(float128, float128, float_status *status);
+int float128_unordered(float128, float128, float_status *status);
+int float128_eq_quiet(float128, float128, float_status *status);
+int float128_le_quiet(float128, float128, float_status *status);
+int float128_lt_quiet(float128, float128, float_status *status);
+int float128_unordered_quiet(float128, float128, float_status *status);
+int float128_compare(float128, float128, float_status *status);
+int float128_compare_quiet(float128, float128, float_status *status);
int float128_is_quiet_nan( float128 );
int float128_is_signaling_nan( float128 );
float128 float128_maybe_silence_nan( float128 );
-float128 float128_scalbn( float128, int STATUS_PARAM );
+float128 float128_scalbn(float128, int, float_status *status);
static inline float128 float128_abs(float128 a)
{
diff --git a/target-mips/msa_helper.c b/target-mips/msa_helper.c
index 6e07f6e..c9fc9f9 100644
--- a/target-mips/msa_helper.c
+++ b/target-mips/msa_helper.c
@@ -1614,7 +1614,8 @@ static inline int get_enabled_exceptions(const CPUMIPSState *env, int c)
return c & enable;
}
-static inline float16 float16_from_float32(int32 a, flag ieee STATUS_PARAM)
+static inline float16 float16_from_float32(int32 a, flag ieee,
+ float_status *status)
{
float16 f_val;
@@ -1624,7 +1625,7 @@ static inline float16 float16_from_float32(int32 a, flag ieee STATUS_PARAM)
return a < 0 ? (f_val | (1 << 15)) : f_val;
}
-static inline float32 float32_from_float64(int64 a STATUS_PARAM)
+static inline float32 float32_from_float64(int64 a, float_status *status)
{
float32 f_val;
@@ -1634,7 +1635,8 @@ static inline float32 float32_from_float64(int64 a STATUS_PARAM)
return a < 0 ? (f_val | (1 << 31)) : f_val;
}
-static inline float32 float32_from_float16(int16_t a, flag ieee STATUS_PARAM)
+static inline float32 float32_from_float16(int16_t a, flag ieee,
+ float_status *status)
{
float32 f_val;
@@ -1644,7 +1646,7 @@ static inline float32 float32_from_float16(int16_t a, flag ieee STATUS_PARAM)
return a < 0 ? (f_val | (1 << 31)) : f_val;
}
-static inline float64 float64_from_float32(int32 a STATUS_PARAM)
+static inline float64 float64_from_float32(int32 a, float_status *status)
{
float64 f_val;
@@ -1654,7 +1656,7 @@ static inline float64 float64_from_float32(int32 a STATUS_PARAM)
return a < 0 ? (f_val | (1ULL << 63)) : f_val;
}
-static inline float32 float32_from_q16(int16_t a STATUS_PARAM)
+static inline float32 float32_from_q16(int16_t a, float_status *status)
{
float32 f_val;
@@ -1665,7 +1667,7 @@ static inline float32 float32_from_q16(int16_t a STATUS_PARAM)
return f_val;
}
-static inline float64 float64_from_q32(int32 a STATUS_PARAM)
+static inline float64 float64_from_q32(int32 a, float_status *status)
{
float64 f_val;
@@ -1676,7 +1678,7 @@ static inline float64 float64_from_q32(int32 a STATUS_PARAM)
return f_val;
}
-static inline int16_t float32_to_q16(float32 a STATUS_PARAM)
+static inline int16_t float32_to_q16(float32 a, float_status *status)
{
int32 q_val;
int32 q_min = 0xffff8000;
@@ -1728,7 +1730,7 @@ static inline int16_t float32_to_q16(float32 a STATUS_PARAM)
return (int16_t)q_val;
}
-static inline int32 float64_to_q32(float64 a STATUS_PARAM)
+static inline int32 float64_to_q32(float64 a, float_status *status)
{
int64 q_val;
int64 q_min = 0xffffffff80000000LL;
--
1.9.1
^ permalink raw reply related [flat|nested] 8+ messages in thread* [Qemu-devel] [PATCH 2/3] softfloat: expand out STATUS_VAR
2015-02-02 20:31 [Qemu-devel] [PATCH 0/3] softfloat: Remove STATUS macros Peter Maydell
2015-02-02 20:31 ` [Qemu-devel] [PATCH 1/3] softfloat: Expand out the STATUS_PARAM macro Peter Maydell
@ 2015-02-02 20:31 ` Peter Maydell
2015-02-02 20:31 ` [Qemu-devel] [PATCH 3/3] softfloat: expand out STATUS macro Peter Maydell
2015-02-02 21:37 ` [Qemu-devel] [PATCH 0/3] softfloat: Remove STATUS macros Richard Henderson
3 siblings, 0 replies; 8+ messages in thread
From: Peter Maydell @ 2015-02-02 20:31 UTC (permalink / raw)
To: qemu-devel; +Cc: Richard Henderson, Maciej W. Rozycki, patches
Expand out and remove the STATUS_VAR macro.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
fpu/softfloat-specialize.h | 50 ++-
fpu/softfloat.c | 995 +++++++++++++++++++++++++--------------------
include/fpu/softfloat.h | 9 +-
target-mips/msa_helper.c | 56 +--
4 files changed, 617 insertions(+), 493 deletions(-)
diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
index 264f6c0..21d3ec2 100644
--- a/fpu/softfloat-specialize.h
+++ b/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;
@@ -514,7 +518,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;
}
@@ -544,7 +548,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;
}
@@ -573,7 +577,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;
}
@@ -625,7 +629,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;
@@ -671,12 +677,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
@@ -776,7 +782,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;
@@ -824,7 +832,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;
@@ -870,12 +880,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
@@ -985,7 +995,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;
@@ -1041,7 +1053,9 @@ static floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b,
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;
@@ -1145,7 +1159,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;
@@ -1188,7 +1204,9 @@ static float128 propagateFloat128NaN(float128 a, float128 b,
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/fpu/softfloat.c b/fpu/softfloat.c
index 6437b17..f56c618 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -176,7 +176,7 @@ static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
z = 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;
@@ -231,7 +231,7 @@ static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
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 );
@@ -279,14 +279,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;
}
@@ -337,7 +337,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);
}
}
@@ -437,12 +437,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 =
@@ -452,7 +452,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;
@@ -479,7 +481,8 @@ static float32
int8 shiftCount;
shiftCount = countLeadingZeros32( zSig ) - 1;
- return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount STATUS_VAR);
+ return roundAndPackFloat32(zSign, zExp - shiftCount, zSig<<shiftCount,
+ status);
}
@@ -524,7 +527,7 @@ float64 float64_squash_input_denormal(float64 a, float_status *status)
{
if (STATUS(flush_inputs_to_zero)) {
if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
- float_raise(float_flag_input_denormal STATUS_VAR);
+ float_raise(float_flag_input_denormal, status);
return make_float64(float64_val(a) & (1ULL << 63));
}
}
@@ -623,12 +626,12 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
|| ( ( zExp == 0x7FD )
&& ( (int64_t) ( zSig + roundIncrement ) < 0 ) )
) {
- float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR);
+ float_raise(float_flag_overflow | float_flag_inexact, status);
return packFloat64( zSign, 0x7FF, - ( 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 packFloat64(zSign, 0, 0);
}
isTiny =
@@ -638,7 +641,9 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
shift64RightJamming( zSig, - zExp, &zSig );
zExp = 0;
roundBits = zSig & 0x3FF;
- 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;
@@ -665,7 +670,8 @@ static float64
int8 shiftCount;
shiftCount = countLeadingZeros64( zSig ) - 1;
- return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount STATUS_VAR);
+ return roundAndPackFloat64(zSign, zExp - shiftCount, zSig<<shiftCount,
+ status);
}
@@ -810,7 +816,7 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
}
if ( zExp <= 0 ) {
if (STATUS(flush_to_zero)) {
- float_raise(float_flag_output_denormal STATUS_VAR);
+ float_raise(float_flag_output_denormal, status);
return packFloatx80(zSign, 0, 0);
}
isTiny =
@@ -820,7 +826,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
shift64RightJamming( zSig0, 1 - zExp, &zSig0 );
zExp = 0;
roundBits = zSig0 & roundMask;
- 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;
zSig0 += roundIncrement;
if ( (int64_t) zSig0 < 0 ) zExp = 1;
@@ -872,7 +880,7 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
) {
roundMask = 0;
overflow:
- float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR);
+ float_raise(float_flag_overflow | float_flag_inexact, status);
if ( ( roundingMode == float_round_to_zero )
|| ( zSign && ( roundingMode == float_round_up ) )
|| ( ! zSign && ( roundingMode == float_round_down ) )
@@ -889,7 +897,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
|| ( zSig0 < LIT64( 0xFFFFFFFFFFFFFFFF ) );
shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );
zExp = 0;
- if ( isTiny && zSig1 ) float_raise( float_flag_underflow STATUS_VAR);
+ if (isTiny && zSig1) {
+ float_raise(float_flag_underflow, status);
+ }
if ( zSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
switch (roundingMode) {
case float_round_nearest_even:
@@ -959,8 +969,8 @@ static floatx80 normalizeRoundAndPackFloatx80(int8 roundingPrecision,
shiftCount = countLeadingZeros64( zSig0 );
shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
zExp -= shiftCount;
- return
- roundAndPackFloatx80( roundingPrecision, zSign, zExp, zSig0, zSig1 STATUS_VAR);
+ return roundAndPackFloatx80(roundingPrecision, zSign, zExp,
+ zSig0, zSig1, status);
}
@@ -1135,7 +1145,7 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
&& increment
)
) {
- float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR);
+ float_raise(float_flag_overflow | float_flag_inexact, status);
if ( ( roundingMode == float_round_to_zero )
|| ( zSign && ( roundingMode == float_round_up ) )
|| ( ! zSign && ( roundingMode == float_round_down ) )
@@ -1152,7 +1162,7 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
}
if ( zExp < 0 ) {
if (STATUS(flush_to_zero)) {
- float_raise(float_flag_output_denormal STATUS_VAR);
+ float_raise(float_flag_output_denormal, status);
return packFloat128(zSign, 0, 0, 0);
}
isTiny =
@@ -1168,7 +1178,9 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
shift128ExtraRightJamming(
zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 );
zExp = 0;
- if ( isTiny && zSig2 ) float_raise( float_flag_underflow STATUS_VAR);
+ if (isTiny && zSig2) {
+ float_raise(float_flag_underflow, status);
+ }
switch (roundingMode) {
case float_round_nearest_even:
case float_round_ties_away:
@@ -1232,7 +1244,7 @@ static float128 normalizeRoundAndPackFloat128(flag zSign, int32 zExp,
zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 );
}
zExp -= shiftCount;
- return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 STATUS_VAR);
+ return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);
}
@@ -1249,8 +1261,7 @@ float32 int32_to_float32(int32_t a, float_status *status)
if ( a == 0 ) return float32_zero;
if ( a == (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
zSign = ( a < 0 );
- return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a STATUS_VAR );
-
+ return normalizeRoundAndPackFloat32(zSign, 0x9C, zSign ? -a : a, status);
}
/*----------------------------------------------------------------------------
@@ -1347,7 +1358,7 @@ float32 int64_to_float32(int64_t a, float_status *status)
else {
absA <<= shiftCount;
}
- return roundAndPackFloat32( zSign, 0x9C - shiftCount, absA STATUS_VAR );
+ return roundAndPackFloat32(zSign, 0x9C - shiftCount, absA, status);
}
}
@@ -1367,8 +1378,7 @@ float64 int64_to_float64(int64_t a, float_status *status)
return packFloat64( 1, 0x43E, 0 );
}
zSign = ( a < 0 );
- return normalizeRoundAndPackFloat64( zSign, 0x43C, zSign ? - a : a STATUS_VAR );
-
+ return normalizeRoundAndPackFloat64(zSign, 0x43C, zSign ? -a : a, status);
}
/*----------------------------------------------------------------------------
@@ -1457,7 +1467,7 @@ float32 uint64_to_float32(uint64_t a, float_status *status)
a <<= shiftcount;
}
- return roundAndPackFloat32(0, 0x9c - shiftcount, a STATUS_VAR);
+ return roundAndPackFloat32(0, 0x9c - shiftcount, a, status);
}
/*----------------------------------------------------------------------------
@@ -1481,7 +1491,7 @@ float64 uint64_to_float64(uint64_t a, float_status *status)
} else {
a <<= shiftcount;
}
- return roundAndPackFloat64(0, exp - shiftcount, a STATUS_VAR);
+ return roundAndPackFloat64(0, exp - shiftcount, a, status);
}
/*----------------------------------------------------------------------------
@@ -1495,7 +1505,7 @@ float128 uint64_to_float128(uint64_t a, float_status *status)
if (a == 0) {
return float128_zero;
}
- return normalizeRoundAndPackFloat128(0, 0x406E, a, 0 STATUS_VAR);
+ return normalizeRoundAndPackFloat128(0, 0x406E, a, 0, status);
}
/*----------------------------------------------------------------------------
@@ -1515,7 +1525,7 @@ int32 float32_to_int32(float32 a, float_status *status)
uint32_t aSig;
uint64_t aSig64;
- a = float32_squash_input_denormal(a STATUS_VAR);
+ a = float32_squash_input_denormal(a, status);
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a );
@@ -1525,7 +1535,7 @@ int32 float32_to_int32(float32 a, float_status *status)
aSig64 = aSig;
aSig64 <<= 32;
if ( 0 < shiftCount ) shift64RightJamming( aSig64, shiftCount, &aSig64 );
- return roundAndPackInt32( aSign, aSig64 STATUS_VAR );
+ return roundAndPackInt32(aSign, aSig64, status);
}
@@ -1545,7 +1555,7 @@ int32 float32_to_int32_round_to_zero(float32 a, float_status *status)
int_fast16_t aExp, shiftCount;
uint32_t aSig;
int32_t z;
- a = float32_squash_input_denormal(a STATUS_VAR);
+ a = float32_squash_input_denormal(a, status);
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
@@ -1553,7 +1563,7 @@ int32 float32_to_int32_round_to_zero(float32 a, float_status *status)
shiftCount = aExp - 0x9E;
if ( 0 <= shiftCount ) {
if ( float32_val(a) != 0xCF000000 ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
}
return (int32_t) 0x80000000;
@@ -1595,7 +1605,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
shiftCount = aExp - 0x8E;
if ( 0 <= shiftCount ) {
if ( float32_val(a) != 0xC7000000 ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return 0x7FFF;
}
@@ -1637,14 +1647,14 @@ int64 float32_to_int64(float32 a, float_status *status)
int_fast16_t aExp, shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
- a = float32_squash_input_denormal(a STATUS_VAR);
+ a = float32_squash_input_denormal(a, status);
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a );
shiftCount = 0xBE - aExp;
if ( shiftCount < 0 ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@@ -1654,7 +1664,7 @@ int64 float32_to_int64(float32 a, float_status *status)
aSig64 = aSig;
aSig64 <<= 40;
shift64ExtraRightJamming( aSig64, 0, shiftCount, &aSig64, &aSigExtra );
- return roundAndPackInt64( aSign, aSig64, aSigExtra STATUS_VAR );
+ return roundAndPackInt64(aSign, aSig64, aSigExtra, status);
}
@@ -1676,13 +1686,13 @@ uint64 float32_to_uint64(float32 a, float_status *status)
int_fast16_t aExp, shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
- 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 ((aSign) && (aExp > 126)) {
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if (float32_is_any_nan(a)) {
return LIT64(0xFFFFFFFFFFFFFFFF);
} else {
@@ -1694,14 +1704,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);
}
/*----------------------------------------------------------------------------
@@ -1718,9 +1728,9 @@ uint64 float32_to_uint64(float32 a, float_status *status)
uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status)
{
signed char current_rounding_mode = STATUS(float_rounding_mode);
- set_float_rounding_mode(float_round_to_zero STATUS_VAR);
- int64_t 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);
+ int64_t v = float32_to_uint64(a, status);
+ set_float_rounding_mode(current_rounding_mode, status);
return v;
}
@@ -1741,7 +1751,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 );
@@ -1749,7 +1759,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 );
}
@@ -1783,13 +1793,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 ) {
@@ -1814,12 +1826,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 ) {
@@ -1844,12 +1858,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 ) {
@@ -1874,12 +1890,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;
}
@@ -1964,7 +1980,9 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
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 ) {
@@ -1978,7 +1996,9 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
}
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 ) {
@@ -1992,13 +2012,15 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
}
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);
}
@@ -2016,7 +2038,7 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
++zExp;
}
roundAndPack:
- return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR );
+ return roundAndPackFloat32(zSign, zExp, zSig, status);
}
@@ -2045,8 +2067,10 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
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 ) {
@@ -2058,7 +2082,9 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
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 ) {
@@ -2076,7 +2102,9 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
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 ) {
@@ -2092,7 +2120,7 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
zExp = aExp;
normalizeRoundAndPack:
--zExp;
- return normalizeRoundAndPackFloat32( zSign, zExp, zSig STATUS_VAR );
+ return normalizeRoundAndPackFloat32(zSign, zExp, zSig, status);
}
@@ -2105,16 +2133,16 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
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);
}
}
@@ -2128,16 +2156,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);
}
}
@@ -2156,8 +2184,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 );
@@ -2168,18 +2196,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 );
@@ -2201,7 +2231,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);
}
@@ -2216,8 +2246,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 );
@@ -2227,25 +2257,31 @@ 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 );
@@ -2265,7 +2301,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);
}
@@ -2284,8 +2320,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 );
@@ -2294,18 +2330,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 );
@@ -2366,8 +2404,7 @@ float32 float32_rem(float32 a, float32 b, float_status *status)
}
zSign = ( (int32_t) aSig < 0 );
if ( zSign ) aSig = - aSig;
- return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR );
-
+ return normalizeRoundAndPackFloat32(aSign ^ zSign, bExp, aSig, status);
}
/*----------------------------------------------------------------------------
@@ -2393,9 +2430,9 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
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);
@@ -2417,11 +2454,11 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
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;
}
@@ -2442,7 +2479,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
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 */
@@ -2468,7 +2505,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
}
/* 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);
}
}
@@ -2482,7 +2519,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
*/
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);
}
@@ -2524,7 +2561,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
pExp--;
}
return roundAndPackFloat32(zSign, pExp - 1,
- pSig STATUS_VAR);
+ pSig, status);
}
normalizeFloat32Subnormal(cSig, &cExp, &cSig);
}
@@ -2592,7 +2629,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
}
shift64RightJamming(zSig64, 32, &zSig64);
- return roundAndPackFloat32(zSign, zExp, zSig64 STATUS_VAR);
+ return roundAndPackFloat32(zSign, zExp, zSig64, status);
}
@@ -2608,20 +2645,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 ) {
@@ -2647,7 +2686,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);
}
@@ -2695,37 +2734,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);
@@ -2742,7 +2783,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 );
@@ -2752,11 +2793,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;
}
@@ -2776,7 +2819,7 @@ float32 float32_log2(float32 a, float_status *status)
if ( zSign )
zSig = -zSig;
- return normalizeRoundAndPackFloat32( zSign, 0x85, zSig STATUS_VAR );
+ return normalizeRoundAndPackFloat32(zSign, 0x85, zSig, status);
}
/*----------------------------------------------------------------------------
@@ -2789,13 +2832,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);
@@ -2814,13 +2857,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 );
@@ -2843,13 +2886,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 );
@@ -2870,13 +2913,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;
@@ -2891,14 +2934,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;
}
@@ -2917,14 +2960,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;
}
@@ -2948,14 +2991,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;
}
@@ -2977,14 +3020,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;
}
@@ -3006,7 +3049,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 );
@@ -3015,7 +3058,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);
}
@@ -3035,7 +3078,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 );
@@ -3056,7 +3099,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 ) != savedASig ) {
@@ -3108,7 +3151,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
}
if ( ( (int16_t)z < 0 ) ^ aSign ) {
invalid:
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
}
if ( ( aSig<<shiftCount ) != savedASig ) {
@@ -3132,7 +3175,7 @@ int64 float64_to_int64(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 );
@@ -3141,7 +3184,7 @@ int64 float64_to_int64(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);
if ( ! aSign
|| ( ( aExp == 0x7FF )
&& ( aSig != LIT64( 0x0010000000000000 ) ) )
@@ -3156,7 +3199,7 @@ int64 float64_to_int64(float64 a, float_status *status)
else {
shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
}
- return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
+ return roundAndPackInt64(aSign, aSig, aSigExtra, status);
}
@@ -3176,7 +3219,7 @@ int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
int_fast16_t aExp, shiftCount;
uint64_t aSig;
int64 z;
- a = float64_squash_input_denormal(a STATUS_VAR);
+ a = float64_squash_input_denormal(a, status);
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
@@ -3186,7 +3229,7 @@ int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
if ( 0 <= shiftCount ) {
if ( 0x43E <= aExp ) {
if ( float64_val(a) != LIT64( 0xC3E0000000000000 ) ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign
|| ( ( aExp == 0x7FF )
&& ( aSig != LIT64( 0x0010000000000000 ) ) )
@@ -3226,13 +3269,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 );
@@ -3241,7 +3286,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);
}
@@ -3339,10 +3384,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);
}
}
@@ -3355,9 +3400,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);
}
}
@@ -3400,7 +3445,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);
}
@@ -3421,7 +3466,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 );
@@ -3430,15 +3475,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);
@@ -3456,7 +3501,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)
@@ -3472,7 +3517,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);
}
@@ -3494,7 +3539,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);
@@ -3503,15 +3548,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);
@@ -3531,7 +3576,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);
}
/*----------------------------------------------------------------------------
@@ -3547,12 +3592,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 ) {
@@ -3578,12 +3625,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 ) {
@@ -3609,12 +3658,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;
}
@@ -3683,7 +3732,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;
}
@@ -3712,7 +3761,9 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
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 ) {
@@ -3726,7 +3777,9 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
}
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 ) {
@@ -3740,13 +3793,15 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
}
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);
}
@@ -3764,7 +3819,7 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
++zExp;
}
roundAndPack:
- return roundAndPackFloat64( zSign, zExp, zSig STATUS_VAR );
+ return roundAndPackFloat64(zSign, zExp, zSig, status);
}
@@ -3793,8 +3848,10 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
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 ) {
@@ -3806,7 +3863,9 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
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 ) {
@@ -3824,7 +3883,9 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
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 ) {
@@ -3840,7 +3901,7 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
zExp = aExp;
normalizeRoundAndPack:
--zExp;
- return normalizeRoundAndPackFloat64( zSign, zExp, zSig STATUS_VAR );
+ return normalizeRoundAndPackFloat64(zSign, zExp, zSig, status);
}
@@ -3853,16 +3914,16 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
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);
}
}
@@ -3876,16 +3937,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);
}
}
@@ -3902,8 +3963,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 );
@@ -3914,18 +3975,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 );
@@ -3947,7 +4010,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);
}
@@ -3964,8 +4027,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 );
@@ -3975,25 +4038,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 );
@@ -4019,7 +4088,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);
}
@@ -4037,8 +4106,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 );
@@ -4046,18 +4115,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 );
@@ -4105,7 +4176,7 @@ float64 float64_rem(float64 a, float64 b, float_status *status)
}
zSign = ( (int64_t) aSig < 0 );
if ( zSign ) aSig = - aSig;
- return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR );
+ return normalizeRoundAndPackFloat64(aSign ^ zSign, bExp, aSig, status);
}
@@ -4131,9 +4202,9 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
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);
@@ -4155,11 +4226,11 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
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;
}
@@ -4180,7 +4251,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
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 */
@@ -4206,7 +4277,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
}
/* 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);
}
}
@@ -4220,7 +4291,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
*/
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);
}
@@ -4261,7 +4332,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
pExp--;
}
return roundAndPackFloat64(zSign, pExp - 1,
- pSig1 STATUS_VAR);
+ pSig1, status);
}
normalizeFloat64Subnormal(cSig, &cExp, &cSig);
}
@@ -4299,7 +4370,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
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) {
@@ -4352,7 +4423,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
if (flags & float_muladd_halve_result) {
zExp--;
}
- return roundAndPackFloat64(zSign, zExp, zSig0 STATUS_VAR);
+ return roundAndPackFloat64(zSign, zExp, zSig0, status);
}
}
@@ -4368,20 +4439,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 ) {
@@ -4404,7 +4477,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);
}
@@ -4418,7 +4491,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 );
@@ -4429,11 +4502,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;
}
@@ -4452,7 +4527,7 @@ float64 float64_log2(float64 a, float_status *status)
if ( zSign )
zSig = -zSig;
- return normalizeRoundAndPackFloat64( zSign, 0x408, zSig STATUS_VAR );
+ return normalizeRoundAndPackFloat64(zSign, 0x408, zSig, status);
}
/*----------------------------------------------------------------------------
@@ -4465,13 +4540,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);
@@ -4491,13 +4566,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 );
@@ -4521,12 +4596,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 );
@@ -4547,13 +4622,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;
@@ -4569,14 +4644,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;
}
@@ -4597,14 +4672,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;
}
@@ -4628,14 +4703,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;
}
@@ -4657,14 +4732,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;
}
@@ -4694,7 +4769,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);
}
@@ -4733,7 +4808,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 ) != savedASig ) {
@@ -4765,7 +4840,7 @@ int64 floatx80_to_int64(floatx80 a, float_status *status)
shiftCount = 0x403E - aExp;
if ( shiftCount <= 0 ) {
if ( shiftCount ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign
|| ( ( aExp == 0x7FFF )
&& ( aSig != LIT64( 0x8000000000000000 ) ) )
@@ -4779,7 +4854,7 @@ int64 floatx80_to_int64(floatx80 a, float_status *status)
else {
shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
}
- return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
+ return roundAndPackInt64(aSign, aSig, aSigExtra, status);
}
@@ -4807,7 +4882,7 @@ int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
if ( 0 <= shiftCount ) {
aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
if ( ( a.high != 0xC03E ) || aSig ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@@ -4845,13 +4920,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, aSig STATUS_VAR );
+ return roundAndPackFloat32(aSign, aExp, aSig, status);
}
@@ -4873,13 +4948,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);
}
@@ -4900,7 +4975,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *status)
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 );
@@ -4924,7 +4999,7 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
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;
}
@@ -5021,7 +5096,9 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
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;
@@ -5030,7 +5107,9 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
}
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;
@@ -5040,7 +5119,7 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
else {
if ( aExp == 0x7FFF ) {
if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
- return propagateFloatx80NaN( a, b STATUS_VAR );
+ return propagateFloatx80NaN(a, b, status);
}
return a;
}
@@ -5060,10 +5139,8 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
zSig0 |= LIT64( 0x8000000000000000 );
++zExp;
roundAndPack:
- return
- roundAndPackFloatx80(
- STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR );
-
+ return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ zSign, zExp, zSig0, zSig1, status);
}
/*----------------------------------------------------------------------------
@@ -5091,9 +5168,9 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
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;
@@ -5108,7 +5185,9 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
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;
@@ -5120,7 +5199,9 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
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;
@@ -5129,10 +5210,8 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
zExp = aExp;
normalizeRoundAndPack:
- return
- normalizeRoundAndPackFloatx80(
- STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR );
-
+ return normalizeRoundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ zSign, zExp, zSig0, zSig1, status);
}
/*----------------------------------------------------------------------------
@@ -5148,10 +5227,10 @@ floatx80 floatx80_add(floatx80 a, floatx80 b, float_status *status)
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);
}
}
@@ -5169,10 +5248,10 @@ floatx80 floatx80_sub(floatx80 a, floatx80 b, float_status *status)
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);
}
}
@@ -5200,16 +5279,18 @@ 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;
@@ -5230,10 +5311,8 @@ floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
--zExp;
}
- return
- roundAndPackFloatx80(
- STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR );
-
+ return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ zSign, zExp, zSig0, zSig1, status);
}
/*----------------------------------------------------------------------------
@@ -5258,27 +5337,33 @@ 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 );
@@ -5310,10 +5395,8 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
}
zSig1 |= ( ( rem1 | rem2 ) != 0 );
}
- return
- roundAndPackFloatx80(
- STATUS(floatx80_rounding_precision), zSign, zExp, zSig0, zSig1 STATUS_VAR );
-
+ return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ zSign, zExp, zSig0, zSig1, status);
}
/*----------------------------------------------------------------------------
@@ -5338,18 +5421,20 @@ 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;
@@ -5408,7 +5493,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);
}
@@ -5430,14 +5515,16 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *status)
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;
@@ -5478,7 +5565,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);
}
@@ -5497,7 +5584,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
@@ -5526,7 +5613,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 );
@@ -5559,7 +5646,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 );
@@ -5589,7 +5676,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;
@@ -5612,7 +5699,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;
}
@@ -5643,7 +5730,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;
}
@@ -5679,7 +5766,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;
}
@@ -5712,7 +5799,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;
}
@@ -5744,7 +5831,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);
}
@@ -5786,7 +5873,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<<shiftCount ) != savedASig ) {
@@ -5820,7 +5907,7 @@ int64 float128_to_int64(float128 a, float_status *status)
shiftCount = 0x402F - aExp;
if ( shiftCount <= 0 ) {
if ( 0x403E < aExp ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign
|| ( ( aExp == 0x7FFF )
&& ( aSig1 || ( aSig0 != LIT64( 0x0001000000000000 ) ) )
@@ -5835,7 +5922,7 @@ int64 float128_to_int64(float128 a, float_status *status)
else {
shift64ExtraRightJamming( aSig0, aSig1, shiftCount, &aSig0, &aSig1 );
}
- return roundAndPackInt64( aSign, aSig0, aSig1 STATUS_VAR );
+ return roundAndPackInt64(aSign, aSig0, aSig1, status);
}
@@ -5870,7 +5957,7 @@ int64 float128_to_int64_round_to_zero(float128 a, float_status *status)
if ( aSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
}
else {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@@ -5920,7 +6007,7 @@ float32 float128_to_float32(float128 a, float_status *status)
aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) {
- return commonNaNToFloat32( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
+ return commonNaNToFloat32(float128ToCommonNaN(a, status), status);
}
return packFloat32( aSign, 0xFF, 0 );
}
@@ -5931,7 +6018,7 @@ float32 float128_to_float32(float128 a, float_status *status)
zSig |= 0x40000000;
aExp -= 0x3F81;
}
- return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
+ return roundAndPackFloat32(aSign, aExp, zSig, status);
}
@@ -5954,7 +6041,7 @@ float64 float128_to_float64(float128 a, float_status *status)
aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) {
- return commonNaNToFloat64( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
+ return commonNaNToFloat64(float128ToCommonNaN(a, status), status);
}
return packFloat64( aSign, 0x7FF, 0 );
}
@@ -5964,7 +6051,7 @@ float64 float128_to_float64(float128 a, float_status *status)
aSig0 |= LIT64( 0x4000000000000000 );
aExp -= 0x3C01;
}
- return roundAndPackFloat64( aSign, aExp, aSig0 STATUS_VAR );
+ return roundAndPackFloat64(aSign, aExp, aSig0, status);
}
@@ -5987,7 +6074,7 @@ floatx80 float128_to_floatx80(float128 a, float_status *status)
aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) {
- return commonNaNToFloatx80( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
+ return commonNaNToFloatx80(float128ToCommonNaN(a, status), status);
}
return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
}
@@ -5999,7 +6086,7 @@ floatx80 float128_to_floatx80(float128 a, float_status *status)
aSig0 |= LIT64( 0x0001000000000000 );
}
shortShift128Left( aSig0, aSig1, 15, &aSig0, &aSig1 );
- return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 STATUS_VAR );
+ return roundAndPackFloatx80(80, aSign, aExp, aSig0, aSig1, status);
}
@@ -6023,7 +6110,7 @@ float128 float128_round_to_int(float128 a, float_status *status)
if ( ( aExp == 0x7FFF )
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) )
) {
- return propagateFloat128NaN( a, a STATUS_VAR );
+ return propagateFloat128NaN(a, a, status);
}
return a;
}
@@ -6165,7 +6252,9 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
expDiff = aExp - bExp;
if ( 0 < expDiff ) {
if ( aExp == 0x7FFF ) {
- if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (aSig0 | aSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return a;
}
if ( bExp == 0 ) {
@@ -6180,7 +6269,9 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
}
else if ( expDiff < 0 ) {
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
if ( aExp == 0 ) {
@@ -6196,7 +6287,7 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
else {
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 | bSig0 | bSig1 ) {
- return propagateFloat128NaN( a, b STATUS_VAR );
+ return propagateFloat128NaN(a, b, status);
}
return a;
}
@@ -6204,7 +6295,7 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
if ( aExp == 0 ) {
if (STATUS(flush_to_zero)) {
if (zSig0 | zSig1) {
- float_raise(float_flag_output_denormal STATUS_VAR);
+ float_raise(float_flag_output_denormal, status);
}
return packFloat128(zSign, 0, 0, 0);
}
@@ -6224,7 +6315,7 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
shift128ExtraRightJamming(
zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );
roundAndPack:
- return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 STATUS_VAR );
+ return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);
}
@@ -6257,9 +6348,9 @@ static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
if ( expDiff < 0 ) goto bExpBigger;
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 | bSig0 | bSig1 ) {
- return propagateFloat128NaN( a, b STATUS_VAR );
+ return propagateFloat128NaN(a, b, status);
}
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
@@ -6275,7 +6366,9 @@ static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
return packFloat128( STATUS(float_rounding_mode) == float_round_down, 0, 0, 0 );
bExpBigger:
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 );
}
if ( aExp == 0 ) {
@@ -6293,7 +6386,9 @@ static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
goto normalizeRoundAndPack;
aExpBigger:
if ( aExp == 0x7FFF ) {
- if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (aSig0 | aSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return a;
}
if ( bExp == 0 ) {
@@ -6309,7 +6404,8 @@ static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
zExp = aExp;
normalizeRoundAndPack:
--zExp;
- return normalizeRoundAndPackFloat128( zSign, zExp - 14, zSig0, zSig1 STATUS_VAR );
+ return normalizeRoundAndPackFloat128(zSign, zExp - 14, zSig0, zSig1,
+ status);
}
@@ -6326,10 +6422,10 @@ float128 float128_add(float128 a, float128 b, float_status *status)
aSign = extractFloat128Sign( a );
bSign = extractFloat128Sign( b );
if ( aSign == bSign ) {
- return addFloat128Sigs( a, b, aSign STATUS_VAR );
+ return addFloat128Sigs(a, b, aSign, status);
}
else {
- return subFloat128Sigs( a, b, aSign STATUS_VAR );
+ return subFloat128Sigs(a, b, aSign, status);
}
}
@@ -6347,10 +6443,10 @@ float128 float128_sub(float128 a, float128 b, float_status *status)
aSign = extractFloat128Sign( a );
bSign = extractFloat128Sign( b );
if ( aSign == bSign ) {
- return subFloat128Sigs( a, b, aSign STATUS_VAR );
+ return subFloat128Sigs(a, b, aSign, status);
}
else {
- return addFloat128Sigs( a, b, aSign STATUS_VAR );
+ return addFloat128Sigs(a, b, aSign, status);
}
}
@@ -6380,16 +6476,18 @@ float128 float128_mul(float128 a, float128 b, float_status *status)
if ( aExp == 0x7FFF ) {
if ( ( aSig0 | aSig1 )
|| ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {
- return propagateFloat128NaN( a, b STATUS_VAR );
+ return propagateFloat128NaN(a, b, status);
}
if ( ( bExp | bSig0 | bSig1 ) == 0 ) goto invalid;
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
if ( ( aExp | aSig0 | aSig1 ) == 0 ) {
invalid:
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
@@ -6415,7 +6513,7 @@ float128 float128_mul(float128 a, float128 b, float_status *status)
zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );
++zExp;
}
- return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 STATUS_VAR );
+ return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);
}
@@ -6443,27 +6541,33 @@ float128 float128_div(float128 a, float128 b, float_status *status)
bSign = extractFloat128Sign( b );
zSign = aSign ^ bSign;
if ( aExp == 0x7FFF ) {
- if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (aSig0 | aSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
goto invalid;
}
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return packFloat128( zSign, 0, 0, 0 );
}
if ( bExp == 0 ) {
if ( ( bSig0 | bSig1 ) == 0 ) {
if ( ( aExp | aSig0 | aSig1 ) == 0 ) {
invalid:
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
}
- float_raise( float_flag_divbyzero STATUS_VAR);
+ float_raise(float_flag_divbyzero, status);
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );
@@ -6499,7 +6603,7 @@ float128 float128_div(float128 a, float128 b, float_status *status)
zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
}
shift128ExtraRightJamming( zSig0, zSig1, 0, 15, &zSig0, &zSig1, &zSig2 );
- return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 STATUS_VAR );
+ return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);
}
@@ -6528,18 +6632,20 @@ float128 float128_rem(float128 a, float128 b, float_status *status)
if ( aExp == 0x7FFF ) {
if ( ( aSig0 | aSig1 )
|| ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {
- return propagateFloat128NaN( a, b STATUS_VAR );
+ return propagateFloat128NaN(a, b, status);
}
goto invalid;
}
if ( bExp == 0x7FFF ) {
- if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b STATUS_VAR );
+ if (bSig0 | bSig1) {
+ return propagateFloat128NaN(a, b, status);
+ }
return a;
}
if ( bExp == 0 ) {
if ( ( bSig0 | bSig1 ) == 0 ) {
invalid:
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
@@ -6607,9 +6713,8 @@ float128 float128_rem(float128 a, float128 b, float_status *status)
}
zSign = ( (int64_t) aSig0 < 0 );
if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );
- return
- normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 STATUS_VAR );
-
+ return normalizeRoundAndPackFloat128(aSign ^ zSign, bExp - 4, aSig0, aSig1,
+ status);
}
/*----------------------------------------------------------------------------
@@ -6631,14 +6736,16 @@ float128 float128_sqrt(float128 a, float_status *status)
aExp = extractFloat128Exp( a );
aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) {
- if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, a STATUS_VAR );
+ if (aSig0 | aSig1) {
+ return propagateFloat128NaN(a, a, status);
+ }
if ( ! aSign ) return a;
goto invalid;
}
if ( aSign ) {
if ( ( aExp | aSig0 | aSig1 ) == 0 ) return a;
invalid:
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
@@ -6677,7 +6784,7 @@ float128 float128_sqrt(float128 a, float_status *status)
zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
}
shift128ExtraRightJamming( zSig0, zSig1, 0, 14, &zSig0, &zSig1, &zSig2 );
- return roundAndPackFloat128( 0, zExp, zSig0, zSig1, zSig2 STATUS_VAR );
+ return roundAndPackFloat128(0, zExp, zSig0, zSig1, zSig2, status);
}
@@ -6696,7 +6803,7 @@ int float128_eq(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return 0;
}
return
@@ -6724,7 +6831,7 @@ int float128_le(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat128Sign( a );
@@ -6757,7 +6864,7 @@ int float128_lt(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat128Sign( a );
@@ -6788,7 +6895,7 @@ int float128_unordered(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return 1;
}
return 0;
@@ -6811,7 +6918,7 @@ int float128_eq_quiet(float128 a, float128 b, float_status *status)
) {
if ( float128_is_signaling_nan( a )
|| float128_is_signaling_nan( b ) ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
}
return 0;
}
@@ -6842,7 +6949,7 @@ int float128_le_quiet(float128 a, float128 b, float_status *status)
) {
if ( float128_is_signaling_nan( a )
|| float128_is_signaling_nan( b ) ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
}
return 0;
}
@@ -6878,7 +6985,7 @@ int float128_lt_quiet(float128 a, float128 b, float_status *status)
) {
if ( float128_is_signaling_nan( a )
|| float128_is_signaling_nan( b ) ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
}
return 0;
}
@@ -6912,7 +7019,7 @@ int float128_unordered_quiet(float128 a, float128 b, float_status *status)
) {
if ( float128_is_signaling_nan( a )
|| float128_is_signaling_nan( b ) ) {
- float_raise( float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
}
return 1;
}
@@ -6922,12 +7029,12 @@ int float128_unordered_quiet(float128 a, float128 b, float_status *status)
/* misc functions */
float32 uint32_to_float32(uint32_t a, float_status *status)
{
- return int64_to_float32(a STATUS_VAR);
+ return int64_to_float32(a, status);
}
float64 uint32_to_float64(uint32_t a, float_status *status)
{
- return int64_to_float64(a STATUS_VAR);
+ return int64_to_float64(a, status);
}
uint32 float32_to_uint32(float32 a, float_status *status)
@@ -6936,7 +7043,7 @@ uint32 float32_to_uint32(float32 a, float_status *status)
uint32 res;
int old_exc_flags = get_float_exception_flags(status);
- v = float32_to_int64(a STATUS_VAR);
+ v = float32_to_int64(a, status);
if (v < 0) {
res = 0;
} else if (v > 0xffffffff) {
@@ -6945,7 +7052,7 @@ uint32 float32_to_uint32(float32 a, float_status *status)
return v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -6955,7 +7062,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) {
@@ -6964,7 +7071,7 @@ uint32 float32_to_uint32_round_to_zero(float32 a, float_status *status)
return v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -6974,7 +7081,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) {
@@ -6984,7 +7091,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;
}
@@ -6994,7 +7101,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) {
@@ -7004,7 +7111,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;
}
@@ -7014,7 +7121,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) {
@@ -7023,7 +7130,7 @@ uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status)
return v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -7033,14 +7140,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 v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -7050,14 +7157,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 v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -7067,7 +7174,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) {
@@ -7077,7 +7184,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;
}
@@ -7087,7 +7194,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) {
@@ -7097,7 +7204,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;
}
@@ -7107,7 +7214,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) {
@@ -7116,7 +7223,7 @@ uint_fast16_t float64_to_uint16_round_to_zero(float64 a, float_status *status)
return v;
}
set_float_exception_flags(old_exc_flags, status);
- float_raise(float_flag_invalid STATUS_VAR);
+ float_raise(float_flag_invalid, status);
return res;
}
@@ -7137,13 +7244,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 {
@@ -7156,7 +7263,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;
@@ -7164,15 +7271,15 @@ 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)
{
signed char current_rounding_mode = STATUS(float_rounding_mode);
- set_float_rounding_mode(float_round_to_zero STATUS_VAR);
- int64_t 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);
+ int64_t v = float64_to_uint64(a, status);
+ set_float_rounding_mode(current_rounding_mode, status);
return v;
}
@@ -7182,8 +7289,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 ) ) || \
@@ -7192,7 +7299,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; \
} \
@@ -7218,13 +7325,13 @@ 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)
@@ -7242,7 +7349,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;
}
@@ -7268,12 +7375,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,
@@ -7288,7 +7395,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;
}
@@ -7312,12 +7419,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
@@ -7342,8 +7449,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) { \
@@ -7355,7 +7462,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); \
@@ -7390,37 +7497,37 @@ 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)
@@ -7434,14 +7541,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;
}
@@ -7461,7 +7568,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)
@@ -7470,14 +7577,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;
}
@@ -7497,7 +7604,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)
@@ -7512,7 +7619,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;
}
@@ -7532,7 +7639,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)
@@ -7547,7 +7654,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;
}
@@ -7567,6 +7674,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/include/fpu/softfloat.h b/include/fpu/softfloat.h
index fab2aee..d13fd0e 100644
--- a/include/fpu/softfloat.h
+++ b/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
@@ -329,22 +328,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/target-mips/msa_helper.c b/target-mips/msa_helper.c
index c9fc9f9..c2160a6 100644
--- a/target-mips/msa_helper.c
+++ b/target-mips/msa_helper.c
@@ -1619,7 +1619,7 @@ static inline float16 float16_from_float32(int32 a, flag ieee,
{
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;
@@ -1629,7 +1629,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;
@@ -1640,7 +1640,7 @@ static inline float32 float32_from_float16(int16_t a, flag ieee,
{
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;
@@ -1650,7 +1650,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;
@@ -1661,8 +1661,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;
}
@@ -1672,8 +1672,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;
}
@@ -1687,43 +1687,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;
}
@@ -1739,43 +1739,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;
}
--
1.9.1
^ permalink raw reply related [flat|nested] 8+ messages in thread* [Qemu-devel] [PATCH 3/3] softfloat: expand out STATUS macro
2015-02-02 20:31 [Qemu-devel] [PATCH 0/3] softfloat: Remove STATUS macros Peter Maydell
2015-02-02 20:31 ` [Qemu-devel] [PATCH 1/3] softfloat: Expand out the STATUS_PARAM macro Peter Maydell
2015-02-02 20:31 ` [Qemu-devel] [PATCH 2/3] softfloat: expand out STATUS_VAR Peter Maydell
@ 2015-02-02 20:31 ` Peter Maydell
2015-02-02 21:37 ` [Qemu-devel] [PATCH 0/3] softfloat: Remove STATUS macros Richard Henderson
3 siblings, 0 replies; 8+ messages in thread
From: Peter Maydell @ 2015-02-02 20:31 UTC (permalink / raw)
To: qemu-devel; +Cc: Richard Henderson, Maciej W. Rozycki, patches
Expand out and remove the STATUS macro.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
fpu/softfloat-specialize.h | 24 ++---
fpu/softfloat.c | 239 ++++++++++++++++++++++++++-------------------
include/fpu/softfloat.h | 30 +++---
3 files changed, 167 insertions(+), 126 deletions(-)
diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
index 21d3ec2..b5b4c67 100644
--- a/fpu/softfloat-specialize.h
+++ b/fpu/softfloat-specialize.h
@@ -172,7 +172,7 @@ const float128 float128_default_nan
void float_raise(int8 flags , float_status *status)
{
- STATUS(float_exception_flags) |= flags;
+ status->float_exception_flags |= flags;
}
/*----------------------------------------------------------------------------
@@ -275,7 +275,7 @@ static float16 commonNaNToFloat16(commonNaNT a, float_status *status)
{
uint16_t mantissa = a.high>>54;
- if (STATUS(default_nan_mode)) {
+ if (status->default_nan_mode) {
return float16_default_nan;
}
@@ -380,7 +380,7 @@ static float32 commonNaNToFloat32(commonNaNT a, float_status *status)
{
uint32_t mantissa = a.high>>41;
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
return float32_default_nan;
}
@@ -633,7 +633,7 @@ static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
float_raise(float_flag_invalid, status);
}
- if ( STATUS(default_nan_mode) )
+ if (status->default_nan_mode)
return float32_default_nan;
if ((uint32_t)(av<<1) < (uint32_t)(bv<<1)) {
@@ -684,7 +684,7 @@ static float32 propagateFloat32MulAddNaN(float32 a, float32 b,
bIsQuietNaN, bIsSignalingNaN,
cIsQuietNaN, cIsSignalingNaN, infzero, status);
- if (STATUS(default_nan_mode)) {
+ if (status->default_nan_mode) {
/* Note that this check is after pickNaNMulAdd so that function
* has an opportunity to set the Invalid flag.
*/
@@ -800,7 +800,7 @@ static float64 commonNaNToFloat64(commonNaNT a, float_status *status)
{
uint64_t mantissa = a.high>>12;
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
return float64_default_nan;
}
@@ -836,7 +836,7 @@ static float64 propagateFloat64NaN(float64 a, float64 b, float_status *status)
float_raise(float_flag_invalid, status);
}
- if ( STATUS(default_nan_mode) )
+ if (status->default_nan_mode)
return float64_default_nan;
if ((uint64_t)(av<<1) < (uint64_t)(bv<<1)) {
@@ -887,7 +887,7 @@ static float64 propagateFloat64MulAddNaN(float64 a, float64 b,
bIsQuietNaN, bIsSignalingNaN,
cIsQuietNaN, cIsSignalingNaN, infzero, status);
- if (STATUS(default_nan_mode)) {
+ if (status->default_nan_mode) {
/* Note that this check is after pickNaNMulAdd so that function
* has an opportunity to set the Invalid flag.
*/
@@ -1019,7 +1019,7 @@ static floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
{
floatx80 z;
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
z.low = floatx80_default_nan_low;
z.high = floatx80_default_nan_high;
return z;
@@ -1057,7 +1057,7 @@ static floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b,
float_raise(float_flag_invalid, status);
}
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
a.low = floatx80_default_nan_low;
a.high = floatx80_default_nan_high;
return a;
@@ -1176,7 +1176,7 @@ static float128 commonNaNToFloat128(commonNaNT a, float_status *status)
{
float128 z;
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
@@ -1208,7 +1208,7 @@ static float128 propagateFloat128NaN(float128 a, float128 b,
float_raise(float_flag_invalid, status);
}
- if ( STATUS(default_nan_mode) ) {
+ if (status->default_nan_mode) {
a.low = float128_default_nan_low;
a.high = float128_default_nan_high;
return a;
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index f56c618..f1170fe 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -151,7 +151,7 @@ static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
int8 roundIncrement, roundBits;
int32_t z;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
switch (roundingMode) {
case float_round_nearest_even:
@@ -179,7 +179,9 @@ static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
float_raise(float_flag_invalid, status);
return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
- if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (roundBits) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return z;
}
@@ -203,7 +205,7 @@ static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
flag roundNearestEven, increment;
int64_t z;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
switch (roundingMode) {
case float_round_nearest_even:
@@ -236,7 +238,9 @@ static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
zSign ? (int64_t) LIT64( 0x8000000000000000 )
: LIT64( 0x7FFFFFFFFFFFFFFF );
}
- if ( absZ1 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (absZ1) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return z;
}
@@ -257,7 +261,7 @@ static int64 roundAndPackUint64(flag zSign, uint64_t absZ0,
int8 roundingMode;
flag roundNearestEven, increment;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = (roundingMode == float_round_nearest_even);
switch (roundingMode) {
case float_round_nearest_even:
@@ -291,7 +295,7 @@ static int64 roundAndPackUint64(flag zSign, uint64_t absZ0,
}
if (absZ1) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return absZ0;
}
@@ -335,7 +339,7 @@ static inline flag extractFloat32Sign( float32 a )
*----------------------------------------------------------------------------*/
float32 float32_squash_input_denormal(float32 a, float_status *status)
{
- if (STATUS(flush_inputs_to_zero)) {
+ if (status->flush_inputs_to_zero) {
if (extractFloat32Exp(a) == 0 && extractFloat32Frac(a) != 0) {
float_raise(float_flag_input_denormal, status);
return make_float32(float32_val(a) & 0x80000000);
@@ -411,7 +415,7 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
int8 roundIncrement, roundBits;
flag isTiny;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
switch (roundingMode) {
case float_round_nearest_even:
@@ -441,12 +445,13 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 ));
}
if ( zExp < 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloat32(zSign, 0, 0);
}
isTiny =
- ( STATUS(float_detect_tininess) == float_tininess_before_rounding )
+ (status->float_detect_tininess
+ == float_tininess_before_rounding)
|| ( zExp < -1 )
|| ( zSig + roundIncrement < 0x80000000 );
shift32RightJamming( zSig, - zExp, &zSig );
@@ -457,7 +462,9 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
}
}
}
- if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (roundBits) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
zSig = ( zSig + roundIncrement )>>7;
zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
if ( zSig == 0 ) zExp = 0;
@@ -525,7 +532,7 @@ static inline flag extractFloat64Sign( float64 a )
*----------------------------------------------------------------------------*/
float64 float64_squash_input_denormal(float64 a, float_status *status)
{
- if (STATUS(flush_inputs_to_zero)) {
+ if (status->flush_inputs_to_zero) {
if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
float_raise(float_flag_input_denormal, status);
return make_float64(float64_val(a) & (1ULL << 63));
@@ -601,7 +608,7 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
int_fast16_t roundIncrement, roundBits;
flag isTiny;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
switch (roundingMode) {
case float_round_nearest_even:
@@ -630,12 +637,13 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 ));
}
if ( zExp < 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloat64(zSign, 0, 0);
}
isTiny =
- ( STATUS(float_detect_tininess) == float_tininess_before_rounding )
+ (status->float_detect_tininess
+ == float_tininess_before_rounding)
|| ( zExp < -1 )
|| ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
shift64RightJamming( zSig, - zExp, &zSig );
@@ -646,7 +654,9 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
}
}
}
- if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (roundBits) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
zSig = ( zSig + roundIncrement )>>10;
zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
if ( zSig == 0 ) zExp = 0;
@@ -776,7 +786,7 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
flag roundNearestEven, increment, isTiny;
int64 roundIncrement, roundMask, roundBits;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
if ( roundingPrecision == 80 ) goto precision80;
if ( roundingPrecision == 64 ) {
@@ -815,12 +825,13 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
goto overflow;
}
if ( zExp <= 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloatx80(zSign, 0, 0);
}
isTiny =
- ( STATUS(float_detect_tininess) == float_tininess_before_rounding )
+ (status->float_detect_tininess
+ == float_tininess_before_rounding)
|| ( zExp < 0 )
|| ( zSig0 <= zSig0 + roundIncrement );
shift64RightJamming( zSig0, 1 - zExp, &zSig0 );
@@ -829,7 +840,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
if (isTiny && roundBits) {
float_raise(float_flag_underflow, status);
}
- if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (roundBits) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
zSig0 += roundIncrement;
if ( (int64_t) zSig0 < 0 ) zExp = 1;
roundIncrement = roundMask + 1;
@@ -840,7 +853,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
return packFloatx80( zSign, zExp, zSig0 );
}
}
- if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (roundBits) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
zSig0 += roundIncrement;
if ( zSig0 < roundIncrement ) {
++zExp;
@@ -891,7 +906,8 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
}
if ( zExp <= 0 ) {
isTiny =
- ( STATUS(float_detect_tininess) == float_tininess_before_rounding )
+ (status->float_detect_tininess
+ == float_tininess_before_rounding)
|| ( zExp < 0 )
|| ! increment
|| ( zSig0 < LIT64( 0xFFFFFFFFFFFFFFFF ) );
@@ -900,7 +916,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
if (isTiny && zSig1) {
float_raise(float_flag_underflow, status);
}
- if ( zSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (zSig1) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
switch (roundingMode) {
case float_round_nearest_even:
case float_round_ties_away:
@@ -927,7 +945,9 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
return packFloatx80( zSign, zExp, zSig0 );
}
}
- if ( zSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (zSig1) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
if ( increment ) {
++zSig0;
if ( zSig0 == 0 ) {
@@ -1114,7 +1134,7 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
int8 roundingMode;
flag roundNearestEven, increment, isTiny;
- roundingMode = STATUS(float_rounding_mode);
+ roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even );
switch (roundingMode) {
case float_round_nearest_even:
@@ -1161,12 +1181,13 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
if ( zExp < 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloat128(zSign, 0, 0, 0);
}
isTiny =
- ( STATUS(float_detect_tininess) == float_tininess_before_rounding )
+ (status->float_detect_tininess
+ == float_tininess_before_rounding)
|| ( zExp < -1 )
|| ! increment
|| lt128(
@@ -1200,7 +1221,9 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
}
}
}
- if ( zSig2 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (zSig2) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
if ( increment ) {
add128( zSig0, zSig1, 0, 1, &zSig0, &zSig1 );
zSig1 &= ~ ( ( zSig2 + zSig2 == 0 ) & roundNearestEven );
@@ -1569,13 +1592,15 @@ int32 float32_to_int32_round_to_zero(float32 a, float_status *status)
return (int32_t) 0x80000000;
}
else if ( aExp <= 0x7E ) {
- if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (aExp | aSig) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return 0;
}
aSig = ( aSig | 0x00800000 )<<8;
z = aSig>>( - shiftCount );
if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
if ( aSign ) z = - z;
return z;
@@ -1614,7 +1639,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
}
else if ( aExp <= 0x7E ) {
if ( aExp | aSig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return 0;
}
@@ -1622,7 +1647,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
aSig = ( aSig | 0x00800000 )<<8;
z = aSig>>( - shiftCount );
if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
if ( aSign ) {
z = - z;
@@ -1727,7 +1752,7 @@ uint64 float32_to_uint64(float32 a, float_status *status)
uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status)
{
- signed char current_rounding_mode = STATUS(float_rounding_mode);
+ signed char current_rounding_mode = status->float_rounding_mode;
set_float_rounding_mode(float_round_to_zero, status);
int64_t v = float32_to_uint64(a, status);
set_float_rounding_mode(current_rounding_mode, status);
@@ -1767,14 +1792,16 @@ int64 float32_to_int64_round_to_zero(float32 a, float_status *status)
return (int64_t) LIT64( 0x8000000000000000 );
}
else if ( aExp <= 0x7E ) {
- if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (aExp | aSig) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return 0;
}
aSig64 = aSig | 0x00800000;
aSig64 <<= 40;
z = aSig64>>( - shiftCount );
if ( (uint64_t) ( aSig64<<( shiftCount & 63 ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
if ( aSign ) z = - z;
return z;
@@ -1901,9 +1928,9 @@ float32 float32_round_to_int(float32 a, float_status *status)
}
if ( aExp <= 0x7E ) {
if ( (uint32_t) ( float32_val(a)<<1 ) == 0 ) return a;
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
aSign = extractFloat32Sign( a );
- switch ( STATUS(float_rounding_mode) ) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
if ( ( aExp == 0x7E ) && extractFloat32Frac( a ) ) {
return packFloat32( aSign, 0x7F, 0 );
@@ -1925,7 +1952,7 @@ float32 float32_round_to_int(float32 a, float_status *status)
lastBitMask <<= 0x96 - aExp;
roundBitsMask = lastBitMask - 1;
z = float32_val(a);
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
z += lastBitMask>>1;
if ((z & roundBitsMask) == 0) {
@@ -1951,7 +1978,9 @@ float32 float32_round_to_int(float32 a, float_status *status)
abort();
}
z &= ~ roundBitsMask;
- if ( z != float32_val(a) ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (z != float32_val(a)) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return make_float32(z);
}
@@ -2018,7 +2047,7 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
return a;
}
if ( aExp == 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
if (aSig | bSig) {
float_raise(float_flag_output_denormal, status);
}
@@ -2079,7 +2108,7 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
}
if ( bSig < aSig ) goto aBigger;
if ( aSig < bSig ) goto bBigger;
- return packFloat32( STATUS(float_rounding_mode) == float_round_down, 0, 0 );
+ return packFloat32(status->float_rounding_mode == float_round_down, 0, 0);
bExpBigger:
if ( bExp == 0xFF ) {
if (bSig) {
@@ -2496,7 +2525,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
/* Adding two exact zeroes */
if (pSign == cSign) {
zSign = pSign;
- } else if (STATUS(float_rounding_mode) == float_round_down) {
+ } else if (status->float_rounding_mode == float_round_down) {
zSign = 1;
} else {
zSign = 0;
@@ -2504,7 +2533,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
return packFloat32(zSign ^ signflip, 0, 0);
}
/* Exact zero plus a denorm */
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloat32(cSign ^ signflip, 0, 0);
}
@@ -2612,7 +2641,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
} else {
/* Exact zero */
zSign = signflip;
- if (STATUS(float_rounding_mode) == float_round_down) {
+ if (status->float_rounding_mode == float_round_down) {
zSign ^= 1;
}
return packFloat32(zSign, 0, 0);
@@ -3088,7 +3117,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 );
@@ -3103,7 +3134,7 @@ int32 float64_to_int32_round_to_zero(float64 a, float_status *status)
return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( ( aSig<<shiftCount ) != savedASig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return z;
@@ -3137,7 +3168,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
}
else if ( aExp < 0x3FF ) {
if ( aExp || aSig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return 0;
}
@@ -3155,7 +3186,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
}
if ( ( aSig<<shiftCount ) != savedASig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return z;
}
@@ -3243,12 +3274,14 @@ int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
}
else {
if ( aExp < 0x3FE ) {
- if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (aExp | aSig) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return 0;
}
z = aSig>>( - shiftCount );
if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
}
if ( aSign ) z = - z;
@@ -3359,7 +3392,7 @@ static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
mask = 0x00001fff;
}
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
increment = (mask + 1) >> 1;
if ((zSig & mask) == increment) {
@@ -3395,7 +3428,7 @@ static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
if (zExp < 0) {
/* Note that flush-to-zero does not affect half-precision results */
is_tiny =
- (STATUS(float_detect_tininess) == float_tininess_before_rounding)
+ (status->float_detect_tininess == float_tininess_before_rounding)
|| (zExp < -1)
|| (!rounding_bumps_exp);
}
@@ -3669,9 +3702,9 @@ float64 float64_round_to_int(float64 a, float_status *status)
}
if ( aExp < 0x3FF ) {
if ( (uint64_t) ( float64_val(a)<<1 ) == 0 ) return a;
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
aSign = extractFloat64Sign( a );
- switch ( STATUS(float_rounding_mode) ) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
if ( ( aExp == 0x3FE ) && extractFloat64Frac( a ) ) {
return packFloat64( aSign, 0x3FF, 0 );
@@ -3694,7 +3727,7 @@ float64 float64_round_to_int(float64 a, float_status *status)
lastBitMask <<= 0x433 - aExp;
roundBitsMask = lastBitMask - 1;
z = float64_val(a);
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
z += lastBitMask >> 1;
if ((z & roundBitsMask) == 0) {
@@ -3720,8 +3753,9 @@ float64 float64_round_to_int(float64 a, float_status *status)
abort();
}
z &= ~ roundBitsMask;
- if ( z != float64_val(a) )
- STATUS(float_exception_flags) |= float_flag_inexact;
+ if (z != float64_val(a)) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return make_float64(z);
}
@@ -3730,10 +3764,10 @@ float64 float64_trunc_to_int(float64 a, float_status *status)
{
int oldmode;
float64 res;
- oldmode = STATUS(float_rounding_mode);
- STATUS(float_rounding_mode) = float_round_to_zero;
+ oldmode = status->float_rounding_mode;
+ status->float_rounding_mode = float_round_to_zero;
res = float64_round_to_int(a, status);
- STATUS(float_rounding_mode) = oldmode;
+ status->float_rounding_mode = oldmode;
return res;
}
@@ -3799,7 +3833,7 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
return a;
}
if ( aExp == 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
if (aSig | bSig) {
float_raise(float_flag_output_denormal, status);
}
@@ -3860,7 +3894,7 @@ static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
}
if ( bSig < aSig ) goto aBigger;
if ( aSig < bSig ) goto bBigger;
- return packFloat64( STATUS(float_rounding_mode) == float_round_down, 0, 0 );
+ return packFloat64(status->float_rounding_mode == float_round_down, 0, 0);
bExpBigger:
if ( bExp == 0x7FF ) {
if (bSig) {
@@ -4268,7 +4302,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
/* Adding two exact zeroes */
if (pSign == cSign) {
zSign = pSign;
- } else if (STATUS(float_rounding_mode) == float_round_down) {
+ } else if (status->float_rounding_mode == float_round_down) {
zSign = 1;
} else {
zSign = 0;
@@ -4276,7 +4310,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
return packFloat64(zSign ^ signflip, 0, 0);
}
/* Exact zero plus a denorm */
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
float_raise(float_flag_output_denormal, status);
return packFloat64(cSign ^ signflip, 0, 0);
}
@@ -4392,7 +4426,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
} else {
/* Exact zero */
zSign = signflip;
- if (STATUS(float_rounding_mode) == float_round_down) {
+ if (status->float_rounding_mode == float_round_down) {
zSign ^= 1;
}
return packFloat64(zSign, 0, 0);
@@ -4798,7 +4832,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;
@@ -4812,7 +4848,7 @@ int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( ( aSig<<shiftCount ) != savedASig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return z;
@@ -4890,12 +4926,14 @@ int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
return (int64_t) LIT64( 0x8000000000000000 );
}
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;
}
z = aSig>>( - shiftCount );
if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
if ( aSign ) z = - z;
return z;
@@ -5008,9 +5046,9 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
&& ( (uint64_t) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {
return a;
}
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
aSign = extractFloatx80Sign( a );
- switch ( STATUS(float_rounding_mode) ) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
if ( ( aExp == 0x3FFE ) && (uint64_t) ( extractFloatx80Frac( a )<<1 )
) {
@@ -5039,7 +5077,7 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
lastBitMask <<= 0x403E - aExp;
roundBitsMask = lastBitMask - 1;
z = a;
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
z.low += lastBitMask>>1;
if ((z.low & roundBitsMask) == 0) {
@@ -5069,7 +5107,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;
}
@@ -5139,7 +5179,7 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
zSig0 |= LIT64( 0x8000000000000000 );
++zExp;
roundAndPack:
- return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ return roundAndPackFloatx80(status->floatx80_rounding_precision,
zSign, zExp, zSig0, zSig1, status);
}
@@ -5182,7 +5222,7 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
zSig1 = 0;
if ( bSig < aSig ) goto aBigger;
if ( aSig < bSig ) goto bBigger;
- return packFloatx80( STATUS(float_rounding_mode) == float_round_down, 0, 0 );
+ return packFloatx80(status->float_rounding_mode == float_round_down, 0, 0);
bExpBigger:
if ( bExp == 0x7FFF ) {
if ((uint64_t)(bSig << 1)) {
@@ -5210,7 +5250,7 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
zExp = aExp;
normalizeRoundAndPack:
- return normalizeRoundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ return normalizeRoundAndPackFloatx80(status->floatx80_rounding_precision,
zSign, zExp, zSig0, zSig1, status);
}
@@ -5311,7 +5351,7 @@ floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
--zExp;
}
- return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ return roundAndPackFloatx80(status->floatx80_rounding_precision,
zSign, zExp, zSig0, zSig1, status);
}
@@ -5395,7 +5435,7 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
}
zSig1 |= ( ( rem1 | rem2 ) != 0 );
}
- return roundAndPackFloatx80(STATUS(floatx80_rounding_precision),
+ return roundAndPackFloatx80(status->floatx80_rounding_precision,
zSign, zExp, zSig0, zSig1, status);
}
@@ -5563,10 +5603,8 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *status)
}
shortShift128Left( 0, zSig1, 1, &zSig0, &zSig1 );
zSig0 |= doubleZSig0;
- return
- roundAndPackFloatx80(
- STATUS(floatx80_rounding_precision), 0, zExp, zSig0, zSig1, status);
-
+ return roundAndPackFloatx80(status->floatx80_rounding_precision,
+ 0, zExp, zSig0, zSig1, status);
}
/*----------------------------------------------------------------------------
@@ -5862,7 +5900,9 @@ int32 float128_to_int32_round_to_zero(float128 a, float_status *status)
goto invalid;
}
else if ( aExp < 0x3FFF ) {
- if ( aExp || aSig0 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (aExp || aSig0) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
return 0;
}
aSig0 |= LIT64( 0x0001000000000000 );
@@ -5877,7 +5917,7 @@ int32 float128_to_int32_round_to_zero(float128 a, float_status *status)
return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( ( aSig0<<shiftCount ) != savedASig ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return z;
@@ -5954,7 +5994,9 @@ int64 float128_to_int64_round_to_zero(float128 a, float_status *status)
aSig0 &= LIT64( 0x0000FFFFFFFFFFFF );
if ( ( a.high == LIT64( 0xC03E000000000000 ) )
&& ( aSig1 < LIT64( 0x0002000000000000 ) ) ) {
- if ( aSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
+ if (aSig1) {
+ status->float_exception_flags |= float_flag_inexact;
+ }
}
else {
float_raise(float_flag_invalid, status);
@@ -5966,20 +6008,20 @@ int64 float128_to_int64_round_to_zero(float128 a, float_status *status)
}
z = ( aSig0<<shiftCount ) | ( aSig1>>( ( - shiftCount ) & 63 ) );
if ( (uint64_t) ( aSig1<<shiftCount ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
}
else {
if ( aExp < 0x3FFF ) {
if ( aExp | aSig0 | aSig1 ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return 0;
}
z = aSig0>>( - shiftCount );
if ( aSig1
|| ( shiftCount && (uint64_t) ( aSig0<<( shiftCount & 63 ) ) ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
}
if ( aSign ) z = - z;
@@ -6118,7 +6160,7 @@ float128 float128_round_to_int(float128 a, float_status *status)
lastBitMask = ( lastBitMask<<( 0x406E - aExp ) )<<1;
roundBitsMask = lastBitMask - 1;
z = a;
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
if ( lastBitMask ) {
add128( z.high, z.low, 0, lastBitMask>>1, &z.high, &z.low );
@@ -6160,9 +6202,9 @@ float128 float128_round_to_int(float128 a, float_status *status)
else {
if ( aExp < 0x3FFF ) {
if ( ( ( (uint64_t) ( a.high<<1 ) ) | a.low ) == 0 ) return a;
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
aSign = extractFloat128Sign( a );
- switch ( STATUS(float_rounding_mode) ) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
if ( ( aExp == 0x3FFE )
&& ( extractFloat128Frac0( a )
@@ -6192,7 +6234,7 @@ float128 float128_round_to_int(float128 a, float_status *status)
roundBitsMask = lastBitMask - 1;
z.low = 0;
z.high = a.high;
- switch (STATUS(float_rounding_mode)) {
+ switch (status->float_rounding_mode) {
case float_round_nearest_even:
z.high += lastBitMask>>1;
if ( ( ( z.high & roundBitsMask ) | a.low ) == 0 ) {
@@ -6222,7 +6264,7 @@ float128 float128_round_to_int(float128 a, float_status *status)
z.high &= ~ roundBitsMask;
}
if ( ( z.low != a.low ) || ( z.high != a.high ) ) {
- STATUS(float_exception_flags) |= float_flag_inexact;
+ status->float_exception_flags |= float_flag_inexact;
}
return z;
@@ -6293,7 +6335,7 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
}
add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );
if ( aExp == 0 ) {
- if (STATUS(flush_to_zero)) {
+ if (status->flush_to_zero) {
if (zSig0 | zSig1) {
float_raise(float_flag_output_denormal, status);
}
@@ -6363,7 +6405,8 @@ static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
if ( aSig0 < bSig0 ) goto bBigger;
if ( bSig1 < aSig1 ) goto aBigger;
if ( aSig1 < bSig1 ) goto bBigger;
- return packFloat128( STATUS(float_rounding_mode) == float_round_down, 0, 0, 0 );
+ return packFloat128(status->float_rounding_mode == float_round_down,
+ 0, 0, 0);
bExpBigger:
if ( bExp == 0x7FFF ) {
if (bSig0 | bSig1) {
@@ -7276,7 +7319,7 @@ uint64_t float64_to_uint64(float64 a, float_status *status)
uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status)
{
- signed char current_rounding_mode = STATUS(float_rounding_mode);
+ signed char current_rounding_mode = status->float_rounding_mode;
set_float_rounding_mode(float_round_to_zero, status);
int64_t v = float64_to_uint64(a, status);
set_float_rounding_mode(current_rounding_mode, status);
@@ -7638,8 +7681,8 @@ floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
}
aExp += n;
- return normalizeRoundAndPackFloatx80( STATUS(floatx80_rounding_precision),
- aSign, aExp, aSig, 0, status);
+ return normalizeRoundAndPackFloatx80(status->floatx80_rounding_precision,
+ aSign, aExp, aSig, 0, status);
}
float128 float128_scalbn(float128 a, int n, float_status *status)
diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
index d13fd0e..ded34eb 100644
--- a/include/fpu/softfloat.h
+++ b/include/fpu/softfloat.h
@@ -108,8 +108,6 @@ typedef int64_t int64;
#define LIT64( a ) a##LL
-#define STATUS(field) status->field
-
/*----------------------------------------------------------------------------
| Software IEC/IEEE floating-point ordering relations
*----------------------------------------------------------------------------*/
@@ -224,60 +222,60 @@ typedef struct float_status {
static inline void set_float_detect_tininess(int val, float_status *status)
{
- STATUS(float_detect_tininess) = val;
+ status->float_detect_tininess = val;
}
static inline void set_float_rounding_mode(int val, float_status *status)
{
- STATUS(float_rounding_mode) = val;
+ status->float_rounding_mode = val;
}
static inline void set_float_exception_flags(int val, float_status *status)
{
- STATUS(float_exception_flags) = val;
+ status->float_exception_flags = val;
}
static inline void set_floatx80_rounding_precision(int val,
float_status *status)
{
- STATUS(floatx80_rounding_precision) = val;
+ status->floatx80_rounding_precision = val;
}
static inline void set_flush_to_zero(flag val, float_status *status)
{
- STATUS(flush_to_zero) = val;
+ status->flush_to_zero = val;
}
static inline void set_flush_inputs_to_zero(flag val, float_status *status)
{
- STATUS(flush_inputs_to_zero) = val;
+ status->flush_inputs_to_zero = val;
}
static inline void set_default_nan_mode(flag val, float_status *status)
{
- STATUS(default_nan_mode) = val;
+ status->default_nan_mode = val;
}
static inline int get_float_detect_tininess(float_status *status)
{
- return STATUS(float_detect_tininess);
+ return status->float_detect_tininess;
}
static inline int get_float_rounding_mode(float_status *status)
{
- return STATUS(float_rounding_mode);
+ return status->float_rounding_mode;
}
static inline int get_float_exception_flags(float_status *status)
{
- return STATUS(float_exception_flags);
+ return status->float_exception_flags;
}
static inline int get_floatx80_rounding_precision(float_status *status)
{
- return STATUS(floatx80_rounding_precision);
+ return status->floatx80_rounding_precision;
}
static inline flag get_flush_to_zero(float_status *status)
{
- return STATUS(flush_to_zero);
+ return status->flush_to_zero;
}
static inline flag get_flush_inputs_to_zero(float_status *status)
{
- return STATUS(flush_inputs_to_zero);
+ return status->flush_inputs_to_zero;
}
static inline flag get_default_nan_mode(float_status *status)
{
- return STATUS(default_nan_mode);
+ return status->default_nan_mode;
}
/*----------------------------------------------------------------------------
--
1.9.1
^ permalink raw reply related [flat|nested] 8+ messages in thread