fpu: Return struct from parts{64,128}_div
At the same time, export. Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Richard Henderson committed
Apr 26, 2026 at 11:05 UTC
4d91aa8f77d020ef0d3f06158ea2cf605ac3f721
3 files changed
+46
-42
fpu/softfloat-parts.c.inc
+20
-25
@@ -807,68 +807,63 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a, FloatPartsN *b,
807
* corresponding value `b'. The operation is performed according to
808
* the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
809
*/
810
-static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,
811
- float_status *s)
810
+FloatPartsN partsN(div)(const FloatPartsN *a, const FloatPartsN *b,
811
+ float_status *s)
812
{
813
int ab_mask = float_cmask(a->cls) | float_cmask(b->cls);
814
- bool sign = a->sign ^ b->sign;
814
+ FloatPartsN r = *a;
815
+
816
+ r.sign ^= b->sign;
817
+ r.exp -= b->exp;
818
819
if (likely(cmask_is_only_normals(ab_mask))) {
820
if (ab_mask & float_cmask_denormal) {
821
float_raise(float_flag_input_denormal_used, s);
822
}
820
- a->sign = sign;
821
- a->exp -= b->exp + fracN(div)(a, b);
822
- return a;
823
+ r.exp -= fracN(div)(&r, b);
824
+ return r;
825
}
826
827
/* 0/0 or Inf/Inf => NaN */
828
if (unlikely(ab_mask == float_cmask_zero)) {
829
float_raise(float_flag_invalid | float_flag_invalid_zdz, s);
828
- goto d_nan;
830
+ return partsN(default_nan)(s);
831
}
832
if (unlikely(ab_mask == float_cmask_inf)) {
833
float_raise(float_flag_invalid | float_flag_invalid_idi, s);
832
- goto d_nan;
834
+ return partsN(default_nan)(s);
835
}
836
837
/* All the NaN cases */
838
if (unlikely(ab_mask & float_cmask_anynan)) {
837
- *a = partsN(pick_nan)(a, b, s);
838
- return a;
839
+ return partsN(pick_nan)(a, b, s);
840
}
841
842
if ((ab_mask & float_cmask_denormal) && b->cls != float_class_zero) {
843
float_raise(float_flag_input_denormal_used, s);
844
}
845
845
- a->sign = sign;
846
-
846
/* Inf / X */
848
- if (a->cls == float_class_inf) {
849
- return a;
847
+ if (r.cls == float_class_inf) {
848
+ return r;
849
}
850
851
/* 0 / X */
853
- if (a->cls == float_class_zero) {
854
- return a;
852
+ if (r.cls == float_class_zero) {
853
+ return r;
854
}
855
856
/* X / Inf */
857
if (b->cls == float_class_inf) {
859
- a->cls = float_class_zero;
860
- return a;
858
+ r.cls = float_class_zero;
859
+ return r;
860
}
861
862
/* X / 0 => Inf */
864
- g_assert(b->cls == float_class_zero);
863
+ assert(b->cls == float_class_zero);
864
float_raise(float_flag_divbyzero, s);
866
- a->cls = float_class_inf;
867
- return a;
868
-
869
- d_nan:
870
- *a = partsN(default_nan)(s);
871
- return a;
865
+ r.cls = float_class_inf;
866
+ return r;
867
}
868
869
/*
fpu/softfloat.c
+17
-17
@@ -2129,9 +2129,9 @@ float16 float16_div(float16 a, float16 b, float_status *status)
2129
{
2130
FloatParts64 pa = float16_unpack_canonical(a, status);
2131
FloatParts64 pb = float16_unpack_canonical(b, status);
2132
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
2132
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
2133
2134
- return float16_round_pack_canonical(pr, status);
2134
+ return float16_round_pack_canonical(&pr, status);
2135
}
2136
2137
static float32 QEMU_SOFTFLOAT_ATTR
@@ -2139,9 +2139,9 @@ soft_f32_div(float32 a, float32 b, float_status *status)
2139
{
2140
FloatParts64 pa = float32_unpack_canonical(a, status);
2141
FloatParts64 pb = float32_unpack_canonical(b, status);
2142
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
2142
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
2143
2144
- return float32_round_pack_canonical(pr, status);
2144
+ return float32_round_pack_canonical(&pr, status);
2145
}
2146
2147
static float64 QEMU_SOFTFLOAT_ATTR
@@ -2149,9 +2149,9 @@ soft_f64_div(float64 a, float64 b, float_status *status)
2149
{
2150
FloatParts64 pa = float64_unpack_canonical(a, status);
2151
FloatParts64 pb = float64_unpack_canonical(b, status);
2152
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
2152
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
2153
2154
- return float64_round_pack_canonical(pr, status);
2154
+ return float64_round_pack_canonical(&pr, status);
2155
}
2156
2157
static float hard_f32_div(float a, float b)
@@ -2216,9 +2216,9 @@ float64 float64r32_div(float64 a, float64 b, float_status *status)
2216
{
2217
FloatParts64 pa = float64_unpack_canonical(a, status);
2218
FloatParts64 pb = float64_unpack_canonical(b, status);
2219
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
2219
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
2220
2221
- return float64r32_round_pack_canonical(pr, status);
2221
+ return float64r32_round_pack_canonical(&pr, status);
2222
}
2223
2224
bfloat16 QEMU_FLATTEN
@@ -2226,9 +2226,9 @@ bfloat16_div(bfloat16 a, bfloat16 b, float_status *status)
2226
{
2227
FloatParts64 pa = bfloat16_unpack_canonical(a, status);
2228
FloatParts64 pb = bfloat16_unpack_canonical(b, status);
2229
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
2229
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
2230
2231
- return bfloat16_round_pack_canonical(pr, status);
2231
+ return bfloat16_round_pack_canonical(&pr, status);
2232
}
2233
2234
float128 QEMU_FLATTEN
@@ -2236,22 +2236,22 @@ float128_div(float128 a, float128 b, float_status *status)
2236
{
2237
FloatParts128 pa = float128_unpack_canonical(a, status);
2238
FloatParts128 pb = float128_unpack_canonical(b, status);
2239
- FloatParts128 *pr = parts128_div(&pa, &pb, status);
2239
+ FloatParts128 pr = parts128_div(&pa, &pb, status);
2240
2241
- return float128_round_pack_canonical(pr, status);
2241
+ return float128_round_pack_canonical(&pr, status);
2242
}
2243
2244
floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
2245
{
2246
- FloatParts128 pa, pb, *pr;
2246
+ FloatParts128 pa, pb;
2247
2248
if (!floatx80_unpack_canonical(&pa, a, status) ||
2249
!floatx80_unpack_canonical(&pb, b, status)) {
2250
return floatx80_default_nan(status);
2251
}
2252
2253
- pr = parts128_div(&pa, &pb, status);
2254
- return floatx80_round_pack_canonical(pr, status);
2253
+ pa = parts128_div(&pa, &pb, status);
2254
+ return floatx80_round_pack_canonical(&pa, status);
2255
}
2256
2257
/*
@@ -5140,8 +5140,8 @@ static void parts_s390_divide_to_integer(FloatParts64 *a, FloatParts64 *b,
5140
uint32_t r_flags;
5141
5142
/* Compute precise quotient */
5143
- q_buf = *a;
5144
- q = parts64_div(&q_buf, b, status);
5143
+ q_buf = parts64_div(a, b, status);
5144
+ q = &q_buf;
5145
5146
/*
5147
* Check whether two closest integers can be precisely represented,
include/fpu/softfloat-parts.h
+9
@@ -163,4 +163,13 @@ float64 float64_round_pack_canonical(FloatParts64 *p, float_status *s);
163
float128 float128_round_pack_canonical(FloatParts128 *p, float_status *s);
164
floatx80 floatx80_round_pack_canonical(FloatParts128 *p, float_status *s);
165
166
+/*
167
+ * Operations
168
+ */
169
+
170
+FloatParts64 parts64_div(const FloatParts64 *a, const FloatParts64 *b,
171
+ float_status *s);
172
+FloatParts128 parts128_div(const FloatParts128 *a, const FloatParts128 *b,
173
+ float_status *s);
174
+
175
#endif