[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Qemu-devel] [PATCH 01/19] fpu/softfloat: Merge NO_SIGNALING_NANS de
From: |
Alex Bennée |
Subject: |
Re: [Qemu-devel] [PATCH 01/19] fpu/softfloat: Merge NO_SIGNALING_NANS definitions |
Date: |
Fri, 11 May 2018 07:44:30 +0100 |
User-agent: |
mu4e 1.1.0; emacs 26.1 |
Richard Henderson <address@hidden> writes:
> Move the ifdef inside the relevant functions instead of
> duplicating the function declarations.
>
> Signed-off-by: Richard Henderson <address@hidden>
Reviewed-by: Alex Bennée <address@hidden>
> ---
> fpu/softfloat-specialize.h | 100 +++++++++++++++----------------------
> 1 file changed, 40 insertions(+), 60 deletions(-)
>
> diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
> index a20b440159..8bd553abd2 100644
> --- a/fpu/softfloat-specialize.h
> +++ b/fpu/softfloat-specialize.h
> @@ -233,17 +233,6 @@ typedef struct {
> uint64_t high, low;
> } commonNaNT;
>
> -#ifdef NO_SIGNALING_NANS
> -int float16_is_quiet_nan(float16 a_, float_status *status)
> -{
> - return float16_is_any_nan(a_);
> -}
> -
> -int float16_is_signaling_nan(float16 a_, float_status *status)
> -{
> - return 0;
> -}
> -#else
>
> /*----------------------------------------------------------------------------
> | Returns 1 if the half-precision floating-point value `a' is a quiet
> | NaN; otherwise returns 0.
> @@ -251,12 +240,16 @@ int float16_is_signaling_nan(float16 a_, float_status
> *status)
>
> int float16_is_quiet_nan(float16 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return float16_is_any_nan(a_);
> +#else
> uint16_t a = float16_val(a_);
> if (status->snan_bit_is_one) {
> return (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
> } else {
> return ((a & ~0x8000) >= 0x7C80);
> }
> +#endif
> }
>
>
> /*----------------------------------------------------------------------------
> @@ -266,14 +259,17 @@ int float16_is_quiet_nan(float16 a_, float_status
> *status)
>
> int float16_is_signaling_nan(float16 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return 0;
> +#else
> uint16_t a = float16_val(a_);
> if (status->snan_bit_is_one) {
> return ((a & ~0x8000) >= 0x7C80);
> } else {
> return (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
> }
> -}
> #endif
> +}
>
>
> /*----------------------------------------------------------------------------
> | Returns a quiet NaN if the half-precision floating point value `a' is a
> @@ -293,17 +289,6 @@ float16 float16_maybe_silence_nan(float16 a_,
> float_status *status)
> return a_;
> }
>
> -#ifdef NO_SIGNALING_NANS
> -int float32_is_quiet_nan(float32 a_, float_status *status)
> -{
> - return float32_is_any_nan(a_);
> -}
> -
> -int float32_is_signaling_nan(float32 a_, float_status *status)
> -{
> - return 0;
> -}
> -#else
>
> /*----------------------------------------------------------------------------
> | Returns 1 if the single-precision floating-point value `a' is a quiet
> | NaN; otherwise returns 0.
> @@ -311,12 +296,16 @@ int float32_is_signaling_nan(float32 a_, float_status
> *status)
>
> int float32_is_quiet_nan(float32 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return float32_is_any_nan(a_);
> +#else
> uint32_t a = float32_val(a_);
> if (status->snan_bit_is_one) {
> return (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
> } else {
> return ((uint32_t)(a << 1) >= 0xFF800000);
> }
> +#endif
> }
>
>
> /*----------------------------------------------------------------------------
> @@ -326,14 +315,17 @@ int float32_is_quiet_nan(float32 a_, float_status
> *status)
>
> int float32_is_signaling_nan(float32 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return 0;
> +#else
> uint32_t a = float32_val(a_);
> if (status->snan_bit_is_one) {
> return ((uint32_t)(a << 1) >= 0xFF800000);
> } else {
> return (((a >> 22) & 0x1FF) == 0x1FE) && (a & 0x003FFFFF);
> }
> -}
> #endif
> +}
>
>
> /*----------------------------------------------------------------------------
> | Returns a quiet NaN if the single-precision floating point value `a' is a
> @@ -704,17 +696,6 @@ static float32 propagateFloat32NaN(float32 a, float32 b,
> float_status *status)
> }
> }
>
> -#ifdef NO_SIGNALING_NANS
> -int float64_is_quiet_nan(float64 a_, float_status *status)
> -{
> - return float64_is_any_nan(a_);
> -}
> -
> -int float64_is_signaling_nan(float64 a_, float_status *status)
> -{
> - return 0;
> -}
> -#else
>
> /*----------------------------------------------------------------------------
> | Returns 1 if the double-precision floating-point value `a' is a quiet
> | NaN; otherwise returns 0.
> @@ -722,6 +703,9 @@ int float64_is_signaling_nan(float64 a_, float_status
> *status)
>
> int float64_is_quiet_nan(float64 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return float64_is_any_nan(a_);
> +#else
> uint64_t a = float64_val(a_);
> if (status->snan_bit_is_one) {
> return (((a >> 51) & 0xFFF) == 0xFFE)
> @@ -729,6 +713,7 @@ int float64_is_quiet_nan(float64 a_, float_status *status)
> } else {
> return ((a << 1) >= 0xFFF0000000000000ULL);
> }
> +#endif
> }
>
>
> /*----------------------------------------------------------------------------
> @@ -738,6 +723,9 @@ int float64_is_quiet_nan(float64 a_, float_status *status)
>
> int float64_is_signaling_nan(float64 a_, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return 0;
> +#else
> uint64_t a = float64_val(a_);
> if (status->snan_bit_is_one) {
> return ((a << 1) >= 0xFFF0000000000000ULL);
> @@ -745,8 +733,8 @@ int float64_is_signaling_nan(float64 a_, float_status
> *status)
> return (((a >> 51) & 0xFFF) == 0xFFE)
> && (a & LIT64(0x0007FFFFFFFFFFFF));
> }
> -}
> #endif
> +}
>
>
> /*----------------------------------------------------------------------------
> | Returns a quiet NaN if the double-precision floating point value `a' is a
> @@ -859,17 +847,6 @@ static float64 propagateFloat64NaN(float64 a, float64 b,
> float_status *status)
> }
> }
>
> -#ifdef NO_SIGNALING_NANS
> -int floatx80_is_quiet_nan(floatx80 a_, float_status *status)
> -{
> - return floatx80_is_any_nan(a_);
> -}
> -
> -int floatx80_is_signaling_nan(floatx80 a_, float_status *status)
> -{
> - return 0;
> -}
> -#else
>
> /*----------------------------------------------------------------------------
> | Returns 1 if the extended double-precision floating-point value `a' is a
> | quiet NaN; otherwise returns 0. This slightly differs from the same
> @@ -878,6 +855,9 @@ int floatx80_is_signaling_nan(floatx80 a_, float_status
> *status)
>
> int floatx80_is_quiet_nan(floatx80 a, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return floatx80_is_any_nan(a);
> +#else
> if (status->snan_bit_is_one) {
> uint64_t aLow;
>
> @@ -889,6 +869,7 @@ int floatx80_is_quiet_nan(floatx80 a, float_status
> *status)
> return ((a.high & 0x7FFF) == 0x7FFF)
> && (LIT64(0x8000000000000000) <= ((uint64_t)(a.low << 1)));
> }
> +#endif
> }
>
>
> /*----------------------------------------------------------------------------
> @@ -899,6 +880,9 @@ int floatx80_is_quiet_nan(floatx80 a, float_status
> *status)
>
> int floatx80_is_signaling_nan(floatx80 a, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return 0;
> +#else
> if (status->snan_bit_is_one) {
> return ((a.high & 0x7FFF) == 0x7FFF)
> && ((a.low << 1) >= 0x8000000000000000ULL);
> @@ -910,8 +894,8 @@ int floatx80_is_signaling_nan(floatx80 a, float_status
> *status)
> && (uint64_t)(aLow << 1)
> && (a.low == aLow);
> }
> -}
> #endif
> +}
>
>
> /*----------------------------------------------------------------------------
> | Returns a quiet NaN if the extended double-precision floating point value
> @@ -1020,17 +1004,6 @@ floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b,
> float_status *status)
> }
> }
>
> -#ifdef NO_SIGNALING_NANS
> -int float128_is_quiet_nan(float128 a_, float_status *status)
> -{
> - return float128_is_any_nan(a_);
> -}
> -
> -int float128_is_signaling_nan(float128 a_, float_status *status)
> -{
> - return 0;
> -}
> -#else
>
> /*----------------------------------------------------------------------------
> | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
> | NaN; otherwise returns 0.
> @@ -1038,6 +1011,9 @@ int float128_is_signaling_nan(float128 a_, float_status
> *status)
>
> int float128_is_quiet_nan(float128 a, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return float128_is_any_nan(a);
> +#else
> if (status->snan_bit_is_one) {
> return (((a.high >> 47) & 0xFFFF) == 0xFFFE)
> && (a.low || (a.high & 0x00007FFFFFFFFFFFULL));
> @@ -1045,6 +1021,7 @@ int float128_is_quiet_nan(float128 a, float_status
> *status)
> return ((a.high << 1) >= 0xFFFF000000000000ULL)
> && (a.low || (a.high & 0x0000FFFFFFFFFFFFULL));
> }
> +#endif
> }
>
>
> /*----------------------------------------------------------------------------
> @@ -1054,6 +1031,9 @@ int float128_is_quiet_nan(float128 a, float_status
> *status)
>
> int float128_is_signaling_nan(float128 a, float_status *status)
> {
> +#ifdef NO_SIGNALING_NANS
> + return 0;
> +#else
> if (status->snan_bit_is_one) {
> return ((a.high << 1) >= 0xFFFF000000000000ULL)
> && (a.low || (a.high & 0x0000FFFFFFFFFFFFULL));
> @@ -1061,8 +1041,8 @@ int float128_is_signaling_nan(float128 a, float_status
> *status)
> return (((a.high >> 47) & 0xFFFF) == 0xFFFE)
> && (a.low || (a.high & LIT64(0x00007FFFFFFFFFFF)));
> }
> -}
> #endif
> +}
>
>
> /*----------------------------------------------------------------------------
> | Returns a quiet NaN if the quadruple-precision floating point value `a' is
--
Alex Bennée