At the same time, export.
Reviewed-by: Philippe Mathieu-Daudé <[email protected]>
Signed-off-by: Richard Henderson <[email protected]>
---
include/fpu/softfloat-parts.h | 9 +++++++
fpu/softfloat.c | 34 +++++++++++++-------------
fpu/softfloat-parts.c.inc | 45 ++++++++++++++++-------------------
3 files changed, 46 insertions(+), 42 deletions(-)
diff --git a/include/fpu/softfloat-parts.h b/include/fpu/softfloat-parts.h
index f631c38c79..44e0cb7d05 100644
--- a/include/fpu/softfloat-parts.h
+++ b/include/fpu/softfloat-parts.h
@@ -163,4 +163,13 @@ float64 float64_round_pack_canonical(FloatParts64 *p,
float_status *s);
float128 float128_round_pack_canonical(FloatParts128 *p, float_status *s);
floatx80 floatx80_round_pack_canonical(FloatParts128 *p, float_status *s);
+/*
+ * Operations
+ */
+
+FloatParts64 parts64_div(const FloatParts64 *a, const FloatParts64 *b,
+ float_status *s);
+FloatParts128 parts128_div(const FloatParts128 *a, const FloatParts128 *b,
+ float_status *s);
+
#endif
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 246209072e..6d69b61c7f 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -2129,9 +2129,9 @@ float16 float16_div(float16 a, float16 b, float_status
*status)
{
FloatParts64 pa = float16_unpack_canonical(a, status);
FloatParts64 pb = float16_unpack_canonical(b, status);
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
- return float16_round_pack_canonical(pr, status);
+ return float16_round_pack_canonical(&pr, status);
}
static float32 QEMU_SOFTFLOAT_ATTR
@@ -2139,9 +2139,9 @@ soft_f32_div(float32 a, float32 b, float_status *status)
{
FloatParts64 pa = float32_unpack_canonical(a, status);
FloatParts64 pb = float32_unpack_canonical(b, status);
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
- return float32_round_pack_canonical(pr, status);
+ return float32_round_pack_canonical(&pr, status);
}
static float64 QEMU_SOFTFLOAT_ATTR
@@ -2149,9 +2149,9 @@ soft_f64_div(float64 a, float64 b, float_status *status)
{
FloatParts64 pa = float64_unpack_canonical(a, status);
FloatParts64 pb = float64_unpack_canonical(b, status);
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
- return float64_round_pack_canonical(pr, status);
+ return float64_round_pack_canonical(&pr, status);
}
static float hard_f32_div(float a, float b)
@@ -2216,9 +2216,9 @@ float64 float64r32_div(float64 a, float64 b, float_status
*status)
{
FloatParts64 pa = float64_unpack_canonical(a, status);
FloatParts64 pb = float64_unpack_canonical(b, status);
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
- return float64r32_round_pack_canonical(pr, status);
+ return float64r32_round_pack_canonical(&pr, status);
}
bfloat16 QEMU_FLATTEN
@@ -2226,9 +2226,9 @@ bfloat16_div(bfloat16 a, bfloat16 b, float_status *status)
{
FloatParts64 pa = bfloat16_unpack_canonical(a, status);
FloatParts64 pb = bfloat16_unpack_canonical(b, status);
- FloatParts64 *pr = parts64_div(&pa, &pb, status);
+ FloatParts64 pr = parts64_div(&pa, &pb, status);
- return bfloat16_round_pack_canonical(pr, status);
+ return bfloat16_round_pack_canonical(&pr, status);
}
float128 QEMU_FLATTEN
@@ -2236,22 +2236,22 @@ float128_div(float128 a, float128 b, float_status
*status)
{
FloatParts128 pa = float128_unpack_canonical(a, status);
FloatParts128 pb = float128_unpack_canonical(b, status);
- FloatParts128 *pr = parts128_div(&pa, &pb, status);
+ FloatParts128 pr = parts128_div(&pa, &pb, status);
- return float128_round_pack_canonical(pr, status);
+ return float128_round_pack_canonical(&pr, status);
}
floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
{
- FloatParts128 pa, pb, *pr;
+ FloatParts128 pa, pb;
if (!floatx80_unpack_canonical(&pa, a, status) ||
!floatx80_unpack_canonical(&pb, b, status)) {
return floatx80_default_nan(status);
}
- pr = parts128_div(&pa, &pb, status);
- return floatx80_round_pack_canonical(pr, status);
+ pa = parts128_div(&pa, &pb, status);
+ return floatx80_round_pack_canonical(&pa, status);
}
/*
@@ -5140,8 +5140,8 @@ static void parts_s390_divide_to_integer(FloatParts64 *a,
FloatParts64 *b,
uint32_t r_flags;
/* Compute precise quotient */
- q_buf = *a;
- q = parts64_div(&q_buf, b, status);
+ q_buf = parts64_div(a, b, status);
+ q = &q_buf;
/*
* Check whether two closest integers can be precisely represented,
diff --git a/fpu/softfloat-parts.c.inc b/fpu/softfloat-parts.c.inc
index 40ea7e3a39..1634160728 100644
--- a/fpu/softfloat-parts.c.inc
+++ b/fpu/softfloat-parts.c.inc
@@ -807,68 +807,63 @@ static FloatPartsN *partsN(muladd_scalbn)(FloatPartsN *a,
FloatPartsN *b,
* corresponding value `b'. The operation is performed according to
* the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*/
-static FloatPartsN *partsN(div)(FloatPartsN *a, FloatPartsN *b,
- float_status *s)
+FloatPartsN partsN(div)(const FloatPartsN *a, const FloatPartsN *b,
+ float_status *s)
{
int ab_mask = float_cmask(a->cls) | float_cmask(b->cls);
- bool sign = a->sign ^ b->sign;
+ FloatPartsN r = *a;
+
+ r.sign ^= b->sign;
+ r.exp -= b->exp;
if (likely(cmask_is_only_normals(ab_mask))) {
if (ab_mask & float_cmask_denormal) {
float_raise(float_flag_input_denormal_used, s);
}
- a->sign = sign;
- a->exp -= b->exp + fracN(div)(a, b);
- return a;
+ r.exp -= fracN(div)(&r, b);
+ return r;
}
/* 0/0 or Inf/Inf => NaN */
if (unlikely(ab_mask == float_cmask_zero)) {
float_raise(float_flag_invalid | float_flag_invalid_zdz, s);
- goto d_nan;
+ return partsN(default_nan)(s);
}
if (unlikely(ab_mask == float_cmask_inf)) {
float_raise(float_flag_invalid | float_flag_invalid_idi, s);
- goto d_nan;
+ return partsN(default_nan)(s);
}
/* All the NaN cases */
if (unlikely(ab_mask & float_cmask_anynan)) {
- *a = partsN(pick_nan)(a, b, s);
- return a;
+ return partsN(pick_nan)(a, b, s);
}
if ((ab_mask & float_cmask_denormal) && b->cls != float_class_zero) {
float_raise(float_flag_input_denormal_used, s);
}
- a->sign = sign;
-
/* Inf / X */
- if (a->cls == float_class_inf) {
- return a;
+ if (r.cls == float_class_inf) {
+ return r;
}
/* 0 / X */
- if (a->cls == float_class_zero) {
- return a;
+ if (r.cls == float_class_zero) {
+ return r;
}
/* X / Inf */
if (b->cls == float_class_inf) {
- a->cls = float_class_zero;
- return a;
+ r.cls = float_class_zero;
+ return r;
}
/* X / 0 => Inf */
- g_assert(b->cls == float_class_zero);
+ assert(b->cls == float_class_zero);
float_raise(float_flag_divbyzero, s);
- a->cls = float_class_inf;
- return a;
-
- d_nan:
- *a = partsN(default_nan)(s);
- return a;
+ r.cls = float_class_inf;
+ return r;
}
/*
--
2.43.0
