From: "Alex Bennée" <alex.bennee@linaro.org>
To: Richard Henderson <richard.henderson@linaro.org>
Cc: qemu-devel@nongnu.org
Subject: Re: [PATCH 08/10] softfloat: Inline float128 compare specializations
Date: Tue, 19 May 2020 10:41:29 +0100 [thread overview]
Message-ID: <87pnb0i7na.fsf@linaro.org> (raw)
In-Reply-To: <20200515190153.6017-9-richard.henderson@linaro.org>
Richard Henderson <richard.henderson@linaro.org> 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 <richard.henderson@linaro.org>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
> ---
> 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
next prev parent reply other threads:[~2020-05-19 9:42 UTC|newest]
Thread overview: 27+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-15 19:01 [PATCH 00/10] softfloat: misc cleanups Richard Henderson
2020-05-15 19:01 ` [PATCH 01/10] softfloat: Use post test for floatN_mul Richard Henderson
2020-05-19 8:48 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 02/10] softfloat: Replace flag with bool Richard Henderson
2020-05-16 5:27 ` Philippe Mathieu-Daudé
2020-05-19 8:53 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 03/10] softfloat: Change tininess_before_rounding to bool Richard Henderson
2020-05-19 8:55 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 04/10] softfloat: Name rounding mode enum Richard Henderson
2020-05-16 5:30 ` Philippe Mathieu-Daudé
2020-05-19 9:06 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 05/10] softfloat: Name compare relation enum Richard Henderson
2020-05-16 5:32 ` Philippe Mathieu-Daudé
2020-05-19 9:08 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 06/10] softfloat: Inline float32 compare specializations Richard Henderson
2020-05-19 9:38 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 07/10] softfloat: Inline float64 " Richard Henderson
2020-05-19 9:41 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 08/10] softfloat: Inline float128 " Richard Henderson
2020-05-19 9:41 ` Alex Bennée [this message]
2020-05-15 19:01 ` [PATCH 09/10] softfloat: Inline floatx80 " Richard Henderson
2020-05-19 9:41 ` Alex Bennée
2020-05-15 19:01 ` [PATCH 10/10] softfloat: Return bool from all classification predicates Richard Henderson
2020-05-16 5:33 ` Philippe Mathieu-Daudé
2020-05-19 10:10 ` Alex Bennée
2020-05-19 15:47 ` Richard Henderson
2020-05-16 10:58 ` [PATCH 00/10] softfloat: misc cleanups no-reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=87pnb0i7na.fsf@linaro.org \
--to=alex.bennee@linaro.org \
--cc=qemu-devel@nongnu.org \
--cc=richard.henderson@linaro.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).