[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [PATCH 09/10] softfloat: Inline floatx80 compare specializations
From: |
Alex Bennée |
Subject: |
Re: [PATCH 09/10] softfloat: Inline floatx80 compare specializations |
Date: |
Tue, 19 May 2020 10:41:59 +0100 |
User-agent: |
mu4e 1.4.6; emacs 28.0.50 |
Richard Henderson <address@hidden> 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 <address@hidden>
Reviewed-by: Alex Bennée <address@hidden>
> ---
> 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
- [PATCH 05/10] softfloat: Name compare relation enum, (continued)
- [PATCH 05/10] softfloat: Name compare relation enum, Richard Henderson, 2020/05/15
- [PATCH 07/10] softfloat: Inline float64 compare specializations, Richard Henderson, 2020/05/15
- [PATCH 06/10] softfloat: Inline float32 compare specializations, Richard Henderson, 2020/05/15
- [PATCH 08/10] softfloat: Inline float128 compare specializations, Richard Henderson, 2020/05/15
- [PATCH 09/10] softfloat: Inline floatx80 compare specializations, Richard Henderson, 2020/05/15
- Re: [PATCH 09/10] softfloat: Inline floatx80 compare specializations,
Alex Bennée <=
- [PATCH 10/10] softfloat: Return bool from all classification predicates, Richard Henderson, 2020/05/15
- Re: [PATCH 00/10] softfloat: misc cleanups, no-reply, 2020/05/16