From: "Alex Bennée" <alex.bennee@linaro.org>
To: Richard Henderson <richard.henderson@linaro.org>
Cc: qemu-devel@nongnu.org
Subject: Re: [PATCH 10/10] softfloat: Return bool from all classification predicates
Date: Tue, 19 May 2020 11:10:13 +0100 [thread overview]
Message-ID: <87k118i6be.fsf@linaro.org> (raw)
In-Reply-To: <20200515190153.6017-11-richard.henderson@linaro.org>
Richard Henderson <richard.henderson@linaro.org> writes:
> This includes *_is_any_nan, *_is_neg, *_is_inf, etc.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
As an aside do you think we'll see any benefit from rolling up the
classifications with the decomposed versions? I would hope the compiler
could drop the stuff it doesn't need but I guess we loose the ability to
inline in the target helpers?
> ---
> include/fpu/softfloat.h | 66 +++++++++++++++++-----------------
> fpu/softfloat-specialize.inc.c | 16 ++++-----
> 2 files changed, 41 insertions(+), 41 deletions(-)
>
> diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
> index 37217d9b9b..16ca697a73 100644
> --- a/include/fpu/softfloat.h
> +++ b/include/fpu/softfloat.h
> @@ -235,31 +235,31 @@ float16 float16_sqrt(float16, float_status *status);
> FloatRelation float16_compare(float16, float16, float_status *status);
> FloatRelation float16_compare_quiet(float16, float16, float_status *status);
>
> -int float16_is_quiet_nan(float16, float_status *status);
> -int float16_is_signaling_nan(float16, float_status *status);
> +bool float16_is_quiet_nan(float16, float_status *status);
> +bool float16_is_signaling_nan(float16, float_status *status);
> float16 float16_silence_nan(float16, float_status *status);
>
> -static inline int float16_is_any_nan(float16 a)
> +static inline bool float16_is_any_nan(float16 a)
> {
> return ((float16_val(a) & ~0x8000) > 0x7c00);
> }
>
> -static inline int float16_is_neg(float16 a)
> +static inline bool float16_is_neg(float16 a)
> {
> return float16_val(a) >> 15;
> }
>
> -static inline int float16_is_infinity(float16 a)
> +static inline bool float16_is_infinity(float16 a)
> {
> return (float16_val(a) & 0x7fff) == 0x7c00;
> }
>
> -static inline int float16_is_zero(float16 a)
> +static inline bool float16_is_zero(float16 a)
> {
> return (float16_val(a) & 0x7fff) == 0;
> }
>
> -static inline int float16_is_zero_or_denormal(float16 a)
> +static inline bool float16_is_zero_or_denormal(float16 a)
> {
> return (float16_val(a) & 0x7c00) == 0;
> }
> @@ -351,8 +351,8 @@ 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, float_status *status);
> -int float32_is_signaling_nan(float32, float_status *status);
> +bool float32_is_quiet_nan(float32, float_status *status);
> +bool float32_is_signaling_nan(float32, float_status *status);
> float32 float32_silence_nan(float32, float_status *status);
> float32 float32_scalbn(float32, int, float_status *status);
>
> @@ -372,27 +372,27 @@ static inline float32 float32_chs(float32 a)
> return make_float32(float32_val(a) ^ 0x80000000);
> }
>
> -static inline int float32_is_infinity(float32 a)
> +static inline bool float32_is_infinity(float32 a)
> {
> return (float32_val(a) & 0x7fffffff) == 0x7f800000;
> }
>
> -static inline int float32_is_neg(float32 a)
> +static inline bool float32_is_neg(float32 a)
> {
> return float32_val(a) >> 31;
> }
>
> -static inline int float32_is_zero(float32 a)
> +static inline bool float32_is_zero(float32 a)
> {
> return (float32_val(a) & 0x7fffffff) == 0;
> }
>
> -static inline int float32_is_any_nan(float32 a)
> +static inline bool float32_is_any_nan(float32 a)
> {
> return ((float32_val(a) & ~(1 << 31)) > 0x7f800000UL);
> }
>
> -static inline int float32_is_zero_or_denormal(float32 a)
> +static inline bool float32_is_zero_or_denormal(float32 a)
> {
> return (float32_val(a) & 0x7f800000) == 0;
> }
> @@ -540,8 +540,8 @@ 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, float_status *status);
> -int float64_is_signaling_nan(float64, float_status *status);
> +bool float64_is_quiet_nan(float64 a, float_status *status);
> +bool float64_is_signaling_nan(float64, float_status *status);
> float64 float64_silence_nan(float64, float_status *status);
> float64 float64_scalbn(float64, int, float_status *status);
>
> @@ -561,27 +561,27 @@ static inline float64 float64_chs(float64 a)
> return make_float64(float64_val(a) ^ 0x8000000000000000LL);
> }
>
> -static inline int float64_is_infinity(float64 a)
> +static inline bool float64_is_infinity(float64 a)
> {
> return (float64_val(a) & 0x7fffffffffffffffLL ) == 0x7ff0000000000000LL;
> }
>
> -static inline int float64_is_neg(float64 a)
> +static inline bool float64_is_neg(float64 a)
> {
> return float64_val(a) >> 63;
> }
>
> -static inline int float64_is_zero(float64 a)
> +static inline bool float64_is_zero(float64 a)
> {
> return (float64_val(a) & 0x7fffffffffffffffLL) == 0;
> }
>
> -static inline int float64_is_any_nan(float64 a)
> +static inline bool float64_is_any_nan(float64 a)
> {
> return ((float64_val(a) & ~(1ULL << 63)) > 0x7ff0000000000000ULL);
> }
>
> -static inline int float64_is_zero_or_denormal(float64 a)
> +static inline bool float64_is_zero_or_denormal(float64 a)
> {
> return (float64_val(a) & 0x7ff0000000000000LL) == 0;
> }
> @@ -708,7 +708,7 @@ static inline floatx80 floatx80_chs(floatx80 a)
> return a;
> }
>
> -static inline int floatx80_is_infinity(floatx80 a)
> +static inline bool floatx80_is_infinity(floatx80 a)
> {
> #if defined(TARGET_M68K)
> return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
> @@ -718,22 +718,22 @@ static inline int floatx80_is_infinity(floatx80 a)
> #endif
> }
>
> -static inline int floatx80_is_neg(floatx80 a)
> +static inline bool floatx80_is_neg(floatx80 a)
> {
> return a.high >> 15;
> }
>
> -static inline int floatx80_is_zero(floatx80 a)
> +static inline bool floatx80_is_zero(floatx80 a)
> {
> return (a.high & 0x7fff) == 0 && a.low == 0;
> }
>
> -static inline int floatx80_is_zero_or_denormal(floatx80 a)
> +static inline bool floatx80_is_zero_or_denormal(floatx80 a)
> {
> return (a.high & 0x7fff) == 0;
> }
>
> -static inline int floatx80_is_any_nan(floatx80 a)
> +static inline bool floatx80_is_any_nan(floatx80 a)
> {
> return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
> }
> @@ -936,8 +936,8 @@ float128 float128_rem(float128, float128, float_status *status);
> float128 float128_sqrt(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);
> -int float128_is_signaling_nan(float128, float_status *status);
> +bool float128_is_quiet_nan(float128, float_status *status);
> +bool float128_is_signaling_nan(float128, float_status *status);
> float128 float128_silence_nan(float128, float_status *status);
> float128 float128_scalbn(float128, int, float_status *status);
>
> @@ -953,22 +953,22 @@ static inline float128 float128_chs(float128 a)
> return a;
> }
>
> -static inline int float128_is_infinity(float128 a)
> +static inline bool float128_is_infinity(float128 a)
> {
> return (a.high & 0x7fffffffffffffffLL) == 0x7fff000000000000LL && a.low == 0;
> }
>
> -static inline int float128_is_neg(float128 a)
> +static inline bool float128_is_neg(float128 a)
> {
> return a.high >> 63;
> }
>
> -static inline int float128_is_zero(float128 a)
> +static inline bool float128_is_zero(float128 a)
> {
> return (a.high & 0x7fffffffffffffffLL) == 0 && a.low == 0;
> }
>
> -static inline int float128_is_zero_or_denormal(float128 a)
> +static inline bool float128_is_zero_or_denormal(float128 a)
> {
> return (a.high & 0x7fff000000000000LL) == 0;
> }
> @@ -983,7 +983,7 @@ static inline bool float128_is_denormal(float128 a)
> return float128_is_zero_or_denormal(a) && !float128_is_zero(a);
> }
>
> -static inline int float128_is_any_nan(float128 a)
> +static inline bool float128_is_any_nan(float128 a)
> {
> return ((a.high >> 48) & 0x7fff) == 0x7fff &&
> ((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
> diff --git a/fpu/softfloat-specialize.inc.c b/fpu/softfloat-specialize.inc.c
> index 025ee4f991..44f5b661f8 100644
> --- a/fpu/softfloat-specialize.inc.c
> +++ b/fpu/softfloat-specialize.inc.c
> @@ -245,7 +245,7 @@ typedef struct {
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float16_is_quiet_nan(float16 a_, float_status *status)
> +bool float16_is_quiet_nan(float16 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return float16_is_any_nan(a_);
> @@ -264,7 +264,7 @@ int float16_is_quiet_nan(float16 a_, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float16_is_signaling_nan(float16 a_, float_status *status)
> +bool float16_is_signaling_nan(float16 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return 0;
> @@ -283,7 +283,7 @@ int float16_is_signaling_nan(float16 a_, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float32_is_quiet_nan(float32 a_, float_status *status)
> +bool float32_is_quiet_nan(float32 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return float32_is_any_nan(a_);
> @@ -302,7 +302,7 @@ int float32_is_quiet_nan(float32 a_, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float32_is_signaling_nan(float32 a_, float_status *status)
> +bool float32_is_signaling_nan(float32 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return 0;
> @@ -637,7 +637,7 @@ static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float64_is_quiet_nan(float64 a_, float_status *status)
> +bool float64_is_quiet_nan(float64 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return float64_is_any_nan(a_);
> @@ -657,7 +657,7 @@ int float64_is_quiet_nan(float64 a_, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float64_is_signaling_nan(float64 a_, float_status *status)
> +bool float64_is_signaling_nan(float64 a_, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return 0;
> @@ -939,7 +939,7 @@ floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status)
> | NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float128_is_quiet_nan(float128 a, float_status *status)
> +bool float128_is_quiet_nan(float128 a, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return float128_is_any_nan(a);
> @@ -959,7 +959,7 @@ int float128_is_quiet_nan(float128 a, float_status *status)
> | signaling NaN; otherwise returns 0.
> *----------------------------------------------------------------------------*/
>
> -int float128_is_signaling_nan(float128 a, float_status *status)
> +bool float128_is_signaling_nan(float128 a, float_status *status)
> {
> #ifdef NO_SIGNALING_NANS
> return 0;
--
Alex Bennée
next prev parent reply other threads:[~2020-05-19 10:11 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
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 [this message]
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=87k118i6be.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).