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

fpu: Use plain 'int' rather than 'int_fast16_t' for exponents

Browse source 
Use the plain 'int' type rather than 'int_fast16_t' for handling
exponents. Exponents don't need to be exactly 16 bits, so using int16_t
for them would confuse more than it clarified.

This should be a safe change because int_fast16_t semantics
permit use of 'int' (and on 32-bit glibc that is what you get).

Backports commit 0c48262d4772d40677364199372fb6ffcf487558 from qemu
This commit is contained in:
Peter Maydell 2018-02-20 18:57:26 -05:00 committed by Lioncash
parent 9d0463feed
commit 36551f59bb
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
2 changed files with 182 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
qemu/fpu/softfloat-macros.h
View file

@ -635,7 +635,7 @@ static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
| value.
*----------------------------------------------------------------------------*/
static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
static uint32_t estimateSqrt32(int aExp, uint32_t a)
{
static const uint16_t sqrtOddAdjustments[] = {
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,

122
qemu/fpu/softfloat.c
View file

@ -118,7 +118,7 @@ static inline uint32_t extractFloat16Frac(float16 a)
| Returns the exponent bits of the half-precision floating-point value `a'.
*----------------------------------------------------------------------------*/
static inline int_fast16_t extractFloat16Exp(float16 a)
static inline int extractFloat16Exp(float16 a)
{
return (float16_val(a) >> 10) & 0x1f;
}
@ -309,7 +309,7 @@ static inline uint32_t extractFloat32Frac( float32 a )
| Returns the exponent bits of the single-precision floating-point value `a'.
*----------------------------------------------------------------------------*/
static inline int_fast16_t extractFloat32Exp(float32 a)
static inline int extractFloat32Exp(float32 a)
{
return ( float32_val(a)>>23 ) & 0xFF;
@ -350,7 +350,7 @@ float32 float32_squash_input_denormal(float32 a, float_status *status)
*----------------------------------------------------------------------------*/
static void
normalizeFloat32Subnormal(uint32_t aSig, int_fast16_t *zExpPtr, uint32_t *zSigPtr)
normalizeFloat32Subnormal(uint32_t aSig, int *zExpPtr, uint32_t *zSigPtr)
{
int8_t shiftCount;
@ -371,7 +371,7 @@ static void
| significand.
*----------------------------------------------------------------------------*/
static inline float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
static inline float32 packFloat32(flag zSign, int zExp, uint32_t zSig)
{
return make_float32(
@ -401,7 +401,7 @@ static inline float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, float_status *status)
static float32 roundAndPackFloat32(flag zSign, int zExp, uint32_t zSig, float_status *status)
{
int8_t roundingMode;
flag roundNearestEven;
@ -472,7 +472,7 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
*----------------------------------------------------------------------------*/
static float32
normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, float_status *status)
normalizeRoundAndPackFloat32(flag zSign, int zExp, uint32_t zSig, float_status *status)
{
int8_t shiftCount;
@ -496,7 +496,7 @@ static inline uint64_t extractFloat64Frac( float64 a )
| Returns the exponent bits of the double-precision floating-point value `a'.
*----------------------------------------------------------------------------*/
static inline int_fast16_t extractFloat64Exp(float64 a)
static inline int extractFloat64Exp(float64 a)
{
return ( float64_val(a)>>52 ) & 0x7FF;
@ -537,7 +537,7 @@ float64 float64_squash_input_denormal(float64 a, float_status *status)
*----------------------------------------------------------------------------*/
static void
normalizeFloat64Subnormal(uint64_t aSig, int_fast16_t *zExpPtr, uint64_t *zSigPtr)
normalizeFloat64Subnormal(uint64_t aSig, int *zExpPtr, uint64_t *zSigPtr)
{
int8_t shiftCount;
@ -558,7 +558,7 @@ static void
| significand.
*----------------------------------------------------------------------------*/
static inline float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
static inline float64 packFloat64(flag zSign, int zExp, uint64_t zSig)
{
return make_float64(
@ -588,11 +588,11 @@ static inline float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig, float_status *status)
static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, float_status *status)
{
int8_t roundingMode;
flag roundNearestEven;
int_fast16_t roundIncrement, roundBits;
int roundIncrement, roundBits;
flag isTiny;
roundingMode = status->float_rounding_mode;
@ -658,7 +658,7 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
*----------------------------------------------------------------------------*/
static float64
normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig, float_status *status)
normalizeRoundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, float_status *status)
{
int8_t shiftCount;
@ -1517,7 +1517,7 @@ float128 uint64_to_float128(uint64_t a, float_status *status)
int32_t float32_to_int32(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
@ -1549,7 +1549,7 @@ int32_t float32_to_int32( float32 a, float_status *status)
int32_t float32_to_int32_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
int32_t z;
@ -1593,7 +1593,7 @@ int32_t float32_to_int32_round_to_zero( float32 a, float_status *status)
int16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
int32_t z;
@ -1643,7 +1643,7 @@ int16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
int64_t float32_to_int64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
@ -1683,7 +1683,7 @@ int64_t float32_to_int64( float32 a, float_status *status)
uint64_t float32_to_uint64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
@ -1749,7 +1749,7 @@ uint64_t float32_to_uint64_round_to_zero(float32 a, float_status *status)
int64_t float32_to_int64_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
@ -1794,7 +1794,7 @@ int64_t float32_to_int64_round_to_zero( float32 a, float_status *status)
float64 float32_to_float64(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
@ -1826,7 +1826,7 @@ float64 float32_to_float64( float32 a, float_status *status)
floatx80 float32_to_floatx80(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
@ -1858,7 +1858,7 @@ floatx80 float32_to_floatx80( float32 a, float_status *status)
float128 float32_to_float128(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
@ -1890,7 +1890,7 @@ float128 float32_to_float128( float32 a, float_status *status)
float32 float32_round_to_int(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t lastBitMask, roundBitsMask;
uint32_t z;
a = float32_squash_input_denormal(a, status);
@ -1969,9 +1969,9 @@ float32 float32_round_to_int( float32 a, float_status *status)
static float32 addFloat32Sigs(float32 a, float32 b, flag zSign, float_status *status)
{
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
int_fast16_t expDiff;
int expDiff;
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
@ -2054,9 +2054,9 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign, float_status *s
static float32 subFloat32Sigs(float32 a, float32 b, flag zSign, float_status *status)
{
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
int_fast16_t expDiff;
int expDiff;
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
@ -2180,7 +2180,7 @@ float32 float32_sub( float32 a, float32 b, float_status *status)
float32 float32_mul(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint32_t aSig, bSig;
uint64_t zSig64;
uint32_t zSig;
@ -2245,7 +2245,7 @@ float32 float32_mul( float32 a, float32 b, float_status *status)
float32 float32_div(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
a = float32_squash_input_denormal(a, status);
b = float32_squash_input_denormal(b, status);
@ -2313,7 +2313,7 @@ float32 float32_div( float32 a, float32 b, float_status *status)
float32 float32_rem(float32 a, float32 b, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp, bExp, expDiff;
int aExp, bExp, expDiff;
uint32_t aSig, bSig;
uint32_t q;
uint64_t aSig64, bSig64, q64;
@ -2421,7 +2421,7 @@ float32 float32_rem( float32 a, float32 b, float_status *status)
float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status *status)
{
flag aSign, bSign, cSign, zSign;
int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
int aExp, bExp, cExp, pExp, zExp, expDiff;
uint32_t aSig, bSig, cSig;
flag pInf, pZero, pSign;
uint64_t pSig64, cSig64, zSig64;
@ -2641,7 +2641,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status
float32 float32_sqrt(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, zExp;
int aExp, zExp;
uint32_t aSig, zSig;
uint64_t rem, term;
a = float32_squash_input_denormal(a, status);
@ -2729,7 +2729,7 @@ static const float64 float32_exp2_coefficients[15] =
float32 float32_exp2(float32 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
float64 r, x, xn;
int i;
@ -2779,7 +2779,7 @@ float32 float32_exp2( float32 a, float_status *status)
float32 float32_log2(float32 a, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig, zSig, i;
a = float32_squash_input_denormal(a, status);
@ -3046,7 +3046,7 @@ int float32_unordered_quiet( float32 a, float32 b, float_status *status )
int32_t float64_to_int32(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
@ -3075,7 +3075,7 @@ int32_t float64_to_int32( float64 a, float_status *status )
int32_t float64_to_int32_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
@ -3125,7 +3125,7 @@ int32_t float64_to_int32_round_to_zero( float64 a, float_status *status )
int16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
@ -3177,7 +3177,7 @@ int16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
int64_t float64_to_int64(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);
@ -3221,7 +3221,7 @@ int64_t float64_to_int64( float64 a, float_status *status )
int64_t float64_to_int64_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig;
int64_t z;
@ -3274,7 +3274,7 @@ int64_t float64_to_int64_round_to_zero( float64 a, float_status *status )
float32 float64_to_float32(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig;
uint32_t zSig;
a = float64_squash_input_denormal(a, status);
@ -3309,7 +3309,7 @@ float32 float64_to_float32( float64 a, float_status *status )
| than the desired result exponent whenever `zSig' is a complete, normalized
| significand.
*----------------------------------------------------------------------------*/
static float16 packFloat16(flag zSign, int_fast16_t zExp, uint16_t zSig)
static float16 packFloat16(flag zSign, int zExp, uint16_t zSig)
{
return make_float16(
(((uint32_t)zSign) << 15) + (((uint32_t)zExp) << 10) + zSig);
@ -3343,7 +3343,7 @@ static float16 packFloat16(flag zSign, int_fast16_t zExp, uint16_t zSig)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
static float16 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
static float16 roundAndPackFloat16(flag zSign, int zExp,
uint32_t zSig, flag ieee, float_status *status)
{
int maxexp = ieee ? 29 : 30;
@ -3429,7 +3429,7 @@ static float16 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
return packFloat16(zSign, zExp, zSig >> 13);
}
static void normalizeFloat16Subnormal(uint32_t aSig, int_fast16_t *zExpPtr,
static void normalizeFloat16Subnormal(uint32_t aSig, int *zExpPtr,
uint32_t *zSigPtr)
{
int8_t shiftCount = countLeadingZeros32(aSig) - 21;
@ -3443,7 +3443,7 @@ static void normalizeFloat16Subnormal(uint32_t aSig, int_fast16_t *zExpPtr,
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
aSign = extractFloat16Sign(a);
@ -3470,7 +3470,7 @@ float32 float16_to_float32(float16 a, flag ieee, float_status *status)
float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
@ -3514,7 +3514,7 @@ float16 float32_to_float16(float32 a, flag ieee, float_status *status)
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint32_t aSig;
aSign = extractFloat16Sign(a);
@ -3542,7 +3542,7 @@ float64 float16_to_float64(float16 a, flag ieee, float_status *status)
float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig;
uint32_t zSig;
@ -3596,7 +3596,7 @@ float16 float64_to_float16(float64 a, flag ieee, float_status *status)
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
@ -3629,7 +3629,7 @@ floatx80 float64_to_floatx80( float64 a, float_status *status )
float128 float64_to_float128(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
@ -3662,7 +3662,7 @@ float128 float64_to_float128( float64 a, float_status *status )
float64 float64_round_to_int(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t lastBitMask, roundBitsMask;
uint64_t z;
a = float64_squash_input_denormal(a, status);
@ -3755,9 +3755,9 @@ float64 float64_trunc_to_int( float64 a, float_status *status)
static float64 addFloat64Sigs(float64 a, float64 b, flag zSign, float_status *status)
{
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
int_fast16_t expDiff;
int expDiff;
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
@ -3840,9 +3840,9 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign, float_status *s
static float64 subFloat64Sigs(float64 a, float64 b, flag zSign, float_status *status)
{
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
int_fast16_t expDiff;
int expDiff;
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
@ -3966,7 +3966,7 @@ float64 float64_sub( float64 a, float64 b, float_status *status )
float64 float64_mul(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
@ -4029,7 +4029,7 @@ float64 float64_mul( float64 a, float64 b, float_status *status )
float64 float64_div(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
int_fast16_t aExp, bExp, zExp;
int aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
uint64_t rem0, rem1;
uint64_t term0, term1;
@ -4107,7 +4107,7 @@ float64 float64_div( float64 a, float64 b, float_status *status )
float64 float64_rem(float64 a, float64 b, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp, bExp, expDiff;
int aExp, bExp, expDiff;
uint64_t aSig, bSig;
uint64_t q, alternateASig;
int64_t sigMean;
@ -4200,7 +4200,7 @@ float64 float64_rem( float64 a, float64 b, float_status *status )
float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status *status)
{
flag aSign, bSign, cSign, zSign;
int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
int aExp, bExp, cExp, pExp, zExp, expDiff;
uint64_t aSig, bSig, cSig;
flag pInf, pZero, pSign;
uint64_t pSig0, pSig1, cSig0, cSig1, zSig0, zSig1;
@ -4441,7 +4441,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status
float64 float64_sqrt(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp, zExp;
int aExp, zExp;
uint64_t aSig, zSig, doubleZSig;
uint64_t rem0, rem1, term0, term1;
a = float64_squash_input_denormal(a, status);
@ -4494,7 +4494,7 @@ float64 float64_sqrt( float64 a, float_status *status )
float64 float64_log2(float64 a, float_status *status)
{
flag aSign, zSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig, aSig0, aSig1, zSig, i;
a = float64_squash_input_denormal(a, status);
@ -5001,7 +5001,7 @@ float64 floatx80_to_float64( floatx80 a, float_status *status )
float128 floatx80_to_float128(floatx80 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
uint64_t aSig, zSig0, zSig1;
if (floatx80_invalid_encoding(a)) {
@ -7295,7 +7295,7 @@ uint16_t float64_to_uint16_round_to_zero(float64 a, float_status *status)
uint64_t float64_to_uint64(float64 a, float_status *status)
{
flag aSign;
int_fast16_t aExp;
int aExp;
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);