fpu: Return struct from float{32,64}_unpack_canonical
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>
Richard Henderson committed
Apr 25, 2026 at 19:41 UTC
5ad853cc5db2998c9ecb54ede259540a5d97dfe0
1 file changed
+107
-193
fpu/softfloat.c
+107
-193
@@ -1516,11 +1516,11 @@ static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p,
1516
return bfloat16_pack_raw(p);
1517
}
1518
1519
-static void float32_unpack_canonical(FloatParts64 *p, float32 f,
1520
- float_status *s)
1519
+static FloatParts64 float32_unpack_canonical(float32 f, float_status *s)
1520
{
1522
- *p = unpack_raw64(&float32_params, f);
1523
- parts64_canonicalize(p, s, &float32_params);
1521
+ FloatParts64 p = unpack_raw64(&float32_params, f);
1522
+ parts64_canonicalize(&p, s, &float32_params);
1523
+ return p;
1524
}
1525
1526
static float32 float32_round_pack_canonical(FloatParts64 *p,
@@ -1530,11 +1530,11 @@ static float32 float32_round_pack_canonical(FloatParts64 *p,
1530
return float32_pack_raw(p);
1531
}
1532
1533
-static void float64_unpack_canonical(FloatParts64 *p, float64 f,
1534
- float_status *s)
1533
+static FloatParts64 float64_unpack_canonical(float64 f, float_status *s)
1534
{
1536
- *p = unpack_raw64(&float64_params, f);
1537
- parts64_canonicalize(p, s, &float64_params);
1535
+ FloatParts64 p = unpack_raw64(&float64_params, f);
1536
+ parts64_canonicalize(&p, s, &float64_params);
1537
+ return p;
1538
}
1539
1540
static float64 float64_round_pack_canonical(FloatParts64 *p,
@@ -1722,11 +1722,9 @@ float16 float16_sub(float16 a, float16 b, float_status *status)
1722
static float32 QEMU_SOFTFLOAT_ATTR
1723
soft_f32_addsub(float32 a, float32 b, float_status *status, bool subtract)
1724
{
1725
- FloatParts64 pa, pb, *pr;
1726
-
1727
- float32_unpack_canonical(&pa, a, status);
1728
- float32_unpack_canonical(&pb, b, status);
1729
- pr = parts64_addsub(&pa, &pb, status, subtract);
1725
+ FloatParts64 pa = float32_unpack_canonical(a, status);
1726
+ FloatParts64 pb = float32_unpack_canonical(b, status);
1727
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
1728
1729
return float32_round_pack_canonical(pr, status);
1730
}
@@ -1744,11 +1742,9 @@ static float32 soft_f32_sub(float32 a, float32 b, float_status *status)
1742
static float64 QEMU_SOFTFLOAT_ATTR
1743
soft_f64_addsub(float64 a, float64 b, float_status *status, bool subtract)
1744
{
1747
- FloatParts64 pa, pb, *pr;
1748
-
1749
- float64_unpack_canonical(&pa, a, status);
1750
- float64_unpack_canonical(&pb, b, status);
1751
- pr = parts64_addsub(&pa, &pb, status, subtract);
1745
+ FloatParts64 pa = float64_unpack_canonical(a, status);
1746
+ FloatParts64 pb = float64_unpack_canonical(b, status);
1747
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
1748
1749
return float64_round_pack_canonical(pr, status);
1750
}
@@ -1841,11 +1837,9 @@ float64_sub(float64 a, float64 b, float_status *s)
1837
static float64 float64r32_addsub(float64 a, float64 b, float_status *status,
1838
bool subtract)
1839
{
1844
- FloatParts64 pa, pb, *pr;
1845
-
1846
- float64_unpack_canonical(&pa, a, status);
1847
- float64_unpack_canonical(&pb, b, status);
1848
- pr = parts64_addsub(&pa, &pb, status, subtract);
1840
+ FloatParts64 pa = float64_unpack_canonical(a, status);
1841
+ FloatParts64 pb = float64_unpack_canonical(b, status);
1842
+ FloatParts64 *pr = parts64_addsub(&pa, &pb, status, subtract);
1843
1844
return float64r32_round_pack_canonical(pr, status);
1845
}
@@ -1942,11 +1936,9 @@ float16 QEMU_FLATTEN float16_mul(float16 a, float16 b, float_status *status)
1936
static float32 QEMU_SOFTFLOAT_ATTR
1937
soft_f32_mul(float32 a, float32 b, float_status *status)
1938
{
1945
- FloatParts64 pa, pb, *pr;
1946
-
1947
- float32_unpack_canonical(&pa, a, status);
1948
- float32_unpack_canonical(&pb, b, status);
1949
- pr = parts64_mul(&pa, &pb, status);
1939
+ FloatParts64 pa = float32_unpack_canonical(a, status);
1940
+ FloatParts64 pb = float32_unpack_canonical(b, status);
1941
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
1942
1943
return float32_round_pack_canonical(pr, status);
1944
}
@@ -1954,11 +1946,9 @@ soft_f32_mul(float32 a, float32 b, float_status *status)
1946
static float64 QEMU_SOFTFLOAT_ATTR
1947
soft_f64_mul(float64 a, float64 b, float_status *status)
1948
{
1957
- FloatParts64 pa, pb, *pr;
1958
-
1959
- float64_unpack_canonical(&pa, a, status);
1960
- float64_unpack_canonical(&pb, b, status);
1961
- pr = parts64_mul(&pa, &pb, status);
1949
+ FloatParts64 pa = float64_unpack_canonical(a, status);
1950
+ FloatParts64 pb = float64_unpack_canonical(b, status);
1951
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
1952
1953
return float64_round_pack_canonical(pr, status);
1954
}
@@ -1989,11 +1979,9 @@ float64_mul(float64 a, float64 b, float_status *s)
1979
1980
float64 float64r32_mul(float64 a, float64 b, float_status *status)
1981
{
1992
- FloatParts64 pa, pb, *pr;
1993
-
1994
- float64_unpack_canonical(&pa, a, status);
1995
- float64_unpack_canonical(&pb, b, status);
1996
- pr = parts64_mul(&pa, &pb, status);
1982
+ FloatParts64 pa = float64_unpack_canonical(a, status);
1983
+ FloatParts64 pb = float64_unpack_canonical(b, status);
1984
+ FloatParts64 *pr = parts64_mul(&pa, &pb, status);
1985
1986
return float64r32_round_pack_canonical(pr, status);
1987
}
@@ -2066,12 +2054,10 @@ float32 QEMU_SOFTFLOAT_ATTR
2054
float32_muladd_scalbn(float32 a, float32 b, float32 c,
2055
int scale, int flags, float_status *status)
2056
{
2069
- FloatParts64 pa, pb, pc, *pr;
2070
-
2071
- float32_unpack_canonical(&pa, a, status);
2072
- float32_unpack_canonical(&pb, b, status);
2073
- float32_unpack_canonical(&pc, c, status);
2074
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
2057
+ FloatParts64 pa = float32_unpack_canonical(a, status);
2058
+ FloatParts64 pb = float32_unpack_canonical(b, status);
2059
+ FloatParts64 pc = float32_unpack_canonical(c, status);
2060
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
2061
2062
/* Round before applying negate result. */
2063
parts64_uncanon(pr, status, &float32_params, false);
@@ -2085,12 +2071,10 @@ float64 QEMU_SOFTFLOAT_ATTR
2071
float64_muladd_scalbn(float64 a, float64 b, float64 c,
2072
int scale, int flags, float_status *status)
2073
{
2088
- FloatParts64 pa, pb, pc, *pr;
2089
-
2090
- float64_unpack_canonical(&pa, a, status);
2091
- float64_unpack_canonical(&pb, b, status);
2092
- float64_unpack_canonical(&pc, c, status);
2093
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
2074
+ FloatParts64 pa = float64_unpack_canonical(a, status);
2075
+ FloatParts64 pb = float64_unpack_canonical(b, status);
2076
+ FloatParts64 pc = float64_unpack_canonical(c, status);
2077
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, scale, flags, status);
2078
2079
/* Round before applying negate result. */
2080
parts64_uncanon(pr, status, &float64_params, false);
@@ -2244,12 +2228,10 @@ float64_muladd(float64 xa, float64 xb, float64 xc, int flags, float_status *s)
2228
float64 float64r32_muladd(float64 a, float64 b, float64 c,
2229
int flags, float_status *status)
2230
{
2247
- FloatParts64 pa, pb, pc, *pr;
2248
-
2249
- float64_unpack_canonical(&pa, a, status);
2250
- float64_unpack_canonical(&pb, b, status);
2251
- float64_unpack_canonical(&pc, c, status);
2252
- pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
2231
+ FloatParts64 pa = float64_unpack_canonical(a, status);
2232
+ FloatParts64 pb = float64_unpack_canonical(b, status);
2233
+ FloatParts64 pc = float64_unpack_canonical(c, status);
2234
+ FloatParts64 *pr = parts64_muladd_scalbn(&pa, &pb, &pc, 0, flags, status);
2235
2236
/* Round before applying negate result. */
2237
parts64_uncanon(pr, status, &float32_params, false);
@@ -2309,11 +2291,9 @@ float16 float16_div(float16 a, float16 b, float_status *status)
2291
static float32 QEMU_SOFTFLOAT_ATTR
2292
soft_f32_div(float32 a, float32 b, float_status *status)
2293
{
2312
- FloatParts64 pa, pb, *pr;
2313
-
2314
- float32_unpack_canonical(&pa, a, status);
2315
- float32_unpack_canonical(&pb, b, status);
2316
- pr = parts64_div(&pa, &pb, status);
2294
+ FloatParts64 pa = float32_unpack_canonical(a, status);
2295
+ FloatParts64 pb = float32_unpack_canonical(b, status);
2296
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
2297
2298
return float32_round_pack_canonical(pr, status);
2299
}
@@ -2321,11 +2301,9 @@ soft_f32_div(float32 a, float32 b, float_status *status)
2301
static float64 QEMU_SOFTFLOAT_ATTR
2302
soft_f64_div(float64 a, float64 b, float_status *status)
2303
{
2324
- FloatParts64 pa, pb, *pr;
2325
-
2326
- float64_unpack_canonical(&pa, a, status);
2327
- float64_unpack_canonical(&pb, b, status);
2328
- pr = parts64_div(&pa, &pb, status);
2304
+ FloatParts64 pa = float64_unpack_canonical(a, status);
2305
+ FloatParts64 pb = float64_unpack_canonical(b, status);
2306
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
2307
2308
return float64_round_pack_canonical(pr, status);
2309
}
@@ -2390,11 +2368,9 @@ float64_div(float64 a, float64 b, float_status *s)
2368
2369
float64 float64r32_div(float64 a, float64 b, float_status *status)
2370
{
2393
- FloatParts64 pa, pb, *pr;
2394
-
2395
- float64_unpack_canonical(&pa, a, status);
2396
- float64_unpack_canonical(&pb, b, status);
2397
- pr = parts64_div(&pa, &pb, status);
2371
+ FloatParts64 pa = float64_unpack_canonical(a, status);
2372
+ FloatParts64 pb = float64_unpack_canonical(b, status);
2373
+ FloatParts64 *pr = parts64_div(&pa, &pb, status);
2374
2375
return float64r32_round_pack_canonical(pr, status);
2376
}
@@ -2440,22 +2416,18 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
2416
2417
float32 float32_rem(float32 a, float32 b, float_status *status)
2418
{
2443
- FloatParts64 pa, pb, *pr;
2444
-
2445
- float32_unpack_canonical(&pa, a, status);
2446
- float32_unpack_canonical(&pb, b, status);
2447
- pr = parts64_modrem(&pa, &pb, NULL, status);
2419
+ FloatParts64 pa = float32_unpack_canonical(a, status);
2420
+ FloatParts64 pb = float32_unpack_canonical(b, status);
2421
+ FloatParts64 *pr = parts64_modrem(&pa, &pb, NULL, status);
2422
2423
return float32_round_pack_canonical(pr, status);
2424
}
2425
2426
float64 float64_rem(float64 a, float64 b, float_status *status)
2427
{
2454
- FloatParts64 pa, pb, *pr;
2455
-
2456
- float64_unpack_canonical(&pa, a, status);
2457
- float64_unpack_canonical(&pb, b, status);
2458
- pr = parts64_modrem(&pa, &pb, NULL, status);
2428
+ FloatParts64 pa = float64_unpack_canonical(a, status);
2429
+ FloatParts64 pb = float64_unpack_canonical(b, status);
2430
+ FloatParts64 *pr = parts64_modrem(&pa, &pb, NULL, status);
2431
2432
return float64_round_pack_canonical(pr, status);
2433
}
@@ -2688,28 +2660,25 @@ float64 float16_to_float64(float16 a, bool ieee, float_status *s)
2660
2661
float8_e4m3 float32_to_float8_e4m3(float32 a, bool saturate, float_status *s)
2662
{
2691
- FloatParts64 p;
2663
+ FloatParts64 p = float32_unpack_canonical(a, s);
2664
2693
- float32_unpack_canonical(&p, a, s);
2665
parts64_float_to_float(&p, s);
2666
return float8_e4m3_round_pack_canonical(&p, s, saturate);
2667
}
2668
2669
float8_e5m2 float32_to_float8_e5m2(float32 a, bool saturate, float_status *s)
2670
{
2700
- FloatParts64 p;
2671
+ FloatParts64 p = float32_unpack_canonical(a, s);
2672
2702
- float32_unpack_canonical(&p, a, s);
2673
parts_float_to_e5m2(&p, s, saturate);
2674
return float8_e5m2_round_pack_canonical(&p, s, saturate);
2675
}
2676
2677
float16 float32_to_float16(float32 a, bool ieee, float_status *s)
2678
{
2709
- FloatParts64 p;
2679
+ FloatParts64 p = float32_unpack_canonical(a, s);
2680
const FloatFmt *fmt;
2681
2712
- float32_unpack_canonical(&p, a, s);
2682
if (ieee) {
2683
parts64_float_to_float(&p, s);
2684
fmt = &float16_params;
@@ -2723,9 +2692,8 @@ float16 float32_to_float16(float32 a, bool ieee, float_status *s)
2692
static float64 QEMU_SOFTFLOAT_ATTR
2693
soft_float32_to_float64(float32 a, float_status *s)
2694
{
2726
- FloatParts64 p;
2695
+ FloatParts64 p = float32_unpack_canonical(a, s);
2696
2728
- float32_unpack_canonical(&p, a, s);
2697
parts64_float_to_float(&p, s);
2698
return float64_round_pack_canonical(&p, s);
2699
}
@@ -2748,10 +2716,9 @@ float64 float32_to_float64(float32 a, float_status *s)
2716
2717
float16 float64_to_float16(float64 a, bool ieee, float_status *s)
2718
{
2751
- FloatParts64 p;
2719
+ FloatParts64 p = float64_unpack_canonical(a, s);
2720
const FloatFmt *fmt;
2721
2754
- float64_unpack_canonical(&p, a, s);
2722
if (ieee) {
2723
parts64_float_to_float(&p, s);
2724
fmt = &float16_params;
@@ -2764,9 +2731,8 @@ float16 float64_to_float16(float64 a, bool ieee, float_status *s)
2731
2732
float32 float64_to_float32(float64 a, float_status *s)
2733
{
2767
- FloatParts64 p;
2734
+ FloatParts64 p = float64_unpack_canonical(a, s);
2735
2769
- float64_unpack_canonical(&p, a, s);
2736
parts64_float_to_float(&p, s);
2737
return float32_round_pack_canonical(&p, s);
2738
}
@@ -2805,18 +2771,16 @@ float64 bfloat16_to_float64(bfloat16 a, float_status *s)
2771
2772
bfloat16 float32_to_bfloat16(float32 a, float_status *s)
2773
{
2808
- FloatParts64 p;
2774
+ FloatParts64 p = float32_unpack_canonical(a, s);
2775
2810
- float32_unpack_canonical(&p, a, s);
2776
parts64_float_to_float(&p, s);
2777
return bfloat16_round_pack_canonical(&p, s);
2778
}
2779
2780
bfloat16 float64_to_bfloat16(float64 a, float_status *s)
2781
{
2817
- FloatParts64 p;
2782
+ FloatParts64 p = float64_unpack_canonical(a, s);
2783
2819
- float64_unpack_canonical(&p, a, s);
2784
parts64_float_to_float(&p, s);
2785
return bfloat16_round_pack_canonical(&p, s);
2786
}
@@ -2843,20 +2807,18 @@ float64 float128_to_float64(float128 a, float_status *s)
2807
2808
float128 float32_to_float128(float32 a, float_status *s)
2809
{
2846
- FloatParts64 p64;
2810
+ FloatParts64 p64 = float32_unpack_canonical(a, s);
2811
FloatParts128 p128;
2812
2849
- float32_unpack_canonical(&p64, a, s);
2813
parts_float_to_float_widen(&p128, &p64, s);
2814
return float128_round_pack_canonical(&p128, s);
2815
}
2816
2817
float128 float64_to_float128(float64 a, float_status *s)
2818
{
2856
- FloatParts64 p64;
2819
+ FloatParts64 p64 = float64_unpack_canonical(a, s);
2820
FloatParts128 p128;
2821
2859
- float64_unpack_canonical(&p64, a, s);
2822
parts_float_to_float_widen(&p128, &p64, s);
2823
return float128_round_pack_canonical(&p128, s);
2824
}
@@ -2901,20 +2863,18 @@ float128 floatx80_to_float128(floatx80 a, float_status *s)
2863
2864
floatx80 float32_to_floatx80(float32 a, float_status *s)
2865
{
2904
- FloatParts64 p64;
2866
+ FloatParts64 p64 = float32_unpack_canonical(a, s);
2867
FloatParts128 p128;
2868
2907
- float32_unpack_canonical(&p64, a, s);
2869
parts_float_to_float_widen(&p128, &p64, s);
2870
return floatx80_round_pack_canonical(&p128, s);
2871
}
2872
2873
floatx80 float64_to_floatx80(float64 a, float_status *s)
2874
{
2914
- FloatParts64 p64;
2875
+ FloatParts64 p64 = float64_unpack_canonical(a, s);
2876
FloatParts128 p128;
2877
2917
- float64_unpack_canonical(&p64, a, s);
2878
parts_float_to_float_widen(&p128, &p64, s);
2879
return floatx80_round_pack_canonical(&p128, s);
2880
}
@@ -2942,18 +2902,16 @@ float16 float16_round_to_int(float16 a, float_status *s)
2902
2903
float32 float32_round_to_int(float32 a, float_status *s)
2904
{
2945
- FloatParts64 p;
2905
+ FloatParts64 p = float32_unpack_canonical(a, s);
2906
2947
- float32_unpack_canonical(&p, a, s);
2907
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float32_params);
2908
return float32_round_pack_canonical(&p, s);
2909
}
2910
2911
float64 float64_round_to_int(float64 a, float_status *s)
2912
{
2954
- FloatParts64 p;
2913
+ FloatParts64 p = float64_unpack_canonical(a, s);
2914
2956
- float64_unpack_canonical(&p, a, s);
2915
parts64_round_to_int(&p, s->float_rounding_mode, 0, s, &float64_params);
2916
return float64_round_pack_canonical(&p, s);
2917
}
@@ -3023,54 +2981,42 @@ int64_t float16_to_int64_scalbn(float16 a, FloatRoundMode rmode, int scale,
2981
int16_t float32_to_int16_scalbn(float32 a, FloatRoundMode rmode, int scale,
2982
float_status *s)
2983
{
3026
- FloatParts64 p;
3027
-
3028
- float32_unpack_canonical(&p, a, s);
2984
+ FloatParts64 p = float32_unpack_canonical(a, s);
2985
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
2986
}
2987
2988
int32_t float32_to_int32_scalbn(float32 a, FloatRoundMode rmode, int scale,
2989
float_status *s)
2990
{
3035
- FloatParts64 p;
3036
-
3037
- float32_unpack_canonical(&p, a, s);
2991
+ FloatParts64 p = float32_unpack_canonical(a, s);
2992
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
2993
}
2994
2995
int64_t float32_to_int64_scalbn(float32 a, FloatRoundMode rmode, int scale,
2996
float_status *s)
2997
{
3044
- FloatParts64 p;
3045
-
3046
- float32_unpack_canonical(&p, a, s);
2998
+ FloatParts64 p = float32_unpack_canonical(a, s);
2999
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
3000
}
3001
3002
int16_t float64_to_int16_scalbn(float64 a, FloatRoundMode rmode, int scale,
3003
float_status *s)
3004
{
3053
- FloatParts64 p;
3054
-
3055
- float64_unpack_canonical(&p, a, s);
3005
+ FloatParts64 p = float64_unpack_canonical(a, s);
3006
return parts64_float_to_sint(&p, rmode, scale, INT16_MIN, INT16_MAX, s);
3007
}
3008
3009
int32_t float64_to_int32_scalbn(float64 a, FloatRoundMode rmode, int scale,
3010
float_status *s)
3011
{
3062
- FloatParts64 p;
3063
-
3064
- float64_unpack_canonical(&p, a, s);
3012
+ FloatParts64 p = float64_unpack_canonical(a, s);
3013
return parts64_float_to_sint(&p, rmode, scale, INT32_MIN, INT32_MAX, s);
3014
}
3015
3016
int64_t float64_to_int64_scalbn(float64 a, FloatRoundMode rmode, int scale,
3017
float_status *s)
3018
{
3071
- FloatParts64 p;
3072
-
3073
- float64_unpack_canonical(&p, a, s);
3019
+ FloatParts64 p = float64_unpack_canonical(a, s);
3020
return parts64_float_to_sint(&p, rmode, scale, INT64_MIN, INT64_MAX, s);
3021
}
3022
@@ -3455,18 +3401,14 @@ static int64_t parts64_float_to_sint_modulo(FloatParts64 *p,
3401
int32_t float64_to_int32_modulo(float64 a, FloatRoundMode rmode,
3402
float_status *s)
3403
{
3458
- FloatParts64 p;
3459
-
3460
- float64_unpack_canonical(&p, a, s);
3404
+ FloatParts64 p = float64_unpack_canonical(a, s);
3405
return parts64_float_to_sint_modulo(&p, rmode, 31, s);
3406
}
3407
3408
int64_t float64_to_int64_modulo(float64 a, FloatRoundMode rmode,
3409
float_status *s)
3410
{
3467
- FloatParts64 p;
3468
-
3469
- float64_unpack_canonical(&p, a, s);
3411
+ FloatParts64 p = float64_unpack_canonical(a, s);
3412
return parts64_float_to_sint_modulo(&p, rmode, 63, s);
3413
}
3414
@@ -3505,54 +3447,42 @@ uint64_t float16_to_uint64_scalbn(float16 a, FloatRoundMode rmode, int scale,
3447
uint16_t float32_to_uint16_scalbn(float32 a, FloatRoundMode rmode, int scale,
3448
float_status *s)
3449
{
3508
- FloatParts64 p;
3509
-
3510
- float32_unpack_canonical(&p, a, s);
3450
+ FloatParts64 p = float32_unpack_canonical(a, s);
3451
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
3452
}
3453
3454
uint32_t float32_to_uint32_scalbn(float32 a, FloatRoundMode rmode, int scale,
3455
float_status *s)
3456
{
3517
- FloatParts64 p;
3518
-
3519
- float32_unpack_canonical(&p, a, s);
3457
+ FloatParts64 p = float32_unpack_canonical(a, s);
3458
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
3459
}
3460
3461
uint64_t float32_to_uint64_scalbn(float32 a, FloatRoundMode rmode, int scale,
3462
float_status *s)
3463
{
3526
- FloatParts64 p;
3527
-
3528
- float32_unpack_canonical(&p, a, s);
3464
+ FloatParts64 p = float32_unpack_canonical(a, s);
3465
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
3466
}
3467
3468
uint16_t float64_to_uint16_scalbn(float64 a, FloatRoundMode rmode, int scale,
3469
float_status *s)
3470
{
3535
- FloatParts64 p;
3536
-
3537
- float64_unpack_canonical(&p, a, s);
3471
+ FloatParts64 p = float64_unpack_canonical(a, s);
3472
return parts64_float_to_uint(&p, rmode, scale, UINT16_MAX, s);
3473
}
3474
3475
uint32_t float64_to_uint32_scalbn(float64 a, FloatRoundMode rmode, int scale,
3476
float_status *s)
3477
{
3544
- FloatParts64 p;
3545
-
3546
- float64_unpack_canonical(&p, a, s);
3478
+ FloatParts64 p = float64_unpack_canonical(a, s);
3479
return parts64_float_to_uint(&p, rmode, scale, UINT32_MAX, s);
3480
}
3481
3482
uint64_t float64_to_uint64_scalbn(float64 a, FloatRoundMode rmode, int scale,
3483
float_status *s)
3484
{
3553
- FloatParts64 p;
3554
-
3555
- float64_unpack_canonical(&p, a, s);
3485
+ FloatParts64 p = float64_unpack_canonical(a, s);
3486
return parts64_float_to_uint(&p, rmode, scale, UINT64_MAX, s);
3487
}
3488
@@ -4266,22 +4196,18 @@ static bfloat16 bfloat16_minmax(bfloat16 a, bfloat16 b,
4196
4197
static float32 float32_minmax(float32 a, float32 b, float_status *s, int flags)
4198
{
4269
- FloatParts64 pa, pb, *pr;
4270
-
4271
- float32_unpack_canonical(&pa, a, s);
4272
- float32_unpack_canonical(&pb, b, s);
4273
- pr = parts64_minmax(&pa, &pb, s, flags);
4199
+ FloatParts64 pa = float32_unpack_canonical(a, s);
4200
+ FloatParts64 pb = float32_unpack_canonical(b, s);
4201
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
4202
4203
return float32_round_pack_canonical(pr, s);
4204
}
4205
4206
static float64 float64_minmax(float64 a, float64 b, float_status *s, int flags)
4207
{
4280
- FloatParts64 pa, pb, *pr;
4281
-
4282
- float64_unpack_canonical(&pa, a, s);
4283
- float64_unpack_canonical(&pb, b, s);
4284
- pr = parts64_minmax(&pa, &pb, s, flags);
4208
+ FloatParts64 pa = float64_unpack_canonical(a, s);
4209
+ FloatParts64 pb = float64_unpack_canonical(b, s);
4210
+ FloatParts64 *pr = parts64_minmax(&pa, &pb, s, flags);
4211
4212
return float64_round_pack_canonical(pr, s);
4213
}
@@ -4347,10 +4273,9 @@ FloatRelation float16_compare_quiet(float16 a, float16 b, float_status *s)
4273
static FloatRelation QEMU_SOFTFLOAT_ATTR
4274
float32_do_compare(float32 a, float32 b, float_status *s, bool is_quiet)
4275
{
4350
- FloatParts64 pa, pb;
4276
+ FloatParts64 pa = float32_unpack_canonical(a, s);
4277
+ FloatParts64 pb = float32_unpack_canonical(b, s);
4278
4352
- float32_unpack_canonical(&pa, a, s);
4353
- float32_unpack_canonical(&pb, b, s);
4279
return parts64_compare(&pa, &pb, s, is_quiet);
4280
}
4281
@@ -4401,10 +4326,9 @@ FloatRelation float32_compare_quiet(float32 a, float32 b, float_status *s)
4326
static FloatRelation QEMU_SOFTFLOAT_ATTR
4327
float64_do_compare(float64 a, float64 b, float_status *s, bool is_quiet)
4328
{
4404
- FloatParts64 pa, pb;
4329
+ FloatParts64 pa = float64_unpack_canonical(a, s);
4330
+ FloatParts64 pb = float64_unpack_canonical(b, s);
4331
4406
- float64_unpack_canonical(&pa, a, s);
4407
- float64_unpack_canonical(&pb, b, s);
4332
return parts64_compare(&pa, &pb, s, is_quiet);
4333
}
4334
@@ -4527,18 +4451,16 @@ float16 float16_scalbn(float16 a, int n, float_status *status)
4451
4452
float32 float32_scalbn(float32 a, int n, float_status *status)
4453
{
4530
- FloatParts64 p;
4454
+ FloatParts64 p = float32_unpack_canonical(a, status);
4455
4532
- float32_unpack_canonical(&p, a, status);
4456
parts64_scalbn(&p, n, status);
4457
return float32_round_pack_canonical(&p, status);
4458
}
4459
4460
float64 float64_scalbn(float64 a, int n, float_status *status)
4461
{
4539
- FloatParts64 p;
4462
+ FloatParts64 p = float64_unpack_canonical(a, status);
4463
4541
- float64_unpack_canonical(&p, a, status);
4464
parts64_scalbn(&p, n, status);
4465
return float64_round_pack_canonical(&p, status);
4466
}
@@ -4586,9 +4508,8 @@ float16 QEMU_FLATTEN float16_sqrt(float16 a, float_status *status)
4508
static float32 QEMU_SOFTFLOAT_ATTR
4509
soft_f32_sqrt(float32 a, float_status *status)
4510
{
4589
- FloatParts64 p;
4511
+ FloatParts64 p = float32_unpack_canonical(a, status);
4512
4591
- float32_unpack_canonical(&p, a, status);
4513
parts64_sqrt(&p, status, &float32_params);
4514
return float32_round_pack_canonical(&p, status);
4515
}
@@ -4596,9 +4517,8 @@ soft_f32_sqrt(float32 a, float_status *status)
4517
static float64 QEMU_SOFTFLOAT_ATTR
4518
soft_f64_sqrt(float64 a, float_status *status)
4519
{
4599
- FloatParts64 p;
4520
+ FloatParts64 p = float64_unpack_canonical(a, status);
4521
4601
- float64_unpack_canonical(&p, a, status);
4522
parts64_sqrt(&p, status, &float64_params);
4523
return float64_round_pack_canonical(&p, status);
4524
}
@@ -4659,9 +4579,8 @@ float64 QEMU_FLATTEN float64_sqrt(float64 xa, float_status *s)
4579
4580
float64 float64r32_sqrt(float64 a, float_status *status)
4581
{
4662
- FloatParts64 p;
4582
+ FloatParts64 p = float64_unpack_canonical(a, status);
4583
4664
- float64_unpack_canonical(&p, a, status);
4584
parts64_sqrt(&p, status, &float64_params);
4585
return float64r32_round_pack_canonical(&p, status);
4586
}
@@ -4822,18 +4741,16 @@ static void parts64_log2(FloatParts64 *a, float_status *s, const FloatFmt *fmt)
4741
4742
float32 float32_log2(float32 a, float_status *status)
4743
{
4825
- FloatParts64 p;
4744
+ FloatParts64 p = float32_unpack_canonical(a, status);
4745
4827
- float32_unpack_canonical(&p, a, status);
4746
parts64_log2(&p, status, &float32_params);
4747
return float32_round_pack_canonical(&p, status);
4748
}
4749
4750
float64 float64_log2(float64 a, float_status *status)
4751
{
4834
- FloatParts64 p;
4752
+ FloatParts64 p = float64_unpack_canonical(a, status);
4753
4836
- float64_unpack_canonical(&p, a, status);
4754
parts64_log2(&p, status, &float64_params);
4755
return float64_round_pack_canonical(&p, status);
4756
}
@@ -5321,10 +5238,9 @@ static const float64 float32_exp2_coefficients[15] =
5238
5239
float32 float32_exp2(float32 a, float_status *status)
5240
{
5324
- FloatParts64 xp, xnp, tp, rp;
5325
- int i;
5241
+ FloatParts64 xnp, tp, rp;
5242
+ FloatParts64 xp = float32_unpack_canonical(a, status);
5243
5327
- float32_unpack_canonical(&xp, a, status);
5244
if (unlikely(xp.cls != float_class_normal)) {
5245
switch (xp.cls) {
5246
case float_class_denormal:
@@ -5344,14 +5260,13 @@ float32 float32_exp2(float32 a, float_status *status)
5260
5261
float_raise(float_flag_inexact, status);
5262
5347
- float64_unpack_canonical(&tp, float64_ln2, status);
5263
+ tp = float64_unpack_canonical(float64_ln2, status);
5264
xp = *parts64_mul(&xp, &tp, status);
5265
xnp = xp;
5266
5351
- float64_unpack_canonical(&rp, float64_one, status);
5352
- for (i = 0 ; i < 15 ; i++) {
5353
-
5354
- float64_unpack_canonical(&tp, float32_exp2_coefficients[i], status);
5267
+ rp = float64_unpack_canonical(float64_one, status);
5268
+ for (int i = 0; i < 15; i++) {
5269
+ tp = float64_unpack_canonical(float32_exp2_coefficients[i], status);
5270
rp = *parts64_muladd_scalbn(&tp, &xnp, &rp, 0, 0, status);
5271
xnp = *parts64_mul(&xnp, &xp, status);
5272
}
@@ -5504,10 +5419,9 @@ void floatN ## _s390_divide_to_integer(floatN a, floatN b, \
5419
uint32_t *cc, int *dxc, \
5420
float_status *status) \
5421
{ \
5507
- FloatParts64 pa, pb, pr, pn; \
5508
- \
5509
- floatN ## _unpack_canonical(&pa, a, status); \
5510
- floatN ## _unpack_canonical(&pb, b, status); \
5422
+ FloatParts64 pa = floatN ## _unpack_canonical(a, status); \
5423
+ FloatParts64 pb = floatN ## _unpack_canonical(b, status); \
5424
+ FloatParts64 pr, pn; \
5425
parts_s390_divide_to_integer(&pa, &pb, final_quotient_rounding_mode, \
5426
mask_underflow, mask_inexact, \
5427
&floatN ## _params, \