Richard Henderson <richard.hender...@linaro.org> writes:
> Replace the floatx80 compare specializations with inline functions > that call the standard floatx80_compare{,_quiet} functions. > Use bool as the return type. > > Signed-off-by: Richard Henderson <richard.hender...@linaro.org> Reviewed-by: Alex Bennée <alex.ben...@linaro.org> > --- > include/fpu/softfloat.h | 49 ++++++-- > fpu/softfloat.c | 257 ---------------------------------------- > 2 files changed, 41 insertions(+), 265 deletions(-) > > diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h > index cfb3cda46b..37217d9b9b 100644 > --- a/include/fpu/softfloat.h > +++ b/include/fpu/softfloat.h > @@ -689,14 +689,6 @@ 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); > FloatRelation floatx80_compare(floatx80, floatx80, float_status *status); > FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status > *status); > int floatx80_is_quiet_nan(floatx80, float_status *status); > @@ -746,6 +738,47 @@ static inline int floatx80_is_any_nan(floatx80 a) > return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1); > } > > +static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare(a, b, s) == float_relation_equal; > +} > + > +static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare(a, b, s) <= float_relation_equal; > +} > + > +static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare(a, b, s) < float_relation_equal; > +} > + > +static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status > *s) > +{ > + return floatx80_compare(a, b, s) == float_relation_unordered; > +} > + > +static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare_quiet(a, b, s) == float_relation_equal; > +} > + > +static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare_quiet(a, b, s) <= float_relation_equal; > +} > + > +static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s) > +{ > + return floatx80_compare_quiet(a, b, s) < float_relation_equal; > +} > + > +static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b, > + float_status *s) > +{ > + return floatx80_compare_quiet(a, b, s) == float_relation_unordered; > +} > + > > /*---------------------------------------------------------------------------- > | Return whether the given value is an invalid floatx80 encoding. > | Invalid floatx80 encodings arise when the integer bit is not set, but > diff --git a/fpu/softfloat.c b/fpu/softfloat.c > index 4567dda112..6c8f2d597a 100644 > --- a/fpu/softfloat.c > +++ b/fpu/softfloat.c > @@ -5849,263 +5849,6 @@ floatx80 floatx80_sqrt(floatx80 a, float_status > *status) > 0, zExp, zSig0, zSig1, status); > } > > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is > equal > -| to the corresponding value `b', and 0 otherwise. The invalid exception is > -| raised if either operand is a NaN. Otherwise, the comparison is performed > -| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_eq(floatx80 a, floatx80 b, float_status *status) > -{ > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b) > - || (extractFloatx80Exp(a) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(a) << 1)) > - || (extractFloatx80Exp(b) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(b) << 1)) > - ) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - return > - ( a.low == b.low ) > - && ( ( a.high == b.high ) > - || ( ( a.low == 0 ) > - && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) ) > - ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is > -| less than or equal to the corresponding value `b', and 0 otherwise. The > -| invalid exception is raised if either operand is a NaN. The comparison is > -| performed according to the IEC/IEEE Standard for Binary Floating-Point > -| Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_le(floatx80 a, floatx80 b, float_status *status) > -{ > - bool aSign, bSign; > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b) > - || (extractFloatx80Exp(a) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(a) << 1)) > - || (extractFloatx80Exp(b) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(b) << 1)) > - ) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - aSign = extractFloatx80Sign( a ); > - bSign = extractFloatx80Sign( b ); > - if ( aSign != bSign ) { > - return > - aSign > - || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | > b.low ) > - == 0 ); > - } > - return > - aSign ? le128( b.high, b.low, a.high, a.low ) > - : le128( a.high, a.low, b.high, b.low ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is > -| less than the corresponding value `b', and 0 otherwise. The invalid > -| exception is raised if either operand is a NaN. The comparison is > performed > -| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_lt(floatx80 a, floatx80 b, float_status *status) > -{ > - bool aSign, bSign; > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b) > - || (extractFloatx80Exp(a) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(a) << 1)) > - || (extractFloatx80Exp(b) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(b) << 1)) > - ) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - aSign = extractFloatx80Sign( a ); > - bSign = extractFloatx80Sign( b ); > - if ( aSign != bSign ) { > - return > - aSign > - && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | > b.low ) > - != 0 ); > - } > - return > - aSign ? lt128( b.high, b.low, a.high, a.low ) > - : lt128( a.high, a.low, b.high, b.low ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point values `a' and > `b' > -| cannot be compared, and 0 otherwise. The invalid exception is raised if > -| 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, float_status *status) > -{ > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b) > - || (extractFloatx80Exp(a) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(a) << 1)) > - || (extractFloatx80Exp(b) == 0x7FFF > - && (uint64_t) (extractFloatx80Frac(b) << 1)) > - ) { > - float_raise(float_flag_invalid, status); > - return 1; > - } > - return 0; > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is > -| equal to the corresponding value `b', and 0 otherwise. Quiet NaNs do not > -| cause an exception. The comparison is performed according to the IEC/IEEE > -| Standard for Binary Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *status) > -{ > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) > - || ( ( extractFloatx80Exp( b ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) > - ) { > - if (floatx80_is_signaling_nan(a, status) > - || floatx80_is_signaling_nan(b, status)) { > - float_raise(float_flag_invalid, status); > - } > - return 0; > - } > - return > - ( a.low == b.low ) > - && ( ( a.high == b.high ) > - || ( ( a.low == 0 ) > - && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) ) > - ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is less > -| than or equal to the corresponding value `b', and 0 otherwise. Quiet NaNs > -| do not cause an exception. Otherwise, the comparison is performed > according > -| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_le_quiet(floatx80 a, floatx80 b, float_status *status) > -{ > - bool aSign, bSign; > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) > - || ( ( extractFloatx80Exp( b ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) > - ) { > - if (floatx80_is_signaling_nan(a, status) > - || floatx80_is_signaling_nan(b, status)) { > - float_raise(float_flag_invalid, status); > - } > - return 0; > - } > - aSign = extractFloatx80Sign( a ); > - bSign = extractFloatx80Sign( b ); > - if ( aSign != bSign ) { > - return > - aSign > - || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | > b.low ) > - == 0 ); > - } > - return > - aSign ? le128( b.high, b.low, a.high, a.low ) > - : le128( a.high, a.low, b.high, b.low ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point value `a' is less > -| than the corresponding value `b', and 0 otherwise. Quiet NaNs do not cause > -| an exception. Otherwise, the comparison is performed according to the > -| IEC/IEEE Standard for Binary Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > - > -int floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *status) > -{ > - bool aSign, bSign; > - > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { > - float_raise(float_flag_invalid, status); > - return 0; > - } > - if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) > - || ( ( extractFloatx80Exp( b ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) > - ) { > - if (floatx80_is_signaling_nan(a, status) > - || floatx80_is_signaling_nan(b, status)) { > - float_raise(float_flag_invalid, status); > - } > - return 0; > - } > - aSign = extractFloatx80Sign( a ); > - bSign = extractFloatx80Sign( b ); > - if ( aSign != bSign ) { > - return > - aSign > - && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | > b.low ) > - != 0 ); > - } > - return > - aSign ? lt128( b.high, b.low, a.high, a.low ) > - : lt128( a.high, a.low, b.high, b.low ); > - > -} > - > -/*---------------------------------------------------------------------------- > -| Returns 1 if the extended double-precision floating-point values `a' and > `b' > -| cannot be compared, and 0 otherwise. Quiet NaNs do not cause an exception. > -| The comparison is performed according to the IEC/IEEE Standard for Binary > -| Floating-Point Arithmetic. > -*----------------------------------------------------------------------------*/ > -int floatx80_unordered_quiet(floatx80 a, floatx80 b, float_status *status) > -{ > - if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) { > - float_raise(float_flag_invalid, status); > - return 1; > - } > - if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) > - || ( ( extractFloatx80Exp( b ) == 0x7FFF ) > - && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) > - ) { > - if (floatx80_is_signaling_nan(a, status) > - || floatx80_is_signaling_nan(b, status)) { > - float_raise(float_flag_invalid, status); > - } > - return 1; > - } > - return 0; > -} > - > > /*---------------------------------------------------------------------------- > | Returns the result of converting the quadruple-precision floating-point > | value `a' to the 32-bit two's complement integer format. The conversion -- Alex Bennée