xemu-project/xemu
1
0
Fork 0
mirror of https://github.com/xemu-project/xemu.git synced 2024-11-23 11:39:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

softfloat: Convert floatx80 float conversions to FloatParts

Browse Source 
This is the last use of commonNaNT and all of the routines
that use it, so remove all of them for Werror.

Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2020-11-21 18:02:23 -08:00
parent 5f9529006e
commit 8ae5719cd4
2 changed files with 67 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
fpu/softfloat-specialize.c.inc
View File

@ -256,14 +256,6 @@ floatx80 floatx80_default_nan(float_status *status)
const floatx80 floatx80_infinity const floatx80 floatx80_infinity
= make_floatx80_init(floatx80_infinity_high, floatx80_infinity_low); = make_floatx80_init(floatx80_infinity_high, floatx80_infinity_low);
/*----------------------------------------------------------------------------
| Internal canonical NaN format.
*----------------------------------------------------------------------------*/
typedef struct {
bool sign;
uint64_t high, low;
} commonNaNT;
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the half-precision floating-point value `a' is a quiet | Returns 1 if the half-precision floating-point value `a' is a quiet
| NaN; otherwise returns 0. | NaN; otherwise returns 0.
@ -379,46 +371,6 @@ bool float32_is_signaling_nan(float32 a_, float_status *status)
} }
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the single-precision floating-point NaN
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
| exception is raised.
*----------------------------------------------------------------------------*/
static commonNaNT float32ToCommonNaN(float32 a, float_status *status)
{
commonNaNT z;
if (float32_is_signaling_nan(a, status)) {
float_raise(float_flag_invalid, status);
}
z.sign = float32_val(a) >> 31;
z.low = 0;
z.high = ((uint64_t)float32_val(a)) << 41;
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the single-
| precision floating-point format.
*----------------------------------------------------------------------------*/
static float32 commonNaNToFloat32(commonNaNT a, float_status *status)
{
uint32_t mantissa = a.high >> 41;
if (status->default_nan_mode) {
return float32_default_nan(status);
}
if (mantissa) {
return make_float32(
(((uint32_t)a.sign) << 31) | 0x7F800000 | (a.high >> 41));
} else {
return float32_default_nan(status);
}
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Select which NaN to propagate for a two-input operation. | Select which NaN to propagate for a two-input operation.
| IEEE754 doesn't specify all the details of this, so the | IEEE754 doesn't specify all the details of this, so the
@ -785,48 +737,6 @@ bool float64_is_signaling_nan(float64 a_, float_status *status)
} }
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the double-precision floating-point NaN
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
| exception is raised.
*----------------------------------------------------------------------------*/
static commonNaNT float64ToCommonNaN(float64 a, float_status *status)
{
commonNaNT z;
if (float64_is_signaling_nan(a, status)) {
float_raise(float_flag_invalid, status);
}
z.sign = float64_val(a) >> 63;
z.low = 0;
z.high = float64_val(a) << 12;
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the double-
| precision floating-point format.
*----------------------------------------------------------------------------*/
static float64 commonNaNToFloat64(commonNaNT a, float_status *status)
{
uint64_t mantissa = a.high >> 12;
if (status->default_nan_mode) {
return float64_default_nan(status);
}
if (mantissa) {
return make_float64(
(((uint64_t) a.sign) << 63)
| UINT64_C(0x7FF0000000000000)
| (a.high >> 12));
} else {
return float64_default_nan(status);
}
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Takes two double-precision floating-point values `a' and `b', one of which | Takes two double-precision floating-point values `a' and `b', one of which
| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
@ -946,55 +856,6 @@ floatx80 floatx80_silence_nan(floatx80 a, float_status *status)
return a; return a;
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the extended double-precision floating-
| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
| invalid exception is raised.
*----------------------------------------------------------------------------*/
static commonNaNT floatx80ToCommonNaN(floatx80 a, float_status *status)
{
floatx80 dflt;
commonNaNT z;
if (floatx80_is_signaling_nan(a, status)) {
float_raise(float_flag_invalid, status);
}
if (a.low >> 63) {
z.sign = a.high >> 15;
z.low = 0;
z.high = a.low << 1;
} else {
dflt = floatx80_default_nan(status);
z.sign = dflt.high >> 15;
z.low = 0;
z.high = dflt.low << 1;
}
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the extended
| double-precision floating-point format.
*----------------------------------------------------------------------------*/
static floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
{
floatx80 z;
if (status->default_nan_mode) {
return floatx80_default_nan(status);
}
if (a.high >> 1) {
z.low = UINT64_C(0x8000000000000000) | a.high >> 1;
z.high = (((uint16_t)a.sign) << 15) | 0x7FFF;
} else {
z = floatx80_default_nan(status);
}
return z;
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Takes two extended double-precision floating-point values `a' and `b', one | Takes two extended double-precision floating-point values `a' and `b', one
| of which is a NaN, and returns the appropriate NaN result. If either `a' or | of which is a NaN, and returns the appropriate NaN result. If either `a' or
@ -1087,42 +948,6 @@ bool float128_is_signaling_nan(float128 a, float_status *status)
} }
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the quadruple-precision floating-point NaN
| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
| exception is raised.
*----------------------------------------------------------------------------*/
static commonNaNT float128ToCommonNaN(float128 a, float_status *status)
{
commonNaNT z;
if (float128_is_signaling_nan(a, status)) {
float_raise(float_flag_invalid, status);
}
z.sign = a.high >> 63;
shortShift128Left(a.high, a.low, 16, &z.high, &z.low);
return z;
}
/*----------------------------------------------------------------------------
| Returns the result of converting the canonical NaN `a' to the quadruple-
| precision floating-point format.
*----------------------------------------------------------------------------*/
static float128 commonNaNToFloat128(commonNaNT a, float_status *status)
{
float128 z;
if (status->default_nan_mode) {
return float128_default_nan(status);
}
shift128Right(a.high, a.low, 16, &z.high, &z.low);
z.high |= (((uint64_t)a.sign) << 63) | UINT64_C(0x7FFF000000000000);
return z;
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Takes two quadruple-precision floating-point values `a' and `b', one of | Takes two quadruple-precision floating-point values `a' and `b', one of
| which is a NaN, and returns the appropriate NaN result. If either `a' or | which is a NaN, and returns the appropriate NaN result. If either `a' or

276
fpu/softfloat.c
View File

@ -2561,6 +2561,73 @@ float128 float64_to_float128(float64 a, float_status *s)
return float128_round_pack_canonical(&p128, s); return float128_round_pack_canonical(&p128, s);
} }
float32 floatx80_to_float32(floatx80 a, float_status *s)
{
FloatParts64 p64;
FloatParts128 p128;
if (floatx80_unpack_canonical(&p128, a, s)) {
parts_float_to_float_narrow(&p64, &p128, s);
} else {
parts_default_nan(&p64, s);
}
return float32_round_pack_canonical(&p64, s);
}
float64 floatx80_to_float64(floatx80 a, float_status *s)
{
FloatParts64 p64;
FloatParts128 p128;
if (floatx80_unpack_canonical(&p128, a, s)) {
parts_float_to_float_narrow(&p64, &p128, s);
} else {
parts_default_nan(&p64, s);
}
return float64_round_pack_canonical(&p64, s);
}
float128 floatx80_to_float128(floatx80 a, float_status *s)
{
FloatParts128 p;
if (floatx80_unpack_canonical(&p, a, s)) {
parts_float_to_float(&p, s);
} else {
parts_default_nan(&p, s);
}
return float128_round_pack_canonical(&p, s);
}
floatx80 float32_to_floatx80(float32 a, float_status *s)
{
FloatParts64 p64;
FloatParts128 p128;
float32_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
floatx80 float64_to_floatx80(float64 a, float_status *s)
{
FloatParts64 p64;
FloatParts128 p128;
float64_unpack_canonical(&p64, a, s);
parts_float_to_float_widen(&p128, &p64, s);
return floatx80_round_pack_canonical(&p128, s);
}
floatx80 float128_to_floatx80(float128 a, float_status *s)
{
FloatParts128 p;
float128_unpack_canonical(&p, a, s);
parts_float_to_float(&p, s);
return floatx80_round_pack_canonical(&p, s);
}
/* /*
* Round to integral value * Round to integral value
*/ */
@ -5046,42 +5113,6 @@ static float128 normalizeRoundAndPackFloat128(bool zSign, int32_t zExp,
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the single-precision floating-point value
| `a' to the extended double-precision floating-point format. The conversion
| is performed according to the IEC/IEEE Standard for Binary Floating-Point
| Arithmetic.
*----------------------------------------------------------------------------*/
floatx80 float32_to_floatx80(float32 a, float_status *status)
{
bool aSign;
int aExp;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a );
if ( aExp == 0xFF ) {
if (aSig) {
floatx80 res = commonNaNToFloatx80(float32ToCommonNaN(a, status),
status);
return floatx80_silence_nan(res, status);
}
return packFloatx80(aSign,
floatx80_infinity_high,
floatx80_infinity_low);
}
if ( aExp == 0 ) {
if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
normalizeFloat32Subnormal( aSig, &aExp, &aSig );
}
aSig |= 0x00800000;
return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns the remainder of the single-precision floating-point value `a' | Returns the remainder of the single-precision floating-point value `a'
| with respect to the corresponding value `b'. The operation is performed | with respect to the corresponding value `b'. The operation is performed
@ -5318,43 +5349,6 @@ float32 float32_log2(float32 a, float_status *status)
return normalizeRoundAndPackFloat32(zSign, 0x85, zSig, status); return normalizeRoundAndPackFloat32(zSign, 0x85, zSig, status);
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the double-precision floating-point value
| `a' to the extended double-precision floating-point format. The conversion
| is performed according to the IEC/IEEE Standard for Binary Floating-Point
| Arithmetic.
*----------------------------------------------------------------------------*/
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
bool aSign;
int aExp;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
aSign = extractFloat64Sign( a );
if ( aExp == 0x7FF ) {
if (aSig) {
floatx80 res = commonNaNToFloatx80(float64ToCommonNaN(a, status),
status);
return floatx80_silence_nan(res, status);
}
return packFloatx80(aSign,
floatx80_infinity_high,
floatx80_infinity_low);
}
if ( aExp == 0 ) {
if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
normalizeFloat64Subnormal( aSig, &aExp, &aSig );
}
return
packFloatx80(
aSign, aExp + 0x3C00, (aSig | UINT64_C(0x0010000000000000)) << 11);
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns the remainder of the double-precision floating-point value `a' | Returns the remainder of the double-precision floating-point value `a'
| with respect to the corresponding value `b'. The operation is performed | with respect to the corresponding value `b'. The operation is performed
@ -5665,104 +5659,6 @@ int64_t floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the extended double-precision floating-
| point value `a' to the single-precision floating-point format. The
| conversion is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
float32 floatx80_to_float32(floatx80 a, float_status *status)
{
bool aSign;
int32_t aExp;
uint64_t aSig;
if (floatx80_invalid_encoding(a)) {
float_raise(float_flag_invalid, status);
return float32_default_nan(status);
}
aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) {
if ( (uint64_t) ( aSig<<1 ) ) {
float32 res = commonNaNToFloat32(floatx80ToCommonNaN(a, status),
status);
return float32_silence_nan(res, status);
}
return packFloat32( aSign, 0xFF, 0 );
}
shift64RightJamming( aSig, 33, &aSig );
if ( aExp || aSig ) aExp -= 0x3F81;
return roundAndPackFloat32(aSign, aExp, aSig, status);
}
/*----------------------------------------------------------------------------
| Returns the result of converting the extended double-precision floating-
| point value `a' to the double-precision floating-point format. The
| conversion is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
float64 floatx80_to_float64(floatx80 a, float_status *status)
{
bool aSign;
int32_t aExp;
uint64_t aSig, zSig;
if (floatx80_invalid_encoding(a)) {
float_raise(float_flag_invalid, status);
return float64_default_nan(status);
}
aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) {
if ( (uint64_t) ( aSig<<1 ) ) {
float64 res = commonNaNToFloat64(floatx80ToCommonNaN(a, status),
status);
return float64_silence_nan(res, status);
}
return packFloat64( aSign, 0x7FF, 0 );
}
shift64RightJamming( aSig, 1, &zSig );
if ( aExp || aSig ) aExp -= 0x3C01;
return roundAndPackFloat64(aSign, aExp, zSig, status);
}
/*----------------------------------------------------------------------------
| Returns the result of converting the extended double-precision floating-
| point value `a' to the quadruple-precision floating-point format. The
| conversion is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
float128 floatx80_to_float128(floatx80 a, float_status *status)
{
bool aSign;
int aExp;
uint64_t aSig, zSig0, zSig1;
if (floatx80_invalid_encoding(a)) {
float_raise(float_flag_invalid, status);
return float128_default_nan(status);
}
aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a );
if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) {
float128 res = commonNaNToFloat128(floatx80ToCommonNaN(a, status),
status);
return float128_silence_nan(res, status);
}
shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
return packFloat128( aSign, aExp, zSig0, zSig1 );
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Rounds the extended double-precision floating-point value `a' | Rounds the extended double-precision floating-point value `a'
| to the precision provided by floatx80_rounding_precision and returns the | to the precision provided by floatx80_rounding_precision and returns the
@ -5935,44 +5831,6 @@ floatx80 floatx80_mod(floatx80 a, floatx80 b, float_status *status)
return floatx80_modrem(a, b, true, &quotient, status); return floatx80_modrem(a, b, true, &quotient, status);
} }
/*----------------------------------------------------------------------------
| Returns the result of converting the quadruple-precision floating-point
| value `a' to the extended double-precision floating-point format. The
| conversion is performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
floatx80 float128_to_floatx80(float128 a, float_status *status)
{
bool aSign;
int32_t aExp;
uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a );
aExp = extractFloat128Exp( a );
aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) {
floatx80 res = commonNaNToFloatx80(float128ToCommonNaN(a, status),
status);
return floatx80_silence_nan(res, status);
}
return packFloatx80(aSign, floatx80_infinity_high,
floatx80_infinity_low);
}
if ( aExp == 0 ) {
if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
}
else {
aSig0 |= UINT64_C(0x0001000000000000);
}
shortShift128Left( aSig0, aSig1, 15, &aSig0, &aSig1 );
return roundAndPackFloatx80(80, aSign, aExp, aSig0, aSig1, status);
}
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns the remainder of the quadruple-precision floating-point value `a' | Returns the remainder of the quadruple-precision floating-point value `a'
| with respect to the corresponding value `b'. The operation is performed | with respect to the corresponding value `b'. The operation is performed