[Qemu-devel] [PATCH 11/14] softfloat: Replace int32 type with int_fast32_t

[Andreas Färber]

Based on the following Coccinelle patch:

@@
typedef int32, int_fast32_t;
@@
-int32
+int_fast32_t

Add typedef for pre-10 Solaris.

Signed-off-by: Andreas Färber <address@hidden>
Cc: Ben Taylor <address@hidden>
---
 fpu/softfloat.c |  124 +++++++++++++++++++++++++++---------------------------
 fpu/softfloat.h |   25 +++++------
 osdep.h         |    1 +
 3 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index b71e47a..b7cd589 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -112,12 +112,12 @@ INLINE flag extractFloat16Sign(float16 a)
 | positive or negative integer is returned.
 *----------------------------------------------------------------------------*/
 
-static int32 roundAndPackInt32( flag zSign, uint64_t absZ STATUS_PARAM)
+static int_fast32_t roundAndPackInt32(flag zSign, uint64_t absZ STATUS_PARAM)
 {
     int_fast8_t roundingMode;
     flag roundNearestEven;
     int_fast8_t roundIncrement, roundBits;
-    int32 z;
+    int_fast32_t z;
 
     roundingMode = STATUS(float_rounding_mode);
     roundNearestEven = ( roundingMode == float_round_nearest_even );
@@ -584,7 +584,7 @@ INLINE uint64_t extractFloatx80Frac( floatx80 a )
 | value `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE int32 extractFloatx80Exp( floatx80 a )
+INLINE int_fast32_t extractFloatx80Exp(floatx80 a)
 {
 
     return a.high & 0x7FFF;
@@ -611,7 +611,7 @@ INLINE flag extractFloatx80Sign( floatx80 a )
 *----------------------------------------------------------------------------*/
 
 static void
- normalizeFloatx80Subnormal( uint64_t aSig, int32 *zExpPtr, uint64_t *zSigPtr )
+ normalizeFloatx80Subnormal(uint64_t aSig, int_fast32_t *zExpPtr, uint64_t 
*zSigPtr)
 {
     int_fast8_t shiftCount;
 
@@ -626,7 +626,7 @@ static void
 | extended double-precision floating-point value, returning the result.
 *----------------------------------------------------------------------------*/
 
-INLINE floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
+INLINE floatx80 packFloatx80(flag zSign, int_fast32_t zExp, uint64_t zSig)
 {
     floatx80 z;
 
@@ -662,7 +662,7 @@ INLINE floatx80 packFloatx80( flag zSign, int32 zExp, 
uint64_t zSig )
 
 static floatx80
  roundAndPackFloatx80(
-     int_fast8_t roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, 
uint64_t zSig1
+     int_fast8_t roundingPrecision, flag zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
  STATUS_PARAM)
 {
     int_fast8_t roundingMode;
@@ -834,7 +834,7 @@ static floatx80
 
 static floatx80
  normalizeRoundAndPackFloatx80(
-     int_fast8_t roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, 
uint64_t zSig1
+     int_fast8_t roundingPrecision, flag zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
  STATUS_PARAM)
 {
     int_fast8_t shiftCount;
@@ -881,7 +881,7 @@ INLINE uint64_t extractFloat128Frac0( float128 a )
 | `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE int32 extractFloat128Exp( float128 a )
+INLINE int_fast32_t extractFloat128Exp(float128 a)
 {
 
     return ( a.high>>48 ) & 0x7FFF;
@@ -913,7 +913,7 @@ static void
  normalizeFloat128Subnormal(
      uint64_t aSig0,
      uint64_t aSig1,
-     int32 *zExpPtr,
+     int_fast32_t *zExpPtr,
      uint64_t *zSig0Ptr,
      uint64_t *zSig1Ptr
  )
@@ -954,7 +954,7 @@ static void
 *----------------------------------------------------------------------------*/
 
 INLINE float128
- packFloat128( flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 )
+ packFloat128(flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1)
 {
     float128 z;
 
@@ -987,7 +987,7 @@ INLINE float128
 
 static float128
  roundAndPackFloat128(
-     flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1, uint64_t zSig2 
STATUS_PARAM)
+     flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1, uint64_t 
zSig2 STATUS_PARAM)
 {
     int_fast8_t roundingMode;
     flag roundNearestEven, increment, isTiny;
@@ -1091,7 +1091,7 @@ static float128
 
 static float128
  normalizeRoundAndPackFloat128(
-     flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 STATUS_PARAM)
+     flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1 
STATUS_PARAM)
 {
     int_fast8_t shiftCount;
     uint64_t zSig2;
@@ -1121,7 +1121,7 @@ static float128
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float32 int32_to_float32( int32 a STATUS_PARAM )
+float32 int32_to_float32(int_fast32_t a STATUS_PARAM)
 {
     flag zSign;
 
@@ -1138,7 +1138,7 @@ float32 int32_to_float32( int32 a STATUS_PARAM )
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float64 int32_to_float64( int32 a STATUS_PARAM )
+float64 int32_to_float64(int_fast32_t a STATUS_PARAM)
 {
     flag zSign;
     uint_fast32_t absA;
@@ -1161,7 +1161,7 @@ float64 int32_to_float64( int32 a STATUS_PARAM )
 | Arithmetic.
 *----------------------------------------------------------------------------*/
 
-floatx80 int32_to_floatx80( int32 a STATUS_PARAM )
+floatx80 int32_to_floatx80(int_fast32_t a STATUS_PARAM)
 {
     flag zSign;
     uint_fast32_t absA;
@@ -1183,7 +1183,7 @@ floatx80 int32_to_floatx80( int32 a STATUS_PARAM )
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-float128 int32_to_float128( int32 a STATUS_PARAM )
+float128 int32_to_float128(int_fast32_t a STATUS_PARAM)
 {
     flag zSign;
     uint_fast32_t absA;
@@ -1310,7 +1310,7 @@ float128 int64_to_float128( int64 a STATUS_PARAM )
     flag zSign;
     uint64 absA;
     int_fast8_t shiftCount;
-    int32 zExp;
+    int_fast32_t zExp;
     uint64_t zSig0, zSig1;
 
     if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
@@ -1342,7 +1342,7 @@ float128 int64_to_float128( int64 a STATUS_PARAM )
 | largest integer with the same sign as `a' is returned.
 *----------------------------------------------------------------------------*/
 
-int32 float32_to_int32( float32 a STATUS_PARAM )
+int_fast32_t float32_to_int32(float32 a STATUS_PARAM)
 {
     flag aSign;
     int_fast16_t aExp, shiftCount;
@@ -1373,12 +1373,12 @@ int32 float32_to_int32( float32 a STATUS_PARAM )
 | returned.
 *----------------------------------------------------------------------------*/
 
-int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
+int_fast32_t float32_to_int32_round_to_zero(float32 a STATUS_PARAM)
 {
     flag aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
-    int32 z;
+    int_fast32_t z;
     a = float32_squash_input_denormal(a STATUS_VAR);
 
     aSig = extractFloat32Frac( a );
@@ -1421,7 +1421,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a 
STATUS_PARAM)
     flag aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
-    int32 z;
+    int_fast32_t z;
 
     aSig = extractFloat32Frac( a );
     aExp = extractFloat32Exp( a );
@@ -2729,7 +2729,7 @@ int float32_unordered_quiet( float32 a, float32 b 
STATUS_PARAM )
 | largest integer with the same sign as `a' is returned.
 *----------------------------------------------------------------------------*/
 
-int32 float64_to_int32( float64 a STATUS_PARAM )
+int_fast32_t float64_to_int32(float64 a STATUS_PARAM)
 {
     flag aSign;
     int_fast16_t aExp, shiftCount;
@@ -2757,12 +2757,12 @@ int32 float64_to_int32( float64 a STATUS_PARAM )
 | returned.
 *----------------------------------------------------------------------------*/
 
-int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
+int_fast32_t float64_to_int32_round_to_zero(float64 a STATUS_PARAM)
 {
     flag aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig, savedASig;
-    int32 z;
+    int_fast32_t z;
     a = float64_squash_input_denormal(a STATUS_VAR);
 
     aSig = extractFloat64Frac( a );
@@ -2809,7 +2809,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a 
STATUS_PARAM)
     flag aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig, savedASig;
-    int32 z;
+    int_fast32_t z;
 
     aSig = extractFloat64Frac( a );
     aExp = extractFloat64Exp( a );
@@ -4216,10 +4216,10 @@ int float64_unordered_quiet( float64 a, float64 b 
STATUS_PARAM )
 | overflows, the largest integer with the same sign as `a' is returned.
 *----------------------------------------------------------------------------*/
 
-int32 floatx80_to_int32( floatx80 a STATUS_PARAM )
+int_fast32_t floatx80_to_int32(floatx80 a STATUS_PARAM)
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig;
 
     aSig = extractFloatx80Frac( a );
@@ -4243,12 +4243,12 @@ int32 floatx80_to_int32( floatx80 a STATUS_PARAM )
 | sign as `a' is returned.
 *----------------------------------------------------------------------------*/
 
-int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM )
+int_fast32_t floatx80_to_int32_round_to_zero(floatx80 a STATUS_PARAM)
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig, savedASig;
-    int32 z;
+    int_fast32_t z;
 
     aSig = extractFloatx80Frac( a );
     aExp = extractFloatx80Exp( a );
@@ -4291,7 +4291,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a 
STATUS_PARAM )
 int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig, aSigExtra;
 
     aSig = extractFloatx80Frac( a );
@@ -4331,7 +4331,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
 int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig;
     int64 z;
 
@@ -4372,7 +4372,7 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a 
STATUS_PARAM )
 float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t aSig;
 
     aSig = extractFloatx80Frac( a );
@@ -4400,7 +4400,7 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
 float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t aSig, zSig;
 
     aSig = extractFloatx80Frac( a );
@@ -4452,7 +4452,7 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
     floatx80 z;
@@ -4525,9 +4525,9 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
 
 static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign 
STATUS_PARAM)
 {
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
-    int32 expDiff;
+    int_fast32_t expDiff;
 
     aSig = extractFloatx80Frac( a );
     aExp = extractFloatx80Exp( a );
@@ -4591,9 +4591,9 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, 
flag zSign STATUS_PARAM
 
 static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign 
STATUS_PARAM )
 {
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
-    int32 expDiff;
+    int_fast32_t expDiff;
     floatx80 z;
 
     aSig = extractFloatx80Frac( a );
@@ -4700,7 +4700,7 @@ floatx80 floatx80_sub( floatx80 a, floatx80 b 
STATUS_PARAM )
 floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
 {
     flag aSign, bSign, zSign;
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
     floatx80 z;
 
@@ -4759,7 +4759,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b 
STATUS_PARAM )
 floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
 {
     flag aSign, bSign, zSign;
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
     uint64_t rem0, rem1, rem2, term0, term1, term2;
     floatx80 z;
@@ -4839,7 +4839,7 @@ floatx80 floatx80_div( floatx80 a, floatx80 b 
STATUS_PARAM )
 floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
 {
     flag aSign, zSign;
-    int32 aExp, bExp, expDiff;
+    int_fast32_t aExp, bExp, expDiff;
     uint64_t aSig0, aSig1, bSig;
     uint64_t q, term0, term1, alternateASig0, alternateASig1;
     floatx80 z;
@@ -4935,7 +4935,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b 
STATUS_PARAM )
 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, zExp;
+    int_fast32_t aExp, zExp;
     uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0;
     uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
     floatx80 z;
@@ -5243,10 +5243,10 @@ int floatx80_unordered_quiet( floatx80 a, floatx80 b 
STATUS_PARAM )
 | largest integer with the same sign as `a' is returned.
 *----------------------------------------------------------------------------*/
 
-int32 float128_to_int32( float128 a STATUS_PARAM )
+int_fast32_t float128_to_int32(float128 a STATUS_PARAM)
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
 
     aSig1 = extractFloat128Frac1( a );
@@ -5272,12 +5272,12 @@ int32 float128_to_int32( float128 a STATUS_PARAM )
 | returned.
 *----------------------------------------------------------------------------*/
 
-int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM )
+int_fast32_t float128_to_int32_round_to_zero(float128 a STATUS_PARAM)
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1, savedASig;
-    int32 z;
+    int_fast32_t z;
 
     aSig1 = extractFloat128Frac1( a );
     aSig0 = extractFloat128Frac0( a );
@@ -5323,7 +5323,7 @@ int32 float128_to_int32_round_to_zero( float128 a 
STATUS_PARAM )
 int64 float128_to_int64( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
 
     aSig1 = extractFloat128Frac1( a );
@@ -5366,7 +5366,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM )
 int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, shiftCount;
+    int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
     int64 z;
 
@@ -5424,7 +5424,7 @@ int64 float128_to_int64_round_to_zero( float128 a 
STATUS_PARAM )
 float32 float128_to_float32( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t aSig0, aSig1;
     uint32_t zSig;
 
@@ -5459,7 +5459,7 @@ float32 float128_to_float32( float128 a STATUS_PARAM )
 float64 float128_to_float64( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t aSig0, aSig1;
 
     aSig1 = extractFloat128Frac1( a );
@@ -5492,7 +5492,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM )
 floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t aSig0, aSig1;
 
     aSig1 = extractFloat128Frac1( a );
@@ -5527,7 +5527,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
 float128 float128_round_to_int( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp;
+    int_fast32_t aExp;
     uint64_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
     float128 z;
@@ -5630,9 +5630,9 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
 
 static float128 addFloat128Sigs( float128 a, float128 b, flag zSign 
STATUS_PARAM)
 {
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
-    int32 expDiff;
+    int_fast32_t expDiff;
 
     aSig1 = extractFloat128Frac1( a );
     aSig0 = extractFloat128Frac0( a );
@@ -5716,9 +5716,9 @@ static float128 addFloat128Sigs( float128 a, float128 b, 
flag zSign STATUS_PARAM
 
 static float128 subFloat128Sigs( float128 a, float128 b, flag zSign 
STATUS_PARAM)
 {
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
-    int32 expDiff;
+    int_fast32_t expDiff;
     float128 z;
 
     aSig1 = extractFloat128Frac1( a );
@@ -5841,7 +5841,7 @@ float128 float128_sub( float128 a, float128 b 
STATUS_PARAM )
 float128 float128_mul( float128 a, float128 b STATUS_PARAM )
 {
     flag aSign, bSign, zSign;
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3;
     float128 z;
 
@@ -5905,7 +5905,7 @@ float128 float128_mul( float128 a, float128 b 
STATUS_PARAM )
 float128 float128_div( float128 a, float128 b STATUS_PARAM )
 {
     flag aSign, bSign, zSign;
-    int32 aExp, bExp, zExp;
+    int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
     uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
     float128 z;
@@ -5989,7 +5989,7 @@ float128 float128_div( float128 a, float128 b 
STATUS_PARAM )
 float128 float128_rem( float128 a, float128 b STATUS_PARAM )
 {
     flag aSign, zSign;
-    int32 aExp, bExp, expDiff;
+    int_fast32_t aExp, bExp, expDiff;
     uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;
     uint64_t allZero, alternateASig0, alternateASig1, sigMean1;
     int64_t sigMean0;
@@ -6098,7 +6098,7 @@ float128 float128_rem( float128 a, float128 b 
STATUS_PARAM )
 float128 float128_sqrt( float128 a STATUS_PARAM )
 {
     flag aSign;
-    int32 aExp, zExp;
+    int_fast32_t aExp, zExp;
     uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;
     uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
     float128 z;
diff --git a/fpu/softfloat.h b/fpu/softfloat.h
index b29fd24..9987443 100644
--- a/fpu/softfloat.h
+++ b/fpu/softfloat.h
@@ -55,7 +55,6 @@ these four paragraphs for those parts of this code that are 
retained.
 | to the same as `int'.
 *----------------------------------------------------------------------------*/
 typedef uint8_t flag;
-typedef signed int int32;
 typedef uint64_t uint64;
 typedef int64_t int64;
 
@@ -220,12 +219,12 @@ enum {
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float32 int32_to_float32( int32 STATUS_PARAM );
-float64 int32_to_float64( int32 STATUS_PARAM );
+float32 int32_to_float32(int_fast32_t STATUS_PARAM);
+float64 int32_to_float64(int_fast32_t STATUS_PARAM);
 float32 uint32_to_float32(uint_fast32_t STATUS_PARAM);
 float64 uint32_to_float64(uint_fast32_t STATUS_PARAM);
-floatx80 int32_to_floatx80( int32 STATUS_PARAM );
-float128 int32_to_float128( int32 STATUS_PARAM );
+floatx80 int32_to_floatx80(int_fast32_t STATUS_PARAM);
+float128 int32_to_float128(int_fast32_t STATUS_PARAM);
 float32 int64_to_float32( int64 STATUS_PARAM );
 float32 uint64_to_float32( uint64 STATUS_PARAM );
 float64 int64_to_float64( int64 STATUS_PARAM );
@@ -256,8 +255,8 @@ extern const float16 float16_default_nan;
 *----------------------------------------------------------------------------*/
 int_fast16_t float32_to_int16_round_to_zero(float32 STATUS_PARAM);
 uint_fast16_t float32_to_uint16_round_to_zero(float32 STATUS_PARAM);
-int32 float32_to_int32( float32 STATUS_PARAM );
-int32 float32_to_int32_round_to_zero( float32 STATUS_PARAM );
+int_fast32_t float32_to_int32(float32 STATUS_PARAM);
+int_fast32_t float32_to_int32_round_to_zero(float32 STATUS_PARAM);
 uint_fast32_t float32_to_uint32(float32 STATUS_PARAM);
 uint_fast32_t float32_to_uint32_round_to_zero(float32 STATUS_PARAM);
 int64 float32_to_int64( float32 STATUS_PARAM );
@@ -360,8 +359,8 @@ extern const float32 float32_default_nan;
 *----------------------------------------------------------------------------*/
 int_fast16_t float64_to_int16_round_to_zero(float64 STATUS_PARAM);
 uint_fast16_t float64_to_uint16_round_to_zero(float64 STATUS_PARAM);
-int32 float64_to_int32( float64 STATUS_PARAM );
-int32 float64_to_int32_round_to_zero( float64 STATUS_PARAM );
+int_fast32_t float64_to_int32(float64 STATUS_PARAM);
+int_fast32_t float64_to_int32_round_to_zero(float64 STATUS_PARAM);
 uint_fast32_t float64_to_uint32(float64 STATUS_PARAM);
 uint_fast32_t float64_to_uint32_round_to_zero(float64 STATUS_PARAM);
 int64 float64_to_int64( float64 STATUS_PARAM );
@@ -464,8 +463,8 @@ extern const float64 float64_default_nan;
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE extended double-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int32 floatx80_to_int32( floatx80 STATUS_PARAM );
-int32 floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM );
+int_fast32_t floatx80_to_int32(floatx80 STATUS_PARAM);
+int_fast32_t floatx80_to_int32_round_to_zero(floatx80 STATUS_PARAM);
 int64 floatx80_to_int64( floatx80 STATUS_PARAM );
 int64 floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM );
 float32 floatx80_to_float32( floatx80 STATUS_PARAM );
@@ -549,8 +548,8 @@ extern const floatx80 floatx80_default_nan;
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE quadruple-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int32 float128_to_int32( float128 STATUS_PARAM );
-int32 float128_to_int32_round_to_zero( float128 STATUS_PARAM );
+int_fast32_t float128_to_int32(float128 STATUS_PARAM);
+int_fast32_t float128_to_int32_round_to_zero(float128 STATUS_PARAM);
 int64 float128_to_int64( float128 STATUS_PARAM );
 int64 float128_to_int64_round_to_zero( float128 STATUS_PARAM );
 float32 float128_to_float32( float128 STATUS_PARAM );
diff --git a/osdep.h b/osdep.h
index c7f3a4e..935810f 100644
--- a/osdep.h
+++ b/osdep.h
@@ -17,6 +17,7 @@ typedef unsigned int            uint_fast16_t;
 typedef unsigned int            uint_fast32_t;
 typedef signed char             int_fast8_t;
 typedef signed int              int_fast16_t;
+typedef signed int              int_fast32_t;
 #endif
 
 #ifndef glue
-- 
1.7.7