diff mbox

[v5,08/10] softfloat: Use [u]int_fast32_t consistently

Message ID 1299458053-69428-8-git-send-email-andreas.faerber@web.de
State New
Headers show

Commit Message

Andreas Färber March 7, 2011, 12:34 a.m. UTC 
v5:
* Initial.

Signed-off-by: Andreas Färber <andreas.faerber@web.de>
---
 fpu/softfloat-native.c |   42 +++++++++++++++++++++---------------------
 fpu/softfloat-native.h |   32 ++++++++++++++++----------------
 fpu/softfloat.c        |   12 ++++++------
 fpu/softfloat.h        |    4 ++--
 4 files changed, 45 insertions(+), 45 deletions(-)
diff mbox

Patch

diff --git a/fpu/softfloat-native.c b/fpu/softfloat-native.c
index 50355a4..2c08958 100644
--- a/fpu/softfloat-native.c
+++ b/fpu/softfloat-native.c
@@ -77,28 +77,28 @@  static double qemu_rint(double x)
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float32 int32_to_float32(int v STATUS_PARAM)
+float32 int32_to_float32(int_fast32_t v STATUS_PARAM)
 {
     return (float32)v;
 }
 
-float32 uint32_to_float32(unsigned int v STATUS_PARAM)
+float32 uint32_to_float32(uint_fast32_t v STATUS_PARAM)
 {
     return (float32)v;
 }
 
-float64 int32_to_float64(int v STATUS_PARAM)
+float64 int32_to_float64(int_fast32_t v STATUS_PARAM)
 {
     return (float64)v;
 }
 
-float64 uint32_to_float64(unsigned int v STATUS_PARAM)
+float64 uint32_to_float64(uint_fast32_t v STATUS_PARAM)
 {
     return (float64)v;
 }
 
 #ifdef FLOATX80
-floatx80 int32_to_floatx80(int v STATUS_PARAM)
+floatx80 int32_to_floatx80(int_fast32_t v STATUS_PARAM)
 {
     return (floatx80)v;
 }
@@ -144,13 +144,13 @@  static inline int long_to_int32(long a)
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE single-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int float32_to_int32( float32 a STATUS_PARAM)
+int_fast32_t float32_to_int32( float32 a STATUS_PARAM)
 {
     return long_to_int32(lrintf(a));
 }
-int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)
+int_fast32_t float32_to_int32_round_to_zero( float32 a STATUS_PARAM)
 {
-    return (int)a;
+    return (int32_t)a;
 }
 int64_t float32_to_int64( float32 a STATUS_PARAM)
 {
@@ -173,10 +173,10 @@  floatx80 float32_to_floatx80( float32 a STATUS_PARAM)
 }
 #endif
 
-unsigned int float32_to_uint32( float32 a STATUS_PARAM)
+uint_fast32_t float32_to_uint32( float32 a STATUS_PARAM)
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = llrintf(a);
     if (v < 0) {
@@ -188,10 +188,10 @@  unsigned int float32_to_uint32( float32 a STATUS_PARAM)
     }
     return res;
 }
-unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM)
+uint_fast32_t float32_to_uint32_round_to_zero( float32 a STATUS_PARAM)
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = (int64_t)a;
     if (v < 0) {
@@ -266,13 +266,13 @@  int float32_is_quiet_nan( float32 a1 )
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE double-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int float64_to_int32( float64 a STATUS_PARAM)
+int_fast32_t float64_to_int32( float64 a STATUS_PARAM)
 {
     return long_to_int32(lrint(a));
 }
-int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)
+int_fast32_t float64_to_int32_round_to_zero( float64 a STATUS_PARAM)
 {
-    return (int)a;
+    return (int32_t)a;
 }
 int64_t float64_to_int64( float64 a STATUS_PARAM)
 {
@@ -299,10 +299,10 @@  float128 float64_to_float128( float64 a STATUS_PARAM)
 }
 #endif
 
-unsigned int float64_to_uint32( float64 a STATUS_PARAM)
+uint_fast32_t float64_to_uint32( float64 a STATUS_PARAM)
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = llrint(a);
     if (v < 0) {
@@ -314,10 +314,10 @@  unsigned int float64_to_uint32( float64 a STATUS_PARAM)
     }
     return res;
 }
-unsigned int float64_to_uint32_round_to_zero( float64 a STATUS_PARAM)
+uint_fast32_t float64_to_uint32_round_to_zero( float64 a STATUS_PARAM)
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = (int64_t)a;
     if (v < 0) {
@@ -427,11 +427,11 @@  int float64_is_quiet_nan( float64 a1 )
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE extended double-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int floatx80_to_int32( floatx80 a STATUS_PARAM)
+int_fast32_t floatx80_to_int32( floatx80 a STATUS_PARAM)
 {
     return long_to_int32(lrintl(a));
 }
-int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)
+int_fast32_t floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)
 {
     return (int)a;
 }
diff --git a/fpu/softfloat-native.h b/fpu/softfloat-native.h
index 80b5f28..6cf5dc3 100644
--- a/fpu/softfloat-native.h
+++ b/fpu/softfloat-native.h
@@ -150,15 +150,15 @@  void set_floatx80_rounding_precision(int val STATUS_PARAM);
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float32 int32_to_float32( int STATUS_PARAM);
-float32 uint32_to_float32( unsigned int STATUS_PARAM);
-float64 int32_to_float64( int STATUS_PARAM);
-float64 uint32_to_float64( unsigned int STATUS_PARAM);
+float32 int32_to_float32( int_fast32_t STATUS_PARAM);
+float32 uint32_to_float32( uint_fast32_t STATUS_PARAM);
+float64 int32_to_float64( int_fast32_t STATUS_PARAM);
+float64 uint32_to_float64( uint_fast32_t STATUS_PARAM);
 #ifdef FLOATX80
-floatx80 int32_to_floatx80( int STATUS_PARAM);
+floatx80 int32_to_floatx80( int_fast32_t STATUS_PARAM);
 #endif
 #ifdef FLOAT128
-float128 int32_to_float128( int STATUS_PARAM);
+float128 int32_to_float128( int_fast32_t STATUS_PARAM);
 #endif
 float32 int64_to_float32( int64_t STATUS_PARAM);
 float32 uint64_to_float32( uint64_t STATUS_PARAM);
@@ -174,10 +174,10 @@  float128 int64_to_float128( int64_t STATUS_PARAM);
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE single-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int float32_to_int32( float32  STATUS_PARAM);
-int float32_to_int32_round_to_zero( float32  STATUS_PARAM);
-unsigned int float32_to_uint32( float32 a STATUS_PARAM);
-unsigned int float32_to_uint32_round_to_zero( float32 a 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 a STATUS_PARAM);
+uint_fast32_t float32_to_uint32_round_to_zero( float32 a STATUS_PARAM);
 int64_t float32_to_int64( float32  STATUS_PARAM);
 int64_t float32_to_int64_round_to_zero( float32  STATUS_PARAM);
 float64 float32_to_float64( float32  STATUS_PARAM);
@@ -279,10 +279,10 @@  INLINE float32 float32_scalbn(float32 a, int n)
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE double-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int float64_to_int32( float64 STATUS_PARAM );
-int float64_to_int32_round_to_zero( float64 STATUS_PARAM );
-unsigned int float64_to_uint32( float64 STATUS_PARAM );
-unsigned int float64_to_uint32_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_t float64_to_int64( float64 STATUS_PARAM );
 int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM );
 uint64_t float64_to_uint64( float64 STATUS_PARAM );
@@ -390,8 +390,8 @@  INLINE float64 float64_scalbn(float64 a, int n)
 /*----------------------------------------------------------------------------
 | Software IEC/IEEE extended double-precision conversion routines.
 *----------------------------------------------------------------------------*/
-int floatx80_to_int32( floatx80 STATUS_PARAM );
-int 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_t floatx80_to_int64( floatx80 STATUS_PARAM);
 int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM);
 float32 floatx80_to_float32( floatx80 STATUS_PARAM );
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index 7f0f603..d1e3a42 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -5819,20 +5819,20 @@  int float128_lt_quiet( float128 a, float128 b STATUS_PARAM )
 #endif
 
 /* misc functions */
-float32 uint32_to_float32( unsigned int a STATUS_PARAM )
+float32 uint32_to_float32( uint_fast32_t a STATUS_PARAM )
 {
     return int64_to_float32(a STATUS_VAR);
 }
 
-float64 uint32_to_float64( unsigned int a STATUS_PARAM )
+float64 uint32_to_float64( uint_fast32_t a STATUS_PARAM )
 {
     return int64_to_float64(a STATUS_VAR);
 }
 
-unsigned int float32_to_uint32( float32 a STATUS_PARAM )
+uint_fast32_t float32_to_uint32( float32 a STATUS_PARAM )
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = float32_to_int64(a STATUS_VAR);
     if (v < 0) {
@@ -5847,10 +5847,10 @@  unsigned int float32_to_uint32( float32 a STATUS_PARAM )
     return res;
 }
 
-unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM )
+uint_fast32_t float32_to_uint32_round_to_zero( float32 a STATUS_PARAM )
 {
     int64_t v;
-    unsigned int res;
+    uint_fast32_t res;
 
     v = float32_to_int64_round_to_zero(a STATUS_VAR);
     if (v < 0) {
diff --git a/fpu/softfloat.h b/fpu/softfloat.h
index 4c64d77..ce65530 100644
--- a/fpu/softfloat.h
+++ b/fpu/softfloat.h
@@ -234,8 +234,8 @@  void float_raise( int_fast8_t flags STATUS_PARAM);
 *----------------------------------------------------------------------------*/
 float32 int32_to_float32( int_fast32_t STATUS_PARAM );
 float64 int32_to_float64( int_fast32_t STATUS_PARAM );
-float32 uint32_to_float32( unsigned int STATUS_PARAM );
-float64 uint32_to_float64( unsigned int STATUS_PARAM );
+float32 uint32_to_float32( uint_fast32_t STATUS_PARAM );
+float64 uint32_to_float64( uint_fast32_t STATUS_PARAM );
 #ifdef FLOATX80
 floatx80 int32_to_floatx80( int_fast32_t STATUS_PARAM );
 #endif