Re: [PATCH 04/10] fpu: Make targets specify whether floatx80 Inf can have Int bit clear

["Philippe Mathieu-Daudé" <philmd@linaro.org>]

On 17/2/25 13:50, Peter Maydell wrote:
> In Intel terminology, a floatx80 Infinity with the explicit integer
> bit clear is a "pseudo-infinity"; for x86 these are not valid
> infinity values.  m68k is looser and does not care whether the
> Integer bit is set or clear in an infinity.
> 
> Move this setting to runtime rather than using an ifdef in
> floatx80_is_infinity().  (This requires us to pass in the
> float_status to that function now.)
> 
> Since this was the last use of the floatx80_infinity global constant,
> we remove it and its definition here.
> 
> Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>

> ---
>   include/fpu/softfloat-types.h  |  5 +++++
>   include/fpu/softfloat.h        | 20 ++++++++++++--------
>   target/i386/tcg/fpu_helper.c   | 20 +++++++++++---------
>   target/m68k/cpu.c              |  4 +++-
>   target/m68k/fpu_helper.c       |  2 +-
>   fpu/softfloat-specialize.c.inc | 10 ----------
>   6 files changed, 32 insertions(+), 29 deletions(-)

Passing float_status argument to floatx80_is_infinity in a preliminary
patch, this becomes simpler (to my taste...):

    4 files changed, 19 insertions(+), 18 deletions(-)

-- >8 --
diff --git a/include/fpu/softfloat-types.h b/include/fpu/softfloat-types.h
index dd22ecdbe60..e1732beba4f 100644
--- a/include/fpu/softfloat-types.h
+++ b/include/fpu/softfloat-types.h
@@ -332,0 +333,5 @@ typedef enum __attribute__((__packed__)) {
+    /*
+     * Are Pseudo-infinities (Inf with the Integer bit zero) valid?
+     * If so, floatx80_is_infinity() will return true for them.
+     */
+    floatx80_pseudo_inf_valid = 2,
diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
index 1fa759779ea..1c8f3cbb78d 100644
--- a/include/fpu/softfloat.h
+++ b/include/fpu/softfloat.h
@@ -963 +962,0 @@ float128 floatx80_to_float128(floatx80, float_status 
*status);
-extern const floatx80 floatx80_infinity;
@@ -1001,6 +1000,11 @@ static inline bool floatx80_is_infinity(floatx80 
a, float_status *status)
-#if defined(TARGET_M68K)
-    return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1);
-#else
-    return (a.high & 0x7fff) == floatx80_infinity.high &&
-                       a.low == floatx80_infinity.low;
-#endif
+    /*
+     * It's target-specific whether the Integer bit is permitted
+     * to be 0 in a valid Infinity value. (x86 says no, m68k says yes).
+     */
+    bool intbit = a.low >> 63;
+
+    if (!intbit &&
+        !(status->floatx80_behaviour & floatx80_pseudo_inf_valid)) {
+        return false;
+    }
+    return (a.high & 0x7fff) == 0x7fff && !(a.low << 1);
diff --git a/target/m68k/cpu.c b/target/m68k/cpu.c
index df66e8ba22a..56b23de21fe 100644
--- a/target/m68k/cpu.c
+++ b/target/m68k/cpu.c
@@ -112,0 +113 @@ static void m68k_cpu_reset_hold(Object *obj, ResetType 
type)
+     *  * input Infinities may have the Integer bit either 0 or 1
@@ -114 +115,2 @@ static void m68k_cpu_reset_hold(Object *obj, ResetType 
type)
-    set_floatx80_behaviour(floatx80_default_inf_int_bit_is_zero,
+    set_floatx80_behaviour(floatx80_default_inf_int_bit_is_zero |
+                           floatx80_pseudo_inf_valid,
diff --git a/fpu/softfloat-specialize.c.inc b/fpu/softfloat-specialize.c.inc
index 73789e97d77..8327f727861 100644
--- a/fpu/softfloat-specialize.c.inc
+++ b/fpu/softfloat-specialize.c.inc
@@ -240,10 +239,0 @@ floatx80 floatx80_default_inf(bool zSign, 
float_status *status)
-#define floatx80_infinity_high 0x7FFF
-#if defined(TARGET_M68K)
-#define floatx80_infinity_low  UINT64_C(0x0000000000000000)
-#else
-#define floatx80_infinity_low  UINT64_C(0x8000000000000000)
-#endif
-
-const floatx80 floatx80_infinity
-    = make_floatx80_init(floatx80_infinity_high, floatx80_infinity_low);
-
---