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

softfloat: improve description of comparison functions 

Make clear for all comparison functions which ones trigger an exception
for all NaNs, and which one only for sNaNs.

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:30 +02:00
parent b689362d14
commit f5a64251f2
1 changed files with 48 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
fpu/softfloat.c
View File

@ -2338,9 +2338,9 @@ int float32_eq( float32 a, float32 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the single-precision floating-point value `a' is less than | Returns 1 if the single-precision floating-point value `a' is less than
| or equal to the corresponding value `b', and 0 otherwise. The comparison | or equal to the corresponding value `b', and 0 otherwise. The invalid
| is performed according to the IEC/IEEE Standard for Binary Floating-Point | exception is raised if either operand is a NaN. The comparison is performed
| Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_le( float32 a, float32 b STATUS_PARAM ) int float32_le( float32 a, float32 b STATUS_PARAM )
@ -2367,8 +2367,9 @@ int float32_le( float32 a, float32 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the single-precision floating-point value `a' is less than | Returns 1 if the single-precision floating-point value `a' is less than
| the corresponding value `b', and 0 otherwise. The comparison is performed | the corresponding value `b', and 0 otherwise. The invalid exception is
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | raised if either operand is a NaN. The comparison is performed according
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_lt( float32 a, float32 b STATUS_PARAM ) int float32_lt( float32 a, float32 b STATUS_PARAM )
@ -2395,8 +2396,9 @@ int float32_lt( float32 a, float32 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the single-precision floating-point values `a' and `b' cannot | Returns 1 if the single-precision floating-point values `a' and `b' cannot
| be compared, and 0 otherwise. The comparison is performed according to the | be compared, and 0 otherwise. The invalid exception is raised if either
| IEC/IEEE Standard for Binary Floating-Point Arithmetic. | operand is a NaN. The comparison is performed according to the IEC/IEEE
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_unordered( float32 a, float32 b STATUS_PARAM ) int float32_unordered( float32 a, float32 b STATUS_PARAM )
@ -2415,8 +2417,9 @@ int float32_unordered( float32 a, float32 b 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. Quiet NaNs do not cause an
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | exception. The comparison is performed according to the IEC/IEEE Standard
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float32_eq_quiet( float32 a, float32 b STATUS_PARAM ) int float32_eq_quiet( float32 a, float32 b STATUS_PARAM )
@ -3602,9 +3605,9 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is less than or | Returns 1 if the double-precision floating-point value `a' is less than or
| equal to the corresponding value `b', and 0 otherwise. The comparison is | equal to the corresponding value `b', and 0 otherwise. The invalid
| performed according to the IEC/IEEE Standard for Binary Floating-Point | exception is raised if either operand is a NaN. The comparison is performed
| Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_le( float64 a, float64 b STATUS_PARAM ) int float64_le( float64 a, float64 b STATUS_PARAM )
@ -3631,8 +3634,9 @@ int float64_le( float64 a, float64 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point value `a' is less than | Returns 1 if the double-precision floating-point value `a' is less than
| the corresponding value `b', and 0 otherwise. The comparison is performed | the corresponding value `b', and 0 otherwise. The invalid exception is
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | raised if either operand is a NaN. The comparison is performed according
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_lt( float64 a, float64 b STATUS_PARAM ) int float64_lt( float64 a, float64 b STATUS_PARAM )
@ -3659,8 +3663,9 @@ int float64_lt( float64 a, float64 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the double-precision floating-point values `a' and `b' cannot | Returns 1 if the double-precision floating-point values `a' and `b' cannot
| be compared, and 0 otherwise. The comparison is performed according to the | be compared, and 0 otherwise. The invalid exception is raised if either
| IEC/IEEE Standard for Binary Floating-Point Arithmetic. | operand is a NaN. The comparison is performed according to the IEC/IEEE
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_unordered( float64 a, float64 b STATUS_PARAM ) int float64_unordered( float64 a, float64 b STATUS_PARAM )
@ -3679,8 +3684,9 @@ 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 comparison is performed | corresponding value `b', and 0 otherwise. Quiet NaNs do not cause an
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | exception.The comparison is performed according to the IEC/IEEE Standard
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float64_eq_quiet( float64 a, float64 b STATUS_PARAM ) int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
@ -4614,8 +4620,9 @@ int floatx80_eq( floatx80 a, floatx80 b 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
| less than or equal to the corresponding value `b', and 0 otherwise. The | less than or equal to the corresponding value `b', and 0 otherwise. The
| comparison is performed according to the IEC/IEEE Standard for Binary | invalid exception is raised if either operand is a NaN. The comparison is
| Floating-Point Arithmetic. | performed according to the IEC/IEEE Standard for Binary Floating-Point
| Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
@ -4646,9 +4653,9 @@ int floatx80_le( floatx80 a, floatx80 b 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
| less than the corresponding value `b', and 0 otherwise. The comparison | less than the corresponding value `b', and 0 otherwise. The invalid
| is performed according to the IEC/IEEE Standard for Binary Floating-Point | exception is raised if either operand is a NaN. The comparison is performed
| Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
@ -4679,8 +4686,9 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the extended double-precision floating-point values `a' and `b' | Returns 1 if the extended double-precision floating-point values `a' and `b'
| cannot be compared, and 0 otherwise. The comparison is performed according | cannot be compared, and 0 otherwise. The invalid exception is raised if
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | either operand is a NaN. The comparison is performed according to the
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM )
{ {
@ -4697,9 +4705,9 @@ int floatx80_unordered( floatx80 a, floatx80 b 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 to the corresponding value `b', and 0 otherwise. The comparison is | equal to the corresponding value `b', and 0 otherwise. Quiet NaNs do not
| performed according to the IEC/IEEE Standard for Binary Floating-Point | cause an exception. The comparison is performed according to the IEC/IEEE
| Arithmetic. | Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM ) int floatx80_eq_quiet( floatx80 a, floatx80 b STATUS_PARAM )
@ -5776,9 +5784,9 @@ int float128_eq( float128 a, float128 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the quadruple-precision floating-point value `a' is less than | Returns 1 if the quadruple-precision floating-point value `a' is less than
| or equal to the corresponding value `b', and 0 otherwise. The comparison | or equal to the corresponding value `b', and 0 otherwise. The invalid
| is performed according to the IEC/IEEE Standard for Binary Floating-Point | exception is raised if either operand is a NaN. The comparison is performed
| Arithmetic. | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_le( float128 a, float128 b STATUS_PARAM ) int float128_le( float128 a, float128 b STATUS_PARAM )
@ -5809,8 +5817,9 @@ int float128_le( float128 a, float128 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the quadruple-precision floating-point value `a' is less than | Returns 1 if the quadruple-precision floating-point value `a' is less than
| the corresponding value `b', and 0 otherwise. The comparison is performed | the corresponding value `b', and 0 otherwise. The invalid exception is
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | raised if either operand is a NaN. The comparison is performed according
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_lt( float128 a, float128 b STATUS_PARAM ) int float128_lt( float128 a, float128 b STATUS_PARAM )
@ -5841,8 +5850,9 @@ int float128_lt( float128 a, float128 b STATUS_PARAM )
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Returns 1 if the quadruple-precision floating-point values `a' and `b' cannot | Returns 1 if the quadruple-precision floating-point values `a' and `b' cannot
| be compared, and 0 otherwise. The comparison is performed according to the | be compared, and 0 otherwise. The invalid exception is raised if either
| IEC/IEEE Standard for Binary Floating-Point Arithmetic. | operand is a NaN. The comparison is performed according to the IEC/IEEE
| Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_unordered( float128 a, float128 b STATUS_PARAM ) int float128_unordered( float128 a, float128 b STATUS_PARAM )
@ -5860,8 +5870,9 @@ 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 comparison is performed | the corresponding value `b', and 0 otherwise. Quiet NaNs do not cause an
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | exception. The comparison is performed according to the IEC/IEEE Standard
| for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int float128_eq_quiet( float128 a, float128 b STATUS_PARAM ) int float128_eq_quiet( float128 a, float128 b STATUS_PARAM )