yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-02-25 06:06:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

softfloat: Change tininess_before_rounding to bool

Browse source 
Slightly tidies the usage within softfloat.c and the
representation in float_status.

Backports commit a828b373bdabc7e53d1e218e3fc76f85b6674688 from qemu
This commit is contained in:
Richard Henderson 2020-05-21 17:52:47 -04:00 committed by Lioncash
parent a417227674
commit a5c8178e35
3 changed files with 27 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
qemu/fpu/softfloat.c
View file

@ -745,8 +745,7 @@ static FloatParts round_canonical(FloatParts p, float_status *s,
p.cls = float_class_zero; p.cls = float_class_zero;
goto do_zero; goto do_zero;
} else { } else {
bool is_tiny = (s->float_detect_tininess bool is_tiny = s->tininess_before_rounding
== float_tininess_before_rounding)
|| (exp < 0) || (exp < 0)
|| !((frac + inc) & DECOMPOSED_OVERFLOW_BIT); || !((frac + inc) & DECOMPOSED_OVERFLOW_BIT);
@ -3540,11 +3539,9 @@ static float32 roundAndPackFloat32(bool zSign, int zExp, uint32_t zSig,
float_raise(float_flag_output_denormal, status); float_raise(float_flag_output_denormal, status);
return packFloat32(zSign, 0, 0); return packFloat32(zSign, 0, 0);
} }
isTiny = isTiny = status->tininess_before_rounding
(status->float_detect_tininess || (zExp < -1)
== float_tininess_before_rounding) || (zSig + roundIncrement < 0x80000000);
|| ( zExp < -1 )
|| ( zSig + roundIncrement < 0x80000000 );
shift32RightJamming( zSig, - zExp, &zSig ); shift32RightJamming( zSig, - zExp, &zSig );
zExp = 0; zExp = 0;
roundBits = zSig & 0x7F; roundBits = zSig & 0x7F;
@ -3696,11 +3693,9 @@ static float64 roundAndPackFloat64(bool zSign, int zExp, uint64_t zSig,
float_raise(float_flag_output_denormal, status); float_raise(float_flag_output_denormal, status);
return packFloat64(zSign, 0, 0); return packFloat64(zSign, 0, 0);
} }
isTiny = isTiny = status->tininess_before_rounding
(status->float_detect_tininess || (zExp < -1)
== float_tininess_before_rounding) || (zSig + roundIncrement < UINT64_C(0x8000000000000000));
|| ( zExp < -1 )
|| ( zSig + roundIncrement < UINT64_C(0x8000000000000000) );
shift64RightJamming( zSig, - zExp, &zSig ); shift64RightJamming( zSig, - zExp, &zSig );
zExp = 0; zExp = 0;
roundBits = zSig & 0x3FF; roundBits = zSig & 0x3FF;
@ -3839,11 +3834,9 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecision, bool zSign,
float_raise(float_flag_output_denormal, status); float_raise(float_flag_output_denormal, status);
return packFloatx80(zSign, 0, 0); return packFloatx80(zSign, 0, 0);
} }
isTiny = isTiny = status->tininess_before_rounding
(status->float_detect_tininess || (zExp < 0 )
== float_tininess_before_rounding) || (zSig0 <= zSig0 + roundIncrement);
|| ( zExp < 0 )
|| ( zSig0 <= zSig0 + roundIncrement );
shift64RightJamming( zSig0, 1 - zExp, &zSig0 ); shift64RightJamming( zSig0, 1 - zExp, &zSig0 );
zExp = 0; zExp = 0;
roundBits = zSig0 & roundMask; roundBits = zSig0 & roundMask;
@ -3917,12 +3910,10 @@ floatx80 roundAndPackFloatx80(int8_t roundingPrecision, bool zSign,
floatx80_infinity_low); floatx80_infinity_low);
} }
if ( zExp <= 0 ) { if ( zExp <= 0 ) {
isTiny = isTiny = status->tininess_before_rounding
(status->float_detect_tininess || (zExp < 0)
== float_tininess_before_rounding) || !increment
|| ( zExp < 0 ) || (zSig0 < UINT64_C(0xFFFFFFFFFFFFFFFF));
|| ! increment
|| ( zSig0 < UINT64_C(0xFFFFFFFFFFFFFFFF) );
shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 ); shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );
zExp = 0; zExp = 0;
if (isTiny && zSig1) { if (isTiny && zSig1) {
@ -4198,17 +4189,12 @@ static float128 roundAndPackFloat128(bool zSign, int32_t zExp,
float_raise(float_flag_output_denormal, status); float_raise(float_flag_output_denormal, status);
return packFloat128(zSign, 0, 0, 0); return packFloat128(zSign, 0, 0, 0);
} }
isTiny = isTiny = status->tininess_before_rounding
(status->float_detect_tininess || (zExp < -1)
== float_tininess_before_rounding) || !increment
|| ( zExp < -1 ) || lt128(zSig0, zSig1,
|| ! increment UINT64_C(0x0001FFFFFFFFFFFF),
|| lt128( UINT64_C(0xFFFFFFFFFFFFFFFF));
zSig0,
zSig1,
UINT64_C(0x0001FFFFFFFFFFFF),
UINT64_C(0xFFFFFFFFFFFFFFFF)
);
shift128ExtraRightJamming( shift128ExtraRightJamming(
zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 ); zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 );
zExp = 0; zExp = 0;

8
qemu/include/fpu/softfloat-helpers.h
View file

@ -53,9 +53,9 @@ this code that are retained.
#include "fpu/softfloat-types.h" #include "fpu/softfloat-types.h"
static inline void set_float_detect_tininess(int val, float_status *status) static inline void set_float_detect_tininess(bool val, float_status *status)
{ {
status->float_detect_tininess = val; status->tininess_before_rounding = val;
} }
static inline void set_float_rounding_mode(int val, float_status *status) static inline void set_float_rounding_mode(int val, float_status *status)
@ -94,9 +94,9 @@ static inline void set_snan_bit_is_one(bool val, float_status *status)
status->snan_bit_is_one = val; status->snan_bit_is_one = val;
} }
static inline int get_float_detect_tininess(float_status *status) static inline bool get_float_detect_tininess(float_status *status)
{ {
return status->float_detect_tininess; return status->tininess_before_rounding;
} }
static inline int get_float_rounding_mode(float_status *status) static inline int get_float_rounding_mode(float_status *status)

8
qemu/include/fpu/softfloat-types.h
View file

@ -116,10 +116,8 @@ typedef struct {
* Software IEC/IEEE floating-point underflow tininess-detection mode. * Software IEC/IEEE floating-point underflow tininess-detection mode.
*/ */
enum { #define float_tininess_after_rounding false
float_tininess_after_rounding = 0, #define float_tininess_before_rounding true
float_tininess_before_rounding = 1
};
/* /*
*Software IEC/IEEE floating-point rounding mode. *Software IEC/IEEE floating-point rounding mode.
@ -158,10 +156,10 @@ enum {
*/ */
typedef struct float_status { typedef struct float_status {
signed char float_detect_tininess;
signed char float_rounding_mode; signed char float_rounding_mode;
uint8_t float_exception_flags; uint8_t float_exception_flags;
signed char floatx80_rounding_precision; signed char floatx80_rounding_precision;
bool tininess_before_rounding;
/* should denormalised results go to zero and set the inexact flag? */ /* should denormalised results go to zero and set the inexact flag? */
bool flush_to_zero; bool flush_to_zero;
/* should denormalised inputs go to zero and set the input_denormal flag? */ /* should denormalised inputs go to zero and set the input_denormal flag? */