Re: [PATCH 08/10] softfloat: Inline float128 compare specializations

[Alex Bennée]

Richard Henderson <address@hidden> writes:

> Replace the float128 compare specializations with inline functions
> that call the standard float128_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         | 238 ----------------------------------------
>  2 files changed, 41 insertions(+), 246 deletions(-)
>
> diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
> index 281f0fd971..cfb3cda46b 100644
> --- a/include/fpu/softfloat.h
> +++ b/include/fpu/softfloat.h
> @@ -901,14 +901,6 @@ 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);
>  FloatRelation float128_compare(float128, float128, float_status *status);
>  FloatRelation float128_compare_quiet(float128, float128, float_status 
> *status);
>  int float128_is_quiet_nan(float128, float_status *status);
> @@ -964,6 +956,47 @@ static inline int float128_is_any_nan(float128 a)
>          ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
>  }
>  
> +static inline bool float128_eq(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare(a, b, s) == float_relation_equal;
> +}
> +
> +static inline bool float128_le(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare(a, b, s) <= float_relation_equal;
> +}
> +
> +static inline bool float128_lt(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare(a, b, s) < float_relation_equal;
> +}
> +
> +static inline bool float128_unordered(float128 a, float128 b, float_status 
> *s)
> +{
> +    return float128_compare(a, b, s) == float_relation_unordered;
> +}
> +
> +static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare_quiet(a, b, s) == float_relation_equal;
> +}
> +
> +static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare_quiet(a, b, s) <= float_relation_equal;
> +}
> +
> +static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
> +{
> +    return float128_compare_quiet(a, b, s) < float_relation_equal;
> +}
> +
> +static inline bool float128_unordered_quiet(float128 a, float128 b,
> +                                           float_status *s)
> +{
> +    return float128_compare_quiet(a, b, s) == float_relation_unordered;
> +}
> +
>  #define float128_zero make_float128(0, 0)
>  
>  
> /*----------------------------------------------------------------------------
> diff --git a/fpu/softfloat.c b/fpu/softfloat.c
> index 5d7fc2c17a..4567dda112 100644
> --- a/fpu/softfloat.c
> +++ b/fpu/softfloat.c
> @@ -7218,244 +7218,6 @@ float128 float128_sqrt(float128 a, float_status 
> *status)
>  
>  }
>  
> -/*----------------------------------------------------------------------------
> -| Returns 1 if the quadruple-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 float128_eq(float128 a, float128 b, float_status *status)
> -{
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        float_raise(float_flag_invalid, status);
> -        return 0;
> -    }
> -    return
> -           ( a.low == b.low )
> -        && (    ( a.high == b.high )
> -             || (    ( a.low == 0 )
> -                  && ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
> -           );
> -
> -}
> -
> -/*----------------------------------------------------------------------------
> -| Returns 1 if the quadruple-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 float128_le(float128 a, float128 b, float_status *status)
> -{
> -    bool aSign, bSign;
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        float_raise(float_flag_invalid, status);
> -        return 0;
> -    }
> -    aSign = extractFloat128Sign( a );
> -    bSign = extractFloat128Sign( b );
> -    if ( aSign != bSign ) {
> -        return
> -               aSign
> -            || (    ( ( (uint64_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 quadruple-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 float128_lt(float128 a, float128 b, float_status *status)
> -{
> -    bool aSign, bSign;
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        float_raise(float_flag_invalid, status);
> -        return 0;
> -    }
> -    aSign = extractFloat128Sign( a );
> -    bSign = extractFloat128Sign( b );
> -    if ( aSign != bSign ) {
> -        return
> -               aSign
> -            && (    ( ( (uint64_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 quadruple-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 float128_unordered(float128 a, float128 b, float_status *status)
> -{
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        float_raise(float_flag_invalid, status);
> -        return 1;
> -    }
> -    return 0;
> -}
> -
> -/*----------------------------------------------------------------------------
> -| Returns 1 if the quadruple-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 float128_eq_quiet(float128 a, float128 b, float_status *status)
> -{
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        if (float128_is_signaling_nan(a, status)
> -         || float128_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 )
> -                  && ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
> -           );
> -
> -}
> -
> -/*----------------------------------------------------------------------------
> -| Returns 1 if the quadruple-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 float128_le_quiet(float128 a, float128 b, float_status *status)
> -{
> -    bool aSign, bSign;
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        if (float128_is_signaling_nan(a, status)
> -         || float128_is_signaling_nan(b, status)) {
> -            float_raise(float_flag_invalid, status);
> -        }
> -        return 0;
> -    }
> -    aSign = extractFloat128Sign( a );
> -    bSign = extractFloat128Sign( b );
> -    if ( aSign != bSign ) {
> -        return
> -               aSign
> -            || (    ( ( (uint64_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 quadruple-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 float128_lt_quiet(float128 a, float128 b, float_status *status)
> -{
> -    bool aSign, bSign;
> -
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        if (float128_is_signaling_nan(a, status)
> -         || float128_is_signaling_nan(b, status)) {
> -            float_raise(float_flag_invalid, status);
> -        }
> -        return 0;
> -    }
> -    aSign = extractFloat128Sign( a );
> -    bSign = extractFloat128Sign( b );
> -    if ( aSign != bSign ) {
> -        return
> -               aSign
> -            && (    ( ( (uint64_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 quadruple-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 float128_unordered_quiet(float128 a, float128 b, float_status *status)
> -{
> -    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
> -              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
> -         || (    ( extractFloat128Exp( b ) == 0x7FFF )
> -              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
> -       ) {
> -        if (float128_is_signaling_nan(a, status)
> -         || float128_is_signaling_nan(b, status)) {
> -            float_raise(float_flag_invalid, status);
> -        }
> -        return 1;
> -    }
> -    return 0;
> -}
> -
>  static inline FloatRelation
>  floatx80_compare_internal(floatx80 a, floatx80 b, bool is_quiet,
>                            float_status *status)


-- 
Alex Bennée