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

target/i386: fix fscale handling of infinite exponents 

The fscale implementation passes infinite exponents through to generic
code that rounds the exponent to a 32-bit integer before using
floatx80_scalbn.  In round-to-nearest mode, and ignoring exceptions,
this works in many cases.  But it fails to handle the special cases of
scaling 0 by a +Inf exponent or an infinity by a -Inf exponent, which
should produce a NaN, and because it produces an inexact result for
finite nonzero numbers being scaled, the result is sometimes incorrect
in other rounding modes.  Add appropriate handling of infinite
exponents to produce a NaN or an appropriately signed exact zero or
infinity as a result.

Signed-off-by: Joseph Myers <joseph@codesourcery.com>
Message-Id: <alpine.DEB.2.21.2005070045010.18350@digraph.polyomino.org.uk>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Joseph Myers 2020-05-07 00:45:38 +00:00 committed by Paolo Bonzini
parent b40eec96b2
commit c1c5fb8f90
2 changed files with 51 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
target/i386/fpu_helper.c
View File

@ -977,6 +977,28 @@ void helper_fscale(CPUX86State *env)
float_raise(float_flag_invalid, &env->fp_status);
ST0 = floatx80_silence_nan(ST0, &env->fp_status);
}
} else if (floatx80_is_infinity(ST1) &&
!floatx80_invalid_encoding(ST0) &&
!floatx80_is_any_nan(ST0)) {
if (floatx80_is_neg(ST1)) {
if (floatx80_is_infinity(ST0)) {
float_raise(float_flag_invalid, &env->fp_status);
ST0 = floatx80_default_nan(&env->fp_status);
} else {
ST0 = (floatx80_is_neg(ST0) ?
floatx80_chs(floatx80_zero) :
floatx80_zero);
}
} else {
if (floatx80_is_zero(ST0)) {
float_raise(float_flag_invalid, &env->fp_status);
ST0 = floatx80_default_nan(&env->fp_status);
} else {
ST0 = (floatx80_is_neg(ST0) ?
floatx80_chs(floatx80_infinity) :
floatx80_infinity);
}
}
} else {
int n = floatx80_to_int32_round_to_zero(ST1, &env->fp_status);
ST0 = floatx80_scalbn(ST0, n, &env->fp_status);

29
tests/tcg/i386/test-i386-fscale.c
View File

@ -31,6 +31,7 @@ int issignaling_ld(long double x)
int main(void)
{
short cw;
int ret = 0;
__asm__ volatile ("fscale" : "=t" (ld_res) :
"0" (2.5L), "u" (__builtin_nansl("")));
@ -62,5 +63,33 @@ int main(void)
printf("FAIL: fscale invalid 4\n");
ret = 1;
}
__asm__ volatile ("fscale" : "=t" (ld_res) :
"0" (0.0L), "u" (__builtin_infl()));
if (!isnan_ld(ld_res) || issignaling_ld(ld_res)) {
printf("FAIL: fscale 0 up inf\n");
ret = 1;
}
__asm__ volatile ("fscale" : "=t" (ld_res) :
"0" (__builtin_infl()), "u" (-__builtin_infl()));
if (!isnan_ld(ld_res) || issignaling_ld(ld_res)) {
printf("FAIL: fscale inf down inf\n");
ret = 1;
}
/* Set round-downward. */
__asm__ volatile ("fnstcw %0" : "=m" (cw));
cw = (cw & ~0xc00) | 0x400;
__asm__ volatile ("fldcw %0" : : "m" (cw));
__asm__ volatile ("fscale" : "=t" (ld_res) :
"0" (1.0L), "u" (__builtin_infl()));
if (ld_res != __builtin_infl()) {
printf("FAIL: fscale finite up inf\n");
ret = 1;
}
__asm__ volatile ("fscale" : "=t" (ld_res) :
"0" (-1.0L), "u" (-__builtin_infl()));
if (ld_res != -0.0L || __builtin_copysignl(1.0L, ld_res) != -1.0L) {
printf("FAIL: fscale finite down inf\n");
ret = 1;
}
return ret;
}