ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

softfloat: Honour default_nan_mode for float-to-float conversions 

Honour the default_nan_mode flag when doing conversions between
different floating point formats, as well as when returning a NaN from
a two-operand floating point function. This corrects the behaviour
of float<->double conversions on both ARM and SH4.

Signed-off-by: Christophe Lyon <christophe.lyon@st.com>
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Aurelien Jarno <aurelien@aurel32.net>
Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>
This commit is contained in:
Christophe Lyon 2011-02-10 11:28:57 +00:00 committed by Aurelien Jarno
parent bb4d4bb376
commit bcd4d9afd4
2 changed files with 37 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
fpu/softfloat-specialize.h
View File

@ -207,9 +207,14 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
| precision floating-point format. | precision floating-point format.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float32 commonNaNToFloat32( commonNaNT a ) static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM)
{ {
bits32 mantissa = a.high>>41; bits32 mantissa = a.high>>41;
if ( STATUS(default_nan_mode) ) {
return float32_default_nan;
}
if ( mantissa ) if ( mantissa )
return make_float32( return make_float32(
( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) ); ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
@ -461,10 +466,14 @@ static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
| precision floating-point format. | precision floating-point format.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float64 commonNaNToFloat64( commonNaNT a ) static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
{ {
bits64 mantissa = a.high>>12; bits64 mantissa = a.high>>12;
if ( STATUS(default_nan_mode) ) {
return float64_default_nan;
}
if ( mantissa ) if ( mantissa )
return make_float64( return make_float64(
( ( (bits64) a.sign )<<63 ) ( ( (bits64) a.sign )<<63 )
@ -618,10 +627,16 @@ static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
| double-precision floating-point format. | double-precision floating-point format.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static floatx80 commonNaNToFloatx80( commonNaNT a ) static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM)
{ {
floatx80 z; floatx80 z;
if ( STATUS(default_nan_mode) ) {
z.low = floatx80_default_nan_low;
z.high = floatx80_default_nan_high;
return z;
}
if (a.high) if (a.high)
z.low = a.high; z.low = a.high;
else else
@ -766,10 +781,16 @@ static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
| precision floating-point format. | precision floating-point format.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float128 commonNaNToFloat128( commonNaNT a ) static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM)
{ {
float128 z; float128 z;
if ( STATUS(default_nan_mode) ) {
z.low = float128_default_nan_low;
z.high = float128_default_nan_high;
return z;
}
shift128Right( a.high, a.low, 16, &z.high, &z.low ); shift128Right( a.high, a.low, 16, &z.high, &z.low );
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 ); z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
return z; return z;

24
fpu/softfloat.c
View File

@ -1561,7 +1561,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM )
aExp = extractFloat32Exp( a ); aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a ); aSign = extractFloat32Sign( a );
if ( aExp == 0xFF ) { if ( aExp == 0xFF ) {
if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a STATUS_VAR )); if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloat64( aSign, 0x7FF, 0 ); return packFloat64( aSign, 0x7FF, 0 );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
@ -1593,7 +1593,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
aExp = extractFloat32Exp( a ); aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a ); aSign = extractFloat32Sign( a );
if ( aExp == 0xFF ) { if ( aExp == 0xFF ) {
if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a STATUS_VAR ) ); if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
@ -1627,7 +1627,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM )
aExp = extractFloat32Exp( a ); aExp = extractFloat32Exp( a );
aSign = extractFloat32Sign( a ); aSign = extractFloat32Sign( a );
if ( aExp == 0xFF ) { if ( aExp == 0xFF ) {
if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a STATUS_VAR ) ); if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloat128( aSign, 0x7FFF, 0, 0 ); return packFloat128( aSign, 0x7FFF, 0, 0 );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
@ -2716,7 +2716,7 @@ float32 float64_to_float32( float64 a STATUS_PARAM )
aExp = extractFloat64Exp( a ); aExp = extractFloat64Exp( a );
aSign = extractFloat64Sign( a ); aSign = extractFloat64Sign( a );
if ( aExp == 0x7FF ) { if ( aExp == 0x7FF ) {
if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a STATUS_VAR ) ); if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloat32( aSign, 0xFF, 0 ); return packFloat32( aSign, 0xFF, 0 );
} }
shift64RightJamming( aSig, 22, &aSig ); shift64RightJamming( aSig, 22, &aSig );
@ -2889,7 +2889,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
aExp = extractFloat64Exp( a ); aExp = extractFloat64Exp( a );
aSign = extractFloat64Sign( a ); aSign = extractFloat64Sign( a );
if ( aExp == 0x7FF ) { if ( aExp == 0x7FF ) {
if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a STATUS_VAR ) ); if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
@ -2924,7 +2924,7 @@ float128 float64_to_float128( float64 a STATUS_PARAM )
aExp = extractFloat64Exp( a ); aExp = extractFloat64Exp( a );
aSign = extractFloat64Sign( a ); aSign = extractFloat64Sign( a );
if ( aExp == 0x7FF ) { if ( aExp == 0x7FF ) {
if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a STATUS_VAR ) ); if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
return packFloat128( aSign, 0x7FFF, 0, 0 ); return packFloat128( aSign, 0x7FFF, 0, 0 );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
@ -3871,7 +3871,7 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) { if ( (bits64) ( aSig<<1 ) ) {
return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat32( aSign, 0xFF, 0 ); return packFloat32( aSign, 0xFF, 0 );
} }
@ -3899,7 +3899,7 @@ float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) { if ( (bits64) ( aSig<<1 ) ) {
return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat64( aSign, 0x7FF, 0 ); return packFloat64( aSign, 0x7FF, 0 );
} }
@ -3928,7 +3928,7 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) { if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 ); shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
return packFloat128( aSign, aExp, zSig0, zSig1 ); return packFloat128( aSign, aExp, zSig0, zSig1 );
@ -4891,7 +4891,7 @@ float32 float128_to_float32( float128 a STATUS_PARAM )
aSign = extractFloat128Sign( a ); aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) { if ( aSig0 | aSig1 ) {
return commonNaNToFloat32( float128ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloat32( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat32( aSign, 0xFF, 0 ); return packFloat32( aSign, 0xFF, 0 );
} }
@ -4925,7 +4925,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM )
aSign = extractFloat128Sign( a ); aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) { if ( aSig0 | aSig1 ) {
return commonNaNToFloat64( float128ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloat64( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat64( aSign, 0x7FF, 0 ); return packFloat64( aSign, 0x7FF, 0 );
} }
@ -4960,7 +4960,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
aSign = extractFloat128Sign( a ); aSign = extractFloat128Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( aSig0 | aSig1 ) { if ( aSig0 | aSig1 ) {
return commonNaNToFloatx80( float128ToCommonNaN( a STATUS_VAR ) ); return commonNaNToFloatx80( float128ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }