* [PULL 01/48] fpu: Drop parts_canonicalize
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
@ 2026-04-29 22:23 ` Richard Henderson
2026-04-29 22:23 ` [PULL 02/48] fpu: Drop parts_uncanon Richard Henderson
` (47 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:23 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use the specific parts{64,12}_canonicalize at each site.
Drop the forward declarations.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 28 ++++++++++------------------
1 file changed, 10 insertions(+), 18 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 91c34307c8..f9997f5236 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -806,14 +806,6 @@ static FloatParts128 *parts128_pick_nan_muladd(FloatParts128 *a,
#define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \
PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM)
-static void parts64_canonicalize(FloatParts64 *p, float_status *status,
- const FloatFmt *fmt);
-static void parts128_canonicalize(FloatParts128 *p, float_status *status,
- const FloatFmt *fmt);
-
-#define parts_canonicalize(A, S, F) \
- PARTS_GENERIC_64_128(canonicalize, A)(A, S, F)
-
static void parts64_uncanon_normal(FloatParts64 *p, float_status *status,
const FloatFmt *fmt, bool saturate);
static void parts128_uncanon_normal(FloatParts128 *p, float_status *status,
@@ -1723,28 +1715,28 @@ static void float4_e2m1_unpack_canonical(FloatParts64 *p, float4_e2m1 f,
float_status *s)
{
float4_e2m1_unpack_raw(p, f);
- parts_canonicalize(p, s, &float4_e2m1_params);
+ parts64_canonicalize(p, s, &float4_e2m1_params);
}
static void float8_e4m3_unpack_canonical(FloatParts64 *p, float8_e4m3 f,
float_status *s)
{
float8_e4m3_unpack_raw(p, f);
- parts_canonicalize(p, s, &float8_e4m3_params);
+ parts64_canonicalize(p, s, &float8_e4m3_params);
}
static void float8_e5m2_unpack_canonical(FloatParts64 *p, float8_e5m2 f,
float_status *s)
{
float8_e5m2_unpack_raw(p, f);
- parts_canonicalize(p, s, &float8_e5m2_params);
+ parts64_canonicalize(p, s, &float8_e5m2_params);
}
static void float16a_unpack_canonical(FloatParts64 *p, float16 f,
float_status *s, const FloatFmt *params)
{
float16_unpack_raw(p, f);
- parts_canonicalize(p, s, params);
+ parts64_canonicalize(p, s, params);
}
static void float16_unpack_canonical(FloatParts64 *p, float16 f,
@@ -1757,7 +1749,7 @@ static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f,
float_status *s)
{
bfloat16_unpack_raw(p, f);
- parts_canonicalize(p, s, &bfloat16_params);
+ parts64_canonicalize(p, s, &bfloat16_params);
}
static float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p,
@@ -1801,7 +1793,7 @@ static void float32_unpack_canonical(FloatParts64 *p, float32 f,
float_status *s)
{
float32_unpack_raw(p, f);
- parts_canonicalize(p, s, &float32_params);
+ parts64_canonicalize(p, s, &float32_params);
}
static float32 float32_round_pack_canonical(FloatParts64 *p,
@@ -1815,7 +1807,7 @@ static void float64_unpack_canonical(FloatParts64 *p, float64 f,
float_status *s)
{
float64_unpack_raw(p, f);
- parts_canonicalize(p, s, &float64_params);
+ parts64_canonicalize(p, s, &float64_params);
}
static float64 float64_round_pack_canonical(FloatParts64 *p,
@@ -1878,7 +1870,7 @@ static void float128_unpack_canonical(FloatParts128 *p, float128 f,
float_status *s)
{
float128_unpack_raw(p, f);
- parts_canonicalize(p, s, &float128_params);
+ parts128_canonicalize(p, s, &float128_params);
}
static float128 float128_round_pack_canonical(FloatParts128 *p,
@@ -1910,7 +1902,7 @@ static bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f,
floatx80_unpack_raw(p, f);
if (likely(p->exp != floatx80_params[floatx80_precision_x].exp_max)) {
- parts_canonicalize(p, s, &floatx80_params[floatx80_precision_x]);
+ parts128_canonicalize(p, s, &floatx80_params[floatx80_precision_x]);
} else {
/* The explicit integer bit is ignored, after invalid checks. */
p->frac_hi &= MAKE_64BIT_MASK(0, 63);
@@ -5611,7 +5603,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
parts_uncanon(r, status, fmt, false);
r_flags = status->float_exception_flags;
r->frac &= (1ULL << fmt->frac_size) - 1;
- parts_canonicalize(r, status, fmt);
+ parts64_canonicalize(r, status, fmt);
/* POp table "Results: DIVIDE TO INTEGER (Part 2 of 2)" */
if (is_q_smallish) {
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 02/48] fpu: Drop parts_uncanon
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
2026-04-29 22:23 ` [PULL 01/48] fpu: Drop parts_canonicalize Richard Henderson
@ 2026-04-29 22:23 ` Richard Henderson
2026-04-29 22:24 ` [PULL 03/48] fpu: Drop parts_uncanon_normal Richard Henderson
` (46 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:23 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_uncanon at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 44 ++++++++++++++++++--------------------------
1 file changed, 18 insertions(+), 26 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index f9997f5236..7c13a7848e 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -814,14 +814,6 @@ static void parts128_uncanon_normal(FloatParts128 *p, float_status *status,
#define parts_uncanon_normal(A, S, F, X) \
PARTS_GENERIC_64_128(uncanon_normal, A)(A, S, F, X)
-static void parts64_uncanon(FloatParts64 *p, float_status *status,
- const FloatFmt *fmt, bool saturate);
-static void parts128_uncanon(FloatParts128 *p, float_status *status,
- const FloatFmt *fmt, bool saturate);
-
-#define parts_uncanon(A, S, F, X) \
- PARTS_GENERIC_64_128(uncanon, A)(A, S, F, X)
-
static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b);
static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b);
static void parts256_add_normal(FloatParts256 *a, FloatParts256 *b);
@@ -1756,7 +1748,7 @@ static float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p,
float_status *s,
bool saturate)
{
- parts_uncanon(p, s, &float8_e4m3_params, saturate);
+ parts64_uncanon(p, s, &float8_e4m3_params, saturate);
return float8_e4m3_pack_raw(p);
}
@@ -1764,7 +1756,7 @@ static float8_e5m2 float8_e5m2_round_pack_canonical(FloatParts64 *p,
float_status *s,
bool saturate)
{
- parts_uncanon(p, s, &float8_e5m2_params, saturate);
+ parts64_uncanon(p, s, &float8_e5m2_params, saturate);
return float8_e5m2_pack_raw(p);
}
@@ -1772,7 +1764,7 @@ static float16 float16a_round_pack_canonical(FloatParts64 *p,
float_status *s,
const FloatFmt *params)
{
- parts_uncanon(p, s, params, false);
+ parts64_uncanon(p, s, params, false);
return float16_pack_raw(p);
}
@@ -1785,7 +1777,7 @@ static float16 float16_round_pack_canonical(FloatParts64 *p,
static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p,
float_status *s)
{
- parts_uncanon(p, s, &bfloat16_params, false);
+ parts64_uncanon(p, s, &bfloat16_params, false);
return bfloat16_pack_raw(p);
}
@@ -1799,7 +1791,7 @@ static void float32_unpack_canonical(FloatParts64 *p, float32 f,
static float32 float32_round_pack_canonical(FloatParts64 *p,
float_status *s)
{
- parts_uncanon(p, s, &float32_params, false);
+ parts64_uncanon(p, s, &float32_params, false);
return float32_pack_raw(p);
}
@@ -1813,14 +1805,14 @@ static void float64_unpack_canonical(FloatParts64 *p, float64 f,
static float64 float64_round_pack_canonical(FloatParts64 *p,
float_status *s)
{
- parts_uncanon(p, s, &float64_params, false);
+ parts64_uncanon(p, s, &float64_params, false);
return float64_pack_raw(p);
}
static float64 float64r32_pack_raw(FloatParts64 *p)
{
/*
- * In parts_uncanon, we placed the fraction for float32 at the lsb.
+ * In parts64_uncanon, we placed the fraction for float32 at the lsb.
* We need to adjust the fraction higher so that the least N bits are
* zero, and the fraction is adjacent to the float64 implicit bit.
*/
@@ -1862,7 +1854,7 @@ static float64 float64r32_pack_raw(FloatParts64 *p)
static float64 float64r32_round_pack_canonical(FloatParts64 *p,
float_status *s)
{
- parts_uncanon(p, s, &float32_params, false);
+ parts64_uncanon(p, s, &float32_params, false);
return float64r32_pack_raw(p);
}
@@ -1876,7 +1868,7 @@ static void float128_unpack_canonical(FloatParts128 *p, float128 f,
static float128 float128_round_pack_canonical(FloatParts128 *p,
float_status *s)
{
- parts_uncanon(p, s, &float128_params, false);
+ parts128_uncanon(p, s, &float128_params, false);
return float128_pack_raw(p);
}
@@ -1924,7 +1916,7 @@ static floatx80 floatx80_round_pack_canonical(FloatParts128 *p,
case float_class_normal:
case float_class_denormal:
if (s->floatx80_rounding_precision == floatx80_precision_x) {
- parts_uncanon_normal(p, s, fmt, false);
+ parts128_uncanon_normal(p, s, fmt, false);
frac = p->frac_hi;
exp = p->exp;
} else {
@@ -1933,7 +1925,7 @@ static floatx80 floatx80_round_pack_canonical(FloatParts128 *p,
p64.sign = p->sign;
p64.exp = p->exp;
frac_truncjam(&p64, p);
- parts_uncanon_normal(&p64, s, fmt, false);
+ parts64_uncanon_normal(&p64, s, fmt, false);
frac = p64.frac;
exp = p64.exp;
}
@@ -2331,7 +2323,7 @@ float16_muladd_scalbn(float16 a, float16 b, float16 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &float16_params, false);
+ parts64_uncanon(pr, status, &float16_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -2356,7 +2348,7 @@ float32_muladd_scalbn(float32 a, float32 b, float32 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &float32_params, false);
+ parts64_uncanon(pr, status, &float32_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -2375,7 +2367,7 @@ float64_muladd_scalbn(float64 a, float64 b, float64 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &float64_params, false);
+ parts64_uncanon(pr, status, &float64_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -2534,7 +2526,7 @@ float64 float64r32_muladd(float64 a, float64 b, float64 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &float32_params, false);
+ parts64_uncanon(pr, status, &float32_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -2552,7 +2544,7 @@ bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &bfloat16_params, false);
+ parts64_uncanon(pr, status, &bfloat16_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -2570,7 +2562,7 @@ float128 QEMU_FLATTEN float128_muladd(float128 a, float128 b, float128 c,
pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
- parts_uncanon(pr, status, &float128_params, false);
+ parts128_uncanon(pr, status, &float128_params, false);
if ((flags & float_muladd_negate_result) && !is_nan(pr->cls)) {
pr->sign ^= 1;
}
@@ -5600,7 +5592,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
/* Round remainder to the target format */
*r = *r_precise;
status->float_exception_flags = 0;
- parts_uncanon(r, status, fmt, false);
+ parts64_uncanon(r, status, fmt, false);
r_flags = status->float_exception_flags;
r->frac &= (1ULL << fmt->frac_size) - 1;
parts64_canonicalize(r, status, fmt);
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 03/48] fpu: Drop parts_uncanon_normal
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
2026-04-29 22:23 ` [PULL 01/48] fpu: Drop parts_canonicalize Richard Henderson
2026-04-29 22:23 ` [PULL 02/48] fpu: Drop parts_uncanon Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 04/48] fpu: Drop parts_default_nan Richard Henderson
` (45 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use partsN(uncanon_normal) at the single call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 8 --------
fpu/softfloat-parts.c.inc | 2 +-
2 files changed, 1 insertion(+), 9 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 7c13a7848e..4876a8bb27 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -806,14 +806,6 @@ static FloatParts128 *parts128_pick_nan_muladd(FloatParts128 *a,
#define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \
PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM)
-static void parts64_uncanon_normal(FloatParts64 *p, float_status *status,
- const FloatFmt *fmt, bool saturate);
-static void parts128_uncanon_normal(FloatParts128 *p, float_status *status,
- const FloatFmt *fmt, bool saturate);
-
-#define parts_uncanon_normal(A, S, F, X) \
- PARTS_GENERIC_64_128(uncanon_normal, A)(A, S, F, X)
-
static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b);
static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b);
static void parts256_add_normal(FloatParts256 *a, FloatParts256 *b);
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 3c323c0cec..948eb7bd6a 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -482,7 +482,7 @@ static void partsN(uncanon)(FloatPartsN *p, float_status *s,
const FloatFmt *fmt, bool saturate)
{
if (likely(is_anynorm(p->cls))) {
- parts_uncanon_normal(p, s, fmt, saturate);
+ partsN(uncanon_normal)(p, s, fmt, saturate);
} else {
switch (p->cls) {
case float_class_zero:
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 04/48] fpu: Drop parts_default_nan
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (2 preceding siblings ...)
2026-04-29 22:24 ` [PULL 03/48] fpu: Drop parts_uncanon_normal Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 05/48] fpu: Drop parts_silence_nan Richard Henderson
` (44 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_default_nan at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 23 +++++++++++------------
fpu/softfloat-parts.c.inc | 24 ++++++++++++------------
2 files changed, 23 insertions(+), 24 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 4876a8bb27..76c1d4e38a 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,7 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-#define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P, S)
#define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P, S)
static void parts64_return_nan(FloatParts64 *a, float_status *s);
@@ -3156,7 +3155,7 @@ float32 floatx80_to_float32(floatx80 a, float_status *s)
if (floatx80_unpack_canonical(&p128, a, s)) {
parts_float_to_float_narrow(&p64, &p128, s);
} else {
- parts_default_nan(&p64, s);
+ parts64_default_nan(&p64, s);
}
return float32_round_pack_canonical(&p64, s);
}
@@ -3169,7 +3168,7 @@ float64 floatx80_to_float64(floatx80 a, float_status *s)
if (floatx80_unpack_canonical(&p128, a, s)) {
parts_float_to_float_narrow(&p64, &p128, s);
} else {
- parts_default_nan(&p64, s);
+ parts64_default_nan(&p64, s);
}
return float64_round_pack_canonical(&p64, s);
}
@@ -3181,7 +3180,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
if (floatx80_unpack_canonical(&p, a, s)) {
parts_float_to_float(&p, s);
} else {
- parts_default_nan(&p, s);
+ parts128_default_nan(&p, s);
}
return float128_round_pack_canonical(&p, s);
}
@@ -3486,7 +3485,7 @@ static int32_t floatx80_to_int32_scalbn(floatx80 a, FloatRoundMode rmode,
FloatParts128 p;
if (!floatx80_unpack_canonical(&p, a, s)) {
- parts_default_nan(&p, s);
+ parts128_default_nan(&p, s);
}
return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
@@ -3497,7 +3496,7 @@ static int64_t floatx80_to_int64_scalbn(floatx80 a, FloatRoundMode rmode,
FloatParts128 p;
if (!floatx80_unpack_canonical(&p, a, s)) {
- parts_default_nan(&p, s);
+ parts128_default_nan(&p, s);
}
return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
@@ -4984,7 +4983,7 @@ float16 float16_default_nan(float_status *status)
{
FloatParts64 p;
- parts_default_nan(&p, status);
+ parts64_default_nan(&p, status);
p.frac >>= float16_params.frac_shift;
return float16_pack_raw(&p);
}
@@ -4993,7 +4992,7 @@ float32 float32_default_nan(float_status *status)
{
FloatParts64 p;
- parts_default_nan(&p, status);
+ parts64_default_nan(&p, status);
p.frac >>= float32_params.frac_shift;
return float32_pack_raw(&p);
}
@@ -5002,7 +5001,7 @@ float64 float64_default_nan(float_status *status)
{
FloatParts64 p;
- parts_default_nan(&p, status);
+ parts64_default_nan(&p, status);
p.frac >>= float64_params.frac_shift;
return float64_pack_raw(&p);
}
@@ -5011,7 +5010,7 @@ float128 float128_default_nan(float_status *status)
{
FloatParts128 p;
- parts_default_nan(&p, status);
+ parts128_default_nan(&p, status);
frac_shr(&p, float128_params.frac_shift);
return float128_pack_raw(&p);
}
@@ -5020,7 +5019,7 @@ bfloat16 bfloat16_default_nan(float_status *status)
{
FloatParts64 p;
- parts_default_nan(&p, status);
+ parts64_default_nan(&p, status);
p.frac >>= bfloat16_params.frac_shift;
return bfloat16_pack_raw(&p);
}
@@ -5537,7 +5536,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
*n = *r;
*cc = 1;
} else if (a->cls == float_class_inf || b->cls == float_class_zero) {
- parts_default_nan(r, status);
+ parts64_default_nan(r, status);
*n = *r;
*cc = 1;
status->float_exception_flags |= float_flag_invalid;
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 948eb7bd6a..37ce731101 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -21,14 +21,14 @@ static void partsN(return_nan)(FloatPartsN *a, float_status *s)
case float_class_snan:
float_raise(float_flag_invalid | float_flag_invalid_snan, s);
if (s->default_nan_mode) {
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
} else {
parts_silence_nan(a, s);
}
break;
case float_class_qnan:
if (s->default_nan_mode) {
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
}
break;
default:
@@ -49,7 +49,7 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b,
}
if (s->default_nan_mode) {
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -184,7 +184,7 @@ static FloatPartsN *partsN(pick_nan_muladd)(FloatPartsN *a, FloatPartsN *b,
return ret;
default_nan:
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -281,7 +281,7 @@ static void partsN(uncanon_e4m3_overflow)(FloatPartsN *p, float_status *s,
p->exp = fmt->exp_max;
p->frac_hi = E4M3_NORMAL_FRAC_MAX;
} else {
- parts_default_nan(p, s);
+ partsN(default_nan)(p, s);
}
}
@@ -568,7 +568,7 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b,
}
/* Inf - Inf */
float_raise(float_flag_invalid | float_flag_invalid_isi, s);
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
} else {
@@ -641,7 +641,7 @@ static FloatPartsN *partsN(mul)(FloatPartsN *a, FloatPartsN *b,
/* Inf * Zero == NaN */
if (unlikely(ab_mask == float_cmask_infzero)) {
float_raise(float_flag_invalid | float_flag_invalid_imz, s);
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -796,7 +796,7 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
goto finish_sign;
d_nan:
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -864,7 +864,7 @@ static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,
return a;
d_nan:
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -896,7 +896,7 @@ static FloatPartsN *partsN(modrem)(FloatPartsN *a, FloatPartsN *b,
/* Inf % N; N % 0 */
if (a->cls == float_class_inf || b->cls == float_class_zero) {
float_raise(float_flag_invalid, s);
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
return a;
}
@@ -1118,7 +1118,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
d_nan:
float_raise(float_flag_invalid | float_flag_invalid_sqrt, status);
- parts_default_nan(a, status);
+ partsN(default_nan)(a, status);
}
/*
@@ -1879,5 +1879,5 @@ static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)
d_nan:
float_raise(float_flag_invalid, s);
- parts_default_nan(a, s);
+ partsN(default_nan)(a, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 05/48] fpu: Drop parts_silence_nan
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (3 preceding siblings ...)
2026-04-29 22:24 ` [PULL 04/48] fpu: Drop parts_default_nan Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 06/48] fpu: Drop parts_return_nan Richard Henderson
` (43 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_silence_nan at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 12 +++++-------
fpu/softfloat-parts.c.inc | 6 +++---
2 files changed, 8 insertions(+), 10 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 76c1d4e38a..571b5f09f3 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,8 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-#define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P, S)
-
static void parts64_return_nan(FloatParts64 *a, float_status *s);
static void parts128_return_nan(FloatParts128 *a, float_status *s);
@@ -5034,7 +5032,7 @@ float16 float16_silence_nan(float16 a, float_status *status)
float16_unpack_raw(&p, a);
p.frac <<= float16_params.frac_shift;
- parts_silence_nan(&p, status);
+ parts64_silence_nan(&p, status);
p.frac >>= float16_params.frac_shift;
return float16_pack_raw(&p);
}
@@ -5045,7 +5043,7 @@ float32 float32_silence_nan(float32 a, float_status *status)
float32_unpack_raw(&p, a);
p.frac <<= float32_params.frac_shift;
- parts_silence_nan(&p, status);
+ parts64_silence_nan(&p, status);
p.frac >>= float32_params.frac_shift;
return float32_pack_raw(&p);
}
@@ -5056,7 +5054,7 @@ float64 float64_silence_nan(float64 a, float_status *status)
float64_unpack_raw(&p, a);
p.frac <<= float64_params.frac_shift;
- parts_silence_nan(&p, status);
+ parts64_silence_nan(&p, status);
p.frac >>= float64_params.frac_shift;
return float64_pack_raw(&p);
}
@@ -5067,7 +5065,7 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status)
bfloat16_unpack_raw(&p, a);
p.frac <<= bfloat16_params.frac_shift;
- parts_silence_nan(&p, status);
+ parts64_silence_nan(&p, status);
p.frac >>= bfloat16_params.frac_shift;
return bfloat16_pack_raw(&p);
}
@@ -5078,7 +5076,7 @@ float128 float128_silence_nan(float128 a, float_status *status)
float128_unpack_raw(&p, a);
frac_shl(&p, float128_params.frac_shift);
- parts_silence_nan(&p, status);
+ parts128_silence_nan(&p, status);
frac_shr(&p, float128_params.frac_shift);
return float128_pack_raw(&p);
}
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 37ce731101..0d4a63fbff 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -23,7 +23,7 @@ static void partsN(return_nan)(FloatPartsN *a, float_status *s)
if (s->default_nan_mode) {
partsN(default_nan)(a, s);
} else {
- parts_silence_nan(a, s);
+ partsN(silence_nan)(a, s);
}
break;
case float_class_qnan:
@@ -109,7 +109,7 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b,
}
if (is_snan(ret->cls)) {
- parts_silence_nan(ret, s);
+ partsN(silence_nan)(ret, s);
}
return ret;
}
@@ -179,7 +179,7 @@ static FloatPartsN *partsN(pick_nan_muladd)(FloatPartsN *a, FloatPartsN *b,
}
if (is_snan(ret->cls)) {
- parts_silence_nan(ret, s);
+ partsN(silence_nan)(ret, s);
}
return ret;
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 06/48] fpu: Drop parts_return_nan
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (4 preceding siblings ...)
2026-04-29 22:24 ` [PULL 05/48] fpu: Drop parts_silence_nan Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 07/48] fpu: Drop parts_pick_nan Richard Henderson
` (42 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_return_nan at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 ++++++-----------
fpu/softfloat-parts.c.inc | 8 ++++----
2 files changed, 10 insertions(+), 15 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 571b5f09f3..50a625fd0a 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,11 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_return_nan(FloatParts64 *a, float_status *s);
-static void parts128_return_nan(FloatParts128 *a, float_status *s);
-
-#define parts_return_nan(P, S) PARTS_GENERIC_64_128(return_nan, P)(P, S)
-
static FloatParts64 *parts64_pick_nan(FloatParts64 *a, FloatParts64 *b,
float_status *s);
static FloatParts128 *parts128_pick_nan(FloatParts128 *a, FloatParts128 *b,
@@ -2831,7 +2826,7 @@ static void parts_float_to_e5m2(FloatParts64 *a, float_status *s, bool saturate)
switch (a->cls) {
case float_class_snan:
case float_class_qnan:
- parts_return_nan(a, s);
+ parts64_return_nan(a, s);
break;
case float_class_inf:
@@ -2858,7 +2853,7 @@ static void parts_float_to_e5m2(FloatParts64 *a, float_status *s, bool saturate)
static void parts64_float_to_float(FloatParts64 *a, float_status *s)
{
if (is_nan(a->cls)) {
- parts_return_nan(a, s);
+ parts64_return_nan(a, s);
}
if (a->cls == float_class_denormal) {
float_raise(float_flag_input_denormal_used, s);
@@ -2868,7 +2863,7 @@ static void parts64_float_to_float(FloatParts64 *a, float_status *s)
static void parts128_float_to_float(FloatParts128 *a, float_status *s)
{
if (is_nan(a->cls)) {
- parts_return_nan(a, s);
+ parts128_return_nan(a, s);
}
if (a->cls == float_class_denormal) {
float_raise(float_flag_input_denormal_used, s);
@@ -2896,7 +2891,7 @@ static void parts_float_to_float_narrow(FloatParts64 *a, FloatParts128 *b,
case float_class_qnan:
/* Discard the low bits of the NaN. */
a->frac = b->frac_hi;
- parts_return_nan(a, s);
+ parts64_return_nan(a, s);
break;
default:
break;
@@ -2912,7 +2907,7 @@ static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b,
frac_widen(a, b);
if (is_nan(a->cls)) {
- parts_return_nan(a, s);
+ parts128_return_nan(a, s);
}
if (a->cls == float_class_denormal) {
float_raise(float_flag_input_denormal_used, s);
@@ -5474,7 +5469,7 @@ float32 float32_exp2(float32 a, float_status *status)
break;
case float_class_snan:
case float_class_qnan:
- parts_return_nan(&xp, status);
+ parts64_return_nan(&xp, status);
return float32_round_pack_canonical(&xp, status);
case float_class_inf:
return xp.sign ? float32_zero : a;
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 0d4a63fbff..3bde254bfe 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -941,7 +941,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
break;
case float_class_snan:
case float_class_qnan:
- parts_return_nan(a, status);
+ partsN(return_nan)(a, status);
return;
case float_class_zero:
return;
@@ -1263,7 +1263,7 @@ static void partsN(round_to_int)(FloatPartsN *a, FloatRoundMode rmode,
switch (a->cls) {
case float_class_qnan:
case float_class_snan:
- parts_return_nan(a, s);
+ partsN(return_nan)(a, s);
break;
case float_class_zero:
case float_class_inf:
@@ -1735,7 +1735,7 @@ static void partsN(scalbn)(FloatPartsN *a, int n, float_status *s)
switch (a->cls) {
case float_class_snan:
case float_class_qnan:
- parts_return_nan(a, s);
+ partsN(return_nan)(a, s);
break;
case float_class_zero:
case float_class_inf:
@@ -1770,7 +1770,7 @@ static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)
break;
case float_class_snan:
case float_class_qnan:
- parts_return_nan(a, s);
+ partsN(return_nan)(a, s);
return;
case float_class_zero:
float_raise(float_flag_divbyzero, s);
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 07/48] fpu: Drop parts_pick_nan
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (5 preceding siblings ...)
2026-04-29 22:24 ` [PULL 06/48] fpu: Drop parts_return_nan Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 08/48] fpu: Drop parts_pick_nan_muladd Richard Henderson
` (41 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_pick_nan at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 11 ++---------
fpu/softfloat-parts.c.inc | 10 +++++-----
2 files changed, 7 insertions(+), 14 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 50a625fd0a..98ddc00936 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,13 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_pick_nan(FloatParts64 *a, FloatParts64 *b,
- float_status *s);
-static FloatParts128 *parts128_pick_nan(FloatParts128 *a, FloatParts128 *b,
- float_status *s);
-
-#define parts_pick_nan(A, B, S) PARTS_GENERIC_64_128(pick_nan, A)(A, B, S)
-
static FloatParts64 *parts64_pick_nan_muladd(FloatParts64 *a, FloatParts64 *b,
FloatParts64 *c, float_status *s,
int ab_mask, int abc_mask);
@@ -5175,7 +5168,7 @@ floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b, float_status *status)
return floatx80_default_nan(status);
}
- pr = parts_pick_nan(&pa, &pb, status);
+ pr = parts128_pick_nan(&pa, &pb, status);
return floatx80_round_pack_canonical(pr, status);
}
@@ -5525,7 +5518,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
{
/* POp table "Results: DIVIDE TO INTEGER (Part 1 of 2)" */
if ((float_cmask(a->cls) | float_cmask(b->cls)) & float_cmask_anynan) {
- *r = *parts_pick_nan(a, b, status);
+ *r = *parts64_pick_nan(a, b, status);
*n = *r;
*cc = 1;
} else if (a->cls == float_class_inf || b->cls == float_class_zero) {
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 3bde254bfe..1a2eb7852d 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -604,7 +604,7 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b,
return b;
p_nan:
- return parts_pick_nan(a, b, s);
+ return partsN(pick_nan)(a, b, s);
}
/*
@@ -646,7 +646,7 @@ static FloatPartsN *partsN(mul)(FloatPartsN *a, FloatPartsN *b,
}
if (unlikely(ab_mask & float_cmask_anynan)) {
- return parts_pick_nan(a, b, s);
+ return partsN(pick_nan)(a, b, s);
}
/* Multiply by 0 or Inf */
@@ -832,7 +832,7 @@ static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,
/* All the NaN cases */
if (unlikely(ab_mask & float_cmask_anynan)) {
- return parts_pick_nan(a, b, s);
+ return partsN(pick_nan)(a, b, s);
}
if ((ab_mask & float_cmask_denormal) && b->cls != float_class_zero) {
@@ -890,7 +890,7 @@ static FloatPartsN *partsN(modrem)(FloatPartsN *a, FloatPartsN *b,
/* All the NaN cases */
if (unlikely(ab_mask & float_cmask_anynan)) {
- return parts_pick_nan(a, b, s);
+ return partsN(pick_nan)(a, b, s);
}
/* Inf % N; N % 0 */
@@ -1592,7 +1592,7 @@ static FloatPartsN *partsN(minmax)(FloatPartsN *a, FloatPartsN *b,
return is_nan(a->cls) ? b : a;
}
- return parts_pick_nan(a, b, s);
+ return partsN(pick_nan)(a, b, s);
}
if (ab_mask & float_cmask_denormal) {
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 08/48] fpu: Drop parts_pick_nan_muladd
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (6 preceding siblings ...)
2026-04-29 22:24 ` [PULL 07/48] fpu: Drop parts_pick_nan Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 09/48] fpu: Reverse the order of softfloat-parts* inclusions Richard Henderson
` (40 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use partsN() at the only call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 12 ------------
fpu/softfloat-parts.c.inc | 2 +-
2 files changed, 1 insertion(+), 13 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 98ddc00936..e5d8b9573a 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,18 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_pick_nan_muladd(FloatParts64 *a, FloatParts64 *b,
- FloatParts64 *c, float_status *s,
- int ab_mask, int abc_mask);
-static FloatParts128 *parts128_pick_nan_muladd(FloatParts128 *a,
- FloatParts128 *b,
- FloatParts128 *c,
- float_status *s,
- int ab_mask, int abc_mask);
-
-#define parts_pick_nan_muladd(A, B, C, S, ABM, ABCM) \
- PARTS_GENERIC_64_128(pick_nan_muladd, A)(A, B, C, S, ABM, ABCM)
-
static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b);
static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b);
static void parts256_add_normal(FloatParts256 *a, FloatParts256 *b);
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 1a2eb7852d..e1ce2be924 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -696,7 +696,7 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
* off to the target-specific pick-a-NaN routine.
*/
if (unlikely(abc_mask & float_cmask_anynan)) {
- return parts_pick_nan_muladd(a, b, c, s, ab_mask, abc_mask);
+ return partsN(pick_nan_muladd)(a, b, c, s, ab_mask, abc_mask);
}
if (flags & float_muladd_negate_c) {
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 09/48] fpu: Reverse the order of softfloat-parts* inclusions
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (7 preceding siblings ...)
2026-04-29 22:24 ` [PULL 08/48] fpu: Drop parts_pick_nan_muladd Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 10/48] fpu: Drop parts_{add,sub}_normal Richard Henderson
` (39 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Define the widest addition primitives first, so that
they're already defined before being used by the
narrower muladd primitive.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index e5d8b9573a..aa96ac530d 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1638,14 +1638,11 @@ static const uint16_t rsqrt_tab[128] = {
#define FloatPartsN glue(FloatParts,N)
#define FloatPartsW glue(FloatParts,W)
-#define N 64
-#define W 128
+#define N 256
#include "softfloat-parts-addsub.c.inc"
-#include "softfloat-parts.c.inc"
#undef N
-#undef W
#define N 128
#define W 256
@@ -1654,9 +1651,11 @@ static const uint16_t rsqrt_tab[128] = {
#undef N
#undef W
-#define N 256
+#define N 64
+#define W 128
#include "softfloat-parts-addsub.c.inc"
+#include "softfloat-parts.c.inc"
#undef N
#undef W
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 10/48] fpu: Drop parts_{add,sub}_normal
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (8 preceding siblings ...)
2026-04-29 22:24 ` [PULL 09/48] fpu: Reverse the order of softfloat-parts* inclusions Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 11/48] fpu: Drop parts_addsub Richard Henderson
` (38 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Drop the forward declarations and the _Generic macros.
Add partsW() for use by muladd_scalbn.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 16 ++--------------
fpu/softfloat-parts.c.inc | 12 ++++++------
2 files changed, 8 insertions(+), 20 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index aa96ac530d..117c335d66 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,20 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_add_normal(FloatParts64 *a, FloatParts64 *b);
-static void parts128_add_normal(FloatParts128 *a, FloatParts128 *b);
-static void parts256_add_normal(FloatParts256 *a, FloatParts256 *b);
-
-#define parts_add_normal(A, B) \
- PARTS_GENERIC_64_128_256(add_normal, A)(A, B)
-
-static bool parts64_sub_normal(FloatParts64 *a, FloatParts64 *b);
-static bool parts128_sub_normal(FloatParts128 *a, FloatParts128 *b);
-static bool parts256_sub_normal(FloatParts256 *a, FloatParts256 *b);
-
-#define parts_sub_normal(A, B) \
- PARTS_GENERIC_64_128_256(sub_normal, A)(A, B)
-
static FloatParts64 *parts64_addsub(FloatParts64 *a, FloatParts64 *b,
float_status *s, bool subtract);
static FloatParts128 *parts128_addsub(FloatParts128 *a, FloatParts128 *b,
@@ -1635,6 +1621,7 @@ static const uint16_t rsqrt_tab[128] = {
};
#define partsN(NAME) glue(glue(glue(parts,N),_),NAME)
+#define partsW(NAME) glue(glue(glue(parts,W),_),NAME)
#define FloatPartsN glue(FloatParts,N)
#define FloatPartsW glue(FloatParts,W)
@@ -1660,6 +1647,7 @@ static const uint16_t rsqrt_tab[128] = {
#undef N
#undef W
#undef partsN
+#undef partsW
#undef FloatPartsN
#undef FloatPartsW
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index e1ce2be924..6e1800b117 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -541,7 +541,7 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b,
if (a->sign != b_sign) {
/* Subtraction */
if (likely(cmask_is_only_normals(ab_mask))) {
- if (parts_sub_normal(a, b)) {
+ if (partsN(sub_normal)(a, b)) {
return a;
}
/* Subtract was exact, fall through to set sign. */
@@ -574,7 +574,7 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b,
} else {
/* Addition */
if (likely(cmask_is_only_normals(ab_mask))) {
- parts_add_normal(a, b);
+ partsN(add_normal)(a, b);
return a;
}
@@ -760,8 +760,8 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
c_widen.exp = c->exp;
if (a->sign == c->sign) {
- parts_add_normal(&p_widen, &c_widen);
- } else if (!parts_sub_normal(&p_widen, &c_widen)) {
+ partsW(add_normal)(&p_widen, &c_widen);
+ } else if (!partsW(sub_normal)(&p_widen, &c_widen)) {
goto return_sub_zero;
}
}
@@ -1869,9 +1869,9 @@ static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)
f.exp = f_exp - frac_normalize(&f);
if (a_exp < 0) {
- parts_sub_normal(a, &f);
+ partsN(sub_normal)(a, &f);
} else if (a_exp > 0) {
- parts_add_normal(a, &f);
+ partsN(add_normal)(a, &f);
} else {
*a = f;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 11/48] fpu: Drop parts_addsub
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (9 preceding siblings ...)
2026-04-29 22:24 ` [PULL 10/48] fpu: Drop parts_{add,sub}_normal Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 12/48] fpu: Drop parts_mul Richard Henderson
` (37 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_addsub at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 22 +++++++---------------
1 file changed, 7 insertions(+), 15 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 117c335d66..dc5ce53105 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_addsub(FloatParts64 *a, FloatParts64 *b,
- float_status *s, bool subtract);
-static FloatParts128 *parts128_addsub(FloatParts128 *a, FloatParts128 *b,
- float_status *s, bool subtract);
-
-#define parts_addsub(A, B, S, Z) \
- PARTS_GENERIC_64_128(addsub, A)(A, B, S, Z)
-
static FloatParts64 *parts64_mul(FloatParts64 *a, FloatParts64 *b,
float_status *s);
static FloatParts128 *parts128_mul(FloatParts128 *a, FloatParts128 *b,
@@ -1923,7 +1915,7 @@ float16_addsub(float16 a, float16 b, float_status *status, bool subtract)
float16_unpack_canonical(&pa, a, status);
float16_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts64_addsub(&pa, &pb, status, subtract);
return float16_round_pack_canonical(pr, status);
}
@@ -1945,7 +1937,7 @@ soft_f32_addsub(float32 a, float32 b, float_status *status, bool subtract)
float32_unpack_canonical(&pa, a, status);
float32_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts64_addsub(&pa, &pb, status, subtract);
return float32_round_pack_canonical(pr, status);
}
@@ -1967,7 +1959,7 @@ soft_f64_addsub(float64 a, float64 b, float_status *status, bool subtract)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts64_addsub(&pa, &pb, status, subtract);
return float64_round_pack_canonical(pr, status);
}
@@ -2064,7 +2056,7 @@ static float64 float64r32_addsub(float64 a, float64 b, float_status *status,
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts64_addsub(&pa, &pb, status, subtract);
return float64r32_round_pack_canonical(pr, status);
}
@@ -2086,7 +2078,7 @@ bfloat16_addsub(bfloat16 a, bfloat16 b, float_status *status, bool subtract)
bfloat16_unpack_canonical(&pa, a, status);
bfloat16_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts64_addsub(&pa, &pb, status, subtract);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2108,7 +2100,7 @@ float128_addsub(float128 a, float128 b, float_status *status, bool subtract)
float128_unpack_canonical(&pa, a, status);
float128_unpack_canonical(&pb, b, status);
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts128_addsub(&pa, &pb, status, subtract);
return float128_round_pack_canonical(pr, status);
}
@@ -2133,7 +2125,7 @@ floatx80_addsub(floatx80 a, floatx80 b, float_status *status, bool subtract)
return floatx80_default_nan(status);
}
- pr = parts_addsub(&pa, &pb, status, subtract);
+ pr = parts128_addsub(&pa, &pb, status, subtract);
return floatx80_round_pack_canonical(pr, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 12/48] fpu: Drop parts_mul
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (10 preceding siblings ...)
2026-04-29 22:24 ` [PULL 11/48] fpu: Drop parts_addsub Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 13/48] fpu: Drop parts_muladd_scalbn Richard Henderson
` (36 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_mul at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 26 +++++++++-----------------
1 file changed, 9 insertions(+), 17 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index dc5ce53105..8adc73c863 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_mul(FloatParts64 *a, FloatParts64 *b,
- float_status *s);
-static FloatParts128 *parts128_mul(FloatParts128 *a, FloatParts128 *b,
- float_status *s);
-
-#define parts_mul(A, B, S) \
- PARTS_GENERIC_64_128(mul, A)(A, B, S)
-
static FloatParts64 *parts64_muladd_scalbn(FloatParts64 *a, FloatParts64 *b,
FloatParts64 *c, int scale,
int flags, float_status *s);
@@ -2149,7 +2141,7 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *status)
float16_unpack_canonical(&pa, a, status);
float16_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts64_mul(&pa, &pb, status);
return float16_round_pack_canonical(pr, status);
}
@@ -2161,7 +2153,7 @@ soft_f32_mul(float32 a, float32 b, float_status *status)
float32_unpack_canonical(&pa, a, status);
float32_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts64_mul(&pa, &pb, status);
return float32_round_pack_canonical(pr, status);
}
@@ -2173,7 +2165,7 @@ soft_f64_mul(float64 a, float64 b, float_status *status)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts64_mul(&pa, &pb, status);
return float64_round_pack_canonical(pr, status);
}
@@ -2208,7 +2200,7 @@ float64 float64r32_mul(float64 a, float64 b, float_status *status)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts64_mul(&pa, &pb, status);
return float64r32_round_pack_canonical(pr, status);
}
@@ -2220,7 +2212,7 @@ bfloat16_mul(bfloat16 a, bfloat16 b, float_status *status)
bfloat16_unpack_canonical(&pa, a, status);
bfloat16_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts64_mul(&pa, &pb, status);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2232,7 +2224,7 @@ float128_mul(float128 a, float128 b, float_status *status)
float128_unpack_canonical(&pa, a, status);
float128_unpack_canonical(&pb, b, status);
- pr = parts_mul(&pa, &pb, status);
+ pr = parts128_mul(&pa, &pb, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2247,7 +2239,7 @@ floatx80_mul(floatx80 a, floatx80 b, float_status *status)
return floatx80_default_nan(status);
}
- pr = parts_mul(&pa, &pb, status);
+ pr = parts128_mul(&pa, &pb, status);
return floatx80_round_pack_canonical(pr, status);
}
@@ -5443,7 +5435,7 @@ float32 float32_exp2(float32 a, float_status *status)
float_raise(float_flag_inexact, status);
float64_unpack_canonical(&tp, float64_ln2, status);
- xp = *parts_mul(&xp, &tp, status);
+ xp = *parts64_mul(&xp, &tp, status);
xnp = xp;
float64_unpack_canonical(&rp, float64_one, status);
@@ -5451,7 +5443,7 @@ float32 float32_exp2(float32 a, float_status *status)
float64_unpack_canonical(&tp, float32_exp2_coefficients[i], status);
rp = *parts_muladd_scalbn(&tp, &xnp, &rp, 0, 0, status);
- xnp = *parts_mul(&xnp, &xp, status);
+ xnp = *parts64_mul(&xnp, &xp, status);
}
return float32_round_pack_canonical(&rp, status);
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 13/48] fpu: Drop parts_muladd_scalbn
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (11 preceding siblings ...)
2026-04-29 22:24 ` [PULL 12/48] fpu: Drop parts_mul Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 14/48] fpu: Drop parts_div Richard Henderson
` (35 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_muladd_scalbn at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 28 +++++++++-------------------
1 file changed, 9 insertions(+), 19 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 8adc73c863..aa62fea47d 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,16 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_muladd_scalbn(FloatParts64 *a, FloatParts64 *b,
- FloatParts64 *c, int scale,
- int flags, float_status *s);
-static FloatParts128 *parts128_muladd_scalbn(FloatParts128 *a, FloatParts128 *b,
- FloatParts128 *c, int scale,
- int flags, float_status *s);
-
-#define parts_muladd_scalbn(A, B, C, Z, Y, S) \
- PARTS_GENERIC_64_128(muladd_scalbn, A)(A, B, C, Z, Y, S)
-
static FloatParts64 *parts64_div(FloatParts64 *a, FloatParts64 *b,
float_status *s);
static FloatParts128 *parts128_div(FloatParts128 *a, FloatParts128 *b,
@@ -2256,7 +2246,7 @@ float16_muladd_scalbn(float16 a, float16 b, float16 c,
float16_unpack_canonical(&pa, a, status);
float16_unpack_canonical(&pb, b, status);
float16_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float16_params, false);
@@ -2281,7 +2271,7 @@ float32_muladd_scalbn(float32 a, float32 b, float32 c,
float32_unpack_canonical(&pa, a, status);
float32_unpack_canonical(&pb, b, status);
float32_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float32_params, false);
@@ -2300,7 +2290,7 @@ float64_muladd_scalbn(float64 a, float64 b, float64 c,
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
float64_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float64_params, false);
@@ -2459,7 +2449,7 @@ float64 float64r32_muladd(float64 a, float64 b, float64 c,
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
float64_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float32_params, false);
@@ -2477,7 +2467,7 @@ bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c,
bfloat16_unpack_canonical(&pa, a, status);
bfloat16_unpack_canonical(&pb, b, status);
bfloat16_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &bfloat16_params, false);
@@ -2495,7 +2485,7 @@ float128 QEMU_FLATTEN float128_muladd(float128 a, float128 b, float128 c,
float128_unpack_canonical(&pa, a, status);
float128_unpack_canonical(&pb, b, status);
float128_unpack_canonical(&pc, c, status);
- pr = parts_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ pr = parts128_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts128_uncanon(pr, status, &float128_params, false);
@@ -5442,7 +5432,7 @@ float32 float32_exp2(float32 a, float_status *status)
for (i = 0 ; i < 15 ; i++) {
float64_unpack_canonical(&tp, float32_exp2_coefficients[i], status);
- rp = *parts_muladd_scalbn(&tp, &xnp, &rp, 0, 0, status);
+ rp = *parts64_muladd_scalbn(&tp, &xnp, &rp, 0, 0, status);
xnp = *parts64_mul(&xnp, &xp, status);
}
@@ -5522,8 +5512,8 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
/* Compute precise remainder */
r_precise_buf = *b;
- r_precise = parts_muladd_scalbn(&r_precise_buf, n, a, 0,
- float_muladd_negate_product, status);
+ r_precise = parts64_muladd_scalbn(&r_precise_buf, n, a, 0,
+ float_muladd_negate_product, status);
/* Round remainder to the target format */
*r = *r_precise;
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 14/48] fpu: Drop parts_div
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (12 preceding siblings ...)
2026-04-29 22:24 ` [PULL 13/48] fpu: Drop parts_muladd_scalbn Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 15/48] fpu: Drop parts_modrem Richard Henderson
` (34 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_div at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 24 ++++++++----------------
1 file changed, 8 insertions(+), 16 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index aa62fea47d..b885eae629 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_div(FloatParts64 *a, FloatParts64 *b,
- float_status *s);
-static FloatParts128 *parts128_div(FloatParts128 *a, FloatParts128 *b,
- float_status *s);
-
-#define parts_div(A, B, S) \
- PARTS_GENERIC_64_128(div, A)(A, B, S)
-
static FloatParts64 *parts64_modrem(FloatParts64 *a, FloatParts64 *b,
uint64_t *mod_quot, float_status *s);
static FloatParts128 *parts128_modrem(FloatParts128 *a, FloatParts128 *b,
@@ -2505,7 +2497,7 @@ float16 float16_div(float16 a, float16 b, float_status *status)
float16_unpack_canonical(&pa, a, status);
float16_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts64_div(&pa, &pb, status);
return float16_round_pack_canonical(pr, status);
}
@@ -2517,7 +2509,7 @@ soft_f32_div(float32 a, float32 b, float_status *status)
float32_unpack_canonical(&pa, a, status);
float32_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts64_div(&pa, &pb, status);
return float32_round_pack_canonical(pr, status);
}
@@ -2529,7 +2521,7 @@ soft_f64_div(float64 a, float64 b, float_status *status)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts64_div(&pa, &pb, status);
return float64_round_pack_canonical(pr, status);
}
@@ -2598,7 +2590,7 @@ float64 float64r32_div(float64 a, float64 b, float_status *status)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts64_div(&pa, &pb, status);
return float64r32_round_pack_canonical(pr, status);
}
@@ -2610,7 +2602,7 @@ bfloat16_div(bfloat16 a, bfloat16 b, float_status *status)
bfloat16_unpack_canonical(&pa, a, status);
bfloat16_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts64_div(&pa, &pb, status);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2622,7 +2614,7 @@ float128_div(float128 a, float128 b, float_status *status)
float128_unpack_canonical(&pa, a, status);
float128_unpack_canonical(&pb, b, status);
- pr = parts_div(&pa, &pb, status);
+ pr = parts128_div(&pa, &pb, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2636,7 +2628,7 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
return floatx80_default_nan(status);
}
- pr = parts_div(&pa, &pb, status);
+ pr = parts128_div(&pa, &pb, status);
return floatx80_round_pack_canonical(pr, status);
}
@@ -5488,7 +5480,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
/* Compute precise quotient */
q_buf = *a;
- q = parts_div(&q_buf, b, status);
+ q = parts64_div(&q_buf, b, status);
/*
* Check whether two closest integers can be precisely represented,
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 15/48] fpu: Drop parts_modrem
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (13 preceding siblings ...)
2026-04-29 22:24 ` [PULL 14/48] fpu: Drop parts_div Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 16/48] fpu: Drop parts_sqrt Richard Henderson
` (33 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_modrem at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 16 ++++------------
1 file changed, 4 insertions(+), 12 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index b885eae629..91d8e48ce4 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_modrem(FloatParts64 *a, FloatParts64 *b,
- uint64_t *mod_quot, float_status *s);
-static FloatParts128 *parts128_modrem(FloatParts128 *a, FloatParts128 *b,
- uint64_t *mod_quot, float_status *s);
-
-#define parts_modrem(A, B, Q, S) \
- PARTS_GENERIC_64_128(modrem, A)(A, B, Q, S)
-
static void parts64_sqrt(FloatParts64 *a, float_status *s, const FloatFmt *f);
static void parts128_sqrt(FloatParts128 *a, float_status *s, const FloatFmt *f);
@@ -2642,7 +2634,7 @@ float32 float32_rem(float32 a, float32 b, float_status *status)
float32_unpack_canonical(&pa, a, status);
float32_unpack_canonical(&pb, b, status);
- pr = parts_modrem(&pa, &pb, NULL, status);
+ pr = parts64_modrem(&pa, &pb, NULL, status);
return float32_round_pack_canonical(pr, status);
}
@@ -2653,7 +2645,7 @@ float64 float64_rem(float64 a, float64 b, float_status *status)
float64_unpack_canonical(&pa, a, status);
float64_unpack_canonical(&pb, b, status);
- pr = parts_modrem(&pa, &pb, NULL, status);
+ pr = parts64_modrem(&pa, &pb, NULL, status);
return float64_round_pack_canonical(pr, status);
}
@@ -2664,7 +2656,7 @@ float128 float128_rem(float128 a, float128 b, float_status *status)
float128_unpack_canonical(&pa, a, status);
float128_unpack_canonical(&pb, b, status);
- pr = parts_modrem(&pa, &pb, NULL, status);
+ pr = parts128_modrem(&pa, &pb, NULL, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2688,7 +2680,7 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
!floatx80_unpack_canonical(&pb, b, status)) {
return floatx80_default_nan(status);
}
- pr = parts_modrem(&pa, &pb, mod ? quotient : NULL, status);
+ pr = parts128_modrem(&pa, &pb, mod ? quotient : NULL, status);
return floatx80_round_pack_canonical(pr, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 16/48] fpu: Drop parts_sqrt
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (14 preceding siblings ...)
2026-04-29 22:24 ` [PULL 15/48] fpu: Drop parts_modrem Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 17/48] fpu: Drop parts_round_to_int_normal Richard Henderson
` (32 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_sqrt at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 20 +++++++-------------
1 file changed, 7 insertions(+), 13 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 91d8e48ce4..0a6bc6d580 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,12 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_sqrt(FloatParts64 *a, float_status *s, const FloatFmt *f);
-static void parts128_sqrt(FloatParts128 *a, float_status *s, const FloatFmt *f);
-
-#define parts_sqrt(A, S, F) \
- PARTS_GENERIC_64_128(sqrt, A)(A, S, F)
-
static bool parts64_round_to_int_normal(FloatParts64 *a, FloatRoundMode rm,
int scale, int frac_size);
static bool parts128_round_to_int_normal(FloatParts128 *a, FloatRoundMode r,
@@ -4757,7 +4751,7 @@ float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status)
FloatParts64 p;
float16_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &float16_params);
+ parts64_sqrt(&p, status, &float16_params);
return float16_round_pack_canonical(&p, status);
}
@@ -4767,7 +4761,7 @@ soft_f32_sqrt(float32 a, float_status *status)
FloatParts64 p;
float32_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &float32_params);
+ parts64_sqrt(&p, status, &float32_params);
return float32_round_pack_canonical(&p, status);
}
@@ -4777,7 +4771,7 @@ soft_f64_sqrt(float64 a, float_status *status)
FloatParts64 p;
float64_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &float64_params);
+ parts64_sqrt(&p, status, &float64_params);
return float64_round_pack_canonical(&p, status);
}
@@ -4840,7 +4834,7 @@ float64 float64r32_sqrt(float64 a, float_status *status)
FloatParts64 p;
float64_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &float64_params);
+ parts64_sqrt(&p, status, &float64_params);
return float64r32_round_pack_canonical(&p, status);
}
@@ -4849,7 +4843,7 @@ bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float_status *status)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &bfloat16_params);
+ parts64_sqrt(&p, status, &bfloat16_params);
return bfloat16_round_pack_canonical(&p, status);
}
@@ -4858,7 +4852,7 @@ float128 QEMU_FLATTEN float128_sqrt(float128 a, float_status *status)
FloatParts128 p;
float128_unpack_canonical(&p, a, status);
- parts_sqrt(&p, status, &float128_params);
+ parts128_sqrt(&p, status, &float128_params);
return float128_round_pack_canonical(&p, status);
}
@@ -4869,7 +4863,7 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *s)
if (!floatx80_unpack_canonical(&p, a, s)) {
return floatx80_default_nan(s);
}
- parts_sqrt(&p, s, &floatx80_params[s->floatx80_rounding_precision]);
+ parts128_sqrt(&p, s, &floatx80_params[s->floatx80_rounding_precision]);
return floatx80_round_pack_canonical(&p, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 17/48] fpu: Drop parts_round_to_int_normal
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (15 preceding siblings ...)
2026-04-29 22:24 ` [PULL 16/48] fpu: Drop parts_sqrt Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-05-05 8:21 ` Philippe Mathieu-Daudé
2026-04-29 22:24 ` [PULL 18/48] fpu: Drop parts_round_to_int Richard Henderson
` (31 subsequent siblings)
48 siblings, 1 reply; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 22 +++++++---------------
fpu/softfloat-parts.c.inc | 10 +++++-----
2 files changed, 12 insertions(+), 20 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 0a6bc6d580..1f03fcf687 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static bool parts64_round_to_int_normal(FloatParts64 *a, FloatRoundMode rm,
- int scale, int frac_size);
-static bool parts128_round_to_int_normal(FloatParts128 *a, FloatRoundMode r,
- int scale, int frac_size);
-
-#define parts_round_to_int_normal(A, R, C, F) \
- PARTS_GENERIC_64_128(round_to_int_normal, A)(A, R, C, F)
-
static void parts64_round_to_int(FloatParts64 *a, FloatRoundMode rm,
int scale, float_status *s,
const FloatFmt *fmt);
@@ -3365,7 +3357,7 @@ static Int128 float128_to_int128_scalbn(float128 a, FloatRoundMode rmode,
case float_class_normal:
case float_class_denormal:
- if (parts_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
+ if (parts128_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
flags = float_flag_inexact;
}
@@ -3793,7 +3785,7 @@ static Int128 float128_to_uint128_scalbn(float128 a, FloatRoundMode rmode,
case float_class_normal:
case float_class_denormal:
- if (parts_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
+ if (parts128_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
flags = float_flag_inexact;
if (p.cls == float_class_zero) {
r = int128_zero();
@@ -5482,11 +5474,11 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
* of distinguishing partial quotients, so ignore the exception.
*/
*n = *q;
- parts_round_to_int_normal(n,
- is_q_smallish ?
- final_quotient_rounding_mode :
- float_round_to_zero,
- 0, fmt->frac_size);
+ parts64_round_to_int_normal(n,
+ is_q_smallish
+ ? final_quotient_rounding_mode
+ : float_round_to_zero,
+ 0, fmt->frac_size);
/* Compute precise remainder */
r_precise_buf = *b;
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 6e1800b117..9b719ac5cf 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -1127,7 +1127,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
* according to the IEC/IEEE Standard for Binary Floating-Point
* Arithmetic.
*
- * parts_round_to_int_normal is an internal helper function for
+ * partsN(round_to_int_normal) is an internal helper function for
* normal numbers only, returning true for inexact but not directly
* raising float_flag_inexact.
*/
@@ -1270,7 +1270,7 @@ static void partsN(round_to_int)(FloatPartsN *a, FloatRoundMode rmode,
break;
case float_class_normal:
case float_class_denormal:
- if (parts_round_to_int_normal(a, rmode, scale, fmt->frac_size)) {
+ if (partsN(round_to_int_normal)(a, rmode, scale, fmt->frac_size)) {
float_raise(float_flag_inexact, s);
}
break;
@@ -1316,7 +1316,7 @@ static int64_t partsN(float_to_sint)(FloatPartsN *p, FloatRoundMode rmode,
case float_class_normal:
case float_class_denormal:
/* TODO: N - 2 is frac_size for rounding; could use input fmt. */
- if (parts_round_to_int_normal(p, rmode, scale, N - 2)) {
+ if (partsN(round_to_int_normal)(p, rmode, scale, N - 2)) {
flags = float_flag_inexact;
}
@@ -1384,7 +1384,7 @@ static uint64_t partsN(float_to_uint)(FloatPartsN *p, FloatRoundMode rmode,
case float_class_normal:
case float_class_denormal:
/* TODO: N - 2 is frac_size for rounding; could use input fmt. */
- if (parts_round_to_int_normal(p, rmode, scale, N - 2)) {
+ if (partsN(round_to_int_normal)(p, rmode, scale, N - 2)) {
flags = float_flag_inexact;
if (p->cls == float_class_zero) {
r = 0;
@@ -1448,7 +1448,7 @@ static int64_t partsN(float_to_sint_modulo)(FloatPartsN *p,
case float_class_normal:
case float_class_denormal:
/* TODO: N - 2 is frac_size for rounding; could use input fmt. */
- if (parts_round_to_int_normal(p, rmode, 0, N - 2)) {
+ if (partsN(round_to_int_normal)(p, rmode, 0, N - 2)) {
flags = float_flag_inexact;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PULL 17/48] fpu: Drop parts_round_to_int_normal
2026-04-29 22:24 ` [PULL 17/48] fpu: Drop parts_round_to_int_normal Richard Henderson
@ 2026-05-05 8:21 ` Philippe Mathieu-Daudé
0 siblings, 0 replies; 51+ messages in thread
From: Philippe Mathieu-Daudé @ 2026-05-05 8:21 UTC (permalink / raw)
To: Richard Henderson, qemu-devel; +Cc: stefanha
On 30/4/26 00:24, Richard Henderson wrote:
> Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
> fpu/softfloat.c | 22 +++++++---------------
> fpu/softfloat-parts.c.inc | 10 +++++-----
> 2 files changed, 12 insertions(+), 20 deletions(-)
>
> diff --git a/fpu/softfloat.c b/fpu/softfloat.c
> index 0a6bc6d580..1f03fcf687 100644
> --- a/fpu/softfloat.c
> +++ b/fpu/softfloat.c
> @@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
> FloatParts128 *: parts128_##NAME, \
> FloatParts256 *: parts256_##NAME)
>
> -static bool parts64_round_to_int_normal(FloatParts64 *a, FloatRoundMode rm,
> - int scale, int frac_size);
> -static bool parts128_round_to_int_normal(FloatParts128 *a, FloatRoundMode r,
> - int scale, int frac_size);
> -
> -#define parts_round_to_int_normal(A, R, C, F) \
> - PARTS_GENERIC_64_128(round_to_int_normal, A)(A, R, C, F)
> -
> static void parts64_round_to_int(FloatParts64 *a, FloatRoundMode rm,
> int scale, float_status *s,
> const FloatFmt *fmt);
> @@ -3365,7 +3357,7 @@ static Int128 float128_to_int128_scalbn(float128 a, FloatRoundMode rmode,
>
> case float_class_normal:
> case float_class_denormal:
> - if (parts_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
> + if (parts128_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
> flags = float_flag_inexact;
> }
>
> @@ -3793,7 +3785,7 @@ static Int128 float128_to_uint128_scalbn(float128 a, FloatRoundMode rmode,
>
> case float_class_normal:
> case float_class_denormal:
> - if (parts_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
> + if (parts128_round_to_int_normal(&p, rmode, scale, 128 - 2)) {
> flags = float_flag_inexact;
> if (p.cls == float_class_zero) {
> r = int128_zero();
> @@ -5482,11 +5474,11 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
> * of distinguishing partial quotients, so ignore the exception.
> */
> *n = *q;
> - parts_round_to_int_normal(n,
> - is_q_smallish ?
> - final_quotient_rounding_mode :
> - float_round_to_zero,
> - 0, fmt->frac_size);
> + parts64_round_to_int_normal(n,
> + is_q_smallish
> + ? final_quotient_rounding_mode
> + : float_round_to_zero,
> + 0, fmt->frac_size);
Coverity wonders whether we should check for inexact here (CID 1658038).
>
> /* Compute precise remainder */
> r_precise_buf = *b;
> diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
> index 6e1800b117..9b719ac5cf 100644
> --- a/fpu/softfloat-parts.c.inc
> +++ b/fpu/softfloat-parts.c.inc
> @@ -1127,7 +1127,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
> * according to the IEC/IEEE Standard for Binary Floating-Point
> * Arithmetic.
> *
> - * parts_round_to_int_normal is an internal helper function for
> + * partsN(round_to_int_normal) is an internal helper function for
> * normal numbers only, returning true for inexact but not directly
> * raising float_flag_inexact.
> */
> @@ -1270,7 +1270,7 @@ static void partsN(round_to_int)(FloatPartsN *a, FloatRoundMode rmode,
> break;
> case float_class_normal:
> case float_class_denormal:
> - if (parts_round_to_int_normal(a, rmode, scale, fmt->frac_size)) {
> + if (partsN(round_to_int_normal)(a, rmode, scale, fmt->frac_size)) {
> float_raise(float_flag_inexact, s);
> }
> break;
> @@ -1316,7 +1316,7 @@ static int64_t partsN(float_to_sint)(FloatPartsN *p, FloatRoundMode rmode,
> case float_class_normal:
> case float_class_denormal:
> /* TODO: N - 2 is frac_size for rounding; could use input fmt. */
> - if (parts_round_to_int_normal(p, rmode, scale, N - 2)) {
> + if (partsN(round_to_int_normal)(p, rmode, scale, N - 2)) {
> flags = float_flag_inexact;
> }
>
> @@ -1384,7 +1384,7 @@ static uint64_t partsN(float_to_uint)(FloatPartsN *p, FloatRoundMode rmode,
> case float_class_normal:
> case float_class_denormal:
> /* TODO: N - 2 is frac_size for rounding; could use input fmt. */
> - if (parts_round_to_int_normal(p, rmode, scale, N - 2)) {
> + if (partsN(round_to_int_normal)(p, rmode, scale, N - 2)) {
> flags = float_flag_inexact;
> if (p->cls == float_class_zero) {
> r = 0;
> @@ -1448,7 +1448,7 @@ static int64_t partsN(float_to_sint_modulo)(FloatPartsN *p,
> case float_class_normal:
> case float_class_denormal:
> /* TODO: N - 2 is frac_size for rounding; could use input fmt. */
> - if (parts_round_to_int_normal(p, rmode, 0, N - 2)) {
> + if (partsN(round_to_int_normal)(p, rmode, 0, N - 2)) {
> flags = float_flag_inexact;
> }
>
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PULL 18/48] fpu: Drop parts_round_to_int
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (16 preceding siblings ...)
2026-04-29 22:24 ` [PULL 17/48] fpu: Drop parts_round_to_int_normal Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 19/48] fpu: Drop parts_float_to_sint Richard Henderson
` (30 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_round_to_int at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 22 ++++++----------------
1 file changed, 6 insertions(+), 16 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 1f03fcf687..e2341871bd 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,16 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_round_to_int(FloatParts64 *a, FloatRoundMode rm,
- int scale, float_status *s,
- const FloatFmt *fmt);
-static void parts128_round_to_int(FloatParts128 *a, FloatRoundMode r,
- int scale, float_status *s,
- const FloatFmt *fmt);
-
-#define parts_round_to_int(A, R, C, S, F) \
- PARTS_GENERIC_64_128(round_to_int, A)(A, R, C, S, F)
-
static int64_t parts64_float_to_sint(FloatParts64 *p, FloatRoundMode rmode,
int scale, int64_t min, int64_t max,
float_status *s);
@@ -3128,7 +3118,7 @@ float16 float16_round_to_int(float16 a, float_status *s)
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float16_params);
+ parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float16_params);
return float16_round_pack_canonical(&p, s);
}
@@ -3137,7 +3127,7 @@ float32 float32_round_to_int(float32 a, float_status *s)
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float32_params);
+ parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float32_params);
return float32_round_pack_canonical(&p, s);
}
@@ -3146,7 +3136,7 @@ float64 float64_round_to_int(float64 a, float_status *s)
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float64_params);
+ parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float64_params);
return float64_round_pack_canonical(&p, s);
}
@@ -3155,7 +3145,7 @@ bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- parts_round_to_int(&p, s->float_rounding_mode, 0, s, &bfloat16_params);
+ parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &bfloat16_params);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -3164,7 +3154,7 @@ float128 float128_round_to_int(float128 a, float_status *s)
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- parts_round_to_int(&p, s->float_rounding_mode, 0, s, &float128_params);
+ parts128_round_to_int(&p, s->float_rounding_mode, 0, s, &float128_params);
return float128_round_pack_canonical(&p, s);
}
@@ -3176,7 +3166,7 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
return floatx80_default_nan(status);
}
- parts_round_to_int(&p, status->float_rounding_mode, 0, status,
+ parts128_round_to_int(&p, status->float_rounding_mode, 0, status,
&floatx80_params[status->floatx80_rounding_precision]);
return floatx80_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 19/48] fpu: Drop parts_float_to_sint
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (17 preceding siblings ...)
2026-04-29 22:24 ` [PULL 18/48] fpu: Drop parts_round_to_int Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 20/48] fpu: Drop parts_float_to_uint Richard Henderson
` (29 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_float_to_sint at each call site.
Note that there was a duplicate macro redefinition.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 49 ++++++++++++++++++-------------------------------
1 file changed, 18 insertions(+), 31 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index e2341871bd..42ef537e12 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,16 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static int64_t parts64_float_to_sint(FloatParts64 *p, FloatRoundMode rmode,
- int scale, int64_t min, int64_t max,
- float_status *s);
-static int64_t parts128_float_to_sint(FloatParts128 *p, FloatRoundMode rmode,
- int scale, int64_t min, int64_t max,
- float_status *s);
-
-#define parts_float_to_sint(P, R, Z, MN, MX, S) \
- PARTS_GENERIC_64_128(float_to_sint, P)(P, R, Z, MN, MX, S)
-
static uint64_t parts64_float_to_uint(FloatParts64 *p, FloatRoundMode rmode,
int scale, uint64_t max,
float_status *s);
@@ -814,9 +804,6 @@ static void parts64_sint_to_float(FloatParts64 *p, int64_t a,
static void parts128_sint_to_float(FloatParts128 *p, int64_t a,
int scale, float_status *s);
-#define parts_float_to_sint(P, R, Z, MN, MX, S) \
- PARTS_GENERIC_64_128(float_to_sint, P)(P, R, Z, MN, MX, S)
-
#define parts_sint_to_float(P, I, Z, S) \
PARTS_GENERIC_64_128(sint_to_float, P)(P, I, Z, S)
@@ -3181,7 +3168,7 @@ int8_t float16_to_int8_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
}
int16_t float16_to_int16_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3190,7 +3177,7 @@ int16_t float16_to_int16_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float16_to_int32_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3199,7 +3186,7 @@ int32_t float16_to_int32_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3208,7 +3195,7 @@ int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3217,7 +3204,7 @@ int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3226,7 +3213,7 @@ int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3235,7 +3222,7 @@ int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3244,7 +3231,7 @@ int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3253,7 +3240,7 @@ int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3262,7 +3249,7 @@ int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
int8_t bfloat16_to_int8_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
@@ -3271,7 +3258,7 @@ int8_t bfloat16_to_int8_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
}
int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
@@ -3280,7 +3267,7 @@ int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
@@ -3289,7 +3276,7 @@ int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
@@ -3298,7 +3285,7 @@ int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
static int32_t float128_to_int32_scalbn(float128 a, FloatRoundMode rmode,
@@ -3307,7 +3294,7 @@ static int32_t float128_to_int32_scalbn(float128 a, FloatRoundMode rmode,
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts128_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
static int64_t float128_to_int64_scalbn(float128 a, FloatRoundMode rmode,
@@ -3316,7 +3303,7 @@ static int64_t float128_to_int64_scalbn(float128 a, FloatRoundMode rmode,
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts128_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
static Int128 float128_to_int128_scalbn(float128 a, FloatRoundMode rmode,
@@ -3382,7 +3369,7 @@ static int32_t floatx80_to_int32_scalbn(floatx80 a, FloatRoundMode rmode,
if (!floatx80_unpack_canonical(&p, a, s)) {
parts128_default_nan(&p, s);
}
- return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
+ return parts128_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
static int64_t floatx80_to_int64_scalbn(floatx80 a, FloatRoundMode rmode,
@@ -3393,7 +3380,7 @@ static int64_t floatx80_to_int64_scalbn(floatx80 a, FloatRoundMode rmode,
if (!floatx80_unpack_canonical(&p, a, s)) {
parts128_default_nan(&p, s);
}
- return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
+ return parts128_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
int8_t float16_to_int8(float16 a, float_status *s)
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 20/48] fpu: Drop parts_float_to_uint
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (18 preceding siblings ...)
2026-04-29 22:24 ` [PULL 19/48] fpu: Drop parts_float_to_sint Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 21/48] fpu: Drop parts_float_to_sint_modulo Richard Henderson
` (28 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_float_to_uint at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 42 ++++++++++++++++--------------------------
1 file changed, 16 insertions(+), 26 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 42ef537e12..869b592cd0 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,16 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static uint64_t parts64_float_to_uint(FloatParts64 *p, FloatRoundMode rmode,
- int scale, uint64_t max,
- float_status *s);
-static uint64_t parts128_float_to_uint(FloatParts128 *p, FloatRoundMode rmode,
- int scale, uint64_t max,
- float_status *s);
-
-#define parts_float_to_uint(P, R, Z, M, S) \
- PARTS_GENERIC_64_128(float_to_uint, P)(P, R, Z, M, S)
-
static int64_t parts64_float_to_sint_modulo(FloatParts64 *p,
FloatRoundMode rmode,
int bitsm1, float_status *s);
@@ -3596,7 +3586,7 @@ uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
}
uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3605,7 +3595,7 @@ uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3614,7 +3604,7 @@ uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int scale,
@@ -3623,7 +3613,7 @@ uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
uint16_t float32_to_uint16_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3632,7 +3622,7 @@ uint16_t float32_to_uint16_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float32_to_uint32_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3641,7 +3631,7 @@ uint32_t float32_to_uint32_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float32_to_uint64_scalbn(float32 a, FloatRoundMode rmode, int scale,
@@ -3650,7 +3640,7 @@ uint64_t float32_to_uint64_scalbn(float32 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
uint16_t float64_to_uint16_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3659,7 +3649,7 @@ uint16_t float64_to_uint16_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float64_to_uint32_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3668,7 +3658,7 @@ uint32_t float64_to_uint32_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int scale,
@@ -3677,7 +3667,7 @@ uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int scale,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode rmode,
@@ -3686,7 +3676,7 @@ uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode rmode,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
}
uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode rmode,
@@ -3695,7 +3685,7 @@ uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode rmode,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode rmode,
@@ -3704,7 +3694,7 @@ uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode rmode,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode rmode,
@@ -3713,7 +3703,7 @@ uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode rmode,
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
+ return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
static uint32_t float128_to_uint32_scalbn(float128 a, FloatRoundMode rmode,
@@ -3722,7 +3712,7 @@ static uint32_t float128_to_uint32_scalbn(float128 a, FloatRoundMode rmode,
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
+ return parts128_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
static uint64_t float128_to_uint64_scalbn(float128 a, FloatRoundMode rmode,
@@ -3731,7 +3721,7 @@ static uint64_t float128_to_uint64_scalbn(float128 a, FloatRoundMode rmode,
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- return parts_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
+ return parts128_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
static Int128 float128_to_uint128_scalbn(float128 a, FloatRoundMode rmode,
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 21/48] fpu: Drop parts_float_to_sint_modulo
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (19 preceding siblings ...)
2026-04-29 22:24 ` [PULL 20/48] fpu: Drop parts_float_to_uint Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 22/48] fpu: Drop parts_sint_to_float Richard Henderson
` (27 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts64_float_to_sint_modulo at each call site.
That leaves parts128_float_to_sint_modulo unused,
so move the whole function back to softfloat.c and
specialize for FloatParts64.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 84 +++++++++++++++++++++++++++++++++------
fpu/softfloat-parts.c.inc | 79 ------------------------------------
2 files changed, 72 insertions(+), 91 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 869b592cd0..0b2638c34b 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,16 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static int64_t parts64_float_to_sint_modulo(FloatParts64 *p,
- FloatRoundMode rmode,
- int bitsm1, float_status *s);
-static int64_t parts128_float_to_sint_modulo(FloatParts128 *p,
- FloatRoundMode rmode,
- int bitsm1, float_status *s);
-
-#define parts_float_to_sint_modulo(P, R, M, S) \
- PARTS_GENERIC_64_128(float_to_sint_modulo, P)(P, R, M, S)
-
static void parts64_sint_to_float(FloatParts64 *p, int64_t a,
int scale, float_status *s);
static void parts128_sint_to_float(FloatParts128 *p, int64_t a,
@@ -3558,13 +3548,83 @@ int64_t bfloat16_to_int64_round_to_zero(bfloat16 a, float_status *s)
return bfloat16_to_int64_scalbn(a, float_round_to_zero, 0, s);
}
+/*
+ * Like partsN(float_to_sint), except do not saturate the result.
+ * Instead, return the rounded unbounded precision two's compliment result,
+ * modulo 2**(bitsm1 + 1).
+ */
+static int64_t parts64_float_to_sint_modulo(FloatParts64 *p,
+ FloatRoundMode rmode,
+ int bitsm1, float_status *s)
+{
+ int flags = 0;
+ uint64_t r;
+ bool overflow = false;
+
+ switch (p->cls) {
+ case float_class_snan:
+ flags |= float_flag_invalid_snan;
+ /* fall through */
+ case float_class_qnan:
+ flags |= float_flag_invalid;
+ r = 0;
+ break;
+
+ case float_class_inf:
+ overflow = true;
+ r = 0;
+ break;
+
+ case float_class_zero:
+ return 0;
+
+ case float_class_normal:
+ case float_class_denormal:
+ /* TODO: 64 - 2 is frac_size for rounding; could use input fmt. */
+ if (parts64_round_to_int_normal(p, rmode, 0, 64 - 2)) {
+ flags = float_flag_inexact;
+ }
+
+ if (p->exp <= DECOMPOSED_BINARY_POINT) {
+ r = p->frac >> (DECOMPOSED_BINARY_POINT - p->exp);
+ if (p->exp < bitsm1) {
+ /* Result in range. */
+ } else if (p->exp == bitsm1) {
+ /* The only in-range value is INT_MIN. */
+ overflow = !p->sign || p->frac != DECOMPOSED_IMPLICIT_BIT;
+ } else {
+ overflow = true;
+ }
+ } else {
+ /* Overflow, but there might still be bits to return. */
+ int shl = p->exp - DECOMPOSED_BINARY_POINT;
+ r = (shl < 64 ? p->frac << shl : 0);
+ overflow = true;
+ }
+
+ if (p->sign) {
+ r = -r;
+ }
+ break;
+
+ default:
+ g_assert_not_reached();
+ }
+
+ if (overflow) {
+ flags = float_flag_invalid | float_flag_invalid_cvti;
+ }
+ float_raise(flags, s);
+ return r;
+}
+
int32_t float64_to_int32_modulo(float64 a, FloatRoundMode rmode,
float_status *s)
{
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_sint_modulo(&p, rmode, 31, s);
+ return parts64_float_to_sint_modulo(&p, rmode, 31, s);
}
int64_t float64_to_int64_modulo(float64 a, FloatRoundMode rmode,
@@ -3573,7 +3633,7 @@ int64_t float64_to_int64_modulo(float64 a, FloatRoundMode rmode,
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- return parts_float_to_sint_modulo(&p, rmode, 63, s);
+ return parts64_float_to_sint_modulo(&p, rmode, 63, s);
}
/*
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 9b719ac5cf..d8eb9f5b78 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -1415,85 +1415,6 @@ static uint64_t partsN(float_to_uint)(FloatPartsN *p, FloatRoundMode rmode,
return r;
}
-/*
- * Like partsN(float_to_sint), except do not saturate the result.
- * Instead, return the rounded unbounded precision two's compliment result,
- * modulo 2**(bitsm1 + 1).
- */
-static int64_t partsN(float_to_sint_modulo)(FloatPartsN *p,
- FloatRoundMode rmode,
- int bitsm1, float_status *s)
-{
- int flags = 0;
- uint64_t r;
- bool overflow = false;
-
- switch (p->cls) {
- case float_class_snan:
- flags |= float_flag_invalid_snan;
- /* fall through */
- case float_class_qnan:
- flags |= float_flag_invalid;
- r = 0;
- break;
-
- case float_class_inf:
- overflow = true;
- r = 0;
- break;
-
- case float_class_zero:
- return 0;
-
- case float_class_normal:
- case float_class_denormal:
- /* TODO: N - 2 is frac_size for rounding; could use input fmt. */
- if (partsN(round_to_int_normal)(p, rmode, 0, N - 2)) {
- flags = float_flag_inexact;
- }
-
- if (p->exp <= DECOMPOSED_BINARY_POINT) {
- /*
- * Because we rounded to integral, and exp < 64,
- * we know frac_low is zero.
- */
- r = p->frac_hi >> (DECOMPOSED_BINARY_POINT - p->exp);
- if (p->exp < bitsm1) {
- /* Result in range. */
- } else if (p->exp == bitsm1) {
- /* The only in-range value is INT_MIN. */
- overflow = !p->sign || p->frac_hi != DECOMPOSED_IMPLICIT_BIT;
- } else {
- overflow = true;
- }
- } else {
- /* Overflow, but there might still be bits to return. */
- int shl = p->exp - DECOMPOSED_BINARY_POINT;
- if (shl < N) {
- frac_shl(p, shl);
- r = p->frac_hi;
- } else {
- r = 0;
- }
- overflow = true;
- }
-
- if (p->sign) {
- r = -r;
- }
- break;
-
- default:
- g_assert_not_reached();
- }
-
- if (overflow) {
- flags = float_flag_invalid | float_flag_invalid_cvti;
- }
- float_raise(flags, s);
- return r;
-}
-
/*
* Integer to float conversions
*
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 22/48] fpu: Drop parts_sint_to_float
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (20 preceding siblings ...)
2026-04-29 22:24 ` [PULL 21/48] fpu: Drop parts_float_to_sint_modulo Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 23/48] fpu: Drop parts_uint_to_float Richard Henderson
` (26 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_sint_to_float at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 18 +++++-------------
fpu/softfloat-parts.c.inc | 2 +-
2 files changed, 6 insertions(+), 14 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 0b2638c34b..bbfdf1a076 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_sint_to_float(FloatParts64 *p, int64_t a,
- int scale, float_status *s);
-static void parts128_sint_to_float(FloatParts128 *p, int64_t a,
- int scale, float_status *s);
-
-#define parts_sint_to_float(P, I, Z, S) \
- PARTS_GENERIC_64_128(sint_to_float, P)(P, I, Z, S)
-
static void parts64_uint_to_float(FloatParts64 *p, uint64_t a,
int scale, float_status *s);
static void parts128_uint_to_float(FloatParts128 *p, uint64_t a,
@@ -4013,7 +4005,7 @@ float16 int64_to_float16_scalbn(int64_t a, int scale, float_status *status)
{
FloatParts64 p;
- parts_sint_to_float(&p, a, scale, status);
+ parts64_sint_to_float(&p, a, scale, status);
return float16_round_pack_canonical(&p, status);
}
@@ -4098,7 +4090,7 @@ float64 int64_to_float64_scalbn(int64_t a, int scale, float_status *status)
return ur.s;
}
- parts_sint_to_float(&p, a, scale, status);
+ parts64_sint_to_float(&p, a, scale, status);
return float64_round_pack_canonical(&p, status);
}
@@ -4131,7 +4123,7 @@ bfloat16 int64_to_bfloat16_scalbn(int64_t a, int scale, float_status *status)
{
FloatParts64 p;
- parts_sint_to_float(&p, a, scale, status);
+ parts64_sint_to_float(&p, a, scale, status);
return bfloat16_round_pack_canonical(&p, status);
}
@@ -4203,7 +4195,7 @@ float128 int64_to_float128(int64_t a, float_status *status)
{
FloatParts128 p;
- parts_sint_to_float(&p, a, 0, status);
+ parts128_sint_to_float(&p, a, 0, status);
return float128_round_pack_canonical(&p, status);
}
@@ -4216,7 +4208,7 @@ floatx80 int64_to_floatx80(int64_t a, float_status *status)
{
FloatParts128 p;
- parts_sint_to_float(&p, a, 0, status);
+ parts128_sint_to_float(&p, a, 0, status);
return floatx80_round_pack_canonical(&p, status);
}
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index d8eb9f5b78..8405cf29cd 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -1779,7 +1779,7 @@ static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)
r |= (a1 || a0 & ~DECOMPOSED_IMPLICIT_BIT);
exact:
- parts_sint_to_float(a, a_exp, 0, s);
+ partsN(sint_to_float)(a, a_exp, 0, s);
if (r == 0) {
return;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 23/48] fpu: Drop parts_uint_to_float
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (21 preceding siblings ...)
2026-04-29 22:24 ` [PULL 22/48] fpu: Drop parts_sint_to_float Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 24/48] fpu: Drop parts_minmax Richard Henderson
` (25 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_uint_to_float at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 18 +++++-------------
1 file changed, 5 insertions(+), 13 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index bbfdf1a076..8d5f3c48e7 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_uint_to_float(FloatParts64 *p, uint64_t a,
- int scale, float_status *s);
-static void parts128_uint_to_float(FloatParts128 *p, uint64_t a,
- int scale, float_status *s);
-
-#define parts_uint_to_float(P, I, Z, S) \
- PARTS_GENERIC_64_128(uint_to_float, P)(P, I, Z, S)
-
static FloatParts64 *parts64_minmax(FloatParts64 *a, FloatParts64 *b,
float_status *s, int flags);
static FloatParts128 *parts128_minmax(FloatParts128 *a, FloatParts128 *b,
@@ -4225,7 +4217,7 @@ float16 uint64_to_float16_scalbn(uint64_t a, int scale, float_status *status)
{
FloatParts64 p;
- parts_uint_to_float(&p, a, scale, status);
+ parts64_uint_to_float(&p, a, scale, status);
return float16_round_pack_canonical(&p, status);
}
@@ -4270,7 +4262,7 @@ float32 uint64_to_float32_scalbn(uint64_t a, int scale, float_status *status)
return ur.s;
}
- parts_uint_to_float(&p, a, scale, status);
+ parts64_uint_to_float(&p, a, scale, status);
return float32_round_pack_canonical(&p, status);
}
@@ -4310,7 +4302,7 @@ float64 uint64_to_float64_scalbn(uint64_t a, int scale, float_status *status)
return ur.s;
}
- parts_uint_to_float(&p, a, scale, status);
+ parts64_uint_to_float(&p, a, scale, status);
return float64_round_pack_canonical(&p, status);
}
@@ -4343,7 +4335,7 @@ bfloat16 uint64_to_bfloat16_scalbn(uint64_t a, int scale, float_status *status)
{
FloatParts64 p;
- parts_uint_to_float(&p, a, scale, status);
+ parts64_uint_to_float(&p, a, scale, status);
return bfloat16_round_pack_canonical(&p, status);
}
@@ -4386,7 +4378,7 @@ float128 uint64_to_float128(uint64_t a, float_status *status)
{
FloatParts128 p;
- parts_uint_to_float(&p, a, 0, status);
+ parts128_uint_to_float(&p, a, 0, status);
return float128_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 24/48] fpu: Drop parts_minmax
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (22 preceding siblings ...)
2026-04-29 22:24 ` [PULL 23/48] fpu: Drop parts_uint_to_float Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 25/48] fpu: Drop parts_compare Richard Henderson
` (24 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_minmax at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 18 +++++-------------
1 file changed, 5 insertions(+), 13 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 8d5f3c48e7..158d539376 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatParts64 *parts64_minmax(FloatParts64 *a, FloatParts64 *b,
- float_status *s, int flags);
-static FloatParts128 *parts128_minmax(FloatParts128 *a, FloatParts128 *b,
- float_status *s, int flags);
-
-#define parts_minmax(A, B, S, F) \
- PARTS_GENERIC_64_128(minmax, A)(A, B, S, F)
-
static FloatRelation parts64_compare(FloatParts64 *a, FloatParts64 *b,
float_status *s, bool q);
static FloatRelation parts128_compare(FloatParts128 *a, FloatParts128 *b,
@@ -4417,7 +4409,7 @@ static float16 float16_minmax(float16 a, float16 b, float_status *s, int flags)
float16_unpack_canonical(&pa, a, s);
float16_unpack_canonical(&pb, b, s);
- pr = parts_minmax(&pa, &pb, s, flags);
+ pr = parts64_minmax(&pa, &pb, s, flags);
return float16_round_pack_canonical(pr, s);
}
@@ -4429,7 +4421,7 @@ static bfloat16 bfloat16_minmax(bfloat16 a, bfloat16 b,
bfloat16_unpack_canonical(&pa, a, s);
bfloat16_unpack_canonical(&pb, b, s);
- pr = parts_minmax(&pa, &pb, s, flags);
+ pr = parts64_minmax(&pa, &pb, s, flags);
return bfloat16_round_pack_canonical(pr, s);
}
@@ -4440,7 +4432,7 @@ static float32 float32_minmax(float32 a, float32 b, float_status *s, int flags)
float32_unpack_canonical(&pa, a, s);
float32_unpack_canonical(&pb, b, s);
- pr = parts_minmax(&pa, &pb, s, flags);
+ pr = parts64_minmax(&pa, &pb, s, flags);
return float32_round_pack_canonical(pr, s);
}
@@ -4451,7 +4443,7 @@ static float64 float64_minmax(float64 a, float64 b, float_status *s, int flags)
float64_unpack_canonical(&pa, a, s);
float64_unpack_canonical(&pb, b, s);
- pr = parts_minmax(&pa, &pb, s, flags);
+ pr = parts64_minmax(&pa, &pb, s, flags);
return float64_round_pack_canonical(pr, s);
}
@@ -4463,7 +4455,7 @@ static float128 float128_minmax(float128 a, float128 b,
float128_unpack_canonical(&pa, a, s);
float128_unpack_canonical(&pb, b, s);
- pr = parts_minmax(&pa, &pb, s, flags);
+ pr = parts128_minmax(&pa, &pb, s, flags);
return float128_round_pack_canonical(pr, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 25/48] fpu: Drop parts_compare
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (23 preceding siblings ...)
2026-04-29 22:24 ` [PULL 24/48] fpu: Drop parts_minmax Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 26/48] fpu: Drop parts_scalbn Richard Henderson
` (23 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_compare at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 22 +++++++---------------
1 file changed, 7 insertions(+), 15 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 158d539376..3aebe4a058 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,14 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static FloatRelation parts64_compare(FloatParts64 *a, FloatParts64 *b,
- float_status *s, bool q);
-static FloatRelation parts128_compare(FloatParts128 *a, FloatParts128 *b,
- float_status *s, bool q);
-
-#define parts_compare(A, B, S, Q) \
- PARTS_GENERIC_64_128(compare, A)(A, B, S, Q)
-
static void parts64_scalbn(FloatParts64 *a, int n, float_status *s);
static void parts128_scalbn(FloatParts128 *a, int n, float_status *s);
@@ -4494,7 +4486,7 @@ float16_do_compare(float16 a, float16 b, float_status *s, bool is_quiet)
float16_unpack_canonical(&pa, a, s);
float16_unpack_canonical(&pb, b, s);
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts64_compare(&pa, &pb, s, is_quiet);
}
FloatRelation float16_compare(float16 a, float16 b, float_status *s)
@@ -4514,7 +4506,7 @@ float32_do_compare(float32 a, float32 b, float_status *s, bool is_quiet)
float32_unpack_canonical(&pa, a, s);
float32_unpack_canonical(&pb, b, s);
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts64_compare(&pa, &pb, s, is_quiet);
}
static FloatRelation QEMU_FLATTEN
@@ -4568,7 +4560,7 @@ float64_do_compare(float64 a, float64 b, float_status *s, bool is_quiet)
float64_unpack_canonical(&pa, a, s);
float64_unpack_canonical(&pb, b, s);
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts64_compare(&pa, &pb, s, is_quiet);
}
static FloatRelation QEMU_FLATTEN
@@ -4622,7 +4614,7 @@ bfloat16_do_compare(bfloat16 a, bfloat16 b, float_status *s, bool is_quiet)
bfloat16_unpack_canonical(&pa, a, s);
bfloat16_unpack_canonical(&pb, b, s);
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts64_compare(&pa, &pb, s, is_quiet);
}
FloatRelation bfloat16_compare(bfloat16 a, bfloat16 b, float_status *s)
@@ -4642,7 +4634,7 @@ float128_do_compare(float128 a, float128 b, float_status *s, bool is_quiet)
float128_unpack_canonical(&pa, a, s);
float128_unpack_canonical(&pb, b, s);
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts128_compare(&pa, &pb, s, is_quiet);
}
FloatRelation float128_compare(float128 a, float128 b, float_status *s)
@@ -4664,7 +4656,7 @@ floatx80_do_compare(floatx80 a, floatx80 b, float_status *s, bool is_quiet)
!floatx80_unpack_canonical(&pb, b, s)) {
return float_relation_unordered;
}
- return parts_compare(&pa, &pb, s, is_quiet);
+ return parts128_compare(&pa, &pb, s, is_quiet);
}
FloatRelation floatx80_compare(floatx80 a, floatx80 b, float_status *s)
@@ -5518,7 +5510,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
saved_r_precise_sign = r_precise->sign;
r->sign = false;
r_precise->sign = false;
- if (parts_compare(r, r_precise, status, true) <
+ if (parts64_compare(r, r_precise, status, true) <
float_relation_equal) {
*dxc = 0x8;
} else {
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 26/48] fpu: Drop parts_scalbn
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (24 preceding siblings ...)
2026-04-29 22:24 ` [PULL 25/48] fpu: Drop parts_compare Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 27/48] fpu: Drop parts_log2 Richard Henderson
` (22 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_scalbn at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 18 ++++++------------
1 file changed, 6 insertions(+), 12 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 3aebe4a058..3e6f2a152a 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,12 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_scalbn(FloatParts64 *a, int n, float_status *s);
-static void parts128_scalbn(FloatParts128 *a, int n, float_status *s);
-
-#define parts_scalbn(A, N, S) \
- PARTS_GENERIC_64_128(scalbn, A)(A, N, S)
-
static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *f);
static void parts128_log2(FloatParts128 *a, float_status *s, const FloatFmt *f);
@@ -4678,7 +4672,7 @@ float16 float16_scalbn(float16 a, int n, float_status *status)
FloatParts64 p;
float16_unpack_canonical(&p, a, status);
- parts_scalbn(&p, n, status);
+ parts64_scalbn(&p, n, status);
return float16_round_pack_canonical(&p, status);
}
@@ -4687,7 +4681,7 @@ float32 float32_scalbn(float32 a, int n, float_status *status)
FloatParts64 p;
float32_unpack_canonical(&p, a, status);
- parts_scalbn(&p, n, status);
+ parts64_scalbn(&p, n, status);
return float32_round_pack_canonical(&p, status);
}
@@ -4696,7 +4690,7 @@ float64 float64_scalbn(float64 a, int n, float_status *status)
FloatParts64 p;
float64_unpack_canonical(&p, a, status);
- parts_scalbn(&p, n, status);
+ parts64_scalbn(&p, n, status);
return float64_round_pack_canonical(&p, status);
}
@@ -4705,7 +4699,7 @@ bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, status);
- parts_scalbn(&p, n, status);
+ parts64_scalbn(&p, n, status);
return bfloat16_round_pack_canonical(&p, status);
}
@@ -4714,7 +4708,7 @@ float128 float128_scalbn(float128 a, int n, float_status *status)
FloatParts128 p;
float128_unpack_canonical(&p, a, status);
- parts_scalbn(&p, n, status);
+ parts128_scalbn(&p, n, status);
return float128_round_pack_canonical(&p, status);
}
@@ -4725,7 +4719,7 @@ floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
if (!floatx80_unpack_canonical(&p, a, status)) {
return floatx80_default_nan(status);
}
- parts_scalbn(&p, n, status);
+ parts128_scalbn(&p, n, status);
return floatx80_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 27/48] fpu: Drop parts_log2
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (25 preceding siblings ...)
2026-04-29 22:24 ` [PULL 26/48] fpu: Drop parts_scalbn Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 28/48] fpu: Drop parts_float_to_float Richard Henderson
` (21 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts64_log2 at each call site.
That leaves parts128_log2 unused, so move the whole function back
to softfloat.c and specialize for FloatParts64.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 133 +++++++++++++++++++++++++++++++++++---
fpu/softfloat-parts.c.inc | 131 -------------------------------------
2 files changed, 125 insertions(+), 139 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 3e6f2a152a..6a38d161f7 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -779,12 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
FloatParts128 *: parts128_##NAME, \
FloatParts256 *: parts256_##NAME)
-static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *f);
-static void parts128_log2(FloatParts128 *a, float_status *s, const FloatFmt *f);
-
-#define parts_log2(A, S, F) \
- PARTS_GENERIC_64_128(log2, A)(A, S, F)
-
/*
* Helper functions for softfloat-parts.c.inc, per-size operations.
*/
@@ -4851,12 +4845,135 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *s)
/*
* log2
*/
+
+static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *fmt)
+{
+ uint64_t a0, a1, r, t, ign;
+ int i, n, a_exp, f_exp;
+
+ if (unlikely(a->cls != float_class_normal)) {
+ switch (a->cls) {
+ case float_class_denormal:
+ if (!a->sign) {
+ /* -ve denormal will be InvalidOperation */
+ float_raise(float_flag_input_denormal_used, s);
+ }
+ break;
+ case float_class_snan:
+ case float_class_qnan:
+ parts64_return_nan(a, s);
+ return;
+ case float_class_zero:
+ float_raise(float_flag_divbyzero, s);
+ /* log2(0) = -inf */
+ a->cls = float_class_inf;
+ a->sign = 1;
+ return;
+ case float_class_inf:
+ if (unlikely(a->sign)) {
+ goto d_nan;
+ }
+ return;
+ default:
+ g_assert_not_reached();
+ }
+ }
+ if (unlikely(a->sign)) {
+ goto d_nan;
+ }
+
+ a_exp = a->exp;
+ f_exp = -1;
+
+ r = 0;
+ t = DECOMPOSED_IMPLICIT_BIT;
+ a0 = a->frac_hi;
+ a1 = 0;
+
+ n = fmt->frac_size + 2;
+ if (unlikely(a_exp == -1)) {
+ /*
+ * When a_exp == -1, we're computing the log2 of a value [0.5,1.0).
+ * When the value is very close to 1.0, there are lots of 1's in
+ * the msb parts of the fraction. At the end, when we subtract
+ * this value from -1.0, we can see a catastrophic loss of precision,
+ * as 0x800..000 - 0x7ff..ffx becomes 0x000..00y, leaving only the
+ * bits of y in the final result. To minimize this, compute as many
+ * digits as we can.
+ * ??? This case needs another algorithm to avoid this.
+ */
+ n = fmt->frac_size * 2 + 2;
+ /* Don't compute a value overlapping the sticky bit */
+ n = MIN(n, 62);
+ }
+
+ for (i = 0; i < n; i++) {
+ if (a1) {
+ mul128To256(a0, a1, a0, a1, &a0, &a1, &ign, &ign);
+ } else if (a0 & 0xffffffffull) {
+ mul64To128(a0, a0, &a0, &a1);
+ } else if (a0 & ~DECOMPOSED_IMPLICIT_BIT) {
+ a0 >>= 32;
+ a0 *= a0;
+ } else {
+ goto exact;
+ }
+
+ if (a0 & DECOMPOSED_IMPLICIT_BIT) {
+ if (unlikely(a_exp == 0 && r == 0)) {
+ /*
+ * When a_exp == 0, we're computing the log2 of a value
+ * [1.0,2.0). When the value is very close to 1.0, there
+ * are lots of 0's in the msb parts of the fraction.
+ * We need to compute more digits to produce a correct
+ * result -- restart at the top of the fraction.
+ * ??? This is likely to lose precision quickly, as for
+ * float128; we may need another method.
+ */
+ f_exp -= i;
+ t = r = DECOMPOSED_IMPLICIT_BIT;
+ i = 0;
+ } else {
+ r |= t;
+ }
+ } else {
+ add128(a0, a1, a0, a1, &a0, &a1);
+ }
+ t >>= 1;
+ }
+
+ /* Set sticky for inexact. */
+ r |= (a1 || a0 & ~DECOMPOSED_IMPLICIT_BIT);
+
+ exact:
+ parts64_sint_to_float(a, a_exp, 0, s);
+ if (r != 0) {
+ FloatParts64 f = {
+ .cls = float_class_normal, .frac = r
+ };
+ f.exp = f_exp - frac_normalize(&f);
+
+ if (a_exp < 0) {
+ parts64_sub_normal(a, &f);
+ } else if (a_exp > 0) {
+ parts64_add_normal(a, &f);
+ } else {
+ *a = f;
+ }
+ }
+ return;
+
+ d_nan:
+ float_raise(float_flag_invalid, s);
+ parts64_default_nan(a, s);
+}
+
float32 float32_log2(float32 a, float_status *status)
{
FloatParts64 p;
float32_unpack_canonical(&p, a, status);
- parts_log2(&p, status, &float32_params);
+ parts64_log2(&p, status, &float32_params);
return float32_round_pack_canonical(&p, status);
}
@@ -4865,7 +4982,7 @@ float64 float64_log2(float64 a, float_status *status)
FloatParts64 p;
float64_unpack_canonical(&p, a, status);
- parts_log2(&p, status, &float64_params);
+ parts64_log2(&p, status, &float64_params);
return float64_round_pack_canonical(&p, status);
}
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 8405cf29cd..5f27efd288 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -1671,134 +1671,3 @@ static void partsN(scalbn)(FloatPartsN *a, int n, float_status *s)
g_assert_not_reached();
}
}
-
-/*
- * Return log2(A)
- */
-static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)
-{
- uint64_t a0, a1, r, t, ign;
- FloatPartsN f;
- int i, n, a_exp, f_exp;
-
- if (unlikely(a->cls != float_class_normal)) {
- switch (a->cls) {
- case float_class_denormal:
- if (!a->sign) {
- /* -ve denormal will be InvalidOperation */
- float_raise(float_flag_input_denormal_used, s);
- }
- break;
- case float_class_snan:
- case float_class_qnan:
- partsN(return_nan)(a, s);
- return;
- case float_class_zero:
- float_raise(float_flag_divbyzero, s);
- /* log2(0) = -inf */
- a->cls = float_class_inf;
- a->sign = 1;
- return;
- case float_class_inf:
- if (unlikely(a->sign)) {
- goto d_nan;
- }
- return;
- default:
- g_assert_not_reached();
- }
- }
- if (unlikely(a->sign)) {
- goto d_nan;
- }
-
- /* TODO: This algorithm looses bits too quickly for float128. */
- g_assert(N == 64);
-
- a_exp = a->exp;
- f_exp = -1;
-
- r = 0;
- t = DECOMPOSED_IMPLICIT_BIT;
- a0 = a->frac_hi;
- a1 = 0;
-
- n = fmt->frac_size + 2;
- if (unlikely(a_exp == -1)) {
- /*
- * When a_exp == -1, we're computing the log2 of a value [0.5,1.0).
- * When the value is very close to 1.0, there are lots of 1's in
- * the msb parts of the fraction. At the end, when we subtract
- * this value from -1.0, we can see a catastrophic loss of precision,
- * as 0x800..000 - 0x7ff..ffx becomes 0x000..00y, leaving only the
- * bits of y in the final result. To minimize this, compute as many
- * digits as we can.
- * ??? This case needs another algorithm to avoid this.
- */
- n = fmt->frac_size * 2 + 2;
- /* Don't compute a value overlapping the sticky bit */
- n = MIN(n, 62);
- }
-
- for (i = 0; i < n; i++) {
- if (a1) {
- mul128To256(a0, a1, a0, a1, &a0, &a1, &ign, &ign);
- } else if (a0 & 0xffffffffull) {
- mul64To128(a0, a0, &a0, &a1);
- } else if (a0 & ~DECOMPOSED_IMPLICIT_BIT) {
- a0 >>= 32;
- a0 *= a0;
- } else {
- goto exact;
- }
-
- if (a0 & DECOMPOSED_IMPLICIT_BIT) {
- if (unlikely(a_exp == 0 && r == 0)) {
- /*
- * When a_exp == 0, we're computing the log2 of a value
- * [1.0,2.0). When the value is very close to 1.0, there
- * are lots of 0's in the msb parts of the fraction.
- * We need to compute more digits to produce a correct
- * result -- restart at the top of the fraction.
- * ??? This is likely to lose precision quickly, as for
- * float128; we may need another method.
- */
- f_exp -= i;
- t = r = DECOMPOSED_IMPLICIT_BIT;
- i = 0;
- } else {
- r |= t;
- }
- } else {
- add128(a0, a1, a0, a1, &a0, &a1);
- }
- t >>= 1;
- }
-
- /* Set sticky for inexact. */
- r |= (a1 || a0 & ~DECOMPOSED_IMPLICIT_BIT);
-
- exact:
- partsN(sint_to_float)(a, a_exp, 0, s);
- if (r == 0) {
- return;
- }
-
- memset(&f, 0, sizeof(f));
- f.cls = float_class_normal;
- f.frac_hi = r;
- f.exp = f_exp - frac_normalize(&f);
-
- if (a_exp < 0) {
- partsN(sub_normal)(a, &f);
- } else if (a_exp > 0) {
- partsN(add_normal)(a, &f);
- } else {
- *a = f;
- }
- return;
-
- d_nan:
- float_raise(float_flag_invalid, s);
- partsN(default_nan)(a, s);
-}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 28/48] fpu: Drop parts_float_to_float
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (26 preceding siblings ...)
2026-04-29 22:24 ` [PULL 27/48] fpu: Drop parts_log2 Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 29/48] fpu: Drop PARTS_GENERIC_64_128{_256} Richard Henderson
` (20 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Use parts{64,128}_float_to_float at each call site.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 37 +++++++++++++++++--------------------
1 file changed, 17 insertions(+), 20 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 6a38d161f7..b1c2f884fc 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -2695,9 +2695,6 @@ static void parts128_float_to_float(FloatParts128 *a, float_status *s)
}
}
-#define parts_float_to_float(P, S) \
- PARTS_GENERIC_64_128(float_to_float, P)(P, S)
-
static void parts_float_to_float_narrow(FloatParts64 *a, FloatParts128 *b,
float_status *s)
{
@@ -2744,7 +2741,7 @@ float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1 a, float_status *s)
FloatParts64 p;
float4_e2m1_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, false);
}
@@ -2753,7 +2750,7 @@ bfloat16 float8_e4m3_to_bfloat16(float8_e4m3 a, float_status *s)
FloatParts64 p;
float8_e4m3_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -2762,7 +2759,7 @@ bfloat16 float8_e5m2_to_bfloat16(float8_e5m2 a, float_status *s)
FloatParts64 p;
float8_e5m2_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -2772,7 +2769,7 @@ float32 float16_to_float32(float16 a, bool ieee, float_status *s)
FloatParts64 p;
float16a_unpack_canonical(&p, a, s, fmt16);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
@@ -2782,7 +2779,7 @@ float64 float16_to_float64(float16 a, bool ieee, float_status *s)
FloatParts64 p;
float16a_unpack_canonical(&p, a, s, fmt16);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
@@ -2791,7 +2788,7 @@ float8_e4m3 float32_to_float8_e4m3(float32 a, bool saturate, float_status *s)
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, saturate);
}
@@ -2811,7 +2808,7 @@ float16 float32_to_float16(float32 a, bool ieee, float_status *s)
float32_unpack_canonical(&p, a, s);
if (ieee) {
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
fmt = &float16_params;
} else {
parts_float_to_ahp(&p, s);
@@ -2826,7 +2823,7 @@ soft_float32_to_float64(float32 a, float_status *s)
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
@@ -2853,7 +2850,7 @@ float16 float64_to_float16(float64 a, bool ieee, float_status *s)
float64_unpack_canonical(&p, a, s);
if (ieee) {
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
fmt = &float16_params;
} else {
parts_float_to_ahp(&p, s);
@@ -2867,7 +2864,7 @@ float32 float64_to_float32(float64 a, float_status *s)
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
@@ -2876,7 +2873,7 @@ float8_e4m3 bfloat16_to_float8_e4m3(bfloat16 a, bool saturate, float_status *s)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, saturate);
}
@@ -2894,7 +2891,7 @@ float32 bfloat16_to_float32(bfloat16 a, float_status *s)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
@@ -2903,7 +2900,7 @@ float64 bfloat16_to_float64(bfloat16 a, float_status *s)
FloatParts64 p;
bfloat16_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
@@ -2912,7 +2909,7 @@ bfloat16 float32_to_bfloat16(float32 a, float_status *s)
FloatParts64 p;
float32_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -2921,7 +2918,7 @@ bfloat16 float64_to_bfloat16(float64 a, float_status *s)
FloatParts64 p;
float64_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -2996,7 +2993,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
FloatParts128 p;
if (floatx80_unpack_canonical(&p, a, s)) {
- parts_float_to_float(&p, s);
+ parts128_float_to_float(&p, s);
} else {
parts128_default_nan(&p, s);
}
@@ -3028,7 +3025,7 @@ floatx80 float128_to_floatx80(float128 a, float_status *s)
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
- parts_float_to_float(&p, s);
+ parts128_float_to_float(&p, s);
return floatx80_round_pack_canonical(&p, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 29/48] fpu: Drop PARTS_GENERIC_64_128{_256}
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (27 preceding siblings ...)
2026-04-29 22:24 ` [PULL 28/48] fpu: Drop parts_float_to_float Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 30/48] fpu: Drop FRAC_GENERIC_64_128{_256} Richard Henderson
` (19 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
These macros are no longer used.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index b1c2f884fc..d077e8da69 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -770,15 +770,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
*----------------------------------------------------------------------------*/
#include "softfloat-specialize.c.inc"
-#define PARTS_GENERIC_64_128(NAME, P) \
- _Generic((P), FloatParts64 *: parts64_##NAME, \
- FloatParts128 *: parts128_##NAME)
-
-#define PARTS_GENERIC_64_128_256(NAME, P) \
- _Generic((P), FloatParts64 *: parts64_##NAME, \
- FloatParts128 *: parts128_##NAME, \
- FloatParts256 *: parts256_##NAME)
-
/*
* Helper functions for softfloat-parts.c.inc, per-size operations.
*/
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 30/48] fpu: Drop FRAC_GENERIC_64_128{_256}
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (28 preceding siblings ...)
2026-04-29 22:24 ` [PULL 29/48] fpu: Drop PARTS_GENERIC_64_128{_256} Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 31/48] fpu: Constify frac{64,128,256}_* inputs Richard Henderson
` (18 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
This requires more complexity to handle const selectors, and
an indirection macro for each function. Easier to just use
the preprocessor.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 69 +++++----------------
fpu/softfloat-parts-addsub.c.inc | 22 +++----
fpu/softfloat-parts.c.inc | 102 +++++++++++++++----------------
3 files changed, 77 insertions(+), 116 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index d077e8da69..e462fb7d74 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -774,15 +774,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
* Helper functions for softfloat-parts.c.inc, per-size operations.
*/
-#define FRAC_GENERIC_64_128(NAME, P) \
- _Generic((P), FloatParts64 *: frac64_##NAME, \
- FloatParts128 *: frac128_##NAME)
-
-#define FRAC_GENERIC_64_128_256(NAME, P) \
- _Generic((P), FloatParts64 *: frac64_##NAME, \
- FloatParts128 *: frac128_##NAME, \
- FloatParts256 *: frac256_##NAME)
-
static bool frac64_add(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b)
{
return uadd64_overflow(a->frac, b->frac, &r->frac);
@@ -806,8 +797,6 @@ static bool frac256_add(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
return c;
}
-#define frac_add(R, A, B) FRAC_GENERIC_64_128_256(add, R)(R, A, B)
-
static bool frac64_addi(FloatParts64 *r, FloatParts64 *a, uint64_t c)
{
return uadd64_overflow(a->frac, c, &r->frac);
@@ -819,8 +808,6 @@ static bool frac128_addi(FloatParts128 *r, FloatParts128 *a, uint64_t c)
return uadd64_overflow(a->frac_hi, c, &r->frac_hi);
}
-#define frac_addi(R, A, C) FRAC_GENERIC_64_128(addi, R)(R, A, C)
-
static void frac64_allones(FloatParts64 *a)
{
a->frac = -1;
@@ -831,8 +818,6 @@ static void frac128_allones(FloatParts128 *a)
a->frac_hi = a->frac_lo = -1;
}
-#define frac_allones(A) FRAC_GENERIC_64_128(allones, A)(A)
-
static FloatRelation frac64_cmp(FloatParts64 *a, FloatParts64 *b)
{
return (a->frac == b->frac ? float_relation_equal
@@ -852,8 +837,6 @@ static FloatRelation frac128_cmp(FloatParts128 *a, FloatParts128 *b)
return ta < tb ? float_relation_less : float_relation_greater;
}
-#define frac_cmp(A, B) FRAC_GENERIC_64_128(cmp, A)(A, B)
-
static void frac64_clear(FloatParts64 *a)
{
a->frac = 0;
@@ -864,8 +847,6 @@ static void frac128_clear(FloatParts128 *a)
a->frac_hi = a->frac_lo = 0;
}
-#define frac_clear(A) FRAC_GENERIC_64_128(clear, A)(A)
-
static bool frac64_div(FloatParts64 *a, FloatParts64 *b)
{
uint64_t n1, n0, r, q;
@@ -945,8 +926,6 @@ static bool frac128_div(FloatParts128 *a, FloatParts128 *b)
return ret;
}
-#define frac_div(A, B) FRAC_GENERIC_64_128(div, A)(A, B)
-
static bool frac64_eqz(FloatParts64 *a)
{
return a->frac == 0;
@@ -957,8 +936,6 @@ static bool frac128_eqz(FloatParts128 *a)
return (a->frac_hi | a->frac_lo) == 0;
}
-#define frac_eqz(A) FRAC_GENERIC_64_128(eqz, A)(A)
-
static void frac64_mulw(FloatParts128 *r, FloatParts64 *a, FloatParts64 *b)
{
mulu64(&r->frac_lo, &r->frac_hi, a->frac, b->frac);
@@ -970,8 +947,6 @@ static void frac128_mulw(FloatParts256 *r, FloatParts128 *a, FloatParts128 *b)
&r->frac_hi, &r->frac_hm, &r->frac_lm, &r->frac_lo);
}
-#define frac_mulw(R, A, B) FRAC_GENERIC_64_128(mulw, A)(R, A, B)
-
static void frac64_neg(FloatParts64 *a)
{
a->frac = -a->frac;
@@ -993,8 +968,6 @@ static void frac256_neg(FloatParts256 *a)
a->frac_hi = usub64_borrow(0, a->frac_hi, &c);
}
-#define frac_neg(A) FRAC_GENERIC_64_128_256(neg, A)(A)
-
static int frac64_normalize(FloatParts64 *a)
{
if (a->frac) {
@@ -1068,8 +1041,6 @@ static int frac256_normalize(FloatParts256 *a)
return ret;
}
-#define frac_normalize(A) FRAC_GENERIC_64_128_256(normalize, A)(A)
-
static void frac64_modrem(FloatParts64 *a, FloatParts64 *b, uint64_t *mod_quot)
{
uint64_t a0, a1, b0, t0, t1, q, quot;
@@ -1248,8 +1219,6 @@ static void frac128_modrem(FloatParts128 *a, FloatParts128 *b,
a->frac_lo = a1 | (a2 != 0);
}
-#define frac_modrem(A, B, Q) FRAC_GENERIC_64_128(modrem, A)(A, B, Q)
-
static void frac64_shl(FloatParts64 *a, int c)
{
a->frac <<= c;
@@ -1273,8 +1242,6 @@ static void frac128_shl(FloatParts128 *a, int c)
a->frac_lo = a1;
}
-#define frac_shl(A, C) FRAC_GENERIC_64_128(shl, A)(A, C)
-
static void frac64_shr(FloatParts64 *a, int c)
{
a->frac >>= c;
@@ -1298,8 +1265,6 @@ static void frac128_shr(FloatParts128 *a, int c)
a->frac_lo = a1;
}
-#define frac_shr(A, C) FRAC_GENERIC_64_128(shr, A)(A, C)
-
static void frac64_shrjam(FloatParts64 *a, int c)
{
uint64_t a0 = a->frac;
@@ -1388,8 +1353,6 @@ static void frac256_shrjam(FloatParts256 *a, int c)
a->frac_hi = a0;
}
-#define frac_shrjam(A, C) FRAC_GENERIC_64_128_256(shrjam, A)(A, C)
-
static bool frac64_sub(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b)
{
return usub64_overflow(a->frac, b->frac, &r->frac);
@@ -1413,8 +1376,6 @@ static bool frac256_sub(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
return c;
}
-#define frac_sub(R, A, B) FRAC_GENERIC_64_128_256(sub, R)(R, A, B)
-
static void frac64_truncjam(FloatParts64 *r, FloatParts128 *a)
{
r->frac = a->frac_hi | (a->frac_lo != 0);
@@ -1426,8 +1387,6 @@ static void frac128_truncjam(FloatParts128 *r, FloatParts256 *a)
r->frac_lo = a->frac_hm | ((a->frac_lm | a->frac_lo) != 0);
}
-#define frac_truncjam(R, A) FRAC_GENERIC_64_128(truncjam, R)(R, A)
-
static void frac64_widen(FloatParts128 *r, FloatParts64 *a)
{
r->frac_hi = a->frac;
@@ -1442,8 +1401,6 @@ static void frac128_widen(FloatParts256 *r, FloatParts128 *a)
r->frac_lo = 0;
}
-#define frac_widen(A, B) FRAC_GENERIC_64_128(widen, B)(A, B)
-
/*
* Reciprocal sqrt table. 1 bit of exponent, 6-bits of mantessa.
* From https://git.musl-libc.org/cgit/musl/tree/src/math/sqrt_data.c
@@ -1468,6 +1425,8 @@ static const uint16_t rsqrt_tab[128] = {
0xba91, 0xb9cc, 0xb90a, 0xb84a, 0xb78c, 0xb6d0, 0xb617, 0xb560,
};
+#define fracN(NAME) glue(glue(glue(frac,N),_),NAME)
+#define fracW(NAME) glue(glue(glue(frac,W),_),NAME)
#define partsN(NAME) glue(glue(glue(parts,N),_),NAME)
#define partsW(NAME) glue(glue(glue(parts,W),_),NAME)
#define FloatPartsN glue(FloatParts,N)
@@ -1494,6 +1453,8 @@ static const uint16_t rsqrt_tab[128] = {
#undef N
#undef W
+#undef fracN
+#undef fracW
#undef partsN
#undef partsW
#undef FloatPartsN
@@ -1624,19 +1585,19 @@ static float64 float64r32_pack_raw(FloatParts64 *p)
* The result is denormal for float32, but can be represented
* in normalized form for float64. Adjust, per canonicalize.
*/
- int shift = frac_normalize(p);
+ int shift = frac64_normalize(p);
p->exp = (float32_params.frac_shift -
float32_params.exp_bias - shift + 1 +
float64_params.exp_bias);
- frac_shr(p, float64_params.frac_shift);
+ frac64_shr(p, float64_params.frac_shift);
} else {
- frac_shl(p, float32_params.frac_shift - float64_params.frac_shift);
+ frac64_shl(p, float32_params.frac_shift - float64_params.frac_shift);
p->exp += float64_params.exp_bias - float32_params.exp_bias;
}
break;
case float_class_snan:
case float_class_qnan:
- frac_shl(p, float32_params.frac_shift - float64_params.frac_shift);
+ frac64_shl(p, float32_params.frac_shift - float64_params.frac_shift);
p->exp = float64_params.exp_max;
break;
case float_class_inf:
@@ -1724,7 +1685,7 @@ static floatx80 floatx80_round_pack_canonical(FloatParts128 *p,
p64.sign = p->sign;
p64.exp = p->exp;
- frac_truncjam(&p64, p);
+ frac64_truncjam(&p64, p);
parts64_uncanon_normal(&p64, s, fmt, false);
frac = p64.frac;
exp = p64.exp;
@@ -2698,7 +2659,7 @@ static void parts_float_to_float_narrow(FloatParts64 *a, FloatParts128 *b,
float_raise(float_flag_input_denormal_used, s);
/* fall through */
case float_class_normal:
- frac_truncjam(a, b);
+ frac64_truncjam(a, b);
break;
case float_class_snan:
case float_class_qnan:
@@ -2717,7 +2678,7 @@ static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b,
a->cls = b->cls;
a->sign = b->sign;
a->exp = b->exp;
- frac_widen(a, b);
+ frac64_widen(a, b);
if (is_nan(a->cls)) {
parts128_return_nan(a, s);
@@ -4939,7 +4900,7 @@ static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *fmt)
FloatParts64 f = {
.cls = float_class_normal, .frac = r
};
- f.exp = f_exp - frac_normalize(&f);
+ f.exp = f_exp - frac64_normalize(&f);
if (a_exp < 0) {
parts64_sub_normal(a, &f);
@@ -5010,7 +4971,7 @@ float128 float128_default_nan(float_status *status)
FloatParts128 p;
parts128_default_nan(&p, status);
- frac_shr(&p, float128_params.frac_shift);
+ frac128_shr(&p, float128_params.frac_shift);
return float128_pack_raw(&p);
}
@@ -5076,9 +5037,9 @@ float128 float128_silence_nan(float128 a, float_status *status)
FloatParts128 p;
float128_unpack_raw(&p, a);
- frac_shl(&p, float128_params.frac_shift);
+ frac128_shl(&p, float128_params.frac_shift);
parts128_silence_nan(&p, status);
- frac_shr(&p, float128_params.frac_shift);
+ frac128_shr(&p, float128_params.frac_shift);
return float128_pack_raw(&p);
}
diff --git a/fpu/softfloat-parts-addsub.c.inc b/fpu/softfloat-parts-addsub.c.inc
index ae5c1017c5..accf996d7c 100644
--- a/fpu/softfloat-parts-addsub.c.inc
+++ b/fpu/softfloat-parts-addsub.c.inc
@@ -20,14 +20,14 @@ static void partsN(add_normal)(FloatPartsN *a, FloatPartsN *b)
int exp_diff = a->exp - b->exp;
if (exp_diff > 0) {
- frac_shrjam(b, exp_diff);
+ fracN(shrjam)(b, exp_diff);
} else if (exp_diff < 0) {
- frac_shrjam(a, -exp_diff);
+ fracN(shrjam)(a, -exp_diff);
a->exp = b->exp;
}
- if (frac_add(a, a, b)) {
- frac_shrjam(a, 1);
+ if (fracN(add)(a, a, b)) {
+ fracN(shrjam)(a, 1);
a->frac_hi |= DECOMPOSED_IMPLICIT_BIT;
a->exp += 1;
}
@@ -39,20 +39,20 @@ static bool partsN(sub_normal)(FloatPartsN *a, FloatPartsN *b)
int shift;
if (exp_diff > 0) {
- frac_shrjam(b, exp_diff);
- frac_sub(a, a, b);
+ fracN(shrjam)(b, exp_diff);
+ fracN(sub)(a, a, b);
} else if (exp_diff < 0) {
a->exp = b->exp;
a->sign ^= 1;
- frac_shrjam(a, -exp_diff);
- frac_sub(a, b, a);
- } else if (frac_sub(a, a, b)) {
+ fracN(shrjam)(a, -exp_diff);
+ fracN(sub)(a, b, a);
+ } else if (fracN(sub)(a, a, b)) {
/* Overflow means that A was less than B. */
- frac_neg(a);
+ fracN(neg)(a);
a->sign ^= 1;
}
- shift = frac_normalize(a);
+ shift = fracN(normalize)(a);
if (likely(shift < N)) {
a->exp -= shift;
return true;
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 5f27efd288..5d344f9afe 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -98,7 +98,7 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b,
ret = b;
break;
}
- cmp = frac_cmp(a, b);
+ cmp = fracN(cmp)(a, b);
if (cmp == 0) {
cmp = a->sign < b->sign;
}
@@ -215,14 +215,14 @@ static void partsN(canonicalize)(FloatPartsN *p, float_status *status,
(status->floatx80_behaviour & floatx80_pseudo_denormal_valid);
if (unlikely(p->exp == 0)) {
- if (likely(frac_eqz(p))) {
+ if (likely(fracN(eqz)(p))) {
p->cls = float_class_zero;
} else if (status->flush_inputs_to_zero) {
float_raise(float_flag_input_denormal_flushed, status);
p->cls = float_class_zero;
- frac_clear(p);
+ fracN(clear)(p);
} else {
- int shift = frac_normalize(p);
+ int shift = fracN(normalize)(p);
p->cls = float_class_denormal;
p->exp = fmt->frac_shift - fmt->exp_bias
- shift + !has_pseudo_denormals;
@@ -232,10 +232,10 @@ static void partsN(canonicalize)(FloatPartsN *p, float_status *status,
if (unlikely(p->exp == fmt->exp_max)) {
switch (fmt->exp_max_kind) {
case float_expmax_ieee:
- if (likely(frac_eqz(p))) {
+ if (likely(fracN(eqz)(p))) {
p->cls = float_class_inf;
} else {
- frac_shl(p, fmt->frac_shift);
+ fracN(shl)(p, fmt->frac_shift);
p->cls = (parts_is_snan_frac(p->frac_hi, status)
? float_class_snan : float_class_qnan);
}
@@ -244,7 +244,7 @@ static void partsN(canonicalize)(FloatPartsN *p, float_status *status,
break;
case float_expmax_e4m3:
if (p->frac_hi == 0b111) {
- frac_shl(p, fmt->frac_shift);
+ fracN(shl)(p, fmt->frac_shift);
p->cls = (parts_is_snan_frac(p->frac_hi, status)
? float_class_snan : float_class_qnan);
return;
@@ -258,7 +258,7 @@ static void partsN(canonicalize)(FloatPartsN *p, float_status *status,
p->cls = float_class_normal;
p->exp -= fmt->exp_bias;
- frac_shl(p, fmt->frac_shift);
+ fracN(shl)(p, fmt->frac_shift);
p->frac_hi |= DECOMPOSED_IMPLICIT_BIT;
}
@@ -344,8 +344,8 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
if (likely(exp > 0)) {
if (p->frac_lo & round_mask) {
flags |= float_flag_inexact;
- if (frac_addi(p, p, inc)) {
- frac_shr(p, 1);
+ if (fracN(addi)(p, p, inc)) {
+ fracN(shr)(p, 1);
p->frac_hi |= DECOMPOSED_IMPLICIT_BIT;
exp++;
}
@@ -361,13 +361,13 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
} else if (overflow_norm) {
flags |= float_flag_inexact;
exp = exp_max - 1;
- frac_allones(p);
+ fracN(allones)(p);
p->frac_lo &= ~round_mask;
} else {
flags |= float_flag_inexact;
p->cls = float_class_inf;
exp = exp_max;
- frac_clear(p);
+ fracN(clear)(p);
}
break;
@@ -378,7 +378,7 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
? float_flag_invalid
: float_flag_overflow | float_flag_inexact);
exp = exp_max;
- frac_allones(p);
+ fracN(allones)(p);
p->frac_lo &= ~round_mask;
}
break;
@@ -395,26 +395,26 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
g_assert_not_reached();
}
}
- frac_shr(p, frac_shift);
+ fracN(shr)(p, frac_shift);
} else if (unlikely(s->rebias_underflow)) {
flags |= float_flag_underflow;
exp += fmt->exp_re_bias;
if (p->frac_lo & round_mask) {
flags |= float_flag_inexact;
- if (frac_addi(p, p, inc)) {
- frac_shr(p, 1);
+ if (fracN(addi)(p, p, inc)) {
+ fracN(shr)(p, 1);
p->frac_hi |= DECOMPOSED_IMPLICIT_BIT;
exp++;
}
p->frac_lo &= ~round_mask;
}
- frac_shr(p, frac_shift);
+ fracN(shr)(p, frac_shift);
} else if (s->flush_to_zero &&
s->ftz_detection == float_ftz_before_rounding) {
flags |= float_flag_output_denormal_flushed;
p->cls = float_class_zero;
exp = 0;
- frac_clear(p);
+ fracN(clear)(p);
} else {
bool is_tiny = s->tininess_before_rounding || exp < 0;
bool has_pseudo_denormals = fmt->has_explicit_bit &&
@@ -422,10 +422,10 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
if (!is_tiny) {
FloatPartsN discard;
- is_tiny = !frac_addi(&discard, p, inc);
+ is_tiny = !fracN(addi)(&discard, p, inc);
}
- frac_shrjam(p, !has_pseudo_denormals - exp);
+ fracN(shrjam)(p, !has_pseudo_denormals - exp);
if (p->frac_lo & round_mask) {
/* Need to recompute round-to-even/round-to-odd. */
@@ -452,12 +452,12 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
break;
}
flags |= float_flag_inexact;
- frac_addi(p, p, inc);
+ fracN(addi)(p, p, inc);
p->frac_lo &= ~round_mask;
}
exp = (p->frac_hi & DECOMPOSED_IMPLICIT_BIT) && !has_pseudo_denormals;
- frac_shr(p, frac_shift);
+ fracN(shr)(p, frac_shift);
if (is_tiny) {
if (s->flush_to_zero) {
@@ -465,11 +465,11 @@ static void partsN(uncanon_normal)(FloatPartsN *p, float_status *s,
flags |= float_flag_output_denormal_flushed;
p->cls = float_class_zero;
exp = 0;
- frac_clear(p);
+ fracN(clear)(p);
} else if (flags & float_flag_inexact) {
flags |= float_flag_underflow;
}
- if (exp == 0 && frac_eqz(p)) {
+ if (exp == 0 && fracN(eqz)(p)) {
p->cls = float_class_zero;
}
}
@@ -487,17 +487,17 @@ static void partsN(uncanon)(FloatPartsN *p, float_status *s,
switch (p->cls) {
case float_class_zero:
p->exp = 0;
- frac_clear(p);
+ fracN(clear)(p);
return;
case float_class_inf:
switch (fmt->exp_max_kind) {
case float_expmax_ieee:
p->exp = fmt->exp_max;
- frac_clear(p);
+ fracN(clear)(p);
break;
case float_expmax_e4m3:
partsN(uncanon_e4m3_overflow)(p, s, fmt, saturate);
- frac_shr(p, fmt->frac_shift);
+ fracN(shr)(p, fmt->frac_shift);
break;
case float_expmax_normal:
default:
@@ -508,7 +508,7 @@ static void partsN(uncanon)(FloatPartsN *p, float_status *s,
case float_class_snan:
assert(fmt->exp_max_kind != float_expmax_normal);
p->exp = fmt->exp_max;
- frac_shr(p, fmt->frac_shift);
+ fracN(shr)(p, fmt->frac_shift);
return;
default:
break;
@@ -625,12 +625,12 @@ static FloatPartsN *partsN(mul)(FloatPartsN *a, FloatPartsN *b,
float_raise(float_flag_input_denormal_used, s);
}
- frac_mulw(&tmp, a, b);
- frac_truncjam(a, &tmp);
+ fracN(mulw)(&tmp, a, b);
+ fracN(truncjam)(a, &tmp);
a->exp += b->exp + 1;
if (!(a->frac_hi & DECOMPOSED_IMPLICIT_BIT)) {
- frac_add(a, a, a);
+ fracN(add)(a, a, a);
a->exp -= 1;
}
@@ -747,16 +747,16 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
/* Perform the multiplication step. */
p_widen.sign = a->sign;
p_widen.exp = a->exp + b->exp + 1;
- frac_mulw(&p_widen, a, b);
+ fracN(mulw)(&p_widen, a, b);
if (!(p_widen.frac_hi & DECOMPOSED_IMPLICIT_BIT)) {
- frac_add(&p_widen, &p_widen, &p_widen);
+ fracW(add)(&p_widen, &p_widen, &p_widen);
p_widen.exp -= 1;
}
/* Perform the addition step. */
if (c->cls != float_class_zero) {
/* Zero-extend C to less significant bits. */
- frac_widen(&c_widen, c);
+ fracN(widen)(&c_widen, c);
c_widen.exp = c->exp;
if (a->sign == c->sign) {
@@ -767,7 +767,7 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
}
/* Narrow with sticky bit, for proper rounding later. */
- frac_truncjam(a, &p_widen);
+ fracN(truncjam)(a, &p_widen);
a->sign = p_widen.sign;
a->exp = p_widen.exp;
@@ -816,7 +816,7 @@ static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,
float_raise(float_flag_input_denormal_used, s);
}
a->sign = sign;
- a->exp -= b->exp + frac_div(a, b);
+ a->exp -= b->exp + fracN(div)(a, b);
return a;
}
@@ -880,7 +880,7 @@ static FloatPartsN *partsN(modrem)(FloatPartsN *a, FloatPartsN *b,
if (ab_mask & float_cmask_denormal) {
float_raise(float_flag_input_denormal_used, s);
}
- frac_modrem(a, b, mod_quot);
+ fracN(modrem)(a, b, mod_quot);
return a;
}
@@ -969,7 +969,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
exp_odd = a->exp & 1;
index = extract64(a->frac_hi, 57, 6) | (!exp_odd << 6);
if (!exp_odd) {
- frac_shr(a, 1);
+ fracN(shr)(a, 1);
}
/*
@@ -1110,7 +1110,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,
/* Convert back from base 4 to base 2. */
a->exp >>= 1;
if (!(a->frac_hi & DECOMPOSED_IMPLICIT_BIT)) {
- frac_add(a, a, a);
+ fracN(add)(a, a, a);
} else {
a->exp += 1;
}
@@ -1150,9 +1150,9 @@ static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmode,
if (a->exp == -1) {
FloatPartsN tmp;
/* Shift left one, discarding DECOMPOSED_IMPLICIT_BIT */
- frac_add(&tmp, a, a);
+ fracN(add)(&tmp, a, a);
/* Anything remaining means frac > 0.5. */
- one = !frac_eqz(&tmp);
+ one = !fracN(eqz)(&tmp);
}
break;
case float_round_ties_away:
@@ -1174,7 +1174,7 @@ static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmode,
g_assert_not_reached();
}
- frac_clear(a);
+ fracN(clear)(a);
a->exp = 0;
if (one) {
a->frac_hi = DECOMPOSED_IMPLICIT_BIT;
@@ -1190,7 +1190,7 @@ static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmode,
* which leaves room for sticky and rounding bit.
*/
shift_adj = (N - 1) - (a->exp + 2);
- frac_shrjam(a, shift_adj);
+ fracN(shrjam)(a, shift_adj);
frac_lsb = 1 << 2;
} else {
/*
@@ -1208,7 +1208,7 @@ static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmode,
if (!(a->frac_lo & rnd_mask)) {
/* Fractional bits already clear, undo the shift above. */
- frac_shl(a, shift_adj);
+ fracN(shl)(a, shift_adj);
return false;
}
@@ -1236,21 +1236,21 @@ static bool partsN(round_to_int_normal)(FloatPartsN *a, FloatRoundMode rmode,
}
if (shift_adj == 0) {
- if (frac_addi(a, a, inc)) {
- frac_shr(a, 1);
+ if (fracN(addi)(a, a, inc)) {
+ fracN(shr)(a, 1);
a->frac_hi |= DECOMPOSED_IMPLICIT_BIT;
a->exp++;
}
a->frac_lo &= ~rnd_mask;
} else {
- frac_addi(a, a, inc);
+ fracN(addi)(a, a, inc);
a->frac_lo &= ~rnd_mask;
/* Be careful shifting back, not to overflow */
- frac_shl(a, shift_adj - 1);
+ fracN(shl)(a, shift_adj - 1);
if (a->frac_hi & DECOMPOSED_IMPLICIT_BIT) {
a->exp++;
} else {
- frac_add(a, a, a);
+ fracN(add)(a, a, a);
}
}
return true;
@@ -1555,7 +1555,7 @@ static FloatPartsN *partsN(minmax)(FloatPartsN *a, FloatPartsN *b,
/* Compare magnitudes. */
cmp = a_exp - b_exp;
if (cmp == 0) {
- cmp = frac_cmp(a, b);
+ cmp = fracN(cmp)(a, b);
}
/*
@@ -1597,7 +1597,7 @@ static FloatRelation partsN(compare)(FloatPartsN *a, FloatPartsN *b,
goto a_sign;
}
if (a->exp == b->exp) {
- cmp = frac_cmp(a, b);
+ cmp = fracN(cmp)(a, b);
} else if (a->exp < b->exp) {
cmp = float_relation_less;
} else {
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 31/48] fpu: Constify frac{64,128,256}_* inputs
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (29 preceding siblings ...)
2026-04-29 22:24 ` [PULL 30/48] fpu: Drop FRAC_GENERIC_64_128{_256} Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 32/48] fpu: Return structure from unpack_raw64 Richard Henderson
` (17 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 53 +++++++++++++++++++++++++++++--------------------
1 file changed, 31 insertions(+), 22 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index e462fb7d74..6cca31af30 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -774,12 +774,14 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)
* Helper functions for softfloat-parts.c.inc, per-size operations.
*/
-static bool frac64_add(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b)
+static bool frac64_add(FloatParts64 *r,
+ const FloatParts64 *a, const FloatParts64 *b)
{
return uadd64_overflow(a->frac, b->frac, &r->frac);
}
-static bool frac128_add(FloatParts128 *r, FloatParts128 *a, FloatParts128 *b)
+static bool frac128_add(FloatParts128 *r,
+ const FloatParts128 *a, const FloatParts128 *b)
{
bool c = 0;
r->frac_lo = uadd64_carry(a->frac_lo, b->frac_lo, &c);
@@ -787,7 +789,8 @@ static bool frac128_add(FloatParts128 *r, FloatParts128 *a, FloatParts128 *b)
return c;
}
-static bool frac256_add(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
+static bool frac256_add(FloatParts256 *r,
+ const FloatParts256 *a, const FloatParts256 *b)
{
bool c = 0;
r->frac_lo = uadd64_carry(a->frac_lo, b->frac_lo, &c);
@@ -797,12 +800,12 @@ static bool frac256_add(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
return c;
}
-static bool frac64_addi(FloatParts64 *r, FloatParts64 *a, uint64_t c)
+static bool frac64_addi(FloatParts64 *r, const FloatParts64 *a, uint64_t c)
{
return uadd64_overflow(a->frac, c, &r->frac);
}
-static bool frac128_addi(FloatParts128 *r, FloatParts128 *a, uint64_t c)
+static bool frac128_addi(FloatParts128 *r, const FloatParts128 *a, uint64_t c)
{
c = uadd64_overflow(a->frac_lo, c, &r->frac_lo);
return uadd64_overflow(a->frac_hi, c, &r->frac_hi);
@@ -818,14 +821,14 @@ static void frac128_allones(FloatParts128 *a)
a->frac_hi = a->frac_lo = -1;
}
-static FloatRelation frac64_cmp(FloatParts64 *a, FloatParts64 *b)
+static FloatRelation frac64_cmp(const FloatParts64 *a, const FloatParts64 *b)
{
return (a->frac == b->frac ? float_relation_equal
: a->frac < b->frac ? float_relation_less
: float_relation_greater);
}
-static FloatRelation frac128_cmp(FloatParts128 *a, FloatParts128 *b)
+static FloatRelation frac128_cmp(const FloatParts128 *a, const FloatParts128 *b)
{
uint64_t ta = a->frac_hi, tb = b->frac_hi;
if (ta == tb) {
@@ -847,7 +850,7 @@ static void frac128_clear(FloatParts128 *a)
a->frac_hi = a->frac_lo = 0;
}
-static bool frac64_div(FloatParts64 *a, FloatParts64 *b)
+static bool frac64_div(FloatParts64 *a, const FloatParts64 *b)
{
uint64_t n1, n0, r, q;
bool ret;
@@ -879,7 +882,7 @@ static bool frac64_div(FloatParts64 *a, FloatParts64 *b)
return ret;
}
-static bool frac128_div(FloatParts128 *a, FloatParts128 *b)
+static bool frac128_div(FloatParts128 *a, const FloatParts128 *b)
{
uint64_t q0, q1, a0, a1, b0, b1;
uint64_t r0, r1, r2, r3, t0, t1, t2, t3;
@@ -926,22 +929,24 @@ static bool frac128_div(FloatParts128 *a, FloatParts128 *b)
return ret;
}
-static bool frac64_eqz(FloatParts64 *a)
+static bool frac64_eqz(const FloatParts64 *a)
{
return a->frac == 0;
}
-static bool frac128_eqz(FloatParts128 *a)
+static bool frac128_eqz(const FloatParts128 *a)
{
return (a->frac_hi | a->frac_lo) == 0;
}
-static void frac64_mulw(FloatParts128 *r, FloatParts64 *a, FloatParts64 *b)
+static void frac64_mulw(FloatParts128 *r,
+ const FloatParts64 *a, const FloatParts64 *b)
{
mulu64(&r->frac_lo, &r->frac_hi, a->frac, b->frac);
}
-static void frac128_mulw(FloatParts256 *r, FloatParts128 *a, FloatParts128 *b)
+static void frac128_mulw(FloatParts256 *r,
+ const FloatParts128 *a, const FloatParts128 *b)
{
mul128To256(a->frac_hi, a->frac_lo, b->frac_hi, b->frac_lo,
&r->frac_hi, &r->frac_hm, &r->frac_lm, &r->frac_lo);
@@ -1041,7 +1046,8 @@ static int frac256_normalize(FloatParts256 *a)
return ret;
}
-static void frac64_modrem(FloatParts64 *a, FloatParts64 *b, uint64_t *mod_quot)
+static void frac64_modrem(FloatParts64 *a, const FloatParts64 *b,
+ uint64_t *mod_quot)
{
uint64_t a0, a1, b0, t0, t1, q, quot;
int exp_diff = a->exp - b->exp;
@@ -1124,7 +1130,7 @@ static void frac64_modrem(FloatParts64 *a, FloatParts64 *b, uint64_t *mod_quot)
a->frac = a0 | (a1 != 0);
}
-static void frac128_modrem(FloatParts128 *a, FloatParts128 *b,
+static void frac128_modrem(FloatParts128 *a, const FloatParts128 *b,
uint64_t *mod_quot)
{
uint64_t a0, a1, a2, b0, b1, t0, t1, t2, q, quot;
@@ -1353,12 +1359,14 @@ static void frac256_shrjam(FloatParts256 *a, int c)
a->frac_hi = a0;
}
-static bool frac64_sub(FloatParts64 *r, FloatParts64 *a, FloatParts64 *b)
+static bool frac64_sub(FloatParts64 *r,
+ const FloatParts64 *a, const FloatParts64 *b)
{
return usub64_overflow(a->frac, b->frac, &r->frac);
}
-static bool frac128_sub(FloatParts128 *r, FloatParts128 *a, FloatParts128 *b)
+static bool frac128_sub(FloatParts128 *r,
+ const FloatParts128 *a, const FloatParts128 *b)
{
bool c = 0;
r->frac_lo = usub64_borrow(a->frac_lo, b->frac_lo, &c);
@@ -1366,7 +1374,8 @@ static bool frac128_sub(FloatParts128 *r, FloatParts128 *a, FloatParts128 *b)
return c;
}
-static bool frac256_sub(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
+static bool frac256_sub(FloatParts256 *r,
+ const FloatParts256 *a, const FloatParts256 *b)
{
bool c = 0;
r->frac_lo = usub64_borrow(a->frac_lo, b->frac_lo, &c);
@@ -1376,24 +1385,24 @@ static bool frac256_sub(FloatParts256 *r, FloatParts256 *a, FloatParts256 *b)
return c;
}
-static void frac64_truncjam(FloatParts64 *r, FloatParts128 *a)
+static void frac64_truncjam(FloatParts64 *r, const FloatParts128 *a)
{
r->frac = a->frac_hi | (a->frac_lo != 0);
}
-static void frac128_truncjam(FloatParts128 *r, FloatParts256 *a)
+static void frac128_truncjam(FloatParts128 *r, const FloatParts256 *a)
{
r->frac_hi = a->frac_hi;
r->frac_lo = a->frac_hm | ((a->frac_lm | a->frac_lo) != 0);
}
-static void frac64_widen(FloatParts128 *r, FloatParts64 *a)
+static void frac64_widen(FloatParts128 *r, const FloatParts64 *a)
{
r->frac_hi = a->frac;
r->frac_lo = 0;
}
-static void frac128_widen(FloatParts256 *r, FloatParts128 *a)
+static void frac128_widen(FloatParts256 *r, const FloatParts128 *a)
{
r->frac_hi = a->frac_hi;
r->frac_hm = a->frac_lo;
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 32/48] fpu: Return structure from unpack_raw64
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (30 preceding siblings ...)
2026-04-29 22:24 ` [PULL 31/48] fpu: Constify frac{64,128,256}_* inputs Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 33/48] fpu: Return struct from float4_e2m1_unpack_canonical Richard Henderson
` (16 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 6cca31af30..99b1cce894 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -633,12 +633,12 @@ static const FloatFmt floatx80_params[3] = {
};
/* Unpack a float to parts, but do not canonicalize. */
-static void unpack_raw64(FloatParts64 *r, const FloatFmt *fmt, uint64_t raw)
+static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
{
const int f_size = fmt->frac_size;
const int e_size = fmt->exp_size;
- *r = (FloatParts64) {
+ return (FloatParts64) {
.cls = float_class_unclassified,
.sign = extract64(raw, f_size + e_size, 1),
.exp = extract64(raw, f_size, e_size),
@@ -648,37 +648,37 @@ static void unpack_raw64(FloatParts64 *r, const FloatFmt *fmt, uint64_t raw)
static void QEMU_FLATTEN float4_e2m1_unpack_raw(FloatParts64 *p, float4_e2m1 f)
{
- unpack_raw64(p, &float4_e2m1_params, f);
+ *p = unpack_raw64(&float4_e2m1_params, f);
}
static void QEMU_FLATTEN float8_e4m3_unpack_raw(FloatParts64 *p, float8_e4m3 f)
{
- unpack_raw64(p, &float8_e4m3_params, f);
+ *p = unpack_raw64(&float8_e4m3_params, f);
}
static void QEMU_FLATTEN float8_e5m2_unpack_raw(FloatParts64 *p, float8_e5m2 f)
{
- unpack_raw64(p, &float8_e5m2_params, f);
+ *p = unpack_raw64(&float8_e5m2_params, f);
}
static void QEMU_FLATTEN float16_unpack_raw(FloatParts64 *p, float16 f)
{
- unpack_raw64(p, &float16_params, f);
+ *p = unpack_raw64(&float16_params, f);
}
static void QEMU_FLATTEN bfloat16_unpack_raw(FloatParts64 *p, bfloat16 f)
{
- unpack_raw64(p, &bfloat16_params, f);
+ *p = unpack_raw64(&bfloat16_params, f);
}
static void QEMU_FLATTEN float32_unpack_raw(FloatParts64 *p, float32 f)
{
- unpack_raw64(p, &float32_params, f);
+ *p = unpack_raw64(&float32_params, f);
}
static void QEMU_FLATTEN float64_unpack_raw(FloatParts64 *p, float64 f)
{
- unpack_raw64(p, &float64_params, f);
+ *p = unpack_raw64(&float64_params, f);
}
static void QEMU_FLATTEN floatx80_unpack_raw(FloatParts128 *p, floatx80 f)
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 33/48] fpu: Return struct from float4_e2m1_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (31 preceding siblings ...)
2026-04-29 22:24 ` [PULL 32/48] fpu: Return structure from unpack_raw64 Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 34/48] fpu: Return struct from float8_e4m3_unpack_canonical Richard Henderson
` (15 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Inline float4_e2m1_unpack_raw at the same time.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 +++++------------
1 file changed, 5 insertions(+), 12 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 99b1cce894..c1d0140484 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float4_e2m1_unpack_raw(FloatParts64 *p, float4_e2m1 f)
-{
- *p = unpack_raw64(&float4_e2m1_params, f);
-}
-
static void QEMU_FLATTEN float8_e4m3_unpack_raw(FloatParts64 *p, float8_e4m3 f)
{
*p = unpack_raw64(&float8_e4m3_params, f);
@@ -1473,11 +1468,11 @@ static const uint16_t rsqrt_tab[128] = {
* Pack/unpack routines with a specific FloatFmt.
*/
-static void float4_e2m1_unpack_canonical(FloatParts64 *p, float4_e2m1 f,
- float_status *s)
+static FloatParts64 float4_e2m1_unpack_canonical(float4_e2m1 f, float_status *s)
{
- float4_e2m1_unpack_raw(p, f);
- parts64_canonicalize(p, s, &float4_e2m1_params);
+ FloatParts64 p = unpack_raw64(&float4_e2m1_params, f);
+ parts64_canonicalize(&p, s, &float4_e2m1_params);
+ return p;
}
static void float8_e4m3_unpack_canonical(FloatParts64 *p, float8_e4m3 f,
@@ -2699,9 +2694,7 @@ static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b,
float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1 a, float_status *s)
{
- FloatParts64 p;
-
- float4_e2m1_unpack_canonical(&p, a, s);
+ FloatParts64 p = float4_e2m1_unpack_canonical(a, s);
parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, false);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 34/48] fpu: Return struct from float8_e4m3_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (32 preceding siblings ...)
2026-04-29 22:24 ` [PULL 33/48] fpu: Return struct from float4_e2m1_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 35/48] fpu: Return struct from float8_e5m2_unpack_canonical Richard Henderson
` (14 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Inline float8_e4m3_unpack_raw at the same time.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 +++++------------
1 file changed, 5 insertions(+), 12 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index c1d0140484..c1b03f30ab 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float8_e4m3_unpack_raw(FloatParts64 *p, float8_e4m3 f)
-{
- *p = unpack_raw64(&float8_e4m3_params, f);
-}
-
static void QEMU_FLATTEN float8_e5m2_unpack_raw(FloatParts64 *p, float8_e5m2 f)
{
*p = unpack_raw64(&float8_e5m2_params, f);
@@ -1475,11 +1470,11 @@ static FloatParts64 float4_e2m1_unpack_canonical(float4_e2m1 f, float_status *s)
return p;
}
-static void float8_e4m3_unpack_canonical(FloatParts64 *p, float8_e4m3 f,
- float_status *s)
+static FloatParts64 float8_e4m3_unpack_canonical(float8_e4m3 f, float_status *s)
{
- float8_e4m3_unpack_raw(p, f);
- parts64_canonicalize(p, s, &float8_e4m3_params);
+ FloatParts64 p = unpack_raw64(&float8_e4m3_params, f);
+ parts64_canonicalize(&p, s, &float8_e4m3_params);
+ return p;
}
static void float8_e5m2_unpack_canonical(FloatParts64 *p, float8_e5m2 f,
@@ -2701,9 +2696,7 @@ float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1 a, float_status *s)
bfloat16 float8_e4m3_to_bfloat16(float8_e4m3 a, float_status *s)
{
- FloatParts64 p;
-
- float8_e4m3_unpack_canonical(&p, a, s);
+ FloatParts64 p = float8_e4m3_unpack_canonical(a, s);
parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 35/48] fpu: Return struct from float8_e5m2_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (33 preceding siblings ...)
2026-04-29 22:24 ` [PULL 34/48] fpu: Return struct from float8_e4m3_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 36/48] fpu: Inline float16_unpack_raw into callers Richard Henderson
` (13 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Inline float8_e5m2_unpack_raw at the same time.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 +++++------------
1 file changed, 5 insertions(+), 12 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index c1b03f30ab..bc6450954e 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float8_e5m2_unpack_raw(FloatParts64 *p, float8_e5m2 f)
-{
- *p = unpack_raw64(&float8_e5m2_params, f);
-}
-
static void QEMU_FLATTEN float16_unpack_raw(FloatParts64 *p, float16 f)
{
*p = unpack_raw64(&float16_params, f);
@@ -1477,11 +1472,11 @@ static FloatParts64 float8_e4m3_unpack_canonical(float8_e4m3 f, float_status *s)
return p;
}
-static void float8_e5m2_unpack_canonical(FloatParts64 *p, float8_e5m2 f,
- float_status *s)
+static FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s)
{
- float8_e5m2_unpack_raw(p, f);
- parts64_canonicalize(p, s, &float8_e5m2_params);
+ FloatParts64 p = unpack_raw64(&float8_e5m2_params, f);
+ parts64_canonicalize(&p, s, &float8_e5m2_params);
+ return p;
}
static void float16a_unpack_canonical(FloatParts64 *p, float16 f,
@@ -2703,9 +2698,7 @@ bfloat16 float8_e4m3_to_bfloat16(float8_e4m3 a, float_status *s)
bfloat16 float8_e5m2_to_bfloat16(float8_e5m2 a, float_status *s)
{
- FloatParts64 p;
-
- float8_e5m2_unpack_canonical(&p, a, s);
+ FloatParts64 p = float8_e5m2_unpack_canonical(a, s);
parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 36/48] fpu: Inline float16_unpack_raw into callers
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (34 preceding siblings ...)
2026-04-29 22:24 ` [PULL 35/48] fpu: Return struct from float8_e5m2_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 37/48] fpu: Return struct from float16a_unpack_canonical Richard Henderson
` (12 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 13 +++----------
1 file changed, 3 insertions(+), 10 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index bc6450954e..cdf95a8517 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float16_unpack_raw(FloatParts64 *p, float16 f)
-{
- *p = unpack_raw64(&float16_params, f);
-}
-
static void QEMU_FLATTEN bfloat16_unpack_raw(FloatParts64 *p, bfloat16 f)
{
*p = unpack_raw64(&bfloat16_params, f);
@@ -1482,7 +1477,7 @@ static FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s)
static void float16a_unpack_canonical(FloatParts64 *p, float16 f,
float_status *s, const FloatFmt *params)
{
- float16_unpack_raw(p, f);
+ *p = unpack_raw64(&float16_params, f);
parts64_canonicalize(p, s, params);
}
@@ -4978,9 +4973,8 @@ bfloat16 bfloat16_default_nan(float_status *status)
float16 float16_silence_nan(float16 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float16_params, a);
- float16_unpack_raw(&p, a);
p.frac <<= float16_params.frac_shift;
parts64_silence_nan(&p, status);
p.frac >>= float16_params.frac_shift;
@@ -5049,9 +5043,8 @@ static bool parts_squash_denormal(FloatParts64 p, float_status *status)
float16 float16_squash_input_denormal(float16 a, float_status *status)
{
if (status->flush_inputs_to_zero) {
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float16_params, a);
- float16_unpack_raw(&p, a);
if (parts_squash_denormal(p, status)) {
return float16_set_sign(float16_zero, p.sign);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 37/48] fpu: Return struct from float16a_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (35 preceding siblings ...)
2026-04-29 22:24 ` [PULL 36/48] fpu: Inline float16_unpack_raw into callers Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 38/48] fpu: Return struct from float16_unpack_canonical Richard Henderson
` (11 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 ++++++++---------
1 file changed, 8 insertions(+), 9 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index cdf95a8517..dee5dcd0d2 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1474,17 +1474,18 @@ static FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s)
return p;
}
-static void float16a_unpack_canonical(FloatParts64 *p, float16 f,
- float_status *s, const FloatFmt *params)
+static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s,
+ const FloatFmt *params)
{
- *p = unpack_raw64(&float16_params, f);
- parts64_canonicalize(p, s, params);
+ FloatParts64 p = unpack_raw64(&float16_params, f);
+ parts64_canonicalize(&p, s, params);
+ return p;
}
static void float16_unpack_canonical(FloatParts64 *p, float16 f,
float_status *s)
{
- float16a_unpack_canonical(p, f, s, &float16_params);
+ *p = float16a_unpack_canonical(f, s, &float16_params);
}
static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f,
@@ -2701,9 +2702,8 @@ bfloat16 float8_e5m2_to_bfloat16(float8_e5m2 a, float_status *s)
float32 float16_to_float32(float16 a, bool ieee, float_status *s)
{
const FloatFmt *fmt16 = ieee ? &float16_params : &float16_params_ahp;
- FloatParts64 p;
+ FloatParts64 p = float16a_unpack_canonical(a, s, fmt16);
- float16a_unpack_canonical(&p, a, s, fmt16);
parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
@@ -2711,9 +2711,8 @@ float32 float16_to_float32(float16 a, bool ieee, float_status *s)
float64 float16_to_float64(float16 a, bool ieee, float_status *s)
{
const FloatFmt *fmt16 = ieee ? &float16_params : &float16_params_ahp;
- FloatParts64 p;
+ FloatParts64 p = float16a_unpack_canonical(a, s, fmt16);
- float16a_unpack_canonical(&p, a, s, fmt16);
parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 38/48] fpu: Return struct from float16_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (36 preceding siblings ...)
2026-04-29 22:24 ` [PULL 37/48] fpu: Return struct from float16a_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 39/48] fpu: Inline bfloat16_unpack_raw into callers Richard Henderson
` (10 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 94 +++++++++++++++++--------------------------------
1 file changed, 32 insertions(+), 62 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index dee5dcd0d2..3612d2fceb 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1482,10 +1482,9 @@ static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s,
return p;
}
-static void float16_unpack_canonical(FloatParts64 *p, float16 f,
- float_status *s)
+static FloatParts64 float16_unpack_canonical(float16 f, float_status *s)
{
- *p = float16a_unpack_canonical(f, s, &float16_params);
+ return float16a_unpack_canonical(f, s, &float16_params);
}
static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f,
@@ -1718,11 +1717,9 @@ static floatx80 floatx80_round_pack_canonical(FloatParts128 *p,
static float16 QEMU_FLATTEN
float16_addsub(float16 a, float16 b, float_status *status, bool subtract)
{
- FloatParts64 pa, pb, *pr;
-
- float16_unpack_canonical(&pa, a, status);
- float16_unpack_canonical(&pb, b, status);
- pr = parts64_addsub(&pa, &pb, status, subtract);
+ FloatParts64 pa = float16_unpack_canonical(a, status);
+ FloatParts64 pb = float16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
return float16_round_pack_canonical(pr, status);
}
@@ -1952,11 +1949,9 @@ floatx80 floatx80_sub(floatx80 a, floatx80 b, float_status *status)
float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float16_unpack_canonical(&pa, a, status);
- float16_unpack_canonical(&pb, b, status);
- pr = parts64_mul(&pa, &pb, status);
+ FloatParts64 pa = float16_unpack_canonical(a, status);
+ FloatParts64 pb = float16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
return float16_round_pack_canonical(pr, status);
}
@@ -2066,12 +2061,11 @@ float16 QEMU_FLATTEN
float16_muladd_scalbn(float16 a, float16 b, float16 c,
int scale, int flags, float_status *status)
{
- FloatParts64 pa, pb, pc, *pr;
-
- float16_unpack_canonical(&pa, a, status);
- float16_unpack_canonical(&pb, b, status);
- float16_unpack_canonical(&pc, c, status);
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ FloatParts64 pa = float16_unpack_canonical(a, status);
+ FloatParts64 pb = float16_unpack_canonical(b, status);
+ FloatParts64 pc = float16_unpack_canonical(c, status);
+ FloatParts64 *pr =
+ parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float16_params, false);
@@ -2326,11 +2320,9 @@ float128 QEMU_FLATTEN float128_muladd(float128 a, float128 b, float128 c,
float16 float16_div(float16 a, float16 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float16_unpack_canonical(&pa, a, status);
- float16_unpack_canonical(&pb, b, status);
- pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pa = float16_unpack_canonical(a, status);
+ FloatParts64 pb = float16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
return float16_round_pack_canonical(pr, status);
}
@@ -2969,9 +2961,8 @@ floatx80 float128_to_floatx80(float128 a, float_status *s)
float16 float16_round_to_int(float16 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float16_unpack_canonical(a, s);
- float16_unpack_canonical(&p, a, s);
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float16_params);
return float16_round_pack_canonical(&p, s);
}
@@ -3032,36 +3023,28 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
int8_t float16_to_int8_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
}
int16_t float16_to_int16_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float16_to_int32_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
@@ -3530,36 +3513,28 @@ int64_t float64_to_int64_modulo(float64 a, FloatRoundMode rmode,
uint8_t float16_to_uint8_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
}
uint16_t float16_to_uint16_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float16_to_uint32_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float16_unpack_canonical(&p, a, s);
+ FloatParts64 p = float16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
@@ -4316,11 +4291,9 @@ float128 uint128_to_float128(Int128 a, float_status *status)
static float16 float16_minmax(float16 a, float16 b, float_status *s, int flags)
{
- FloatParts64 pa, pb, *pr;
-
- float16_unpack_canonical(&pa, a, s);
- float16_unpack_canonical(&pb, b, s);
- pr = parts64_minmax(&pa, &pb, s, flags);
+ FloatParts64 pa = float16_unpack_canonical(a, s);
+ FloatParts64 pb = float16_unpack_canonical(b, s);
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
return float16_round_pack_canonical(pr, s);
}
@@ -4401,10 +4374,9 @@ MINMAX_2(float128)
static FloatRelation QEMU_FLATTEN
float16_do_compare(float16 a, float16 b, float_status *s, bool is_quiet)
{
- FloatParts64 pa, pb;
+ FloatParts64 pa = float16_unpack_canonical(a, s);
+ FloatParts64 pb = float16_unpack_canonical(b, s);
- float16_unpack_canonical(&pa, a, s);
- float16_unpack_canonical(&pb, b, s);
return parts64_compare(&pa, &pb, s, is_quiet);
}
@@ -4594,9 +4566,8 @@ FloatRelation floatx80_compare_quiet(floatx80 a, floatx80 b, float_status *s)
float16 float16_scalbn(float16 a, int n, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float16_unpack_canonical(a, status);
- float16_unpack_canonical(&p, a, status);
parts64_scalbn(&p, n, status);
return float16_round_pack_canonical(&p, status);
}
@@ -4654,9 +4625,8 @@ floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float16_unpack_canonical(a, status);
- float16_unpack_canonical(&p, a, status);
parts64_sqrt(&p, status, &float16_params);
return float16_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 39/48] fpu: Inline bfloat16_unpack_raw into callers
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (37 preceding siblings ...)
2026-04-29 22:24 ` [PULL 38/48] fpu: Return struct from float16_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 40/48] fpu: Return struct from bfloat16_unpack_canonical Richard Henderson
` (9 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 13 +++----------
1 file changed, 3 insertions(+), 10 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 3612d2fceb..566154a729 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN bfloat16_unpack_raw(FloatParts64 *p, bfloat16 f)
-{
- *p = unpack_raw64(&bfloat16_params, f);
-}
-
static void QEMU_FLATTEN float32_unpack_raw(FloatParts64 *p, float32 f)
{
*p = unpack_raw64(&float32_params, f);
@@ -1490,7 +1485,7 @@ static FloatParts64 float16_unpack_canonical(float16 f, float_status *s)
static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f,
float_status *s)
{
- bfloat16_unpack_raw(p, f);
+ *p = unpack_raw64(&bfloat16_params, f);
parts64_canonicalize(p, s, &bfloat16_params);
}
@@ -4974,9 +4969,8 @@ float64 float64_silence_nan(float64 a, float_status *status)
bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&bfloat16_params, a);
- bfloat16_unpack_raw(&p, a);
p.frac <<= bfloat16_params.frac_shift;
parts64_silence_nan(&p, status);
p.frac >>= bfloat16_params.frac_shift;
@@ -5050,9 +5044,8 @@ float64 float64_squash_input_denormal(float64 a, float_status *status)
bfloat16 bfloat16_squash_input_denormal(bfloat16 a, float_status *status)
{
if (status->flush_inputs_to_zero) {
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&bfloat16_params, a);
- bfloat16_unpack_raw(&p, a);
if (parts_squash_denormal(p, status)) {
return bfloat16_set_sign(bfloat16_zero, p.sign);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 40/48] fpu: Return struct from bfloat16_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (38 preceding siblings ...)
2026-04-29 22:24 ` [PULL 39/48] fpu: Inline bfloat16_unpack_raw into callers Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 41/48] fpu: Inline float32_unpack_raw into callers Richard Henderson
` (8 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 108 +++++++++++++++++-------------------------------
1 file changed, 37 insertions(+), 71 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 566154a729..19cca8fb85 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1482,11 +1482,11 @@ static FloatParts64 float16_unpack_canonical(float16 f, float_status *s)
return float16a_unpack_canonical(f, s, &float16_params);
}
-static void bfloat16_unpack_canonical(FloatParts64 *p, bfloat16 f,
- float_status *s)
+static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s)
{
- *p = unpack_raw64(&bfloat16_params, f);
- parts64_canonicalize(p, s, &bfloat16_params);
+ FloatParts64 p = unpack_raw64(&bfloat16_params, f);
+ parts64_canonicalize(&p, s, &bfloat16_params);
+ return p;
}
static float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p,
@@ -1873,11 +1873,9 @@ float64 float64r32_sub(float64 a, float64 b, float_status *status)
static bfloat16 QEMU_FLATTEN
bfloat16_addsub(bfloat16 a, bfloat16 b, float_status *status, bool subtract)
{
- FloatParts64 pa, pb, *pr;
-
- bfloat16_unpack_canonical(&pa, a, status);
- bfloat16_unpack_canonical(&pb, b, status);
- pr = parts64_addsub(&pa, &pb, status, subtract);
+ FloatParts64 pa = bfloat16_unpack_canonical(a, status);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2013,11 +2011,9 @@ float64 float64r32_mul(float64 a, float64 b, float_status *status)
bfloat16 QEMU_FLATTEN
bfloat16_mul(bfloat16 a, bfloat16 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- bfloat16_unpack_canonical(&pa, a, status);
- bfloat16_unpack_canonical(&pb, b, status);
- pr = parts64_mul(&pa, &pb, status);
+ FloatParts64 pa = bfloat16_unpack_canonical(a, status);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2276,12 +2272,10 @@ float64 float64r32_muladd(float64 a, float64 b, float64 c,
bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c,
int flags, float_status *status)
{
- FloatParts64 pa, pb, pc, *pr;
-
- bfloat16_unpack_canonical(&pa, a, status);
- bfloat16_unpack_canonical(&pb, b, status);
- bfloat16_unpack_canonical(&pc, c, status);
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ FloatParts64 pa = bfloat16_unpack_canonical(a, status);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, status);
+ FloatParts64 pc = bfloat16_unpack_canonical(c, status);
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &bfloat16_params, false);
@@ -2418,11 +2412,9 @@ float64 float64r32_div(float64 a, float64 b, float_status *status)
bfloat16 QEMU_FLATTEN
bfloat16_div(bfloat16 a, bfloat16 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- bfloat16_unpack_canonical(&pa, a, status);
- bfloat16_unpack_canonical(&pb, b, status);
- pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pa = bfloat16_unpack_canonical(a, status);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
return bfloat16_round_pack_canonical(pr, status);
}
@@ -2791,36 +2783,32 @@ float32 float64_to_float32(float64 a, float_status *s)
float8_e4m3 bfloat16_to_float8_e4m3(bfloat16 a, bool saturate, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
- bfloat16_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, saturate);
}
float8_e5m2 bfloat16_to_float8_e5m2(bfloat16 a, bool saturate, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
- bfloat16_unpack_canonical(&p, a, s);
parts_float_to_e5m2(&p, s, saturate);
return float8_e5m2_round_pack_canonical(&p, s, saturate);
}
float32 bfloat16_to_float32(bfloat16 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
- bfloat16_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
float64 bfloat16_to_float64(bfloat16 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
- bfloat16_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
@@ -2982,9 +2970,8 @@ float64 float64_round_to_int(float64 a, float_status *s)
bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
- bfloat16_unpack_canonical(&p, a, s);
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &bfloat16_params);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -3100,36 +3087,28 @@ int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale,
int8_t bfloat16_to_int8_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT8_MIN, INT8_MAX, s);
}
int16_t bfloat16_to_int16_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t bfloat16_to_int32_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
@@ -3590,36 +3569,28 @@ uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int scale,
uint8_t bfloat16_to_uint8_scalbn(bfloat16 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT8_MAX, s);
}
uint16_t bfloat16_to_uint16_scalbn(bfloat16 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t bfloat16_to_uint32_scalbn(bfloat16 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts64 p;
-
- bfloat16_unpack_canonical(&p, a, s);
+ FloatParts64 p = bfloat16_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
@@ -4296,11 +4267,9 @@ static float16 float16_minmax(float16 a, float16 b, float_status *s, int flags)
static bfloat16 bfloat16_minmax(bfloat16 a, bfloat16 b,
float_status *s, int flags)
{
- FloatParts64 pa, pb, *pr;
-
- bfloat16_unpack_canonical(&pa, a, s);
- bfloat16_unpack_canonical(&pb, b, s);
- pr = parts64_minmax(&pa, &pb, s, flags);
+ FloatParts64 pa = bfloat16_unpack_canonical(a, s);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, s);
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
return bfloat16_round_pack_canonical(pr, s);
}
@@ -4496,10 +4465,9 @@ FloatRelation float64_compare_quiet(float64 a, float64 b, float_status *s)
static FloatRelation QEMU_FLATTEN
bfloat16_do_compare(bfloat16 a, bfloat16 b, float_status *s, bool is_quiet)
{
- FloatParts64 pa, pb;
+ FloatParts64 pa = bfloat16_unpack_canonical(a, s);
+ FloatParts64 pb = bfloat16_unpack_canonical(b, s);
- bfloat16_unpack_canonical(&pa, a, s);
- bfloat16_unpack_canonical(&pb, b, s);
return parts64_compare(&pa, &pb, s, is_quiet);
}
@@ -4587,9 +4555,8 @@ float64 float64_scalbn(float64 a, int n, float_status *status)
bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, status);
- bfloat16_unpack_canonical(&p, a, status);
parts64_scalbn(&p, n, status);
return bfloat16_round_pack_canonical(&p, status);
}
@@ -4711,9 +4678,8 @@ float64 float64r32_sqrt(float64 a, float_status *status)
bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = bfloat16_unpack_canonical(a, status);
- bfloat16_unpack_canonical(&p, a, status);
parts64_sqrt(&p, status, &bfloat16_params);
return bfloat16_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 41/48] fpu: Inline float32_unpack_raw into callers
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (39 preceding siblings ...)
2026-04-29 22:24 ` [PULL 40/48] fpu: Return struct from bfloat16_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 42/48] fpu: Inline float64_unpack_raw " Richard Henderson
` (7 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 13 +++----------
1 file changed, 3 insertions(+), 10 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 19cca8fb85..5e33eab8d5 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float32_unpack_raw(FloatParts64 *p, float32 f)
-{
- *p = unpack_raw64(&float32_params, f);
-}
-
static void QEMU_FLATTEN float64_unpack_raw(FloatParts64 *p, float64 f)
{
*p = unpack_raw64(&float64_params, f);
@@ -1529,7 +1524,7 @@ static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p,
static void float32_unpack_canonical(FloatParts64 *p, float32 f,
float_status *s)
{
- float32_unpack_raw(p, f);
+ *p = unpack_raw64(&float32_params, f);
parts64_canonicalize(p, s, &float32_params);
}
@@ -4913,9 +4908,8 @@ float16 float16_silence_nan(float16 a, float_status *status)
float32 float32_silence_nan(float32 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float32_params, a);
- float32_unpack_raw(&p, a);
p.frac <<= float32_params.frac_shift;
parts64_silence_nan(&p, status);
p.frac >>= float32_params.frac_shift;
@@ -4984,9 +4978,8 @@ float16 float16_squash_input_denormal(float16 a, float_status *status)
float32 float32_squash_input_denormal(float32 a, float_status *status)
{
if (status->flush_inputs_to_zero) {
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float32_params, a);
- float32_unpack_raw(&p, a);
if (parts_squash_denormal(p, status)) {
return float32_set_sign(float32_zero, p.sign);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 42/48] fpu: Inline float64_unpack_raw into callers
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (40 preceding siblings ...)
2026-04-29 22:24 ` [PULL 41/48] fpu: Inline float32_unpack_raw into callers Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 43/48] fpu: Return struct from float{32,64}_unpack_canonical Richard Henderson
` (6 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 13 +++----------
1 file changed, 3 insertions(+), 10 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 5e33eab8d5..e1b92b38b6 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,11 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float64_unpack_raw(FloatParts64 *p, float64 f)
-{
- *p = unpack_raw64(&float64_params, f);
-}
-
static void QEMU_FLATTEN floatx80_unpack_raw(FloatParts128 *p, floatx80 f)
{
*p = (FloatParts128) {
@@ -1538,7 +1533,7 @@ static float32 float32_round_pack_canonical(FloatParts64 *p,
static void float64_unpack_canonical(FloatParts64 *p, float64 f,
float_status *s)
{
- float64_unpack_raw(p, f);
+ *p = unpack_raw64(&float64_params, f);
parts64_canonicalize(p, s, &float64_params);
}
@@ -4918,9 +4913,8 @@ float32 float32_silence_nan(float32 a, float_status *status)
float64 float64_silence_nan(float64 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float64_params, a);
- float64_unpack_raw(&p, a);
p.frac <<= float64_params.frac_shift;
parts64_silence_nan(&p, status);
p.frac >>= float64_params.frac_shift;
@@ -4990,9 +4984,8 @@ float32 float32_squash_input_denormal(float32 a, float_status *status)
float64 float64_squash_input_denormal(float64 a, float_status *status)
{
if (status->flush_inputs_to_zero) {
- FloatParts64 p;
+ FloatParts64 p = unpack_raw64(&float64_params, a);
- float64_unpack_raw(&p, a);
if (parts_squash_denormal(p, status)) {
return float64_set_sign(float64_zero, p.sign);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 43/48] fpu: Return struct from float{32,64}_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (41 preceding siblings ...)
2026-04-29 22:24 ` [PULL 42/48] fpu: Inline float64_unpack_raw " Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 44/48] fpu: Inline floatx80_unpack_raw into only caller Richard Henderson
` (5 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
We must change float32 and float64 at once because
of the DEFINE_S390_DIVIDE_TO_INTEGER macro.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 300 +++++++++++++++++-------------------------------
1 file changed, 107 insertions(+), 193 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index e1b92b38b6..b3208c1891 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1516,11 +1516,11 @@ static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p,
return bfloat16_pack_raw(p);
}
-static void float32_unpack_canonical(FloatParts64 *p, float32 f,
- float_status *s)
+static FloatParts64 float32_unpack_canonical(float32 f, float_status *s)
{
- *p = unpack_raw64(&float32_params, f);
- parts64_canonicalize(p, s, &float32_params);
+ FloatParts64 p = unpack_raw64(&float32_params, f);
+ parts64_canonicalize(&p, s, &float32_params);
+ return p;
}
static float32 float32_round_pack_canonical(FloatParts64 *p,
@@ -1530,11 +1530,11 @@ static float32 float32_round_pack_canonical(FloatParts64 *p,
return float32_pack_raw(p);
}
-static void float64_unpack_canonical(FloatParts64 *p, float64 f,
- float_status *s)
+static FloatParts64 float64_unpack_canonical(float64 f, float_status *s)
{
- *p = unpack_raw64(&float64_params, f);
- parts64_canonicalize(p, s, &float64_params);
+ FloatParts64 p = unpack_raw64(&float64_params, f);
+ parts64_canonicalize(&p, s, &float64_params);
+ return p;
}
static float64 float64_round_pack_canonical(FloatParts64 *p,
@@ -1722,11 +1722,9 @@ float16 float16_sub(float16 a, float16 b, float_status *status)
static float32 QEMU_SOFTFLOAT_ATTR
soft_f32_addsub(float32 a, float32 b, float_status *status, bool subtract)
{
- FloatParts64 pa, pb, *pr;
-
- float32_unpack_canonical(&pa, a, status);
- float32_unpack_canonical(&pb, b, status);
- pr = parts64_addsub(&pa, &pb, status, subtract);
+ FloatParts64 pa = float32_unpack_canonical(a, status);
+ FloatParts64 pb = float32_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
return float32_round_pack_canonical(pr, status);
}
@@ -1744,11 +1742,9 @@ static float32 soft_f32_sub(float32 a, float32 b, float_status *status)
static float64 QEMU_SOFTFLOAT_ATTR
soft_f64_addsub(float64 a, float64 b, float_status *status, bool subtract)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_addsub(&pa, &pb, status, subtract);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
return float64_round_pack_canonical(pr, status);
}
@@ -1841,11 +1837,9 @@ float64_sub(float64 a, float64 b, float_status *s)
static float64 float64r32_addsub(float64 a, float64 b, float_status *status,
bool subtract)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_addsub(&pa, &pb, status, subtract);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
return float64r32_round_pack_canonical(pr, status);
}
@@ -1942,11 +1936,9 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *status)
static float32 QEMU_SOFTFLOAT_ATTR
soft_f32_mul(float32 a, float32 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float32_unpack_canonical(&pa, a, status);
- float32_unpack_canonical(&pb, b, status);
- pr = parts64_mul(&pa, &pb, status);
+ FloatParts64 pa = float32_unpack_canonical(a, status);
+ FloatParts64 pb = float32_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
return float32_round_pack_canonical(pr, status);
}
@@ -1954,11 +1946,9 @@ soft_f32_mul(float32 a, float32 b, float_status *status)
static float64 QEMU_SOFTFLOAT_ATTR
soft_f64_mul(float64 a, float64 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_mul(&pa, &pb, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
return float64_round_pack_canonical(pr, status);
}
@@ -1989,11 +1979,9 @@ float64_mul(float64 a, float64 b, float_status *s)
float64 float64r32_mul(float64 a, float64 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_mul(&pa, &pb, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
return float64r32_round_pack_canonical(pr, status);
}
@@ -2066,12 +2054,10 @@ float32 QEMU_SOFTFLOAT_ATTR
float32_muladd_scalbn(float32 a, float32 b, float32 c,
int scale, int flags, float_status *status)
{
- FloatParts64 pa, pb, pc, *pr;
-
- float32_unpack_canonical(&pa, a, status);
- float32_unpack_canonical(&pb, b, status);
- float32_unpack_canonical(&pc, c, status);
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ FloatParts64 pa = float32_unpack_canonical(a, status);
+ FloatParts64 pb = float32_unpack_canonical(b, status);
+ FloatParts64 pc = float32_unpack_canonical(c, status);
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float32_params, false);
@@ -2085,12 +2071,10 @@ float64 QEMU_SOFTFLOAT_ATTR
float64_muladd_scalbn(float64 a, float64 b, float64 c,
int scale, int flags, float_status *status)
{
- FloatParts64 pa, pb, pc, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- float64_unpack_canonical(&pc, c, status);
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 pc = float64_unpack_canonical(c, status);
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float64_params, false);
@@ -2244,12 +2228,10 @@ float64_muladd(float64 xa, float64 xb, float64 xc, int flags, float_status *s)
float64 float64r32_muladd(float64 a, float64 b, float64 c,
int flags, float_status *status)
{
- FloatParts64 pa, pb, pc, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- float64_unpack_canonical(&pc, c, status);
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 pc = float64_unpack_canonical(c, status);
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts64_uncanon(pr, status, &float32_params, false);
@@ -2309,11 +2291,9 @@ float16 float16_div(float16 a, float16 b, float_status *status)
static float32 QEMU_SOFTFLOAT_ATTR
soft_f32_div(float32 a, float32 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float32_unpack_canonical(&pa, a, status);
- float32_unpack_canonical(&pb, b, status);
- pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pa = float32_unpack_canonical(a, status);
+ FloatParts64 pb = float32_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
return float32_round_pack_canonical(pr, status);
}
@@ -2321,11 +2301,9 @@ soft_f32_div(float32 a, float32 b, float_status *status)
static float64 QEMU_SOFTFLOAT_ATTR
soft_f64_div(float64 a, float64 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
return float64_round_pack_canonical(pr, status);
}
@@ -2390,11 +2368,9 @@ float64_div(float64 a, float64 b, float_status *s)
float64 float64r32_div(float64 a, float64 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
return float64r32_round_pack_canonical(pr, status);
}
@@ -2440,22 +2416,18 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
float32 float32_rem(float32 a, float32 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float32_unpack_canonical(&pa, a, status);
- float32_unpack_canonical(&pb, b, status);
- pr = parts64_modrem(&pa, &pb, NULL, status);
+ FloatParts64 pa = float32_unpack_canonical(a, status);
+ FloatParts64 pb = float32_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_modrem(&pa, &pb, NULL, status);
return float32_round_pack_canonical(pr, status);
}
float64 float64_rem(float64 a, float64 b, float_status *status)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, status);
- float64_unpack_canonical(&pb, b, status);
- pr = parts64_modrem(&pa, &pb, NULL, status);
+ FloatParts64 pa = float64_unpack_canonical(a, status);
+ FloatParts64 pb = float64_unpack_canonical(b, status);
+ FloatParts64 *pr = parts64_modrem(&pa, &pb, NULL, status);
return float64_round_pack_canonical(pr, status);
}
@@ -2688,28 +2660,25 @@ float64 float16_to_float64(float16 a, bool ieee, float_status *s)
float8_e4m3 float32_to_float8_e4m3(float32 a, bool saturate, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
- float32_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float8_e4m3_round_pack_canonical(&p, s, saturate);
}
float8_e5m2 float32_to_float8_e5m2(float32 a, bool saturate, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
- float32_unpack_canonical(&p, a, s);
parts_float_to_e5m2(&p, s, saturate);
return float8_e5m2_round_pack_canonical(&p, s, saturate);
}
float16 float32_to_float16(float32 a, bool ieee, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
const FloatFmt *fmt;
- float32_unpack_canonical(&p, a, s);
if (ieee) {
parts64_float_to_float(&p, s);
fmt = &float16_params;
@@ -2723,9 +2692,8 @@ float16 float32_to_float16(float32 a, bool ieee, float_status *s)
static float64 QEMU_SOFTFLOAT_ATTR
soft_float32_to_float64(float32 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
- float32_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float64_round_pack_canonical(&p, s);
}
@@ -2748,10 +2716,9 @@ float64 float32_to_float64(float32 a, float_status *s)
float16 float64_to_float16(float64 a, bool ieee, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, s);
const FloatFmt *fmt;
- float64_unpack_canonical(&p, a, s);
if (ieee) {
parts64_float_to_float(&p, s);
fmt = &float16_params;
@@ -2764,9 +2731,8 @@ float16 float64_to_float16(float64 a, bool ieee, float_status *s)
float32 float64_to_float32(float64 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, s);
- float64_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return float32_round_pack_canonical(&p, s);
}
@@ -2805,18 +2771,16 @@ float64 bfloat16_to_float64(bfloat16 a, float_status *s)
bfloat16 float32_to_bfloat16(float32 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
- float32_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
bfloat16 float64_to_bfloat16(float64 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, s);
- float64_unpack_canonical(&p, a, s);
parts64_float_to_float(&p, s);
return bfloat16_round_pack_canonical(&p, s);
}
@@ -2843,20 +2807,18 @@ float64 float128_to_float64(float128 a, float_status *s)
float128 float32_to_float128(float32 a, float_status *s)
{
- FloatParts64 p64;
+ FloatParts64 p64 = float32_unpack_canonical(a, s);
FloatParts128 p128;
- float32_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return float128_round_pack_canonical(&p128, s);
}
float128 float64_to_float128(float64 a, float_status *s)
{
- FloatParts64 p64;
+ FloatParts64 p64 = float64_unpack_canonical(a, s);
FloatParts128 p128;
- float64_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return float128_round_pack_canonical(&p128, s);
}
@@ -2901,20 +2863,18 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
floatx80 float32_to_floatx80(float32 a, float_status *s)
{
- FloatParts64 p64;
+ FloatParts64 p64 = float32_unpack_canonical(a, s);
FloatParts128 p128;
- float32_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
floatx80 float64_to_floatx80(float64 a, float_status *s)
{
- FloatParts64 p64;
+ FloatParts64 p64 = float64_unpack_canonical(a, s);
FloatParts128 p128;
- float64_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
@@ -2942,18 +2902,16 @@ float16 float16_round_to_int(float16 a, float_status *s)
float32 float32_round_to_int(float32 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, s);
- float32_unpack_canonical(&p, a, s);
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float32_params);
return float32_round_pack_canonical(&p, s);
}
float64 float64_round_to_int(float64 a, float_status *s)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, s);
- float64_unpack_canonical(&p, a, s);
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float64_params);
return float64_round_pack_canonical(&p, s);
}
@@ -3023,54 +2981,42 @@ int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale,
int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
}
int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
@@ -3455,18 +3401,14 @@ static int64_t parts64_float_to_sint_modulo(FloatParts64 *p,
int32_t float64_to_int32_modulo(float64 a, FloatRoundMode rmode,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_sint_modulo(&p, rmode, 31, s);
}
int64_t float64_to_int64_modulo(float64 a, FloatRoundMode rmode,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_sint_modulo(&p, rmode, 63, s);
}
@@ -3505,54 +3447,42 @@ uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int scale,
uint16_t float32_to_uint16_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float32_to_uint32_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float32_to_uint64_scalbn(float32 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float32_unpack_canonical(&p, a, s);
+ FloatParts64 p = float32_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
uint16_t float64_to_uint16_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
}
uint32_t float64_to_uint32_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int scale,
float_status *s)
{
- FloatParts64 p;
-
- float64_unpack_canonical(&p, a, s);
+ FloatParts64 p = float64_unpack_canonical(a, s);
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
@@ -4266,22 +4196,18 @@ static bfloat16 bfloat16_minmax(bfloat16 a, bfloat16 b,
static float32 float32_minmax(float32 a, float32 b, float_status *s, int flags)
{
- FloatParts64 pa, pb, *pr;
-
- float32_unpack_canonical(&pa, a, s);
- float32_unpack_canonical(&pb, b, s);
- pr = parts64_minmax(&pa, &pb, s, flags);
+ FloatParts64 pa = float32_unpack_canonical(a, s);
+ FloatParts64 pb = float32_unpack_canonical(b, s);
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
return float32_round_pack_canonical(pr, s);
}
static float64 float64_minmax(float64 a, float64 b, float_status *s, int flags)
{
- FloatParts64 pa, pb, *pr;
-
- float64_unpack_canonical(&pa, a, s);
- float64_unpack_canonical(&pb, b, s);
- pr = parts64_minmax(&pa, &pb, s, flags);
+ FloatParts64 pa = float64_unpack_canonical(a, s);
+ FloatParts64 pb = float64_unpack_canonical(b, s);
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
return float64_round_pack_canonical(pr, s);
}
@@ -4347,10 +4273,9 @@ FloatRelation float16_compare_quiet(float16 a, float16 b, float_status *s)
static FloatRelation QEMU_SOFTFLOAT_ATTR
float32_do_compare(float32 a, float32 b, float_status *s, bool is_quiet)
{
- FloatParts64 pa, pb;
+ FloatParts64 pa = float32_unpack_canonical(a, s);
+ FloatParts64 pb = float32_unpack_canonical(b, s);
- float32_unpack_canonical(&pa, a, s);
- float32_unpack_canonical(&pb, b, s);
return parts64_compare(&pa, &pb, s, is_quiet);
}
@@ -4401,10 +4326,9 @@ FloatRelation float32_compare_quiet(float32 a, float32 b, float_status *s)
static FloatRelation QEMU_SOFTFLOAT_ATTR
float64_do_compare(float64 a, float64 b, float_status *s, bool is_quiet)
{
- FloatParts64 pa, pb;
+ FloatParts64 pa = float64_unpack_canonical(a, s);
+ FloatParts64 pb = float64_unpack_canonical(b, s);
- float64_unpack_canonical(&pa, a, s);
- float64_unpack_canonical(&pb, b, s);
return parts64_compare(&pa, &pb, s, is_quiet);
}
@@ -4527,18 +4451,16 @@ float16 float16_scalbn(float16 a, int n, float_status *status)
float32 float32_scalbn(float32 a, int n, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, status);
- float32_unpack_canonical(&p, a, status);
parts64_scalbn(&p, n, status);
return float32_round_pack_canonical(&p, status);
}
float64 float64_scalbn(float64 a, int n, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, status);
- float64_unpack_canonical(&p, a, status);
parts64_scalbn(&p, n, status);
return float64_round_pack_canonical(&p, status);
}
@@ -4586,9 +4508,8 @@ float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status)
static float32 QEMU_SOFTFLOAT_ATTR
soft_f32_sqrt(float32 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, status);
- float32_unpack_canonical(&p, a, status);
parts64_sqrt(&p, status, &float32_params);
return float32_round_pack_canonical(&p, status);
}
@@ -4596,9 +4517,8 @@ soft_f32_sqrt(float32 a, float_status *status)
static float64 QEMU_SOFTFLOAT_ATTR
soft_f64_sqrt(float64 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, status);
- float64_unpack_canonical(&p, a, status);
parts64_sqrt(&p, status, &float64_params);
return float64_round_pack_canonical(&p, status);
}
@@ -4659,9 +4579,8 @@ float64 QEMU_FLATTEN float64_sqrt(float64 xa, float_status *s)
float64 float64r32_sqrt(float64 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, status);
- float64_unpack_canonical(&p, a, status);
parts64_sqrt(&p, status, &float64_params);
return float64r32_round_pack_canonical(&p, status);
}
@@ -4822,18 +4741,16 @@ static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *fmt)
float32 float32_log2(float32 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float32_unpack_canonical(a, status);
- float32_unpack_canonical(&p, a, status);
parts64_log2(&p, status, &float32_params);
return float32_round_pack_canonical(&p, status);
}
float64 float64_log2(float64 a, float_status *status)
{
- FloatParts64 p;
+ FloatParts64 p = float64_unpack_canonical(a, status);
- float64_unpack_canonical(&p, a, status);
parts64_log2(&p, status, &float64_params);
return float64_round_pack_canonical(&p, status);
}
@@ -5321,10 +5238,9 @@ static const float64 float32_exp2_coefficients[15] =
float32 float32_exp2(float32 a, float_status *status)
{
- FloatParts64 xp, xnp, tp, rp;
- int i;
+ FloatParts64 xnp, tp, rp;
+ FloatParts64 xp = float32_unpack_canonical(a, status);
- float32_unpack_canonical(&xp, a, status);
if (unlikely(xp.cls != float_class_normal)) {
switch (xp.cls) {
case float_class_denormal:
@@ -5344,14 +5260,13 @@ float32 float32_exp2(float32 a, float_status *status)
float_raise(float_flag_inexact, status);
- float64_unpack_canonical(&tp, float64_ln2, status);
+ tp = float64_unpack_canonical(float64_ln2, status);
xp = *parts64_mul(&xp, &tp, status);
xnp = xp;
- float64_unpack_canonical(&rp, float64_one, status);
- for (i = 0 ; i < 15 ; i++) {
-
- float64_unpack_canonical(&tp, float32_exp2_coefficients[i], status);
+ rp = float64_unpack_canonical(float64_one, status);
+ for (int i = 0; i < 15; i++) {
+ tp = float64_unpack_canonical(float32_exp2_coefficients[i], status);
rp = *parts64_muladd_scalbn(&tp, &xnp, &rp, 0, 0, status);
xnp = *parts64_mul(&xnp, &xp, status);
}
@@ -5504,10 +5419,9 @@ void floatN ## _s390_divide_to_integer(floatN a, floatN b, \
uint32_t *cc, int *dxc, \
float_status *status) \
{ \
- FloatParts64 pa, pb, pr, pn; \
- \
- floatN ## _unpack_canonical(&pa, a, status); \
- floatN ## _unpack_canonical(&pb, b, status); \
+ FloatParts64 pa = floatN ## _unpack_canonical(a, status); \
+ FloatParts64 pb = floatN ## _unpack_canonical(b, status); \
+ FloatParts64 pr, pn; \
parts_s390_divide_to_integer(&pa, &pb, final_quotient_rounding_mode, \
mask_underflow, mask_inexact, \
&floatN ## _params, \
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 44/48] fpu: Inline floatx80_unpack_raw into only caller
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (42 preceding siblings ...)
2026-04-29 22:24 ` [PULL 43/48] fpu: Return struct from float{32,64}_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 45/48] fpu: Return struct from float128_unpack_raw Richard Henderson
` (4 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 17 ++++++-----------
1 file changed, 6 insertions(+), 11 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index b3208c1891..5412fd0360 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,16 +646,6 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN floatx80_unpack_raw(FloatParts128 *p, floatx80 f)
-{
- *p = (FloatParts128) {
- .cls = float_class_unclassified,
- .sign = extract32(f.high, 15, 1),
- .exp = extract32(f.high, 0, 15),
- .frac_hi = f.low
- };
-}
-
static void QEMU_FLATTEN float128_unpack_raw(FloatParts128 *p, float128 f)
{
const int f_size = float128_params.frac_size - 64;
@@ -1626,7 +1616,12 @@ static bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f,
return false;
}
- floatx80_unpack_raw(p, f);
+ *p = (FloatParts128) {
+ .cls = float_class_unclassified,
+ .sign = extract32(f.high, 15, 1),
+ .exp = extract32(f.high, 0, 15),
+ .frac_hi = f.low
+ };
if (likely(p->exp != floatx80_params[floatx80_precision_x].exp_max)) {
parts128_canonicalize(p, s, &floatx80_params[floatx80_precision_x]);
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 45/48] fpu: Return struct from float128_unpack_raw
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (43 preceding siblings ...)
2026-04-29 22:24 ` [PULL 44/48] fpu: Inline floatx80_unpack_raw into only caller Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 46/48] fpu: Return struct from float128_unpack_canonical Richard Henderson
` (3 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 9 ++++-----
1 file changed, 4 insertions(+), 5 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 5412fd0360..a9c91fb8a4 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -646,12 +646,12 @@ static FloatParts64 unpack_raw64(const FloatFmt *fmt, uint64_t raw)
};
}
-static void QEMU_FLATTEN float128_unpack_raw(FloatParts128 *p, float128 f)
+static FloatParts128 float128_unpack_raw(float128 f)
{
const int f_size = float128_params.frac_size - 64;
const int e_size = float128_params.exp_size;
- *p = (FloatParts128) {
+ return (FloatParts128) {
.cls = float_class_unclassified,
.sign = extract64(f.high, f_size + e_size, 1),
.exp = extract64(f.high, f_size, e_size),
@@ -1586,7 +1586,7 @@ static float64 float64r32_round_pack_canonical(FloatParts64 *p,
static void float128_unpack_canonical(FloatParts128 *p, float128 f,
float_status *s)
{
- float128_unpack_raw(p, f);
+ *p = float128_unpack_raw(f);
parts128_canonicalize(p, s, &float128_params);
}
@@ -4845,9 +4845,8 @@ bfloat16 bfloat16_silence_nan(bfloat16 a, float_status *status)
float128 float128_silence_nan(float128 a, float_status *status)
{
- FloatParts128 p;
+ FloatParts128 p = float128_unpack_raw(a);
- float128_unpack_raw(&p, a);
frac128_shl(&p, float128_params.frac_shift);
parts128_silence_nan(&p, status);
frac128_shr(&p, float128_params.frac_shift);
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 46/48] fpu: Return struct from float128_unpack_canonical
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (44 preceding siblings ...)
2026-04-29 22:24 ` [PULL 45/48] fpu: Return struct from float128_unpack_raw Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 47/48] fpu: Change parts_float_to_float_narrow to parts128_to_parts64 Richard Henderson
` (2 subsequent siblings)
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 105 +++++++++++++++++-------------------------------
1 file changed, 37 insertions(+), 68 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index a9c91fb8a4..77585fa11f 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -1583,11 +1583,11 @@ static float64 float64r32_round_pack_canonical(FloatParts64 *p,
return float64r32_pack_raw(p);
}
-static void float128_unpack_canonical(FloatParts128 *p, float128 f,
- float_status *s)
+static FloatParts128 float128_unpack_canonical(float128 f, float_status *s)
{
- *p = float128_unpack_raw(f);
- parts128_canonicalize(p, s, &float128_params);
+ FloatParts128 p = float128_unpack_raw(f);
+ parts128_canonicalize(&p, s, &float128_params);
+ return p;
}
static float128 float128_round_pack_canonical(FloatParts128 *p,
@@ -1872,11 +1872,9 @@ bfloat16 bfloat16_sub(bfloat16 a, bfloat16 b, float_status *status)
static float128 QEMU_FLATTEN
float128_addsub(float128 a, float128 b, float_status *status, bool subtract)
{
- FloatParts128 pa, pb, *pr;
-
- float128_unpack_canonical(&pa, a, status);
- float128_unpack_canonical(&pb, b, status);
- pr = parts128_addsub(&pa, &pb, status, subtract);
+ FloatParts128 pa = float128_unpack_canonical(a, status);
+ FloatParts128 pb = float128_unpack_canonical(b, status);
+ FloatParts128 *pr = parts128_addsub(&pa, &pb, status, subtract);
return float128_round_pack_canonical(pr, status);
}
@@ -1994,11 +1992,9 @@ bfloat16_mul(bfloat16 a, bfloat16 b, float_status *status)
float128 QEMU_FLATTEN
float128_mul(float128 a, float128 b, float_status *status)
{
- FloatParts128 pa, pb, *pr;
-
- float128_unpack_canonical(&pa, a, status);
- float128_unpack_canonical(&pb, b, status);
- pr = parts128_mul(&pa, &pb, status);
+ FloatParts128 pa = float128_unpack_canonical(a, status);
+ FloatParts128 pb = float128_unpack_canonical(b, status);
+ FloatParts128 *pr = parts128_mul(&pa, &pb, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2255,12 +2251,10 @@ bfloat16 QEMU_FLATTEN bfloat16_muladd(bfloat16 a, bfloat16 b, bfloat16 c,
float128 QEMU_FLATTEN float128_muladd(float128 a, float128 b, float128 c,
int flags, float_status *status)
{
- FloatParts128 pa, pb, pc, *pr;
-
- float128_unpack_canonical(&pa, a, status);
- float128_unpack_canonical(&pb, b, status);
- float128_unpack_canonical(&pc, c, status);
- pr = parts128_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
+ FloatParts128 pa = float128_unpack_canonical(a, status);
+ FloatParts128 pb = float128_unpack_canonical(b, status);
+ FloatParts128 pc = float128_unpack_canonical(c, status);
+ FloatParts128 *pr = parts128_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
/* Round before applying negate result. */
parts128_uncanon(pr, status, &float128_params, false);
@@ -2383,11 +2377,9 @@ bfloat16_div(bfloat16 a, bfloat16 b, float_status *status)
float128 QEMU_FLATTEN
float128_div(float128 a, float128 b, float_status *status)
{
- FloatParts128 pa, pb, *pr;
-
- float128_unpack_canonical(&pa, a, status);
- float128_unpack_canonical(&pb, b, status);
- pr = parts128_div(&pa, &pb, status);
+ FloatParts128 pa = float128_unpack_canonical(a, status);
+ FloatParts128 pb = float128_unpack_canonical(b, status);
+ FloatParts128 *pr = parts128_div(&pa, &pb, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2429,11 +2421,9 @@ float64 float64_rem(float64 a, float64 b, float_status *status)
float128 float128_rem(float128 a, float128 b, float_status *status)
{
- FloatParts128 pa, pb, *pr;
-
- float128_unpack_canonical(&pa, a, status);
- float128_unpack_canonical(&pb, b, status);
- pr = parts128_modrem(&pa, &pb, NULL, status);
+ FloatParts128 pa = float128_unpack_canonical(a, status);
+ FloatParts128 pb = float128_unpack_canonical(b, status);
+ FloatParts128 *pr = parts128_modrem(&pa, &pb, NULL, status);
return float128_round_pack_canonical(pr, status);
}
@@ -2782,20 +2772,18 @@ bfloat16 float64_to_bfloat16(float64 a, float_status *s)
float32 float128_to_float32(float128 a, float_status *s)
{
+ FloatParts128 p128 = float128_unpack_canonical(a, s);
FloatParts64 p64;
- FloatParts128 p128;
- float128_unpack_canonical(&p128, a, s);
parts_float_to_float_narrow(&p64, &p128, s);
return float32_round_pack_canonical(&p64, s);
}
float64 float128_to_float64(float128 a, float_status *s)
{
+ FloatParts128 p128 = float128_unpack_canonical(a, s);
FloatParts64 p64;
- FloatParts128 p128;
- float128_unpack_canonical(&p128, a, s);
parts_float_to_float_narrow(&p64, &p128, s);
return float64_round_pack_canonical(&p64, s);
}
@@ -2876,9 +2864,8 @@ floatx80 float64_to_floatx80(float64 a, float_status *s)
floatx80 float128_to_floatx80(float128 a, float_status *s)
{
- FloatParts128 p;
+ FloatParts128 p = float128_unpack_canonical(a, s);
- float128_unpack_canonical(&p, a, s);
parts128_float_to_float(&p, s);
return floatx80_round_pack_canonical(&p, s);
}
@@ -2921,9 +2908,8 @@ bfloat16 bfloat16_round_to_int(bfloat16 a, float_status *s)
float128 float128_round_to_int(float128 a, float_status *s)
{
- FloatParts128 p;
+ FloatParts128 p = float128_unpack_canonical(a, s);
- float128_unpack_canonical(&p, a, s);
parts128_round_to_int(&p, s->float_rounding_mode, 0, s, &float128_params);
return float128_round_pack_canonical(&p, s);
}
@@ -3046,18 +3032,14 @@ int64_t bfloat16_to_int64_scalbn(bfloat16 a, FloatRoundMode rmode, int scale,
static int32_t float128_to_int32_scalbn(float128 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
return parts128_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
}
static int64_t float128_to_int64_scalbn(float128 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
return parts128_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
}
@@ -3066,9 +3048,7 @@ static Int128 float128_to_int128_scalbn(float128 a, FloatRoundMode rmode,
{
int flags = 0;
Int128 r;
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
switch (p.cls) {
case float_class_snan:
@@ -3512,18 +3492,14 @@ uint64_t bfloat16_to_uint64_scalbn(bfloat16 a, FloatRoundMode rmode,
static uint32_t float128_to_uint32_scalbn(float128 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
return parts128_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
}
static uint64_t float128_to_uint64_scalbn(float128 a, FloatRoundMode rmode,
int scale, float_status *s)
{
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
return parts128_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
}
@@ -3532,9 +3508,7 @@ static Int128 float128_to_uint128_scalbn(float128 a, FloatRoundMode rmode,
{
int flags = 0;
Int128 r;
- FloatParts128 p;
-
- float128_unpack_canonical(&p, a, s);
+ FloatParts128 p = float128_unpack_canonical(a, s);
switch (p.cls) {
case float_class_snan:
@@ -4210,11 +4184,9 @@ static float64 float64_minmax(float64 a, float64 b, float_status *s, int flags)
static float128 float128_minmax(float128 a, float128 b,
float_status *s, int flags)
{
- FloatParts128 pa, pb, *pr;
-
- float128_unpack_canonical(&pa, a, s);
- float128_unpack_canonical(&pb, b, s);
- pr = parts128_minmax(&pa, &pb, s, flags);
+ FloatParts128 pa = float128_unpack_canonical(a, s);
+ FloatParts128 pb = float128_unpack_canonical(b, s);
+ FloatParts128 *pr = parts128_minmax(&pa, &pb, s, flags);
return float128_round_pack_canonical(pr, s);
}
@@ -4393,10 +4365,9 @@ FloatRelation bfloat16_compare_quiet(bfloat16 a, bfloat16 b, float_status *s)
static FloatRelation QEMU_FLATTEN
float128_do_compare(float128 a, float128 b, float_status *s, bool is_quiet)
{
- FloatParts128 pa, pb;
+ FloatParts128 pa = float128_unpack_canonical(a, s);
+ FloatParts128 pb = float128_unpack_canonical(b, s);
- float128_unpack_canonical(&pa, a, s);
- float128_unpack_canonical(&pb, b, s);
return parts128_compare(&pa, &pb, s, is_quiet);
}
@@ -4470,9 +4441,8 @@ bfloat16 bfloat16_scalbn(bfloat16 a, int n, float_status *status)
float128 float128_scalbn(float128 a, int n, float_status *status)
{
- FloatParts128 p;
+ FloatParts128 p = float128_unpack_canonical(a, status);
- float128_unpack_canonical(&p, a, status);
parts128_scalbn(&p, n, status);
return float128_round_pack_canonical(&p, status);
}
@@ -4590,9 +4560,8 @@ bfloat16 QEMU_FLATTEN bfloat16_sqrt(bfloat16 a, float_status *status)
float128 QEMU_FLATTEN float128_sqrt(float128 a, float_status *status)
{
- FloatParts128 p;
+ FloatParts128 p = float128_unpack_canonical(a, status);
- float128_unpack_canonical(&p, a, status);
parts128_sqrt(&p, status, &float128_params);
return float128_round_pack_canonical(&p, status);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 47/48] fpu: Change parts_float_to_float_narrow to parts128_to_parts64
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (45 preceding siblings ...)
2026-04-29 22:24 ` [PULL 46/48] fpu: Return struct from float128_unpack_canonical Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-29 22:24 ` [PULL 48/48] fpu: Change parts_float_to_float_widen to parts64_to_parts128 Richard Henderson
2026-04-30 17:35 ` [PULL 00/48] fpu patch queue Stefan Hajnoczi
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Rename and return FloatParts64 structure.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 30 +++++++++++++++---------------
1 file changed, 15 insertions(+), 15 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 77585fa11f..99f0036d0d 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -2563,29 +2563,31 @@ static void parts128_float_to_float(FloatParts128 *a, float_status *s)
}
}
-static void parts_float_to_float_narrow(FloatParts64 *a, FloatParts128 *b,
- float_status *s)
+static FloatParts64 parts128_to_parts64(FloatParts128 *b, float_status *s)
{
- a->cls = b->cls;
- a->sign = b->sign;
- a->exp = b->exp;
+ FloatParts64 r = {
+ .cls = b->cls,
+ .sign = b->sign,
+ .exp = b->exp,
+ };
- switch (a->cls) {
+ switch (r.cls) {
case float_class_denormal:
float_raise(float_flag_input_denormal_used, s);
/* fall through */
case float_class_normal:
- frac64_truncjam(a, b);
+ frac64_truncjam(&r, b);
break;
case float_class_snan:
case float_class_qnan:
/* Discard the low bits of the NaN. */
- a->frac = b->frac_hi;
- parts64_return_nan(a, s);
+ r.frac = b->frac_hi;
+ parts64_return_nan(&r, s);
break;
default:
break;
}
+ return r;
}
static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b,
@@ -2773,18 +2775,16 @@ bfloat16 float64_to_bfloat16(float64 a, float_status *s)
float32 float128_to_float32(float128 a, float_status *s)
{
FloatParts128 p128 = float128_unpack_canonical(a, s);
- FloatParts64 p64;
+ FloatParts64 p64 = parts128_to_parts64(&p128, s);
- parts_float_to_float_narrow(&p64, &p128, s);
return float32_round_pack_canonical(&p64, s);
}
float64 float128_to_float64(float128 a, float_status *s)
{
FloatParts128 p128 = float128_unpack_canonical(a, s);
- FloatParts64 p64;
+ FloatParts64 p64 = parts128_to_parts64(&p128, s);
- parts_float_to_float_narrow(&p64, &p128, s);
return float64_round_pack_canonical(&p64, s);
}
@@ -2812,7 +2812,7 @@ float32 floatx80_to_float32(floatx80 a, float_status *s)
FloatParts128 p128;
if (floatx80_unpack_canonical(&p128, a, s)) {
- parts_float_to_float_narrow(&p64, &p128, s);
+ p64 = parts128_to_parts64(&p128, s);
} else {
parts64_default_nan(&p64, s);
}
@@ -2825,7 +2825,7 @@ float64 floatx80_to_float64(floatx80 a, float_status *s)
FloatParts128 p128;
if (floatx80_unpack_canonical(&p128, a, s)) {
- parts_float_to_float_narrow(&p64, &p128, s);
+ p64 = parts128_to_parts64(&p128, s);
} else {
parts64_default_nan(&p64, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PULL 48/48] fpu: Change parts_float_to_float_widen to parts64_to_parts128
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (46 preceding siblings ...)
2026-04-29 22:24 ` [PULL 47/48] fpu: Change parts_float_to_float_narrow to parts128_to_parts64 Richard Henderson
@ 2026-04-29 22:24 ` Richard Henderson
2026-04-30 17:35 ` [PULL 00/48] fpu patch queue Stefan Hajnoczi
48 siblings, 0 replies; 51+ messages in thread
From: Richard Henderson @ 2026-04-29 22:24 UTC (permalink / raw)
To: qemu-devel; +Cc: stefanha, Philippe Mathieu-Daudé
Rename and return FloatParts128 structure.
Use switch instead of 2 ifs.
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
fpu/softfloat.c | 39 +++++++++++++++++++++------------------
1 file changed, 21 insertions(+), 18 deletions(-)
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 99f0036d0d..5d58caf5ea 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -2590,20 +2590,27 @@ static FloatParts64 parts128_to_parts64(FloatParts128 *b, float_status *s)
return r;
}
-static void parts_float_to_float_widen(FloatParts128 *a, FloatParts64 *b,
- float_status *s)
+static FloatParts128 parts64_to_parts128(FloatParts64 *b, float_status *s)
{
- a->cls = b->cls;
- a->sign = b->sign;
- a->exp = b->exp;
- frac64_widen(a, b);
+ FloatParts128 r = {
+ .cls = b->cls,
+ .sign = b->sign,
+ .exp = b->exp,
+ .frac_hi = b->frac,
+ };
- if (is_nan(a->cls)) {
- parts128_return_nan(a, s);
- }
- if (a->cls == float_class_denormal) {
+ switch (r.cls) {
+ case float_class_qnan:
+ case float_class_snan:
+ parts128_return_nan(&r, s);
+ break;
+ case float_class_denormal:
float_raise(float_flag_input_denormal_used, s);
+ break;
+ default:
+ break;
}
+ return r;
}
float8_e4m3 float4_e2m1_to_float8_e4m3(float4_e2m1 a, float_status *s)
@@ -2791,18 +2798,16 @@ float64 float128_to_float64(float128 a, float_status *s)
float128 float32_to_float128(float32 a, float_status *s)
{
FloatParts64 p64 = float32_unpack_canonical(a, s);
- FloatParts128 p128;
+ FloatParts128 p128 = parts64_to_parts128(&p64, s);
- parts_float_to_float_widen(&p128, &p64, s);
return float128_round_pack_canonical(&p128, s);
}
float128 float64_to_float128(float64 a, float_status *s)
{
FloatParts64 p64 = float64_unpack_canonical(a, s);
- FloatParts128 p128;
+ FloatParts128 p128 = parts64_to_parts128(&p64, s);
- parts_float_to_float_widen(&p128, &p64, s);
return float128_round_pack_canonical(&p128, s);
}
@@ -2847,18 +2852,16 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
floatx80 float32_to_floatx80(float32 a, float_status *s)
{
FloatParts64 p64 = float32_unpack_canonical(a, s);
- FloatParts128 p128;
+ FloatParts128 p128 = parts64_to_parts128(&p64, s);
- parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
floatx80 float64_to_floatx80(float64 a, float_status *s)
{
FloatParts64 p64 = float64_unpack_canonical(a, s);
- FloatParts128 p128;
+ FloatParts128 p128 = parts64_to_parts128(&p64, s);
- parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
--
2.43.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PULL 00/48] fpu patch queue
2026-04-29 22:23 [PULL 00/48] fpu patch queue Richard Henderson
` (47 preceding siblings ...)
2026-04-29 22:24 ` [PULL 48/48] fpu: Change parts_float_to_float_widen to parts64_to_parts128 Richard Henderson
@ 2026-04-30 17:35 ` Stefan Hajnoczi
48 siblings, 0 replies; 51+ messages in thread
From: Stefan Hajnoczi @ 2026-04-30 17:35 UTC (permalink / raw)
To: Richard Henderson; +Cc: qemu-devel, stefanha
[-- Attachment #1: Type: text/plain, Size: 116 bytes --]
Applied, thanks.
Please update the changelog at https://wiki.qemu.org/ChangeLog/11.1 for any user-visible changes.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 51+ messages in thread