mirror of
https://github.com/yuzu-emu/unicorn.git
synced 2025-08-04 08:12:01 +00:00
softfloat: Inline float128 compare specializations
Replace the float128 compare specializations with inline functions
that call the standard float128_compare{,_quiet} functions.
Use bool as the return type.
Backports commit b7b1ac684fea49c6bfe1ad8b706aed7b09116d15 from qemu
This commit is contained in:
Richard Henderson
Lioncash
parent
18a46c4d79
commit
57d2419cd3
|
|
@ -7180,244 +7180,6 @@ float128 float128_sqrt(float128 a, float_status *status)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-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 float128_eq(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
return
|
|
||||||
( a.low == b.low )
|
|
||||||
&& ( ( a.high == b.high )
|
|
||||||
|| ( ( a.low == 0 )
|
|
||||||
&& ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
|
|
||||||
);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-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 float128_le(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloat128Sign( a );
|
|
||||||
bSign = extractFloat128Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
|| ( ( ( (uint64_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 quadruple-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 float128_lt(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloat128Sign( a );
|
|
||||||
bSign = extractFloat128Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
&& ( ( ( (uint64_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 quadruple-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 float128_unordered(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-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 float128_eq_quiet(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
if (float128_is_signaling_nan(a, status)
|
|
||||||
|| float128_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 )
|
|
||||||
&& ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
|
|
||||||
);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
|
||||||
| Returns 1 if the quadruple-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 float128_le_quiet(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
if (float128_is_signaling_nan(a, status)
|
|
||||||
|| float128_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloat128Sign( a );
|
|
||||||
bSign = extractFloat128Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
|| ( ( ( (uint64_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 quadruple-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 float128_lt_quiet(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
bool aSign, bSign;
|
|
||||||
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
if (float128_is_signaling_nan(a, status)
|
|
||||||
|| float128_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
aSign = extractFloat128Sign( a );
|
|
||||||
bSign = extractFloat128Sign( b );
|
|
||||||
if ( aSign != bSign ) {
|
|
||||||
return
|
|
||||||
aSign
|
|
||||||
&& ( ( ( (uint64_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 quadruple-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 float128_unordered_quiet(float128 a, float128 b, float_status *status)
|
|
||||||
{
|
|
||||||
if ( ( ( extractFloat128Exp( a ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
|
|
||||||
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
|
|
||||||
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
|
|
||||||
) {
|
|
||||||
if (float128_is_signaling_nan(a, status)
|
|
||||||
|| float128_is_signaling_nan(b, status)) {
|
|
||||||
float_raise(float_flag_invalid, status);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline FloatRelation
|
static inline FloatRelation
|
||||||
floatx80_compare_internal(floatx80 a, floatx80 b, bool is_quiet,
|
floatx80_compare_internal(floatx80 a, floatx80 b, bool is_quiet,
|
||||||
float_status *status)
|
float_status *status)
|
||||||
|
|
|
||||||
|
|
@ -904,14 +904,6 @@ float128 float128_mul(float128, float128, float_status *status);
|
||||||
float128 float128_div(float128, float128, float_status *status);
|
float128 float128_div(float128, float128, float_status *status);
|
||||||
float128 float128_rem(float128, float128, float_status *status);
|
float128 float128_rem(float128, float128, float_status *status);
|
||||||
float128 float128_sqrt(float128, float_status *status);
|
float128 float128_sqrt(float128, float_status *status);
|
||||||
int float128_eq(float128, float128, float_status *status);
|
|
||||||
int float128_le(float128, float128, float_status *status);
|
|
||||||
int float128_lt(float128, float128, float_status *status);
|
|
||||||
int float128_unordered(float128, float128, float_status *status);
|
|
||||||
int float128_eq_quiet(float128, float128, float_status *status);
|
|
||||||
int float128_le_quiet(float128, float128, float_status *status);
|
|
||||||
int float128_lt_quiet(float128, float128, float_status *status);
|
|
||||||
int float128_unordered_quiet(float128, float128, float_status *status);
|
|
||||||
FloatRelation float128_compare(float128, float128, float_status *status);
|
FloatRelation float128_compare(float128, float128, float_status *status);
|
||||||
FloatRelation float128_compare_quiet(float128, float128, float_status *status);
|
FloatRelation float128_compare_quiet(float128, float128, float_status *status);
|
||||||
int float128_is_quiet_nan(float128, float_status *status);
|
int float128_is_quiet_nan(float128, float_status *status);
|
||||||
|
|
@ -967,6 +959,47 @@ static inline int float128_is_any_nan(float128 a)
|
||||||
((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
|
((a.low != 0) || ((a.high & 0xffffffffffffLL) != 0));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline bool float128_eq(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare(a, b, s) == float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_le(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare(a, b, s) <= float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_lt(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare(a, b, s) < float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_unordered(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare(a, b, s) == float_relation_unordered;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_eq_quiet(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare_quiet(a, b, s) == float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_le_quiet(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare_quiet(a, b, s) <= float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_lt_quiet(float128 a, float128 b, float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare_quiet(a, b, s) < float_relation_equal;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool float128_unordered_quiet(float128 a, float128 b,
|
||||||
|
float_status *s)
|
||||||
|
{
|
||||||
|
return float128_compare_quiet(a, b, s) == float_relation_unordered;
|
||||||
|
}
|
||||||
|
|
||||||
#define float128_zero make_float128(0, 0)
|
#define float128_zero make_float128(0, 0)
|
||||||
|
|
||||||
/*----------------------------------------------------------------------------
|
/*----------------------------------------------------------------------------
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue