fpu: Return struct from parts{64,128}_default_nan
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Richard Henderson committed
Apr 25, 2026 at 21:19 UTC
8fb0b7c6e3ba006c0c03e2c71cbc970c27a49b9d
3 files changed
+33
-40
fpu/softfloat-parts.c.inc
+11
-11
@@ -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
- partsN(default_nan)(a, s);
24
+ *a = partsN(default_nan)(s);
25
} else {
26
partsN(silence_nan)(a, s);
27
}
28
break;
29
case float_class_qnan:
30
if (s->default_nan_mode) {
31
- partsN(default_nan)(a, s);
31
+ *a = partsN(default_nan)(s);
32
}
33
break;
34
default:
@@ -49,7 +49,7 @@ static FloatPartsN *partsN(pick_nan)(FloatPartsN *a, FloatPartsN *b,
49
}
50
51
if (s->default_nan_mode) {
52
- partsN(default_nan)(a, s);
52
+ *a = partsN(default_nan)(s);
53
return a;
54
}
55
@@ -184,7 +184,7 @@ static FloatPartsN *partsN(pick_nan_muladd)(FloatPartsN *a, FloatPartsN *b,
184
return ret;
185
186
default_nan:
187
- partsN(default_nan)(a, s);
187
+ *a = partsN(default_nan)(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
- partsN(default_nan)(p, s);
284
+ *p = partsN(default_nan)(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
- partsN(default_nan)(a, s);
571
+ *a = partsN(default_nan)(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
- partsN(default_nan)(a, s);
644
+ *a = partsN(default_nan)(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
- partsN(default_nan)(a, s);
799
+ *a = partsN(default_nan)(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
- partsN(default_nan)(a, s);
867
+ *a = partsN(default_nan)(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
- partsN(default_nan)(a, s);
899
+ *a = partsN(default_nan)(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
- partsN(default_nan)(a, status);
1121
+ *a = partsN(default_nan)(status);
1122
}
1123
1124
/*
fpu/softfloat-specialize.c.inc
+10
-12
@@ -118,7 +118,7 @@ static bool parts_is_snan_frac(uint64_t frac, float_status *status)
118
| The pattern for a default generated deconstructed floating-point NaN.
119
*----------------------------------------------------------------------------*/
120
121
-static void parts64_default_nan(FloatParts64 *p, float_status *status)
121
+static FloatParts64 parts64_default_nan(float_status *status)
122
{
123
bool sign = 0;
124
uint64_t frac;
@@ -134,7 +134,7 @@ static void parts64_default_nan(FloatParts64 *p, float_status *status)
134
frac = deposit64(0, DECOMPOSED_BINARY_POINT - 7, 7, dnan_pattern);
135
frac = deposit64(frac, 0, DECOMPOSED_BINARY_POINT - 7, -(dnan_pattern & 1));
136
137
- *p = (FloatParts64) {
137
+ return (FloatParts64) {
138
.cls = float_class_qnan,
139
.sign = sign,
140
.exp = INT_MAX,
@@ -142,17 +142,16 @@ static void parts64_default_nan(FloatParts64 *p, float_status *status)
142
};
143
}
144
145
-static void parts128_default_nan(FloatParts128 *p, float_status *status)
145
+static FloatParts128 parts128_default_nan(float_status *status)
146
{
147
/*
148
* Extrapolate from the choices made by parts64_default_nan to fill
149
* in the quad-floating format. If the low bit is set, assume we
150
* want to set all non-snan bits.
151
*/
152
- FloatParts64 p64;
153
- parts64_default_nan(&p64, status);
152
+ FloatParts64 p64 = parts64_default_nan(status);
153
155
- *p = (FloatParts128) {
154
+ return (FloatParts128) {
155
.cls = float_class_qnan,
156
.sign = p64.sign,
157
.exp = INT_MAX,
@@ -197,19 +196,18 @@ static void parts128_silence_nan(FloatParts128 *p, float_status *status)
196
*----------------------------------------------------------------------------*/
197
floatx80 floatx80_default_nan(float_status *status)
198
{
200
- floatx80 r;
199
/*
200
* Extrapolate from the choices made by parts64_default_nan to fill
201
* in the floatx80 format. We assume that floatx80's explicit
202
* integer bit is always set (this is true for i386 and m68k,
203
* which are the only real users of this format).
204
*/
207
- FloatParts64 p64;
208
- parts64_default_nan(&p64, status);
205
+ FloatParts64 p64 = parts64_default_nan(status);
206
210
- r.high = 0x7FFF | (p64.sign << 15);
211
- r.low = (1ULL << DECOMPOSED_BINARY_POINT) | p64.frac;
212
- return r;
207
+ return (floatx80) {
208
+ .high = 0x7FFF | (p64.sign << 15),
209
+ .low = (1ULL << DECOMPOSED_BINARY_POINT) | p64.frac,
210
+ };
211
}
212
213
/*----------------------------------------------------------------------------
fpu/softfloat.c
+12
-17
@@ -2678,7 +2678,7 @@ float32 floatx80_to_float32(floatx80 a, float_status *s)
2678
if (floatx80_unpack_canonical(&p128, a, s)) {
2679
p64 = parts128_to_parts64(&p128, s);
2680
} else {
2681
- parts64_default_nan(&p64, s);
2681
+ p64 = parts64_default_nan(s);
2682
}
2683
return float32_round_pack_canonical(&p64, s);
2684
}
@@ -2691,7 +2691,7 @@ float64 floatx80_to_float64(floatx80 a, float_status *s)
2691
if (floatx80_unpack_canonical(&p128, a, s)) {
2692
p64 = parts128_to_parts64(&p128, s);
2693
} else {
2694
- parts64_default_nan(&p64, s);
2694
+ p64 = parts64_default_nan(s);
2695
}
2696
return float64_round_pack_canonical(&p64, s);
2697
}
@@ -2703,7 +2703,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
2703
if (floatx80_unpack_canonical(&p, a, s)) {
2704
parts128_float_to_float(&p, s);
2705
} else {
2706
- parts128_default_nan(&p, s);
2706
+ p = parts128_default_nan(s);
2707
}
2708
return float128_round_pack_canonical(&p, s);
2709
}
@@ -2964,7 +2964,7 @@ static int32_t floatx80_to_int32_scalbn(floatx80 a, FloatRoundMode rmode,
2964
FloatParts128 p;
2965
2966
if (!floatx80_unpack_canonical(&p, a, s)) {
2967
- parts128_default_nan(&p, s);
2967
+ p = parts128_default_nan(s);
2968
}
2969
return parts128_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
2970
}
@@ -2975,7 +2975,7 @@ static int64_t floatx80_to_int64_scalbn(floatx80 a, FloatRoundMode rmode,
2975
FloatParts128 p;
2976
2977
if (!floatx80_unpack_canonical(&p, a, s)) {
2978
- parts128_default_nan(&p, s);
2978
+ p = parts128_default_nan(s);
2979
}
2980
return parts128_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
2981
}
@@ -4562,7 +4562,7 @@ static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *fmt)
4562
4563
d_nan:
4564
float_raise(float_flag_invalid, s);
4565
- parts64_default_nan(a, s);
4565
+ *a = parts64_default_nan(s);
4566
}
4567
4568
float32 float32_log2(float32 a, float_status *status)
@@ -4587,45 +4587,40 @@ float64 float64_log2(float64 a, float_status *status)
4587
4588
float16 float16_default_nan(float_status *status)
4589
{
4590
- FloatParts64 p;
4590
+ FloatParts64 p = parts64_default_nan(status);
4591
4592
- parts64_default_nan(&p, status);
4592
p.frac >>= float16_params.frac_shift;
4593
return pack_raw64(&p, &float16_params);
4594
}
4595
4596
float32 float32_default_nan(float_status *status)
4597
{
4599
- FloatParts64 p;
4598
+ FloatParts64 p = parts64_default_nan(status);
4599
4601
- parts64_default_nan(&p, status);
4600
p.frac >>= float32_params.frac_shift;
4601
return pack_raw64(&p, &float32_params);
4602
}
4603
4604
float64 float64_default_nan(float_status *status)
4605
{
4608
- FloatParts64 p;
4606
+ FloatParts64 p = parts64_default_nan(status);
4607
4610
- parts64_default_nan(&p, status);
4608
p.frac >>= float64_params.frac_shift;
4609
return pack_raw64(&p, &float64_params);
4610
}
4611
4612
float128 float128_default_nan(float_status *status)
4613
{
4617
- FloatParts128 p;
4614
+ FloatParts128 p = parts128_default_nan(status);
4615
4619
- parts128_default_nan(&p, status);
4616
frac128_shr(&p, float128_params.frac_shift);
4617
return float128_pack_raw(&p);
4618
}
4619
4620
bfloat16 bfloat16_default_nan(float_status *status)
4621
{
4626
- FloatParts64 p;
4622
+ FloatParts64 p = parts64_default_nan(status);
4623
4628
- parts64_default_nan(&p, status);
4624
p.frac >>= bfloat16_params.frac_shift;
4625
return pack_raw64(&p, &bfloat16_params);
4626
}
@@ -5131,7 +5126,7 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
5126
*n = *r;
5127
*cc = 1;
5128
} else if (a->cls == float_class_inf || b->cls == float_class_zero) {
5134
- parts64_default_nan(r, status);
5129
+ *r = parts64_default_nan(status);
5130
*n = *r;
5131
*cc = 1;
5132
status->float_exception_flags |= float_flag_invalid;