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).
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Aurelien Jarno <aurelien@aurel32.net>
Message-id:
1453807806-32698-4-git-send-email-peter.maydell@linaro.org
| value.
*----------------------------------------------------------------------------*/
| 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,
{
static const uint16_t sqrtOddAdjustments[] = {
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
| Returns the exponent bits of the half-precision floating-point value `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;
}
{
return (float16_val(a) >> 10) & 0x1f;
}
| Returns the exponent bits of the single-precision floating-point value `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;
{
return ( float32_val(a)>>23 ) & 0xFF;
*----------------------------------------------------------------------------*/
static void
*----------------------------------------------------------------------------*/
static void
- normalizeFloat32Subnormal(uint32_t aSig, int_fast16_t *zExpPtr, uint32_t *zSigPtr)
+ normalizeFloat32Subnormal(uint32_t aSig, int *zExpPtr, uint32_t *zSigPtr)
| significand.
*----------------------------------------------------------------------------*/
| 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)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
+static float32 roundAndPackFloat32(flag zSign, int zExp, uint32_t zSig,
float_status *status)
{
int8_t roundingMode;
float_status *status)
{
int8_t roundingMode;
*----------------------------------------------------------------------------*/
static float32
*----------------------------------------------------------------------------*/
static float32
- normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
+ normalizeRoundAndPackFloat32(flag zSign, int zExp, uint32_t zSig,
float_status *status)
{
int8_t shiftCount;
float_status *status)
{
int8_t shiftCount;
| Returns the exponent bits of the double-precision floating-point value `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;
{
return ( float64_val(a)>>52 ) & 0x7FF;
*----------------------------------------------------------------------------*/
static void
*----------------------------------------------------------------------------*/
static void
- normalizeFloat64Subnormal(uint64_t aSig, int_fast16_t *zExpPtr, uint64_t *zSigPtr)
+ normalizeFloat64Subnormal(uint64_t aSig, int *zExpPtr, uint64_t *zSigPtr)
| significand.
*----------------------------------------------------------------------------*/
| 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)
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
-static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
+static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig,
float_status *status)
{
int8_t roundingMode;
flag roundNearestEven;
float_status *status)
{
int8_t roundingMode;
flag roundNearestEven;
- int_fast16_t roundIncrement, roundBits;
+ int roundIncrement, roundBits;
flag isTiny;
roundingMode = status->float_rounding_mode;
flag isTiny;
roundingMode = status->float_rounding_mode;
*----------------------------------------------------------------------------*/
static float64
*----------------------------------------------------------------------------*/
static float64
- normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
+ normalizeRoundAndPackFloat64(flag zSign, int zExp, uint64_t zSig,
float_status *status)
{
int8_t shiftCount;
float_status *status)
{
int8_t shiftCount;
int32_t float32_to_int32(float32 a, float_status *status)
{
flag aSign;
int32_t float32_to_int32(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
int32_t float32_to_int32_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int32_t float32_to_int32_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
int32_t z;
int shiftCount;
uint32_t aSig;
int32_t z;
int16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
int32_t z;
int shiftCount;
uint32_t aSig;
int32_t z;
int64_t float32_to_int64(float32 a, float_status *status)
{
flag aSign;
int64_t float32_to_int64(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
uint64_t float32_to_uint64(float32 a, float_status *status)
{
flag aSign;
uint64_t float32_to_uint64(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
int shiftCount;
uint32_t aSig;
uint64_t aSig64, aSigExtra;
int64_t float32_to_int64_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int64_t float32_to_int64_round_to_zero(float32 a, float_status *status)
{
flag aSign;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
int shiftCount;
uint32_t aSig;
uint64_t aSig64;
float64 float32_to_float64(float32 a, float_status *status)
{
flag aSign;
float64 float32_to_float64(float32 a, float_status *status)
{
flag aSign;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
floatx80 float32_to_floatx80(float32 a, float_status *status)
{
flag aSign;
floatx80 float32_to_floatx80(float32 a, float_status *status)
{
flag aSign;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
float128 float32_to_float128(float32 a, float_status *status)
{
flag aSign;
float128 float32_to_float128(float32 a, float_status *status)
{
flag aSign;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
float32 float32_round_to_int(float32 a, float_status *status)
{
flag aSign;
float32 float32_round_to_int(float32 a, float_status *status)
{
flag aSign;
uint32_t lastBitMask, roundBitsMask;
uint32_t z;
a = float32_squash_input_denormal(a, status);
uint32_t lastBitMask, roundBitsMask;
uint32_t z;
a = float32_squash_input_denormal(a, status);
static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
float_status *status)
{
static float32 addFloat32Sigs(float32 a, float32 b, flag zSign,
float_status *status)
{
- int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
uint32_t aSig, bSig, zSig;
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
float_status *status)
{
static float32 subFloat32Sigs(float32 a, float32 b, flag zSign,
float_status *status)
{
- int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
uint32_t aSig, bSig, zSig;
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a );
float32 float32_mul(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
float32 float32_mul(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
- int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig;
uint64_t zSig64;
uint32_t zSig;
uint32_t aSig, bSig;
uint64_t zSig64;
uint32_t zSig;
float32 float32_div(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
float32 float32_div(float32 a, float32 b, float_status *status)
{
flag aSign, bSign, zSign;
- int_fast16_t aExp, bExp, zExp;
uint32_t aSig, bSig, zSig;
a = float32_squash_input_denormal(a, status);
b = float32_squash_input_denormal(b, status);
uint32_t aSig, bSig, zSig;
a = float32_squash_input_denormal(a, status);
b = float32_squash_input_denormal(b, status);
float32 float32_rem(float32 a, float32 b, float_status *status)
{
flag aSign, zSign;
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;
uint32_t aSig, bSig;
uint32_t q;
uint64_t aSig64, bSig64, q64;
float_status *status)
{
flag aSign, bSign, cSign, zSign;
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;
uint32_t aSig, bSig, cSig;
flag pInf, pZero, pSign;
uint64_t pSig64, cSig64, zSig64;
float32 float32_sqrt(float32 a, float_status *status)
{
flag aSign;
float32 float32_sqrt(float32 a, float_status *status)
{
flag aSign;
- int_fast16_t aExp, zExp;
uint32_t aSig, zSig;
uint64_t rem, term;
a = float32_squash_input_denormal(a, status);
uint32_t aSig, zSig;
uint64_t rem, term;
a = float32_squash_input_denormal(a, status);
float32 float32_exp2(float32 a, float_status *status)
{
flag aSign;
float32 float32_exp2(float32 a, float_status *status)
{
flag aSign;
uint32_t aSig;
float64 r, x, xn;
int i;
uint32_t aSig;
float64 r, x, xn;
int i;
float32 float32_log2(float32 a, float_status *status)
{
flag aSign, zSign;
float32 float32_log2(float32 a, float_status *status)
{
flag aSign, zSign;
uint32_t aSig, zSig, i;
a = float32_squash_input_denormal(a, status);
uint32_t aSig, zSig, i;
a = float32_squash_input_denormal(a, status);
int32_t float64_to_int32(float64 a, float_status *status)
{
flag aSign;
int32_t float64_to_int32(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
int shiftCount;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
int32_t float64_to_int32_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int32_t float64_to_int32_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
int16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
int shiftCount;
uint64_t aSig, savedASig;
int32_t z;
int64_t float64_to_int64(float64 a, float_status *status)
{
flag aSign;
int64_t float64_to_int64(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);
int64_t float64_to_int64_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int64_t float64_to_int64_round_to_zero(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig;
int64_t z;
int shiftCount;
uint64_t aSig;
int64_t z;
float32 float64_to_float32(float64 a, float_status *status)
{
flag aSign;
float32 float64_to_float32(float64 a, float_status *status)
{
flag aSign;
uint64_t aSig;
uint32_t zSig;
a = float64_squash_input_denormal(a, status);
uint64_t aSig;
uint32_t zSig;
a = float64_squash_input_denormal(a, status);
| than the desired result exponent whenever `zSig' is a complete, normalized
| significand.
*----------------------------------------------------------------------------*/
| 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);
{
return make_float16(
(((uint32_t)zSign) << 15) + (((uint32_t)zExp) << 10) + zSig);
| Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
| 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)
{
uint32_t zSig, flag ieee,
float_status *status)
{
return packFloat16(zSign, zExp, zSig >> 13);
}
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;
uint32_t *zSigPtr)
{
int8_t shiftCount = countLeadingZeros32(aSig) - 21;
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
flag aSign;
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
flag aSign;
uint32_t aSig;
aSign = extractFloat16Sign(a);
uint32_t aSig;
aSign = extractFloat16Sign(a);
float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
flag aSign;
float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
flag aSign;
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
uint32_t aSig;
a = float32_squash_input_denormal(a, status);
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
flag aSign;
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
flag aSign;
uint32_t aSig;
aSign = extractFloat16Sign(a);
uint32_t aSig;
aSign = extractFloat16Sign(a);
float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
flag aSign;
float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
flag aSign;
uint64_t aSig;
uint32_t zSig;
uint64_t aSig;
uint32_t zSig;
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
flag aSign;
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
flag aSign;
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
uint64_t aSig;
a = float64_squash_input_denormal(a, status);
float128 float64_to_float128(float64 a, float_status *status)
{
flag aSign;
float128 float64_to_float128(float64 a, float_status *status)
{
flag aSign;
uint64_t aSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
uint64_t aSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
float64 float64_round_to_int(float64 a, float_status *status)
{
flag aSign;
float64 float64_round_to_int(float64 a, float_status *status)
{
flag aSign;
uint64_t lastBitMask, roundBitsMask;
uint64_t z;
a = float64_squash_input_denormal(a, status);
uint64_t lastBitMask, roundBitsMask;
uint64_t z;
a = float64_squash_input_denormal(a, status);
static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
float_status *status)
{
static float64 addFloat64Sigs(float64 a, float64 b, flag zSign,
float_status *status)
{
- int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
uint64_t aSig, bSig, zSig;
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
float_status *status)
{
static float64 subFloat64Sigs(float64 a, float64 b, flag zSign,
float_status *status)
{
- int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
uint64_t aSig, bSig, zSig;
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
float64 float64_mul(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
float64 float64_mul(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
- int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
uint64_t aSig, bSig, zSig0, zSig1;
a = float64_squash_input_denormal(a, status);
float64 float64_div(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
float64 float64_div(float64 a, float64 b, float_status *status)
{
flag aSign, bSign, zSign;
- int_fast16_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig;
uint64_t rem0, rem1;
uint64_t term0, term1;
uint64_t aSig, bSig, zSig;
uint64_t rem0, rem1;
uint64_t term0, term1;
float64 float64_rem(float64 a, float64 b, float_status *status)
{
flag aSign, zSign;
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;
uint64_t aSig, bSig;
uint64_t q, alternateASig;
int64_t sigMean;
float_status *status)
{
flag aSign, bSign, cSign, zSign;
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;
uint64_t aSig, bSig, cSig;
flag pInf, pZero, pSign;
uint64_t pSig0, pSig1, cSig0, cSig1, zSig0, zSig1;
float64 float64_sqrt(float64 a, float_status *status)
{
flag aSign;
float64 float64_sqrt(float64 a, float_status *status)
{
flag aSign;
- int_fast16_t aExp, zExp;
uint64_t aSig, zSig, doubleZSig;
uint64_t rem0, rem1, term0, term1;
a = float64_squash_input_denormal(a, status);
uint64_t aSig, zSig, doubleZSig;
uint64_t rem0, rem1, term0, term1;
a = float64_squash_input_denormal(a, status);
float64 float64_log2(float64 a, float_status *status)
{
flag aSign, zSign;
float64 float64_log2(float64 a, float_status *status)
{
flag aSign, zSign;
uint64_t aSig, aSig0, aSig1, zSig, i;
a = float64_squash_input_denormal(a, status);
uint64_t aSig, aSig0, aSig1, zSig, i;
a = float64_squash_input_denormal(a, status);
float128 floatx80_to_float128(floatx80 a, float_status *status)
{
flag aSign;
float128 floatx80_to_float128(floatx80 a, float_status *status)
{
flag aSign;
uint64_t aSig, zSig0, zSig1;
aSig = extractFloatx80Frac( a );
uint64_t aSig, zSig0, zSig1;
aSig = extractFloatx80Frac( a );
uint64_t float64_to_uint64(float64 a, float_status *status)
{
flag aSign;
uint64_t float64_to_uint64(float64 a, float_status *status)
{
flag aSign;
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);
int shiftCount;
uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a, status);