mirrors/qemu
0
0
Fork 0
mirror of https://github.com/qemu/qemu.git synced 2024-11-25 03:43:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

softfloat: move float*_eq and float*_eq_quiet

Browse Source 
I am not a big fan of code moving, but having the signaling version in
the middle of quiet versions and vice versa doesn't make the code easy
to read.

This patch is a simple code move, basically swapping locations of
float*_eq and float*_eq_quiet.

Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>
This commit is contained in:
Aurelien Jarno 2011-04-14 00:49:29 +02:00
parent 2657d0ff8f
commit b689362d14
2 changed files with 58 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
fpu/softfloat.c
View File

@ -2314,26 +2314,26 @@ float32 float32_log2( float32 a STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the single-precision floating-point value `a' is equal to | Returns 1 if the single-precision floating-point value `a' is equal to
| the corresponding value `b', and 0 otherwise. The comparison is performed | the corresponding value `b', and 0 otherwise. The invalid exception is
| raised if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_eq_quiet( float32 a, float32 b STATUS_PARAM ) int float32_eq( float32 a, float32 b STATUS_PARAM )
{ {
uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) { ) {
if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) { float_raise( float_flag_invalid STATUS_VAR);
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
return ( float32_val(a) == float32_val(b) ) || av = float32_val(a);
( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 ); bv = float32_val(b);
return ( av == bv ) || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
@ -2412,29 +2412,28 @@ int float32_unordered( float32 a, float32 b STATUS_PARAM )
} }
return 0; return 0;
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the single-precision floating-point value `a' is equal to | Returns 1 if the single-precision floating-point value `a' is equal to
| the corresponding value `b', and 0 otherwise. The invalid exception is | the corresponding value `b', and 0 otherwise. The comparison is performed
| raised if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_eq( float32 a, float32 b STATUS_PARAM ) int float32_eq_quiet( float32 a, float32 b STATUS_PARAM )
{ {
uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) ) if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) ) || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
av = float32_val(a); return ( float32_val(a) == float32_val(b) ) ||
bv = float32_val(b); ( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 );
return ( av == bv ) || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
@ -3578,11 +3577,12 @@ float64 float64_log2( float64 a STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is equal to the | Returns 1 if the double-precision floating-point value `a' is equal to the
| corresponding value `b', and 0 otherwise. The comparison is performed | corresponding value `b', and 0 otherwise. The invalid exception is raised
| if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_eq_quiet( float64 a, float64 b STATUS_PARAM ) int float64_eq( float64 a, float64 b STATUS_PARAM )
{ {
uint64_t av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
@ -3591,9 +3591,7 @@ int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) { ) {
if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) { float_raise( float_flag_invalid STATUS_VAR);
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
av = float64_val(a); av = float64_val(a);
@ -3681,12 +3679,11 @@ int float64_unordered( float64 a, float64 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is equal to the | Returns 1 if the double-precision floating-point value `a' is equal to the
| corresponding value `b', and 0 otherwise. The invalid exception is raised | corresponding value `b', and 0 otherwise. The comparison is performed
| if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_eq( float64 a, float64 b STATUS_PARAM ) int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
{ {
uint64_t av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
@ -3695,7 +3692,9 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) ) if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) ) || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
av = float64_val(a); av = float64_val(a);
@ -4586,13 +4585,13 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the extended double-precision floating-point value `a' is | Returns 1 if the extended double-precision floating-point value `a' is equal
| equal to the corresponding value `b', and 0 otherwise. The comparison is | to the corresponding value `b', and 0 otherwise. The invalid exception is
| performed according to the IEC/IEEE Standard for Binary Floating-Point | raised if either operand is a NaN. Otherwise, the comparison is performed
| Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
{ {
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
@ -4600,10 +4599,7 @@ int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
if ( floatx80_is_signaling_nan( a ) float_raise( float_flag_invalid STATUS_VAR);
|| floatx80_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
return return
@ -4700,13 +4696,13 @@ int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM )
} }
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the extended double-precision floating-point value `a' is equal | Returns 1 if the extended double-precision floating-point value `a' is
| to the corresponding value `b', and 0 otherwise. The invalid exception is | equal to the corresponding value `b', and 0 otherwise. The comparison is
| raised if either operand is a NaN. Otherwise, the comparison is performed | performed according to the IEC/IEEE Standard for Binary Floating-Point
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM )
{ {
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
@ -4714,7 +4710,10 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); if ( floatx80_is_signaling_nan( a )
|| floatx80_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
return return
@ -5750,11 +5749,12 @@ float128 float128_sqrt( float128 a STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the quadruple-precision floating-point value `a' is equal to | Returns 1 if the quadruple-precision floating-point value `a' is equal to
| the corresponding value `b', and 0 otherwise. The comparison is performed | the corresponding value `b', and 0 otherwise. The invalid exception is
| raised if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_eq_quiet( float128 a, float128 b STATUS_PARAM ) int float128_eq( float128 a, float128 b STATUS_PARAM )
{ {
if ( ( ( extractFloat128Exp( a ) == 0x7FFF ) if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
@ -5762,10 +5762,7 @@ int float128_eq_quiet( float128 a, float128 b STATUS_PARAM )
|| ( ( extractFloat128Exp( b ) == 0x7FFF ) || ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) ) && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) { ) {
if ( float128_is_signaling_nan( a ) float_raise( float_flag_invalid STATUS_VAR);
|| float128_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
return return
@ -5863,12 +5860,11 @@ int float128_unordered( float128 a, float128 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the quadruple-precision floating-point value `a' is equal to | Returns 1 if the quadruple-precision floating-point value `a' is equal to
| the corresponding value `b', and 0 otherwise. The invalid exception is | the corresponding value `b', and 0 otherwise. The comparison is performed
| raised if either operand is a NaN. Otherwise, the comparison is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_eq( float128 a, float128 b STATUS_PARAM ) int float128_eq_quiet( float128 a, float128 b STATUS_PARAM )
{ {
if ( ( ( extractFloat128Exp( a ) == 0x7FFF ) if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
@ -5876,7 +5872,10 @@ int float128_eq( float128 a, float128 b STATUS_PARAM )
|| ( ( extractFloat128Exp( b ) == 0x7FFF ) || ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) ) && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); if ( float128_is_signaling_nan( a )
|| float128_is_signaling_nan( b ) ) {
float_raise( float_flag_invalid STATUS_VAR);
}
return 0; return 0;
} }
return return

16
fpu/softfloat.h
View File

@ -320,11 +320,11 @@ float32 float32_rem( float32, float32 STATUS_PARAM );
float32 float32_sqrt( float32 STATUS_PARAM ); float32 float32_sqrt( float32 STATUS_PARAM );
float32 float32_exp2( float32 STATUS_PARAM ); float32 float32_exp2( float32 STATUS_PARAM );
float32 float32_log2( float32 STATUS_PARAM ); float32 float32_log2( float32 STATUS_PARAM );
int float32_eq_quiet( float32, float32 STATUS_PARAM ); int float32_eq( float32, float32 STATUS_PARAM );
int float32_le( float32, float32 STATUS_PARAM ); int float32_le( float32, float32 STATUS_PARAM );
int float32_lt( float32, float32 STATUS_PARAM ); int float32_lt( float32, float32 STATUS_PARAM );
int float32_unordered( float32, float32 STATUS_PARAM ); int float32_unordered( float32, float32 STATUS_PARAM );
int float32_eq( float32, float32 STATUS_PARAM ); int float32_eq_quiet( float32, float32 STATUS_PARAM );
int float32_le_quiet( float32, float32 STATUS_PARAM ); int float32_le_quiet( float32, float32 STATUS_PARAM );
int float32_lt_quiet( float32, float32 STATUS_PARAM ); int float32_lt_quiet( float32, float32 STATUS_PARAM );
int float32_unordered_quiet( float32, float32 STATUS_PARAM ); int float32_unordered_quiet( float32, float32 STATUS_PARAM );
@ -436,11 +436,11 @@ float64 float64_div( float64, float64 STATUS_PARAM );
float64 float64_rem( float64, float64 STATUS_PARAM ); float64 float64_rem( float64, float64 STATUS_PARAM );
float64 float64_sqrt( float64 STATUS_PARAM ); float64 float64_sqrt( float64 STATUS_PARAM );
float64 float64_log2( float64 STATUS_PARAM ); float64 float64_log2( float64 STATUS_PARAM );
int float64_eq_quiet( float64, float64 STATUS_PARAM ); int float64_eq( float64, float64 STATUS_PARAM );
int float64_le( float64, float64 STATUS_PARAM ); int float64_le( float64, float64 STATUS_PARAM );
int float64_lt( float64, float64 STATUS_PARAM ); int float64_lt( float64, float64 STATUS_PARAM );
int float64_unordered( float64, float64 STATUS_PARAM ); int float64_unordered( float64, float64 STATUS_PARAM );
int float64_eq( float64, float64 STATUS_PARAM ); int float64_eq_quiet( float64, float64 STATUS_PARAM );
int float64_le_quiet( float64, float64 STATUS_PARAM ); int float64_le_quiet( float64, float64 STATUS_PARAM );
int float64_lt_quiet( float64, float64 STATUS_PARAM ); int float64_lt_quiet( float64, float64 STATUS_PARAM );
int float64_unordered_quiet( float64, float64 STATUS_PARAM ); int float64_unordered_quiet( float64, float64 STATUS_PARAM );
@ -539,11 +539,11 @@ floatx80 floatx80_mul( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM ); floatx80 floatx80_div( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM );
floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); floatx80 floatx80_sqrt( floatx80 STATUS_PARAM );
int floatx80_eq_quiet( floatx80, floatx80 STATUS_PARAM ); int floatx80_eq( floatx80, floatx80 STATUS_PARAM );
int floatx80_le( floatx80, floatx80 STATUS_PARAM ); int floatx80_le( floatx80, floatx80 STATUS_PARAM );
int floatx80_lt( floatx80, floatx80 STATUS_PARAM ); int floatx80_lt( floatx80, floatx80 STATUS_PARAM );
int floatx80_unordered( floatx80, floatx80 STATUS_PARAM ); int floatx80_unordered( floatx80, floatx80 STATUS_PARAM );
int floatx80_eq( floatx80, floatx80 STATUS_PARAM ); int floatx80_eq_quiet( floatx80, floatx80 STATUS_PARAM );
int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM ); int floatx80_le_quiet( floatx80, floatx80 STATUS_PARAM );
int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM ); int floatx80_lt_quiet( floatx80, floatx80 STATUS_PARAM );
int floatx80_unordered_quiet( floatx80, floatx80 STATUS_PARAM ); int floatx80_unordered_quiet( floatx80, floatx80 STATUS_PARAM );
@ -624,11 +624,11 @@ float128 float128_mul( float128, float128 STATUS_PARAM );
float128 float128_div( float128, float128 STATUS_PARAM ); float128 float128_div( float128, float128 STATUS_PARAM );
float128 float128_rem( float128, float128 STATUS_PARAM ); float128 float128_rem( float128, float128 STATUS_PARAM );
float128 float128_sqrt( float128 STATUS_PARAM ); float128 float128_sqrt( float128 STATUS_PARAM );
int float128_eq_quiet( float128, float128 STATUS_PARAM ); int float128_eq( float128, float128 STATUS_PARAM );
int float128_le( float128, float128 STATUS_PARAM ); int float128_le( float128, float128 STATUS_PARAM );
int float128_lt( float128, float128 STATUS_PARAM ); int float128_lt( float128, float128 STATUS_PARAM );
int float128_unordered( float128, float128 STATUS_PARAM ); int float128_unordered( float128, float128 STATUS_PARAM );
int float128_eq( float128, float128 STATUS_PARAM ); int float128_eq_quiet( float128, float128 STATUS_PARAM );
int float128_le_quiet( float128, float128 STATUS_PARAM ); int float128_le_quiet( float128, float128 STATUS_PARAM );
int float128_lt_quiet( float128, float128 STATUS_PARAM ); int float128_lt_quiet( float128, float128 STATUS_PARAM );
int float128_unordered_quiet( float128, float128 STATUS_PARAM ); int float128_unordered_quiet( float128, float128 STATUS_PARAM );