david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

softfloat:

Browse Source 
* drop confusing softfloat-only types
  * fix return type of roundAndPackFloat16
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABCAAGBQJWokeFAAoJEDwlJe0UNgze+hsP/jIo8Rsa19/yUkxSr4ZwKBhX
 NjMJd+1juLUgZdb/8nPc0fWUDHM3+DQ+VD0AIpbOx0QOf53OCiEvKtSKjnot0Oef
 2jakgmR0fb0dQ7/r4jzwKLekLVYKkxlwG3EO+WbrA7cROx2JF47/IJfkXUV7j7L8
 HByJc5/STOL+kEnwP+uNvq5b1rRo/F7B2auXdijFGXtcyxMTBNx4jW05ATYZos2Y
 24MWK95SaialFhaWUXdG3j+Puho/l3ATJnWpfJvEzH03tC8d9K2WdJ7TR1a+g6Iq
 9/X/Hsa3SifCJ8OLqbKINJCGdov9H53P/WSh258qey4rSvg8LyR8zBQYg5sos25O
 f8FQusCIGcW7qfP4Cd03KXtlb03weY/iMGfLjNmkoNB73s0n9Z9xsvPD44rvSOj3
 7ew6is3ZZimn19nel1aGb+jhCge+6iTEFVytJiNt+CPeu3m+82uSRqr6aCkoRFEW
 copMc8rRxqGWj11dHzX4qnvPeYaq8hL8rCR4ossfgXF/ONdpNCfs8mTv5t9mKKq/
 K0N2JGy8EoPXa2/55D7/KF9DCmmzWa6efKE2eV08MdyRTxAbc/Pl2HpdPKYIOTOK
 FXF/XmV/kts+z7zhigxrDpPKvE4uX2BE7A0kKSVKBpelEl33R4wufIJRZFdNJBXt
 IX3Bc+5XYrG3pNt489c9
 =gXbe
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-softfloat-20160122' into staging

softfloat:
 * drop confusing softfloat-only types
 * fix return type of roundAndPackFloat16

# gpg: Signature made Fri 22 Jan 2016 15:15:17 GMT using RSA key ID 14360CDE
# gpg: Good signature from "Peter Maydell <peter.maydell@linaro.org>"
# gpg:                 aka "Peter Maydell <pmaydell@gmail.com>"
# gpg:                 aka "Peter Maydell <pmaydell@chiark.greenend.org.uk>"

* remotes/pmaydell/tags/pull-softfloat-20160122:
  softfloat: fix return type of roundAndPackFloat16
  fpu: Replace uint8 typedef with uint8_t
  fpu: Replace int8 typedef with int8_t
  fpu: Replace uint32 typedef with uint32_t
  fpu: Replace int32 typedef with int32_t
  fpu: Replace uint64 typedef with uint64_t
  fpu: Replace int64 typedef with int64_t

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2016-01-22 15:19:20 +00:00
commit 047e363b05
20 changed files with 188 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crypto/secret.c
View File

@ -434,7 +434,7 @@ int qcrypto_secret_lookup(const char *secretid,
return -1; return -1;
} }
*data = g_new0(uint8, secret->rawlen + 1); *data = g_new0(uint8_t, secret->rawlen + 1);
memcpy(*data, secret->rawdata, secret->rawlen); memcpy(*data, secret->rawdata, secret->rawlen);
(*data)[secret->rawlen] = '\0'; (*data)[secret->rawlen] = '\0';
*datalen = secret->rawlen; *datalen = secret->rawlen;

26
fpu/softfloat-macros.h
View File

@ -164,7 +164,7 @@ static inline void
uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr) uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{ {
uint64_t z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8_t negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
z1 = a1; z1 = a1;
@ -201,7 +201,7 @@ static inline void
uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr) uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{ {
uint64_t z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8_t negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
z1 = a1; z1 = a1;
@ -236,7 +236,7 @@ static inline void
uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr) uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{ {
uint64_t z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8_t negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
z1 = a1; z1 = a1;
@ -294,7 +294,7 @@ static inline void
) )
{ {
uint64_t z0, z1, z2; uint64_t z0, z1, z2;
int8 negCount = ( - count ) & 63; int8_t negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
z2 = a2; z2 = a2;
@ -371,7 +371,7 @@ static inline void
) )
{ {
uint64_t z0, z1, z2; uint64_t z0, z1, z2;
int8 negCount; int8_t negCount;
z2 = a2<<count; z2 = a2<<count;
z1 = a1<<count; z1 = a1<<count;
@ -428,7 +428,7 @@ static inline void
) )
{ {
uint64_t z0, z1, z2; uint64_t z0, z1, z2;
int8 carry0, carry1; int8_t carry0, carry1;
z2 = a2 + b2; z2 = a2 + b2;
carry1 = ( z2 < a2 ); carry1 = ( z2 < a2 );
@ -484,7 +484,7 @@ static inline void
) )
{ {
uint64_t z0, z1, z2; uint64_t z0, z1, z2;
int8 borrow0, borrow1; int8_t borrow0, borrow1;
z2 = a2 - b2; z2 = a2 - b2;
borrow1 = ( a2 < b2 ); borrow1 = ( a2 < b2 );
@ -645,7 +645,7 @@ static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
}; };
int8 index; int8_t index;
uint32_t z; uint32_t z;
index = ( a>>27 ) & 15; index = ( a>>27 ) & 15;
@ -669,7 +669,7 @@ static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
| `a'. If `a' is zero, 32 is returned. | `a'. If `a' is zero, 32 is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int8 countLeadingZeros32( uint32_t a ) static int8_t countLeadingZeros32( uint32_t a )
{ {
#if SOFTFLOAT_GNUC_PREREQ(3, 4) #if SOFTFLOAT_GNUC_PREREQ(3, 4)
if (a) { if (a) {
@ -678,7 +678,7 @@ static int8 countLeadingZeros32( uint32_t a )
return 32; return 32;
} }
#else #else
static const int8 countLeadingZerosHigh[] = { static const int8_t countLeadingZerosHigh[] = {
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@ -696,7 +696,7 @@ static int8 countLeadingZeros32( uint32_t a )
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}; };
int8 shiftCount; int8_t shiftCount;
shiftCount = 0; shiftCount = 0;
if ( a < 0x10000 ) { if ( a < 0x10000 ) {
@ -717,7 +717,7 @@ static int8 countLeadingZeros32( uint32_t a )
| `a'. If `a' is zero, 64 is returned. | `a'. If `a' is zero, 64 is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int8 countLeadingZeros64( uint64_t a ) static int8_t countLeadingZeros64( uint64_t a )
{ {
#if SOFTFLOAT_GNUC_PREREQ(3, 4) #if SOFTFLOAT_GNUC_PREREQ(3, 4)
if (a) { if (a) {
@ -726,7 +726,7 @@ static int8 countLeadingZeros64( uint64_t a )
return 64; return 64;
} }
#else #else
int8 shiftCount; int8_t shiftCount;
shiftCount = 0; shiftCount = 0;
if ( a < ( (uint64_t) 1 )<<32 ) { if ( a < ( (uint64_t) 1 )<<32 ) {

2
fpu/softfloat-specialize.h
View File

@ -174,7 +174,7 @@ const float128 float128_default_nan
| should be simply `float_exception_flags |= flags;'. | should be simply `float_exception_flags |= flags;'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
void float_raise(int8 flags, float_status *status) void float_raise(int8_t flags, float_status *status)
{ {
status->float_exception_flags |= flags; status->float_exception_flags |= flags;
} }

220
fpu/softfloat.c
View File

@ -144,11 +144,11 @@ static inline flag extractFloat16Sign(float16 a)
| positive or negative integer is returned. | positive or negative integer is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status) static int32_t roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven; flag roundNearestEven;
int8 roundIncrement, roundBits; int8_t roundIncrement, roundBits;
int32_t z; int32_t z;
roundingMode = status->float_rounding_mode; roundingMode = status->float_rounding_mode;
@ -198,10 +198,10 @@ static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1, static int64_t roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
float_status *status) float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven, increment; flag roundNearestEven, increment;
int64_t z; int64_t z;
@ -255,10 +255,10 @@ static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
| exception is raised and the largest unsigned integer is returned. | exception is raised and the largest unsigned integer is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int64 roundAndPackUint64(flag zSign, uint64_t absZ0, static int64_t roundAndPackUint64(flag zSign, uint64_t absZ0,
uint64_t absZ1, float_status *status) uint64_t absZ1, float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven, increment; flag roundNearestEven, increment;
roundingMode = status->float_rounding_mode; roundingMode = status->float_rounding_mode;
@ -358,7 +358,7 @@ float32 float32_squash_input_denormal(float32 a, float_status *status)
static void static void
normalizeFloat32Subnormal(uint32_t aSig, int_fast16_t *zExpPtr, uint32_t *zSigPtr) normalizeFloat32Subnormal(uint32_t aSig, int_fast16_t *zExpPtr, uint32_t *zSigPtr)
{ {
int8 shiftCount; int8_t shiftCount;
shiftCount = countLeadingZeros32( aSig ) - 8; shiftCount = countLeadingZeros32( aSig ) - 8;
*zSigPtr = aSig<<shiftCount; *zSigPtr = aSig<<shiftCount;
@ -410,9 +410,9 @@ static inline float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
float_status *status) float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven; flag roundNearestEven;
int8 roundIncrement, roundBits; int8_t roundIncrement, roundBits;
flag isTiny; flag isTiny;
roundingMode = status->float_rounding_mode; roundingMode = status->float_rounding_mode;
@ -485,7 +485,7 @@ static float32
normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig, normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
float_status *status) float_status *status)
{ {
int8 shiftCount; int8_t shiftCount;
shiftCount = countLeadingZeros32( zSig ) - 1; shiftCount = countLeadingZeros32( zSig ) - 1;
return roundAndPackFloat32(zSign, zExp - shiftCount, zSig<<shiftCount, return roundAndPackFloat32(zSign, zExp - shiftCount, zSig<<shiftCount,
@ -551,7 +551,7 @@ float64 float64_squash_input_denormal(float64 a, float_status *status)
static void static void
normalizeFloat64Subnormal(uint64_t aSig, int_fast16_t *zExpPtr, uint64_t *zSigPtr) normalizeFloat64Subnormal(uint64_t aSig, int_fast16_t *zExpPtr, uint64_t *zSigPtr)
{ {
int8 shiftCount; int8_t shiftCount;
shiftCount = countLeadingZeros64( aSig ) - 11; shiftCount = countLeadingZeros64( aSig ) - 11;
*zSigPtr = aSig<<shiftCount; *zSigPtr = aSig<<shiftCount;
@ -603,7 +603,7 @@ static inline float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig, static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
float_status *status) float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven; flag roundNearestEven;
int_fast16_t roundIncrement, roundBits; int_fast16_t roundIncrement, roundBits;
flag isTiny; flag isTiny;
@ -677,7 +677,7 @@ static float64
normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig, normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
float_status *status) float_status *status)
{ {
int8 shiftCount; int8_t shiftCount;
shiftCount = countLeadingZeros64( zSig ) - 1; shiftCount = countLeadingZeros64( zSig ) - 1;
return roundAndPackFloat64(zSign, zExp - shiftCount, zSig<<shiftCount, return roundAndPackFloat64(zSign, zExp - shiftCount, zSig<<shiftCount,
@ -702,7 +702,7 @@ static inline uint64_t extractFloatx80Frac( floatx80 a )
| value `a'. | value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static inline int32 extractFloatx80Exp( floatx80 a ) static inline int32_t extractFloatx80Exp( floatx80 a )
{ {
return a.high & 0x7FFF; return a.high & 0x7FFF;
@ -729,9 +729,9 @@ static inline flag extractFloatx80Sign( floatx80 a )
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static void static void
normalizeFloatx80Subnormal( uint64_t aSig, int32 *zExpPtr, uint64_t *zSigPtr ) normalizeFloatx80Subnormal( uint64_t aSig, int32_t *zExpPtr, uint64_t *zSigPtr )
{ {
int8 shiftCount; int8_t shiftCount;
shiftCount = countLeadingZeros64( aSig ); shiftCount = countLeadingZeros64( aSig );
*zSigPtr = aSig<<shiftCount; *zSigPtr = aSig<<shiftCount;
@ -744,7 +744,7 @@ static void
| extended double-precision floating-point value, returning the result. | extended double-precision floating-point value, returning the result.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static inline floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig ) static inline floatx80 packFloatx80( flag zSign, int32_t zExp, uint64_t zSig )
{ {
floatx80 z; floatx80 z;
@ -778,13 +778,13 @@ static inline floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
| Floating-Point Arithmetic. | Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign, static floatx80 roundAndPackFloatx80(int8_t roundingPrecision, flag zSign,
int32 zExp, uint64_t zSig0, uint64_t zSig1, int32_t zExp, uint64_t zSig0, uint64_t zSig1,
float_status *status) float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven, increment, isTiny; flag roundNearestEven, increment, isTiny;
int64 roundIncrement, roundMask, roundBits; int64_t roundIncrement, roundMask, roundBits;
roundingMode = status->float_rounding_mode; roundingMode = status->float_rounding_mode;
roundNearestEven = ( roundingMode == float_round_nearest_even ); roundNearestEven = ( roundingMode == float_round_nearest_even );
@ -974,12 +974,12 @@ static floatx80 roundAndPackFloatx80(int8 roundingPrecision, flag zSign,
| normalized. | normalized.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static floatx80 normalizeRoundAndPackFloatx80(int8 roundingPrecision, static floatx80 normalizeRoundAndPackFloatx80(int8_t roundingPrecision,
flag zSign, int32 zExp, flag zSign, int32_t zExp,
uint64_t zSig0, uint64_t zSig1, uint64_t zSig0, uint64_t zSig1,
float_status *status) float_status *status)
{ {
int8 shiftCount; int8_t shiftCount;
if ( zSig0 == 0 ) { if ( zSig0 == 0 ) {
zSig0 = zSig1; zSig0 = zSig1;
@ -1023,7 +1023,7 @@ static inline uint64_t extractFloat128Frac0( float128 a )
| `a'. | `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static inline int32 extractFloat128Exp( float128 a ) static inline int32_t extractFloat128Exp( float128 a )
{ {
return ( a.high>>48 ) & 0x7FFF; return ( a.high>>48 ) & 0x7FFF;
@ -1055,12 +1055,12 @@ static void
normalizeFloat128Subnormal( normalizeFloat128Subnormal(
uint64_t aSig0, uint64_t aSig0,
uint64_t aSig1, uint64_t aSig1,
int32 *zExpPtr, int32_t *zExpPtr,
uint64_t *zSig0Ptr, uint64_t *zSig0Ptr,
uint64_t *zSig1Ptr uint64_t *zSig1Ptr
) )
{ {
int8 shiftCount; int8_t shiftCount;
if ( aSig0 == 0 ) { if ( aSig0 == 0 ) {
shiftCount = countLeadingZeros64( aSig1 ) - 15; shiftCount = countLeadingZeros64( aSig1 ) - 15;
@ -1096,7 +1096,7 @@ static void
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static inline float128 static inline float128
packFloat128( flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 ) packFloat128( flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1 )
{ {
float128 z; float128 z;
@ -1127,11 +1127,11 @@ static inline float128
| overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic. | overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float128 roundAndPackFloat128(flag zSign, int32 zExp, static float128 roundAndPackFloat128(flag zSign, int32_t zExp,
uint64_t zSig0, uint64_t zSig1, uint64_t zSig0, uint64_t zSig1,
uint64_t zSig2, float_status *status) uint64_t zSig2, float_status *status)
{ {
int8 roundingMode; int8_t roundingMode;
flag roundNearestEven, increment, isTiny; flag roundNearestEven, increment, isTiny;
roundingMode = status->float_rounding_mode; roundingMode = status->float_rounding_mode;
@ -1245,11 +1245,11 @@ static float128 roundAndPackFloat128(flag zSign, int32 zExp,
| point exponent. | point exponent.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float128 normalizeRoundAndPackFloat128(flag zSign, int32 zExp, static float128 normalizeRoundAndPackFloat128(flag zSign, int32_t zExp,
uint64_t zSig0, uint64_t zSig1, uint64_t zSig0, uint64_t zSig1,
float_status *status) float_status *status)
{ {
int8 shiftCount; int8_t shiftCount;
uint64_t zSig2; uint64_t zSig2;
if ( zSig0 == 0 ) { if ( zSig0 == 0 ) {
@ -1296,8 +1296,8 @@ float32 int32_to_float32(int32_t a, float_status *status)
float64 int32_to_float64(int32_t a, float_status *status) float64 int32_to_float64(int32_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint32 absA; uint32_t absA;
int8 shiftCount; int8_t shiftCount;
uint64_t zSig; uint64_t zSig;
if ( a == 0 ) return float64_zero; if ( a == 0 ) return float64_zero;
@ -1319,8 +1319,8 @@ float64 int32_to_float64(int32_t a, float_status *status)
floatx80 int32_to_floatx80(int32_t a, float_status *status) floatx80 int32_to_floatx80(int32_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint32 absA; uint32_t absA;
int8 shiftCount; int8_t shiftCount;
uint64_t zSig; uint64_t zSig;
if ( a == 0 ) return packFloatx80( 0, 0, 0 ); if ( a == 0 ) return packFloatx80( 0, 0, 0 );
@ -1341,8 +1341,8 @@ floatx80 int32_to_floatx80(int32_t a, float_status *status)
float128 int32_to_float128(int32_t a, float_status *status) float128 int32_to_float128(int32_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint32 absA; uint32_t absA;
int8 shiftCount; int8_t shiftCount;
uint64_t zSig0; uint64_t zSig0;
if ( a == 0 ) return packFloat128( 0, 0, 0, 0 ); if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
@ -1363,8 +1363,8 @@ float128 int32_to_float128(int32_t a, float_status *status)
float32 int64_to_float32(int64_t a, float_status *status) float32 int64_to_float32(int64_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint64 absA; uint64_t absA;
int8 shiftCount; int8_t shiftCount;
if ( a == 0 ) return float32_zero; if ( a == 0 ) return float32_zero;
zSign = ( a < 0 ); zSign = ( a < 0 );
@ -1414,8 +1414,8 @@ float64 int64_to_float64(int64_t a, float_status *status)
floatx80 int64_to_floatx80(int64_t a, float_status *status) floatx80 int64_to_floatx80(int64_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint64 absA; uint64_t absA;
int8 shiftCount; int8_t shiftCount;
if ( a == 0 ) return packFloatx80( 0, 0, 0 ); if ( a == 0 ) return packFloatx80( 0, 0, 0 );
zSign = ( a < 0 ); zSign = ( a < 0 );
@ -1434,9 +1434,9 @@ floatx80 int64_to_floatx80(int64_t a, float_status *status)
float128 int64_to_float128(int64_t a, float_status *status) float128 int64_to_float128(int64_t a, float_status *status)
{ {
flag zSign; flag zSign;
uint64 absA; uint64_t absA;
int8 shiftCount; int8_t shiftCount;
int32 zExp; int32_t zExp;
uint64_t zSig0, zSig1; uint64_t zSig0, zSig1;
if ( a == 0 ) return packFloat128( 0, 0, 0, 0 ); if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
@ -1541,7 +1541,7 @@ float128 uint64_to_float128(uint64_t a, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float32_to_int32(float32 a, float_status *status) int32_t float32_to_int32(float32 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -1572,7 +1572,7 @@ int32 float32_to_int32(float32 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float32_to_int32_round_to_zero(float32 a, float_status *status) int32_t float32_to_int32_round_to_zero(float32 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -1622,7 +1622,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
uint32_t aSig; uint32_t aSig;
int32 z; int32_t z;
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
aExp = extractFloat32Exp( a ); aExp = extractFloat32Exp( a );
@ -1666,7 +1666,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float32_to_int64(float32 a, float_status *status) int64_t float32_to_int64(float32 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -1705,7 +1705,7 @@ int64 float32_to_int64(float32 a, float_status *status)
| raise the inexact exception flag. | raise the inexact exception flag.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
uint64 float32_to_uint64(float32 a, float_status *status) uint64_t float32_to_uint64(float32 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -1750,7 +1750,7 @@ uint64 float32_to_uint64(float32 a, float_status *status)
| not round to zero will raise the inexact flag. | not round to zero will raise the inexact flag.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status) uint64_t float32_to_uint64_round_to_zero(float32 a, float_status *status)
{ {
signed char current_rounding_mode = status->float_rounding_mode; signed char current_rounding_mode = status->float_rounding_mode;
set_float_rounding_mode(float_round_to_zero, status); set_float_rounding_mode(float_round_to_zero, status);
@ -1769,13 +1769,13 @@ uint64 float32_to_uint64_round_to_zero(float32 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float32_to_int64_round_to_zero(float32 a, float_status *status) int64_t float32_to_int64_round_to_zero(float32 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
uint32_t aSig; uint32_t aSig;
uint64_t aSig64; uint64_t aSig64;
int64 z; int64_t z;
a = float32_squash_input_denormal(a, status); a = float32_squash_input_denormal(a, status);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
@ -3073,7 +3073,7 @@ int float32_unordered_quiet(float32 a, float32 b, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float64_to_int32(float64 a, float_status *status) int32_t float64_to_int32(float64 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -3101,7 +3101,7 @@ int32 float64_to_int32(float64 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float64_to_int32_round_to_zero(float64 a, float_status *status) int32_t float64_to_int32_round_to_zero(float64 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -3155,7 +3155,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
uint64_t aSig, savedASig; uint64_t aSig, savedASig;
int32 z; int32_t z;
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a ); aExp = extractFloat64Exp( a );
@ -3201,7 +3201,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float64_to_int64(float64 a, float_status *status) int64_t float64_to_int64(float64 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
@ -3244,12 +3244,12 @@ int64 float64_to_int64(float64 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float64_to_int64_round_to_zero(float64 a, float_status *status) int64_t float64_to_int64_round_to_zero(float64 a, float_status *status)
{ {
flag aSign; flag aSign;
int_fast16_t aExp, shiftCount; int_fast16_t aExp, shiftCount;
uint64_t aSig; uint64_t aSig;
int64 z; int64_t z;
a = float64_squash_input_denormal(a, status); a = float64_squash_input_denormal(a, status);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
@ -3368,7 +3368,7 @@ static float16 packFloat16(flag zSign, int_fast16_t zExp, uint16_t zSig)
| Binary Floating-Point Arithmetic. | Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float32 roundAndPackFloat16(flag zSign, int_fast16_t zExp, static float16 roundAndPackFloat16(flag zSign, int_fast16_t zExp,
uint32_t zSig, flag ieee, uint32_t zSig, flag ieee,
float_status *status) float_status *status)
{ {
@ -4790,10 +4790,10 @@ int float64_unordered_quiet(float64 a, float64 b, float_status *status)
| overflows, the largest integer with the same sign as `a' is returned. | overflows, the largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 floatx80_to_int32(floatx80 a, float_status *status) int32_t floatx80_to_int32(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig; uint64_t aSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
@ -4817,10 +4817,10 @@ int32 floatx80_to_int32(floatx80 a, float_status *status)
| sign as `a' is returned. | sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status) int32_t floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig, savedASig; uint64_t aSig, savedASig;
int32_t z; int32_t z;
@ -4864,10 +4864,10 @@ int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
| overflows, the largest integer with the same sign as `a' is returned. | overflows, the largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 floatx80_to_int64(floatx80 a, float_status *status) int64_t floatx80_to_int64(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig, aSigExtra; uint64_t aSig, aSigExtra;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
@ -4904,12 +4904,12 @@ int64 floatx80_to_int64(floatx80 a, float_status *status)
| sign as `a' is returned. | sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status) int64_t floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig; uint64_t aSig;
int64 z; int64_t z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
@ -4950,7 +4950,7 @@ int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
float32 floatx80_to_float32(floatx80 a, float_status *status) float32 floatx80_to_float32(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t aSig; uint64_t aSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
@ -4978,7 +4978,7 @@ float32 floatx80_to_float32(floatx80 a, float_status *status)
float64 floatx80_to_float64(floatx80 a, float_status *status) float64 floatx80_to_float64(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t aSig, zSig; uint64_t aSig, zSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
@ -5030,7 +5030,7 @@ float128 floatx80_to_float128(floatx80 a, float_status *status)
floatx80 floatx80_round_to_int(floatx80 a, float_status *status) floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t lastBitMask, roundBitsMask; uint64_t lastBitMask, roundBitsMask;
floatx80 z; floatx80 z;
@ -5125,9 +5125,9 @@ floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign, static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
float_status *status) float_status *status)
{ {
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
int32 expDiff; int32_t expDiff;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
@ -5194,9 +5194,9 @@ static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign, static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
float_status *status) float_status *status)
{ {
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
int32 expDiff; int32_t expDiff;
floatx80 z; floatx80 z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
@ -5305,7 +5305,7 @@ floatx80 floatx80_sub(floatx80 a, floatx80 b, float_status *status)
floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status) floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
floatx80 z; floatx80 z;
@ -5364,7 +5364,7 @@ floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status) floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
uint64_t rem0, rem1, rem2, term0, term1, term2; uint64_t rem0, rem1, rem2, term0, term1, term2;
floatx80 z; floatx80 z;
@ -5448,7 +5448,7 @@ floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status) floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
{ {
flag aSign, zSign; flag aSign, zSign;
int32 aExp, bExp, expDiff; int32_t aExp, bExp, expDiff;
uint64_t aSig0, aSig1, bSig; uint64_t aSig0, aSig1, bSig;
uint64_t q, term0, term1, alternateASig0, alternateASig1; uint64_t q, term0, term1, alternateASig0, alternateASig1;
floatx80 z; floatx80 z;
@ -5546,7 +5546,7 @@ floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
floatx80 floatx80_sqrt(floatx80 a, float_status *status) floatx80 floatx80_sqrt(floatx80 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, zExp; int32_t aExp, zExp;
uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0; uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0;
uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
floatx80 z; floatx80 z;
@ -5854,10 +5854,10 @@ int floatx80_unordered_quiet(floatx80 a, floatx80 b, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float128_to_int32(float128 a, float_status *status) int32_t float128_to_int32(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
@ -5883,10 +5883,10 @@ int32 float128_to_int32(float128 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float128_to_int32_round_to_zero(float128 a, float_status *status) int32_t float128_to_int32_round_to_zero(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig0, aSig1, savedASig; uint64_t aSig0, aSig1, savedASig;
int32_t z; int32_t z;
@ -5933,10 +5933,10 @@ int32 float128_to_int32_round_to_zero(float128 a, float_status *status)
| largest integer with the same sign as `a' is returned. | largest integer with the same sign as `a' is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float128_to_int64(float128 a, float_status *status) int64_t float128_to_int64(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
@ -5976,12 +5976,12 @@ int64 float128_to_int64(float128 a, float_status *status)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int64 float128_to_int64_round_to_zero(float128 a, float_status *status) int64_t float128_to_int64_round_to_zero(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32_t aExp, shiftCount;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
int64 z; int64_t z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
@ -6039,7 +6039,7 @@ int64 float128_to_int64_round_to_zero(float128 a, float_status *status)
float32 float128_to_float32(float128 a, float_status *status) float32 float128_to_float32(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
uint32_t zSig; uint32_t zSig;
@ -6074,7 +6074,7 @@ float32 float128_to_float32(float128 a, float_status *status)
float64 float128_to_float64(float128 a, float_status *status) float64 float128_to_float64(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
@ -6107,7 +6107,7 @@ float64 float128_to_float64(float128 a, float_status *status)
floatx80 float128_to_floatx80(float128 a, float_status *status) floatx80 float128_to_floatx80(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
@ -6142,7 +6142,7 @@ floatx80 float128_to_floatx80(float128 a, float_status *status)
float128 float128_round_to_int(float128 a, float_status *status) float128 float128_round_to_int(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp; int32_t aExp;
uint64_t lastBitMask, roundBitsMask; uint64_t lastBitMask, roundBitsMask;
float128 z; float128 z;
@ -6281,9 +6281,9 @@ float128 float128_round_to_int(float128 a, float_status *status)
static float128 addFloat128Sigs(float128 a, float128 b, flag zSign, static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
float_status *status) float_status *status)
{ {
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
int32 expDiff; int32_t expDiff;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
@ -6372,9 +6372,9 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign,
static float128 subFloat128Sigs(float128 a, float128 b, flag zSign, static float128 subFloat128Sigs(float128 a, float128 b, flag zSign,
float_status *status) float_status *status)
{ {
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
int32 expDiff; int32_t expDiff;
float128 z; float128 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
@ -6503,7 +6503,7 @@ float128 float128_sub(float128 a, float128 b, float_status *status)
float128 float128_mul(float128 a, float128 b, float_status *status) float128 float128_mul(float128 a, float128 b, float_status *status)
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3;
float128 z; float128 z;
@ -6569,7 +6569,7 @@ float128 float128_mul(float128 a, float128 b, float_status *status)
float128 float128_div(float128 a, float128 b, float_status *status) float128 float128_div(float128 a, float128 b, float_status *status)
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32_t aExp, bExp, zExp;
uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
float128 z; float128 z;
@ -6659,7 +6659,7 @@ float128 float128_div(float128 a, float128 b, float_status *status)
float128 float128_rem(float128 a, float128 b, float_status *status) float128 float128_rem(float128 a, float128 b, float_status *status)
{ {
flag aSign, zSign; flag aSign, zSign;
int32 aExp, bExp, expDiff; int32_t aExp, bExp, expDiff;
uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2; uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;
uint64_t allZero, alternateASig0, alternateASig1, sigMean1; uint64_t allZero, alternateASig0, alternateASig1, sigMean1;
int64_t sigMean0; int64_t sigMean0;
@ -6769,7 +6769,7 @@ float128 float128_rem(float128 a, float128 b, float_status *status)
float128 float128_sqrt(float128 a, float_status *status) float128 float128_sqrt(float128 a, float_status *status)
{ {
flag aSign; flag aSign;
int32 aExp, zExp; int32_t aExp, zExp;
uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0; uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;
uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
float128 z; float128 z;
@ -7080,10 +7080,10 @@ float64 uint32_to_float64(uint32_t a, float_status *status)
return int64_to_float64(a, status); return int64_to_float64(a, status);
} }
uint32 float32_to_uint32(float32 a, float_status *status) uint32_t float32_to_uint32(float32 a, float_status *status)
{ {
int64_t v; int64_t v;
uint32 res; uint32_t res;
int old_exc_flags = get_float_exception_flags(status); int old_exc_flags = get_float_exception_flags(status);
v = float32_to_int64(a, status); v = float32_to_int64(a, status);
@ -7099,10 +7099,10 @@ uint32 float32_to_uint32(float32 a, float_status *status)
return res; return res;
} }
uint32 float32_to_uint32_round_to_zero(float32 a, float_status *status) uint32_t float32_to_uint32_round_to_zero(float32 a, float_status *status)
{ {
int64_t v; int64_t v;
uint32 res; uint32_t res;
int old_exc_flags = get_float_exception_flags(status); int old_exc_flags = get_float_exception_flags(status);
v = float32_to_int64_round_to_zero(a, status); v = float32_to_int64_round_to_zero(a, status);
@ -7177,10 +7177,10 @@ uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status)
return res; return res;
} }
uint32 float64_to_uint32(float64 a, float_status *status) uint32_t float64_to_uint32(float64 a, float_status *status)
{ {
uint64_t v; uint64_t v;
uint32 res; uint32_t res;
int old_exc_flags = get_float_exception_flags(status); int old_exc_flags = get_float_exception_flags(status);
v = float64_to_uint64(a, status); v = float64_to_uint64(a, status);
@ -7194,10 +7194,10 @@ uint32 float64_to_uint32(float64 a, float_status *status)
return res; return res;
} }
uint32 float64_to_uint32_round_to_zero(float64 a, float_status *status) uint32_t float64_to_uint32_round_to_zero(float64 a, float_status *status)
{ {
uint64_t v; uint64_t v;
uint32 res; uint32_t res;
int old_exc_flags = get_float_exception_flags(status); int old_exc_flags = get_float_exception_flags(status);
v = float64_to_uint64_round_to_zero(a, status); v = float64_to_uint64_round_to_zero(a, status);

2
hw/i386/pc.c
View File

@ -1454,7 +1454,7 @@ void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi,
ISADevice **rtc_state, ISADevice **rtc_state,
bool create_fdctrl, bool create_fdctrl,
bool no_vmport, bool no_vmport,
uint32 hpet_irqs) uint32_t hpet_irqs)
{ {
int i; int i;
DriveInfo *fd[MAX_FD]; DriveInfo *fd[MAX_FD];

2
hw/ipmi/isa_ipmi_bt.c
View File

@ -405,7 +405,7 @@ static void ipmi_bt_class_init(IPMIInterfaceClass *iic)
typedef struct ISAIPMIBTDevice { typedef struct ISAIPMIBTDevice {
ISADevice dev; ISADevice dev;
int32 isairq; int32_t isairq;
IPMIBT bt; IPMIBT bt;
IPMIFwInfo fwinfo; IPMIFwInfo fwinfo;
} ISAIPMIBTDevice; } ISAIPMIBTDevice;

2
hw/ipmi/isa_ipmi_kcs.c
View File

@ -368,7 +368,7 @@ static void ipmi_kcs_class_init(IPMIInterfaceClass *iic)
typedef struct ISAIPMIKCSDevice { typedef struct ISAIPMIKCSDevice {
ISADevice dev; ISADevice dev;
int32 isairq; int32_t isairq;
IPMIKCS kcs; IPMIKCS kcs;
IPMIFwInfo fwinfo; IPMIFwInfo fwinfo;
} ISAIPMIKCSDevice; } ISAIPMIKCSDevice;

2
hw/misc/imx25_ccm.c
View File

@ -249,7 +249,7 @@ static void imx25_ccm_reset(DeviceState *dev)
static uint64_t imx25_ccm_read(void *opaque, hwaddr offset, unsigned size) static uint64_t imx25_ccm_read(void *opaque, hwaddr offset, unsigned size)
{ {
uint32 value = 0; uint32_t value = 0;
IMX25CCMState *s = (IMX25CCMState *)opaque; IMX25CCMState *s = (IMX25CCMState *)opaque;
if (offset < 0x70) { if (offset < 0x70) {

2
hw/misc/imx31_ccm.c
View File

@ -261,7 +261,7 @@ static void imx31_ccm_reset(DeviceState *dev)
static uint64_t imx31_ccm_read(void *opaque, hwaddr offset, unsigned size) static uint64_t imx31_ccm_read(void *opaque, hwaddr offset, unsigned size)
{ {
uint32 value = 0; uint32_t value = 0;
IMX31CCMState *s = (IMX31CCMState *)opaque; IMX31CCMState *s = (IMX31CCMState *)opaque;
if ((offset >> 2) < IMX31_CCM_MAX_REG) { if ((offset >> 2) < IMX31_CCM_MAX_REG) {

2
hw/net/vmware_utils.h
View File

@ -49,7 +49,7 @@ vmw_shmem_rw(hwaddr addr, void *buf, int len, int is_write)
} }
static inline void static inline void
vmw_shmem_set(hwaddr addr, uint8 val, int len) vmw_shmem_set(hwaddr addr, uint8_t val, int len)
{ {
int i; int i;
VMW_SHPRN("SHMEM set: %" PRIx64 ", len: %d (value 0x%X)", addr, len, val); VMW_SHPRN("SHMEM set: %" PRIx64 ", len: %d (value 0x%X)", addr, len, val);

2
hw/net/vmxnet3.c
View File

@ -522,7 +522,7 @@ vmxnet3_dec_rx_completion_counter(VMXNET3State *s, int qidx)
vmxnet3_ring_dec(&s->rxq_descr[qidx].comp_ring); vmxnet3_ring_dec(&s->rxq_descr[qidx].comp_ring);
} }
static void vmxnet3_complete_packet(VMXNET3State *s, int qidx, uint32 tx_ridx) static void vmxnet3_complete_packet(VMXNET3State *s, int qidx, uint32_t tx_ridx)
{ {
struct Vmxnet3_TxCompDesc txcq_descr; struct Vmxnet3_TxCompDesc txcq_descr;

4
hw/ppc/spapr_events.c
View File

@ -459,7 +459,7 @@ void spapr_hotplug_req_add_by_index(sPAPRDRConnector *drc)
{ {
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
sPAPRDRConnectorType drc_type = drck->get_type(drc); sPAPRDRConnectorType drc_type = drck->get_type(drc);
uint32 index = drck->get_index(drc); uint32_t index = drck->get_index(drc);
spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX, spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX,
RTAS_LOG_V6_HP_ACTION_ADD, drc_type, index); RTAS_LOG_V6_HP_ACTION_ADD, drc_type, index);
@ -469,7 +469,7 @@ void spapr_hotplug_req_remove_by_index(sPAPRDRConnector *drc)
{ {
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc); sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
sPAPRDRConnectorType drc_type = drck->get_type(drc); sPAPRDRConnectorType drc_type = drck->get_type(drc);
uint32 index = drck->get_index(drc); uint32_t index = drck->get_index(drc);
spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX, spapr_hotplug_req_event(RTAS_LOG_V6_HP_ID_DRC_INDEX,
RTAS_LOG_V6_HP_ACTION_REMOVE, drc_type, index); RTAS_LOG_V6_HP_ACTION_REMOVE, drc_type, index);

68
include/fpu/softfloat.h
View File

@ -90,21 +90,11 @@ this code that are retained.
#include "config-host.h" #include "config-host.h"
#include "qemu/osdep.h" #include "qemu/osdep.h"
/*---------------------------------------------------------------------------- /* This 'flag' type must be able to hold at least 0 and 1. It should
| Each of the following `typedef's defines the most convenient type that holds * probably be replaced with 'bool' but the uses would need to be audited
| integers of at least as many bits as specified. For example, `uint8' should * to check that they weren't accidentally relying on it being a larger type.
| be the most convenient type that can hold unsigned integers of as many as */
| 8 bits. The `flag' type must be able to hold either a 0 or 1. For most
| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
| to the same as `int'.
*----------------------------------------------------------------------------*/
typedef uint8_t flag; typedef uint8_t flag;
typedef uint8_t uint8;
typedef int8_t int8;
typedef unsigned int uint32;
typedef signed int int32;
typedef uint64_t uint64;
typedef int64_t int64;
#define LIT64( a ) a##LL #define LIT64( a ) a##LL
@ -282,7 +272,7 @@ static inline flag get_default_nan_mode(float_status *status)
| Routine to raise any or all of the software IEC/IEEE floating-point | Routine to raise any or all of the software IEC/IEEE floating-point
| exception flags. | exception flags.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
void float_raise(int8 flags, float_status *status); void float_raise(int8_t flags, float_status *status);
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| If `a' is denormal and we are in flush-to-zero mode then set the | If `a' is denormal and we are in flush-to-zero mode then set the
@ -376,14 +366,14 @@ int_fast16_t float32_to_int16(float32, float_status *status);
uint_fast16_t float32_to_uint16(float32, float_status *status); uint_fast16_t float32_to_uint16(float32, float_status *status);
int_fast16_t float32_to_int16_round_to_zero(float32, float_status *status); int_fast16_t float32_to_int16_round_to_zero(float32, float_status *status);
uint_fast16_t float32_to_uint16_round_to_zero(float32, float_status *status); uint_fast16_t float32_to_uint16_round_to_zero(float32, float_status *status);
int32 float32_to_int32(float32, float_status *status); int32_t float32_to_int32(float32, float_status *status);
int32 float32_to_int32_round_to_zero(float32, float_status *status); int32_t float32_to_int32_round_to_zero(float32, float_status *status);
uint32 float32_to_uint32(float32, float_status *status); uint32_t float32_to_uint32(float32, float_status *status);
uint32 float32_to_uint32_round_to_zero(float32, float_status *status); uint32_t float32_to_uint32_round_to_zero(float32, float_status *status);
int64 float32_to_int64(float32, float_status *status); int64_t float32_to_int64(float32, float_status *status);
uint64 float32_to_uint64(float32, float_status *status); uint64_t float32_to_uint64(float32, float_status *status);
uint64 float32_to_uint64_round_to_zero(float32, float_status *status); uint64_t float32_to_uint64_round_to_zero(float32, float_status *status);
int64 float32_to_int64_round_to_zero(float32, float_status *status); int64_t float32_to_int64_round_to_zero(float32, float_status *status);
float64 float32_to_float64(float32, float_status *status); float64 float32_to_float64(float32, float_status *status);
floatx80 float32_to_floatx80(float32, float_status *status); floatx80 float32_to_floatx80(float32, float_status *status);
float128 float32_to_float128(float32, float_status *status); float128 float32_to_float128(float32, float_status *status);
@ -488,14 +478,14 @@ int_fast16_t float64_to_int16(float64, float_status *status);
uint_fast16_t float64_to_uint16(float64, float_status *status); uint_fast16_t float64_to_uint16(float64, float_status *status);
int_fast16_t float64_to_int16_round_to_zero(float64, float_status *status); int_fast16_t float64_to_int16_round_to_zero(float64, float_status *status);
uint_fast16_t float64_to_uint16_round_to_zero(float64, float_status *status); uint_fast16_t float64_to_uint16_round_to_zero(float64, float_status *status);
int32 float64_to_int32(float64, float_status *status); int32_t float64_to_int32(float64, float_status *status);
int32 float64_to_int32_round_to_zero(float64, float_status *status); int32_t float64_to_int32_round_to_zero(float64, float_status *status);
uint32 float64_to_uint32(float64, float_status *status); uint32_t float64_to_uint32(float64, float_status *status);
uint32 float64_to_uint32_round_to_zero(float64, float_status *status); uint32_t float64_to_uint32_round_to_zero(float64, float_status *status);
int64 float64_to_int64(float64, float_status *status); int64_t float64_to_int64(float64, float_status *status);
int64 float64_to_int64_round_to_zero(float64, float_status *status); int64_t float64_to_int64_round_to_zero(float64, float_status *status);
uint64 float64_to_uint64(float64 a, float_status *status); uint64_t float64_to_uint64(float64 a, float_status *status);
uint64 float64_to_uint64_round_to_zero(float64 a, float_status *status); uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status);
float32 float64_to_float32(float64, float_status *status); float32 float64_to_float32(float64, float_status *status);
floatx80 float64_to_floatx80(float64, float_status *status); floatx80 float64_to_floatx80(float64, float_status *status);
float128 float64_to_float128(float64, float_status *status); float128 float64_to_float128(float64, float_status *status);
@ -596,10 +586,10 @@ extern const float64 float64_default_nan;
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Software IEC/IEEE extended double-precision conversion routines. | Software IEC/IEEE extended double-precision conversion routines.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 floatx80_to_int32(floatx80, float_status *status); int32_t floatx80_to_int32(floatx80, float_status *status);
int32 floatx80_to_int32_round_to_zero(floatx80, float_status *status); int32_t floatx80_to_int32_round_to_zero(floatx80, float_status *status);
int64 floatx80_to_int64(floatx80, float_status *status); int64_t floatx80_to_int64(floatx80, float_status *status);
int64 floatx80_to_int64_round_to_zero(floatx80, float_status *status); int64_t floatx80_to_int64_round_to_zero(floatx80, float_status *status);
float32 floatx80_to_float32(floatx80, float_status *status); float32 floatx80_to_float32(floatx80, float_status *status);
float64 floatx80_to_float64(floatx80, float_status *status); float64 floatx80_to_float64(floatx80, float_status *status);
float128 floatx80_to_float128(floatx80, float_status *status); float128 floatx80_to_float128(floatx80, float_status *status);
@ -681,10 +671,10 @@ extern const floatx80 floatx80_default_nan;
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
| Software IEC/IEEE quadruple-precision conversion routines. | Software IEC/IEEE quadruple-precision conversion routines.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
int32 float128_to_int32(float128, float_status *status); int32_t float128_to_int32(float128, float_status *status);
int32 float128_to_int32_round_to_zero(float128, float_status *status); int32_t float128_to_int32_round_to_zero(float128, float_status *status);
int64 float128_to_int64(float128, float_status *status); int64_t float128_to_int64(float128, float_status *status);
int64 float128_to_int64_round_to_zero(float128, float_status *status); int64_t float128_to_int64_round_to_zero(float128, float_status *status);
float32 float128_to_float32(float128, float_status *status); float32 float128_to_float32(float128, float_status *status);
float64 float128_to_float64(float128, float_status *status); float64 float128_to_float64(float128, float_status *status);
floatx80 float128_to_floatx80(float128, float_status *status); floatx80 float128_to_floatx80(float128, float_status *status);

2
include/hw/i386/pc.h
View File

@ -258,7 +258,7 @@ void pc_basic_device_init(ISABus *isa_bus, qemu_irq *gsi,
ISADevice **rtc_state, ISADevice **rtc_state,
bool create_fdctrl, bool create_fdctrl,
bool no_vmport, bool no_vmport,
uint32 hpet_irqs); uint32_t hpet_irqs);
void pc_init_ne2k_isa(ISABus *bus, NICInfo *nd); void pc_init_ne2k_isa(ISABus *bus, NICInfo *nd);
void pc_cmos_init(PCMachineState *pcms, void pc_cmos_init(PCMachineState *pcms,
BusState *ide0, BusState *ide1, BusState *ide0, BusState *ide1,

2
migration/ram.c
View File

@ -265,7 +265,7 @@ struct DecompressParam {
QemuMutex mutex; QemuMutex mutex;
QemuCond cond; QemuCond cond;
void *des; void *des;
uint8 *compbuf; uint8_t *compbuf;
int len; int len;
}; };
typedef struct DecompressParam DecompressParam; typedef struct DecompressParam DecompressParam;

2
target-alpha/fpu_helper.c
View File

@ -437,7 +437,7 @@ uint64_t helper_cvtqs(CPUAlphaState *env, uint64_t a)
return float32_to_s(fr); return float32_to_s(fr);
} }
/* Implement float64 to uint64 conversion without saturation -- we must /* Implement float64 to uint64_t conversion without saturation -- we must
supply the truncated result. This behaviour is used by the compiler supply the truncated result. This behaviour is used by the compiler
to get unsigned conversion for free with the same instruction. */ to get unsigned conversion for free with the same instruction. */

4
target-mips/kvm.c
View File

@ -277,7 +277,7 @@ static inline int kvm_mips_get_one_reg(CPUState *cs, uint64_t reg_id,
return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg); return kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &cp0reg);
} }
static inline int kvm_mips_get_one_ulreg(CPUState *cs, uint64 reg_id, static inline int kvm_mips_get_one_ulreg(CPUState *cs, uint64_t reg_id,
target_ulong *addr) target_ulong *addr)
{ {
int ret; int ret;
@ -294,7 +294,7 @@ static inline int kvm_mips_get_one_ulreg(CPUState *cs, uint64 reg_id,
return ret; return ret;
} }
static inline int kvm_mips_get_one_reg64(CPUState *cs, uint64 reg_id, static inline int kvm_mips_get_one_reg64(CPUState *cs, uint64_t reg_id,
uint64_t *addr) uint64_t *addr)
{ {
struct kvm_one_reg cp0reg = { struct kvm_one_reg cp0reg = {

36
target-mips/msa_helper.c
View File

@ -1604,7 +1604,7 @@ static inline int get_enabled_exceptions(const CPUMIPSState *env, int c)
return c & enable; return c & enable;
} }
static inline float16 float16_from_float32(int32 a, flag ieee, static inline float16 float16_from_float32(int32_t a, flag ieee,
float_status *status) float_status *status)
{ {
float16 f_val; float16 f_val;
@ -1615,7 +1615,7 @@ static inline float16 float16_from_float32(int32 a, flag ieee,
return a < 0 ? (f_val | (1 << 15)) : f_val; return a < 0 ? (f_val | (1 << 15)) : f_val;
} }
static inline float32 float32_from_float64(int64 a, float_status *status) static inline float32 float32_from_float64(int64_t a, float_status *status)
{ {
float32 f_val; float32 f_val;
@ -1636,7 +1636,7 @@ static inline float32 float32_from_float16(int16_t a, flag ieee,
return a < 0 ? (f_val | (1 << 31)) : f_val; return a < 0 ? (f_val | (1 << 31)) : f_val;
} }
static inline float64 float64_from_float32(int32 a, float_status *status) static inline float64 float64_from_float32(int32_t a, float_status *status)
{ {
float64 f_val; float64 f_val;
@ -1657,7 +1657,7 @@ static inline float32 float32_from_q16(int16_t a, float_status *status)
return f_val; return f_val;
} }
static inline float64 float64_from_q32(int32 a, float_status *status) static inline float64 float64_from_q32(int32_t a, float_status *status)
{ {
float64 f_val; float64 f_val;
@ -1670,9 +1670,9 @@ static inline float64 float64_from_q32(int32 a, float_status *status)
static inline int16_t float32_to_q16(float32 a, float_status *status) static inline int16_t float32_to_q16(float32 a, float_status *status)
{ {
int32 q_val; int32_t q_val;
int32 q_min = 0xffff8000; int32_t q_min = 0xffff8000;
int32 q_max = 0x00007fff; int32_t q_max = 0x00007fff;
int ieee_ex; int ieee_ex;
@ -1690,7 +1690,7 @@ static inline int16_t float32_to_q16(float32 a, float_status *status)
if (ieee_ex & float_flag_overflow) { if (ieee_ex & float_flag_overflow) {
float_raise(float_flag_inexact, status); float_raise(float_flag_inexact, status);
return (int32)a < 0 ? q_min : q_max; return (int32_t)a < 0 ? q_min : q_max;
} }
/* conversion to int */ /* conversion to int */
@ -1704,7 +1704,7 @@ static inline int16_t float32_to_q16(float32 a, float_status *status)
set_float_exception_flags(ieee_ex & (~float_flag_invalid) set_float_exception_flags(ieee_ex & (~float_flag_invalid)
, status); , status);
float_raise(float_flag_overflow | float_flag_inexact, status); float_raise(float_flag_overflow | float_flag_inexact, status);
return (int32)a < 0 ? q_min : q_max; return (int32_t)a < 0 ? q_min : q_max;
} }
if (q_val < q_min) { if (q_val < q_min) {
@ -1720,11 +1720,11 @@ static inline int16_t float32_to_q16(float32 a, float_status *status)
return (int16_t)q_val; return (int16_t)q_val;
} }
static inline int32 float64_to_q32(float64 a, float_status *status) static inline int32_t float64_to_q32(float64 a, float_status *status)
{ {
int64 q_val; int64_t q_val;
int64 q_min = 0xffffffff80000000LL; int64_t q_min = 0xffffffff80000000LL;
int64 q_max = 0x000000007fffffffLL; int64_t q_max = 0x000000007fffffffLL;
int ieee_ex; int ieee_ex;
@ -1742,7 +1742,7 @@ static inline int32 float64_to_q32(float64 a, float_status *status)
if (ieee_ex & float_flag_overflow) { if (ieee_ex & float_flag_overflow) {
float_raise(float_flag_inexact, status); float_raise(float_flag_inexact, status);
return (int64)a < 0 ? q_min : q_max; return (int64_t)a < 0 ? q_min : q_max;
} }
/* conversion to integer */ /* conversion to integer */
@ -1756,20 +1756,20 @@ static inline int32 float64_to_q32(float64 a, float_status *status)
set_float_exception_flags(ieee_ex & (~float_flag_invalid) set_float_exception_flags(ieee_ex & (~float_flag_invalid)
, status); , status);
float_raise(float_flag_overflow | float_flag_inexact, status); float_raise(float_flag_overflow | float_flag_inexact, status);
return (int64)a < 0 ? q_min : q_max; return (int64_t)a < 0 ? q_min : q_max;
} }
if (q_val < q_min) { if (q_val < q_min) {
float_raise(float_flag_overflow | float_flag_inexact, status); float_raise(float_flag_overflow | float_flag_inexact, status);
return (int32)q_min; return (int32_t)q_min;
} }
if (q_max < q_val) { if (q_max < q_val) {
float_raise(float_flag_overflow | float_flag_inexact, status); float_raise(float_flag_overflow | float_flag_inexact, status);
return (int32)q_max; return (int32_t)q_max;
} }
return (int32)q_val; return (int32_t)q_val;
} }
#define MSA_FLOAT_COND(DEST, OP, ARG1, ARG2, BITS, QUIET) \ #define MSA_FLOAT_COND(DEST, OP, ARG1, ARG2, BITS, QUIET) \

2
target-s390x/kvm.c
View File

@ -1433,7 +1433,7 @@ static int kvm_s390_store_status(S390CPU *cpu, hwaddr addr, bool store_arch)
cpu_physical_memory_write(offsetof(LowCore, ar_access_id), &ar_id, 1); cpu_physical_memory_write(offsetof(LowCore, ar_access_id), &ar_id, 1);
} }
for (i = 0; i < 16; ++i) { for (i = 0; i < 16; ++i) {
*((uint64 *)mem + i) = get_freg(&cpu->env, i)->ll; *((uint64_t *)mem + i) = get_freg(&cpu->env, i)->ll;
} }
memcpy(mem + 128, &cpu->env.regs, 128); memcpy(mem + 128, &cpu->env.regs, 128);
memcpy(mem + 256, &cpu->env.psw, 16); memcpy(mem + 256, &cpu->env.psw, 16);

2
tests/vhost-user-test.c
View File

@ -439,7 +439,7 @@ static void wait_for_log_fd(TestServer *s)
g_mutex_unlock(&s->data_mutex); g_mutex_unlock(&s->data_mutex);
} }
static void write_guest_mem(TestServer *s, uint32 seed) static void write_guest_mem(TestServer *s, uint32_t seed)
{ {
uint32_t *guest_mem; uint32_t *guest_mem;
int i, j; int i, j;