motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-04 08:13:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

softfloat: Change tininess_before_rounding to bool

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

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 2020-05-04 21:19:39 -07:00
parent c120391c00
commit a828b373bd
4 changed files with 28 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

54
fpu/softfloat.c
View file

@ -744,8 +744,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);
@ -3579,11 +3578,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;
@ -3735,11 +3732,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;
@ -3878,11 +3873,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;
@ -3956,12 +3949,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) {
@ -4237,17 +4228,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
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
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? */

2
tests/fp/fp-test.c
View file

@ -989,7 +989,7 @@ static void QEMU_NORETURN run_test(void)
verCases_tininessCode = 0; verCases_tininessCode = 0;
slowfloat_detectTininess = tmode; slowfloat_detectTininess = tmode;
qsf.float_detect_tininess = sf_tininess_to_qemu(tmode); qsf.tininess_before_rounding = sf_tininess_to_qemu(tmode);
if (attrs & FUNC_EFF_TININESSMODE || if (attrs & FUNC_EFF_TININESSMODE ||
((attrs & FUNC_EFF_TININESSMODE_REDUCEDPREC) && ((attrs & FUNC_EFF_TININESSMODE_REDUCEDPREC) &&