yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-04-17 14:51:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

softfloat: return low bits of quotient from floatx80_modrem

Browse source 
Both x87 and m68k need the low parts of the quotient for their
remainder operations. Arrange for floatx80_modrem to track those bits
and return them via a pointer.

The architectures using float32_rem and float64_rem do not appear to
need this information, so the *_rem interface is left unchanged and
the information returned only from floatx80_modrem. The logic used to
determine the low 7 bits of the quotient for m68k
(target/m68k/fpu_helper.c:make_quotient) appears completely bogus (it
looks at the result of converting the remainder to integer, the
quotient having been discarded by that point); this patch does not
change that, but the m68k maintainers may wish to do so.

Backports commit 445810ec915687d37b8ae0ef8d7340ab4a153efa from qemu
This commit is contained in:
Joseph Myers 2021-02-25 13:39:08 -05:00 committed by Lioncash
parent e4cfbc1f06
commit 8d0bf2d6e1
2 changed files with 20 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
qemu/fpu/softfloat.c
View file

@ -5661,10 +5661,11 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
| `a' with respect to the corresponding value `b'. The operation is performed
| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic,
| if 'mod' is false; if 'mod' is true, return the remainder based on truncating
| the quotient toward zero instead.
| the quotient toward zero instead. '*quotient' is set to the low 64 bits of
| the absolute value of the integer quotient.
*----------------------------------------------------------------------------*/
floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod, uint64_t *quotient,
float_status *status)
{
bool aSign, zSign;
@ -5672,6 +5673,7 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
uint64_t aSig0, aSig1, bSig;
uint64_t q, term0, term1, alternateASig0, alternateASig1;
*quotient = 0;
if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
float_raise(float_flag_invalid, status);
return floatx80_default_nan(status);
@ -5731,6 +5733,7 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
expDiff = 0;
}
q = ( bSig <= aSig0 );
*quotient = q = ( bSig <= aSig0 );
if ( q ) aSig0 -= bSig;
expDiff -= 64;
while ( 0 < expDiff ) {
@ -5740,6 +5743,8 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );
expDiff -= 62;
*quotient <<= 62;
*quotient += q;
}
expDiff += 64;
if ( 0 < expDiff ) {
@ -5753,6 +5758,12 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
++q;
sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
}
if (expDiff < 64) {
*quotient <<= expDiff;
} else {
*quotient = 0;
}
*quotient += q;
}
else {
term1 = 0;
@ -5767,6 +5778,7 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
aSig0 = alternateASig0;
aSig1 = alternateASig1;
zSign = ! zSign;
++*quotient;
}
}
return
@ -5783,7 +5795,8 @@ floatx80 floatx80_modrem(floatx80 a, floatx80 b, bool mod,
floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
{
return floatx80_modrem(a, b, false, status);
uint64_t quotient;
return floatx80_modrem(a, b, false, &quotient, status);
}
/*----------------------------------------------------------------------------
@ -5794,7 +5807,8 @@ floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
floatx80 floatx80_mod(floatx80 a, floatx80 b, float_status *status)
{
return floatx80_modrem(a, b, true, status);
uint64_t quotient;
return floatx80_modrem(a, b, true, &quotient, status);
}
/*----------------------------------------------------------------------------

3
qemu/include/fpu/softfloat.h
View file

@ -690,7 +690,8 @@ floatx80 floatx80_add(floatx80, floatx80, float_status *status);
floatx80 floatx80_sub(floatx80, floatx80, float_status *status);
floatx80 floatx80_mul(floatx80, floatx80, float_status *status);
floatx80 floatx80_div(floatx80, floatx80, float_status *status);
floatx80 floatx80_modrem(floatx80, floatx80, bool, float_status *status);
floatx80 floatx80_modrem(floatx80, floatx80, bool, uint64_t *,
float_status *status);
floatx80 floatx80_mod(floatx80, floatx80, float_status *status);
floatx80 floatx80_rem(floatx80, floatx80, float_status *status);
floatx80 floatx80_sqrt(floatx80, float_status *status);