softfloat: Inline floatx80 compare specializations
Replace the floatx80 compare specializations with inline functions
that call the standard floatx80_compare{,_quiet} functions.
Use bool as the return type.
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
parent
b7b1ac684f
commit
c6baf65000
257
fpu/softfloat.c
257
fpu/softfloat.c
@ -5849,263 +5849,6 @@ floatx80 floatx80_sqrt(floatx80 a, float_status *status)
|
|||||||
0, zExp, zSig0, zSig1, status);
|
0, zExp, zSig0, zSig1, status);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point value `a' is equal
|
|
||||||
| to 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.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_eq(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)
|
|
||||||
|| (extractFloatx80Exp(a) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(a) << 1))
|
|
||||||
|| (extractFloatx80Exp(b) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(b) << 1))
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
return
|
|
||||||
( a.low == b.low )
|
|
||||||
&& ( ( a.high == b.high )
|
|
||||||
|| ( ( a.low == 0 )
|
|
||||||
&& ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
|
|
||||||
);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| 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
|
|
||||||
| invalid exception is raised if either operand is a NaN. The comparison is
|
|
||||||
| performed according to the IEC/IEEE Standard for Binary Floating-Point
|
|
||||||
| Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_le(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)
|
|
||||||
|| (extractFloatx80Exp(a) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(a) << 1))
|
|
||||||
|| (extractFloatx80Exp(b) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(b) << 1))
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloatx80Sign( a );
|
|
||||||
bSign = extractFloatx80Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
|| ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
|
|
||||||
== 0 );
|
|
||||||
}
|
|
||||||
return
|
|
||||||
aSign ? le128( b.high, b.low, a.high, a.low )
|
|
||||||
: le128( a.high, a.low, b.high, b.low );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point value `a' is
|
|
||||||
| less than the corresponding value `b', and 0 otherwise. The invalid
|
|
||||||
| exception is raised if either operand is a NaN. The comparison is performed
|
|
||||||
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_lt(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)
|
|
||||||
|| (extractFloatx80Exp(a) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(a) << 1))
|
|
||||||
|| (extractFloatx80Exp(b) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(b) << 1))
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloatx80Sign( a );
|
|
||||||
bSign = extractFloatx80Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
&& ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
|
|
||||||
!= 0 );
|
|
||||||
}
|
|
||||||
return
|
|
||||||
aSign ? lt128( b.high, b.low, a.high, a.low )
|
|
||||||
: lt128( a.high, a.low, b.high, b.low );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point values `a' and `b'
|
|
||||||
| cannot be compared, and 0 otherwise. The invalid exception is raised if
|
|
||||||
| 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, float_status *status)
|
|
||||||
{
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)
|
|
||||||
|| (extractFloatx80Exp(a) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(a) << 1))
|
|
||||||
|| (extractFloatx80Exp(b) == 0x7FFF
|
|
||||||
&& (uint64_t) (extractFloatx80Frac(b) << 1))
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point value `a' is
|
|
||||||
| equal to the corresponding value `b', and 0 otherwise. Quiet NaNs do not
|
|
||||||
| cause an exception. The comparison is performed according to the IEC/IEEE
|
|
||||||
| Standard for Binary Floating-Point Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|
|
||||||
|| ( ( extractFloatx80Exp( b ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
|
|
||||||
) {
|
|
||||||
if (floatx80_is_signaling_nan(a, status)
|
|
||||||
|| floatx80_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
return
|
|
||||||
( a.low == b.low )
|
|
||||||
&& ( ( a.high == b.high )
|
|
||||||
|| ( ( a.low == 0 )
|
|
||||||
&& ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
|
|
||||||
);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point value `a' is less
|
|
||||||
| than or equal to the corresponding value `b', and 0 otherwise. Quiet NaNs
|
|
||||||
| do not cause an exception. Otherwise, the comparison is performed according
|
|
||||||
| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_le_quiet(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|
|
||||||
|| ( ( extractFloatx80Exp( b ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
|
|
||||||
) {
|
|
||||||
if (floatx80_is_signaling_nan(a, status)
|
|
||||||
|| floatx80_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloatx80Sign( a );
|
|
||||||
bSign = extractFloatx80Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
|| ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
|
|
||||||
== 0 );
|
|
||||||
}
|
|
||||||
return
|
|
||||||
aSign ? le128( b.high, b.low, a.high, a.low )
|
|
||||||
: le128( a.high, a.low, b.high, b.low );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point value `a' is less
|
|
||||||
| than the corresponding value `b', and 0 otherwise. Quiet NaNs do not cause
|
|
||||||
| an exception. Otherwise, the comparison is performed according to the
|
|
||||||
| IEC/IEEE Standard for Binary Floating-Point Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
int floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|
|
||||||
|| ( ( extractFloatx80Exp( b ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
|
|
||||||
) {
|
|
||||||
if (floatx80_is_signaling_nan(a, status)
|
|
||||||
|| floatx80_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloatx80Sign( a );
|
|
||||||
bSign = extractFloatx80Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
&& ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
|
|
||||||
!= 0 );
|
|
||||||
}
|
|
||||||
return
|
|
||||||
aSign ? lt128( b.high, b.low, a.high, a.low )
|
|
||||||
: lt128( a.high, a.low, b.high, b.low );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the extended double-precision floating-point values `a' and `b'
|
|
||||||
| cannot be compared, and 0 otherwise. Quiet NaNs do not cause an exception.
|
|
||||||
| The comparison is performed according to the IEC/IEEE Standard for Binary
|
|
||||||
| Floating-Point Arithmetic.
|
|
||||||
*----------------------------------------------------------------------------*/
|
|
||||||
int floatx80_unordered_quiet(floatx80 a, floatx80 b, float_status *status)
|
|
||||||
{
|
|
||||||
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|
|
||||||
|| ( ( extractFloatx80Exp( b ) == 0x7FFF )
|
|
||||||
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
|
|
||||||
) {
|
|
||||||
if (floatx80_is_signaling_nan(a, status)
|
|
||||||
|| floatx80_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Returns the result of converting the quadruple-precision floating-point
|
| Returns the result of converting the quadruple-precision floating-point
|
||||||
| value `a' to the 32-bit two's complement integer format. The conversion
|
| value `a' to the 32-bit two's complement integer format. The conversion
|
||||||
|
|||||||
@ -689,14 +689,6 @@ floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
|
|||||||
floatx80 floatx80_div(floatx80, floatx80, float_status *status);
|
floatx80 floatx80_div(floatx80, floatx80, float_status *status);
|
||||||
floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
|
floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
|
||||||
floatx80 floatx80_sqrt(floatx80, float_status *status);
|
floatx80 floatx80_sqrt(floatx80, float_status *status);
|
||||||
int floatx80_eq(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_le(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_lt(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_unordered(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_eq_quiet(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_le_quiet(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_lt_quiet(floatx80, floatx80, float_status *status);
|
|
||||||
int floatx80_unordered_quiet(floatx80, floatx80, float_status *status);
|
|
||||||
FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
|
FloatRelation floatx80_compare(floatx80, floatx80, float_status *status);
|
||||||
FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
|
FloatRelation floatx80_compare_quiet(floatx80, floatx80, float_status *status);
|
||||||
int floatx80_is_quiet_nan(floatx80, float_status *status);
|
int floatx80_is_quiet_nan(floatx80, float_status *status);
|
||||||
@ -746,6 +738,47 @@ static inline int floatx80_is_any_nan(floatx80 a)
|
|||||||
return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
|
return ((a.high & 0x7fff) == 0x7fff) && (a.low<<1);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_eq(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare(a, b, s) == float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_le(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare(a, b, s) <= float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_lt(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare(a, b, s) < float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_unordered(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare(a, b, s) == float_relation_unordered;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare_quiet(a, b, s) == float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_le_quiet(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare_quiet(a, b, s) <= float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare_quiet(a, b, s) < float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool floatx80_unordered_quiet(floatx80 a, floatx80 b,
|
||||||
|
float_status *s)
|
||||||
|
{
|
||||||
|
return floatx80_compare_quiet(a, b, s) == float_relation_unordered;
|
||||||
|
}
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
| Return whether the given value is an invalid floatx80 encoding.
|
| Return whether the given value is an invalid floatx80 encoding.
|
||||||
| Invalid floatx80 encodings arise when the integer bit is not set, but
|
| Invalid floatx80 encodings arise when the integer bit is not set, but
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user