@samitouri / QOSamiQemu / commits / 3259530107

fpu: Drop parts_default_nan

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>

Richard Henderson committed Apr 26, 2026 at 18:48 UTC 325953010725ffb34b2c8b89d41a1e18b72918a4

2 files changed +23 -24

fpu/softfloat-parts.c.inc

+12 -12

@@ -21,14 +21,14 @@ static void partsN(return_nan)(FloatPartsN *a, float_status *s)

21 case float_class_snan:

22 float_raise(float_flag_invalid | float_flag_invalid_snan, s);

23 if (s->default_nan_mode) {

24 - parts_default_nan(a, s);

24 + partsN(default_nan)(a, s);

25 } else {

26 parts_silence_nan(a, s);

27 }

28 break;

29 case float_class_qnan:

30 if (s->default_nan_mode) {

31 - parts_default_nan(a, s);

31 + partsN(default_nan)(a, s);

32 }

33 break;

34 default:

@@ -49,7 +49,7 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b,

49 }

51 if (s->default_nan_mode) {

52 - parts_default_nan(a, s);

52 + partsN(default_nan)(a, s);

53 return a;

54 }

@@ -184,7 +184,7 @@ static FloatPartsN *partsN(pick_nan_muladd)(FloatPartsN *a, FloatPartsN *b,

184 return ret;

185

186 default_nan:

187 - parts_default_nan(a, s);

187 + partsN(default_nan)(a, s);

188 return a;

189 }

190

@@ -281,7 +281,7 @@ static void partsN(uncanon_e4m3_overflow)(FloatPartsN *p, float_status *s,

281 p->exp = fmt->exp_max;

282 p->frac_hi = E4M3_NORMAL_FRAC_MAX;

283 } else {

284 - parts_default_nan(p, s);

284 + partsN(default_nan)(p, s);

285 }

286 }

287

@@ -568,7 +568,7 @@ static FloatPartsN *partsN(addsub)(FloatPartsN *a, FloatPartsN *b,

568 }

569 /* Inf - Inf */

570 float_raise(float_flag_invalid | float_flag_invalid_isi, s);

571 - parts_default_nan(a, s);

571 + partsN(default_nan)(a, s);

572 return a;

573 }

574 } else {

@@ -641,7 +641,7 @@ static FloatPartsN *partsN(mul)(FloatPartsN *a, FloatPartsN *b,

641 /* Inf * Zero == NaN */

642 if (unlikely(ab_mask == float_cmask_infzero)) {

643 float_raise(float_flag_invalid | float_flag_invalid_imz, s);

644 - parts_default_nan(a, s);

644 + partsN(default_nan)(a, s);

645 return a;

646 }

647

@@ -796,7 +796,7 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,

796 goto finish_sign;

797

798 d_nan:

799 - parts_default_nan(a, s);

799 + partsN(default_nan)(a, s);

800 return a;

801 }

802

@@ -864,7 +864,7 @@ static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,

864 return a;

865

866 d_nan:

867 - parts_default_nan(a, s);

867 + partsN(default_nan)(a, s);

868 return a;

869 }

870

@@ -896,7 +896,7 @@ static FloatPartsN *partsN(modrem)(FloatPartsN *a, FloatPartsN *b,

896 /* Inf % N; N % 0 */

897 if (a->cls == float_class_inf || b->cls == float_class_zero) {

898 float_raise(float_flag_invalid, s);

899 - parts_default_nan(a, s);

899 + partsN(default_nan)(a, s);

900 return a;

901 }

902

@@ -1118,7 +1118,7 @@ static void partsN(sqrt)(FloatPartsN *a, float_status *status,

1118

1119 d_nan:

1120 float_raise(float_flag_invalid | float_flag_invalid_sqrt, status);

1121 - parts_default_nan(a, status);

1121 + partsN(default_nan)(a, status);

1122 }

1123

1124 /*

@@ -1879,5 +1879,5 @@ static void partsN(log2)(FloatPartsN *a, float_status *s, const FloatFmt *fmt)

1879

1880 d_nan:

1881 float_raise(float_flag_invalid, s);

1882 - parts_default_nan(a, s);

1882 + partsN(default_nan)(a, s);

1883 }

fpu/softfloat.c

+11 -12

@@ -779,7 +779,6 @@ static float128 QEMU_FLATTEN float128_pack_raw(const FloatParts128 *p)

779 FloatParts128 *: parts128_##NAME, \

780 FloatParts256 *: parts256_##NAME)

781

782 -#define parts_default_nan(P, S) PARTS_GENERIC_64_128(default_nan, P)(P, S)

782 #define parts_silence_nan(P, S) PARTS_GENERIC_64_128(silence_nan, P)(P, S)

783

784 static void parts64_return_nan(FloatParts64 *a, float_status *s);

@@ -3156,7 +3155,7 @@ float32 floatx80_to_float32(floatx80 a, float_status *s)

3155 if (floatx80_unpack_canonical(&p128, a, s)) {

3156 parts_float_to_float_narrow(&p64, &p128, s);

3157 } else {

3159 - parts_default_nan(&p64, s);

3158 + parts64_default_nan(&p64, s);

3159 }

3160 return float32_round_pack_canonical(&p64, s);

3161 }

@@ -3169,7 +3168,7 @@ float64 floatx80_to_float64(floatx80 a, float_status *s)

3168 if (floatx80_unpack_canonical(&p128, a, s)) {

3169 parts_float_to_float_narrow(&p64, &p128, s);

3170 } else {

3172 - parts_default_nan(&p64, s);

3171 + parts64_default_nan(&p64, s);

3172 }

3173 return float64_round_pack_canonical(&p64, s);

3174 }

@@ -3181,7 +3180,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)

3180 if (floatx80_unpack_canonical(&p, a, s)) {

3181 parts_float_to_float(&p, s);

3182 } else {

3184 - parts_default_nan(&p, s);

3183 + parts128_default_nan(&p, s);

3184 }

3185 return float128_round_pack_canonical(&p, s);

3186 }

@@ -3486,7 +3485,7 @@ static int32_t floatx80_to_int32_scalbn(floatx80 a, FloatRoundMode rmode,

3485 FloatParts128 p;

3486

3487 if (!floatx80_unpack_canonical(&p, a, s)) {

3489 - parts_default_nan(&p, s);

3488 + parts128_default_nan(&p, s);

3489 }

3490 return parts_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);

3491 }

@@ -3497,7 +3496,7 @@ static int64_t floatx80_to_int64_scalbn(floatx80 a, FloatRoundMode rmode,

3496 FloatParts128 p;

3497

3498 if (!floatx80_unpack_canonical(&p, a, s)) {

3500 - parts_default_nan(&p, s);

3499 + parts128_default_nan(&p, s);

3500 }

3501 return parts_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);

3502 }

@@ -4984,7 +4983,7 @@ float16 float16_default_nan(float_status *status)

4983 {

4984 FloatParts64 p;

4985

4987 - parts_default_nan(&p, status);

4986 + parts64_default_nan(&p, status);

4987 p.frac >>= float16_params.frac_shift;

4988 return float16_pack_raw(&p);

4989 }

@@ -4993,7 +4992,7 @@ float32 float32_default_nan(float_status *status)

4992 {

4993 FloatParts64 p;

4994

4996 - parts_default_nan(&p, status);

4995 + parts64_default_nan(&p, status);

4996 p.frac >>= float32_params.frac_shift;

4997 return float32_pack_raw(&p);

4998 }

@@ -5002,7 +5001,7 @@ float64 float64_default_nan(float_status *status)

5001 {

5002 FloatParts64 p;

5003

5005 - parts_default_nan(&p, status);

5004 + parts64_default_nan(&p, status);

5005 p.frac >>= float64_params.frac_shift;

5006 return float64_pack_raw(&p);

5007 }

@@ -5011,7 +5010,7 @@ float128 float128_default_nan(float_status *status)

5010 {

5011 FloatParts128 p;

5012

5014 - parts_default_nan(&p, status);

5013 + parts128_default_nan(&p, status);

5014 frac_shr(&p, float128_params.frac_shift);

5015 return float128_pack_raw(&p);

5016 }

@@ -5020,7 +5019,7 @@ bfloat16 bfloat16_default_nan(float_status *status)

5019 {

5020 FloatParts64 p;

5021

5023 - parts_default_nan(&p, status);

5022 + parts64_default_nan(&p, status);

5023 p.frac >>= bfloat16_params.frac_shift;

5024 return bfloat16_pack_raw(&p);

5025 }

@@ -5537,7 +5536,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,

5536 *n = *r;

5537 *cc = 1;

5538 } else if (a->cls == float_class_inf || b->cls == float_class_zero) {

5540 - parts_default_nan(r, status);

5539 + parts64_default_nan(r, status);

5540 *n = *r;

5541 *cc = 1;

5542 status->float_exception_flags |= float_flag_invalid;