@samitouri / QOSamiQemu / commits / 5511af9044

fpu: Export unpack_canonical and round_pack_canonical routines

Export the unpacking and repacking into the various formats. Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>

Richard Henderson committed Apr 25, 2026 at 20:57 UTC 5511af9044ec751f064683c26b6978bf4a85b89f

2 files changed +49 -28

fpu/softfloat.c

+19 -28

@@ -1296,21 +1296,21 @@ static const uint16_t rsqrt_tab[128] = {

1296 * Pack/unpack routines with a specific FloatFmt.

1297 */

1298

1299 -static FloatParts64 float4_e2m1_unpack_canonical(float4_e2m1 f, float_status *s)

1299 +FloatParts64 float4_e2m1_unpack_canonical(float4_e2m1 f, float_status *s)

1300 {

1301 FloatParts64 p = unpack_raw64(&float4_e2m1_params, f);

1302 parts64_canonicalize(&p, s, &float4_e2m1_params);

1303 return p;

1304 }

1305

1306 -static FloatParts64 float8_e4m3_unpack_canonical(float8_e4m3 f, float_status *s)

1306 +FloatParts64 float8_e4m3_unpack_canonical(float8_e4m3 f, float_status *s)

1307 {

1308 FloatParts64 p = unpack_raw64(&float8_e4m3_params, f);

1309 parts64_canonicalize(&p, s, &float8_e4m3_params);

1310 return p;

1311 }

1312

1313 -static FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s)

1313 +FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s)

1314 {

1315 FloatParts64 p = unpack_raw64(&float8_e5m2_params, f);

1316 parts64_canonicalize(&p, s, &float8_e5m2_params);

@@ -1325,29 +1325,27 @@ static FloatParts64 float16a_unpack_canonical(float16 f, float_status *s,

1325 return p;

1326 }

1327

1328 -static FloatParts64 float16_unpack_canonical(float16 f, float_status *s)

1328 +FloatParts64 float16_unpack_canonical(float16 f, float_status *s)

1329 {

1330 return float16a_unpack_canonical(f, s, &float16_params);

1331 }

1332

1333 -static FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s)

1333 +FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s)

1334 {

1335 FloatParts64 p = unpack_raw64(&bfloat16_params, f);

1336 parts64_canonicalize(&p, s, &bfloat16_params);

1337 return p;

1338 }

1339

1340 -static float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p,

1341 - float_status *s,

1342 - bool saturate)

1340 +float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p, float_status *s,

1341 + bool saturate)

1342 {

1343 parts64_uncanon(p, s, &float8_e4m3_params, saturate);

1344 return pack_raw64(p, &float8_e4m3_params);

1345 }

1346

1348 -static float8_e5m2 float8_e5m2_round_pack_canonical(FloatParts64 *p,

1349 - float_status *s,

1350 - bool saturate)

1347 +float8_e5m2 float8_e5m2_round_pack_canonical(FloatParts64 *p, float_status *s,

1348 + bool saturate)

1349 {

1350 parts64_uncanon(p, s, &float8_e5m2_params, saturate);

1351 return pack_raw64(p, &float8_e5m2_params);

@@ -1361,42 +1359,38 @@ static float16 float16a_round_pack_canonical(FloatParts64 *p,

1359 return pack_raw64(p, &float16_params);

1360 }

1361

1364 -static float16 float16_round_pack_canonical(FloatParts64 *p,

1365 - float_status *s)

1362 +float16 float16_round_pack_canonical(FloatParts64 *p, float_status *s)

1363 {

1364 return float16a_round_pack_canonical(p, s, &float16_params);

1365 }

1366

1370 -static bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p,

1371 - float_status *s)

1367 +bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p, float_status *s)

1368 {

1369 parts64_uncanon(p, s, &bfloat16_params, false);

1370 return pack_raw64(p, &bfloat16_params);

1371 }

1372

1377 -static FloatParts64 float32_unpack_canonical(float32 f, float_status *s)

1373 +FloatParts64 float32_unpack_canonical(float32 f, float_status *s)

1374 {

1375 FloatParts64 p = unpack_raw64(&float32_params, f);

1376 parts64_canonicalize(&p, s, &float32_params);

1377 return p;

1378 }

1379

1384 -static float32 float32_round_pack_canonical(FloatParts64 *p,

1385 - float_status *s)

1380 +float32 float32_round_pack_canonical(FloatParts64 *p, float_status *s)

1381 {

1382 parts64_uncanon(p, s, &float32_params, false);

1383 return pack_raw64(p, &float32_params);

1384 }

1385

1391 -static FloatParts64 float64_unpack_canonical(float64 f, float_status *s)

1386 +FloatParts64 float64_unpack_canonical(float64 f, float_status *s)

1387 {

1388 FloatParts64 p = unpack_raw64(&float64_params, f);

1389 parts64_canonicalize(&p, s, &float64_params);

1390 return p;

1391 }

1392

1398 -static float64 float64_round_pack_canonical(FloatParts64 *p,

1399 - float_status *s)

1393 +float64 float64_round_pack_canonical(FloatParts64 *p, float_status *s)

1394 {

1395 parts64_uncanon(p, s, &float64_params, false);

1396 return pack_raw64(p, &float64_params);

@@ -1451,23 +1445,21 @@ static float64 float64r32_round_pack_canonical(FloatParts64 *p,

1445 return float64r32_pack_raw(p);

1446 }

1447

1454 -static FloatParts128 float128_unpack_canonical(float128 f, float_status *s)

1448 +FloatParts128 float128_unpack_canonical(float128 f, float_status *s)

1449 {

1450 FloatParts128 p = float128_unpack_raw(f);

1451 parts128_canonicalize(&p, s, &float128_params);

1452 return p;

1453 }

1454

1461 -static float128 float128_round_pack_canonical(FloatParts128 *p,

1462 - float_status *s)

1455 +float128 float128_round_pack_canonical(FloatParts128 *p, float_status *s)

1456 {

1457 parts128_uncanon(p, s, &float128_params, false);

1458 return float128_pack_raw(p);

1459 }

1460

1461 /* Returns false if the encoding is invalid. */

1469 -static bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f,

1470 - float_status *s)

1462 +bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f, float_status *s)

1463 {

1464 /* Ensure rounding precision is set before beginning. */

1465 switch (s->floatx80_rounding_precision) {

@@ -1503,8 +1495,7 @@ static bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f,

1495 return true;

1496 }

1497

1506 -static floatx80 floatx80_round_pack_canonical(FloatParts128 *p,

1507 - float_status *s)

1498 +floatx80 floatx80_round_pack_canonical(FloatParts128 *p, float_status *s)

1499 {

1500 const FloatFmt *fmt = &floatx80_params[s->floatx80_rounding_precision];

1501 uint64_t frac;

include/fpu/softfloat-parts.h

+30

@@ -133,4 +133,34 @@ typedef struct {

133 uint64_t frac_lo;

134 } FloatParts128;

135

136 +/*

137 + * Unpack routines from a specific floating-point format.

138 + */

139 +

140 +FloatParts64 float4_e2m1_unpack_canonical(float4_e2m1 f, float_status *s);

141 +FloatParts64 float8_e4m3_unpack_canonical(float8_e4m3 f, float_status *s);

142 +FloatParts64 float8_e5m2_unpack_canonical(float8_e5m2 f, float_status *s);

143 +FloatParts64 float16_unpack_canonical(float16 f, float_status *s);

144 +FloatParts64 bfloat16_unpack_canonical(bfloat16 f, float_status *s);

145 +FloatParts64 float32_unpack_canonical(float32 f, float_status *s);

146 +FloatParts64 float64_unpack_canonical(float64 f, float_status *s);

147 +FloatParts128 float128_unpack_canonical(float128 f, float_status *s);

148 +/* Returns false if the encoding is invalid. */

149 +bool floatx80_unpack_canonical(FloatParts128 *p, floatx80 f, float_status *s);

150 +

151 +/*

152 + * Pack routines to a specific floating-point format.

153 + */

154 +

155 +float8_e4m3 float8_e4m3_round_pack_canonical(FloatParts64 *p, float_status *s,

156 + bool saturate);

157 +float8_e5m2 float8_e5m2_round_pack_canonical(FloatParts64 *p, float_status *s,

158 + bool saturate);

159 +float16 float16_round_pack_canonical(FloatParts64 *p, float_status *s);

160 +bfloat16 bfloat16_round_pack_canonical(FloatParts64 *p, float_status *s);

161 +float32 float32_round_pack_canonical(FloatParts64 *p, float_status *s);

162 +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 #endif