qemu-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Qemu-devel] [PATCH 14/14] softfloat: Replace flag type with bool


From: Andreas Färber
Subject: [Qemu-devel] [PATCH 14/14] softfloat: Replace flag type with bool
Date: Mon, 16 Jan 2012 01:47:03 +0100

Based on the following Coccinelle patch:

@@
typedef flag, bool;
@@
-flag
+bool

Also drop the comment block now that the last typedef is removed.

Signed-off-by: Andreas Färber <address@hidden>
---
 fpu/softfloat-macros.h     |    8 +-
 fpu/softfloat-specialize.h |   54 +++++-----
 fpu/softfloat.c            |  278 ++++++++++++++++++++++----------------------
 fpu/softfloat.h            |   27 ++---
 4 files changed, 179 insertions(+), 188 deletions(-)

diff --git a/fpu/softfloat-macros.h b/fpu/softfloat-macros.h
index b82871a..fe68176 100644
--- a/fpu/softfloat-macros.h
+++ b/fpu/softfloat-macros.h
@@ -702,7 +702,7 @@ static int_fast8_t countLeadingZeros64(uint64_t a)
 | Otherwise, returns 0.
 *----------------------------------------------------------------------------*/
 
-INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
+INLINE bool eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 {
 
     return ( a0 == b0 ) && ( a1 == b1 );
@@ -715,7 +715,7 @@ INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, 
uint64_t b1 )
 | Otherwise, returns 0.
 *----------------------------------------------------------------------------*/
 
-INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
+INLINE bool le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 {
 
     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
@@ -728,7 +728,7 @@ INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, 
uint64_t b1 )
 | returns 0.
 *----------------------------------------------------------------------------*/
 
-INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
+INLINE bool lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 {
 
     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
@@ -741,7 +741,7 @@ INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, 
uint64_t b1 )
 | Otherwise, returns 0.
 *----------------------------------------------------------------------------*/
 
-INLINE flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
+INLINE bool ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 {
 
     return ( a0 != b0 ) || ( a1 != b1 );
diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
index d57af1a..6fc24cf 100644
--- a/fpu/softfloat-specialize.h
+++ b/fpu/softfloat-specialize.h
@@ -123,7 +123,7 @@ void float_raise(int_fast8_t flags STATUS_PARAM)
 | Internal canonical NaN format.
 *----------------------------------------------------------------------------*/
 typedef struct {
-    flag sign;
+    bool sign;
     uint64_t high, low;
 } commonNaNT;
 
@@ -325,8 +325,8 @@ static float32 commonNaNToFloat32( commonNaNT a 
STATUS_PARAM)
 *----------------------------------------------------------------------------*/
 
 #if defined(TARGET_ARM)
-static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
-                    flag aIsLargerSignificand)
+static int pickNaN(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool bIsSNaN,
+                    bool aIsLargerSignificand)
 {
     /* ARM mandated NaN propagation rules: take the first of:
      *  1. A if it is signaling
@@ -346,8 +346,8 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
     }
 }
 #elif defined(TARGET_MIPS)
-static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
-                    flag aIsLargerSignificand)
+static int pickNaN(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool bIsSNaN,
+                    bool aIsLargerSignificand)
 {
     /* According to MIPS specifications, if one of the two operands is
      * a sNaN, a new qNaN has to be generated. This is done in
@@ -373,8 +373,8 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
     }
 }
 #elif defined(TARGET_PPC)
-static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
-                   flag aIsLargerSignificand)
+static int pickNaN(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool bIsSNaN,
+                   bool aIsLargerSignificand)
 {
     /* PowerPC propagation rules:
      *  1. A if it sNaN or qNaN
@@ -388,8 +388,8 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
     }
 }
 #else
-static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
-                    flag aIsLargerSignificand)
+static int pickNaN(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool bIsSNaN,
+                    bool aIsLargerSignificand)
 {
     /* This implements x87 NaN propagation rules:
      * SNaN + QNaN => return the QNaN
@@ -426,8 +426,8 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
 | Return values : 0 : a; 1 : b; 2 : c; 3 : default-NaN
 *----------------------------------------------------------------------------*/
 #if defined(TARGET_ARM)
-static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag 
bIsSNaN,
-                         flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+static int pickNaNMulAdd(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool 
bIsSNaN,
+                         bool cIsQNaN, bool cIsSNaN, bool infzero STATUS_PARAM)
 {
     /* For ARM, the (inf,zero,qnan) case sets InvalidOp and returns
      * the default NaN
@@ -455,8 +455,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
     }
 }
 #elif defined(TARGET_PPC)
-static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag 
bIsSNaN,
-                         flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+static int pickNaNMulAdd(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool 
bIsSNaN,
+                         bool cIsQNaN, bool cIsSNaN, bool infzero STATUS_PARAM)
 {
     /* For PPC, the (inf,zero,qnan) case sets InvalidOp, but we prefer
      * to return an input NaN if we have one (ie c) rather than generating
@@ -482,8 +482,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
 /* A default implementation: prefer a to b to c.
  * This is unlikely to actually match any real implementation.
  */
-static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag 
bIsSNaN,
-                         flag cIsQNaN, flag cIsSNaN, flag infzero STATUS_PARAM)
+static int pickNaNMulAdd(bool aIsQNaN, bool aIsSNaN, bool bIsQNaN, bool 
bIsSNaN,
+                         bool cIsQNaN, bool cIsSNaN, bool infzero STATUS_PARAM)
 {
     if (aIsSNaN || aIsQNaN) {
         return 0;
@@ -503,8 +503,8 @@ static int pickNaNMulAdd(flag aIsQNaN, flag aIsSNaN, flag 
bIsQNaN, flag bIsSNaN,
 
 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
-    flag aIsLargerSignificand;
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
+    bool aIsLargerSignificand;
     uint32_t av, bv;
 
     aIsQuietNaN = float32_is_quiet_nan( a );
@@ -545,9 +545,9 @@ static float32 propagateFloat32NaN( float32 a, float32 b 
STATUS_PARAM)
 *----------------------------------------------------------------------------*/
 
 static float32 propagateFloat32MulAddNaN(float32 a, float32 b,
-                                         float32 c, flag infzero STATUS_PARAM)
+                                         float32 c, bool infzero STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
         cIsQuietNaN, cIsSignalingNaN;
     int which;
 
@@ -690,8 +690,8 @@ static float64 commonNaNToFloat64( commonNaNT a 
STATUS_PARAM)
 
 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
-    flag aIsLargerSignificand;
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
+    bool aIsLargerSignificand;
     uint64_t av, bv;
 
     aIsQuietNaN = float64_is_quiet_nan( a );
@@ -732,9 +732,9 @@ static float64 propagateFloat64NaN( float64 a, float64 b 
STATUS_PARAM)
 *----------------------------------------------------------------------------*/
 
 static float64 propagateFloat64MulAddNaN(float64 a, float64 b,
-                                         float64 c, flag infzero STATUS_PARAM)
+                                         float64 c, bool infzero STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
         cIsQuietNaN, cIsSignalingNaN;
     int which;
 
@@ -897,8 +897,8 @@ static floatx80 commonNaNToFloatx80( commonNaNT a 
STATUS_PARAM)
 
 static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
-    flag aIsLargerSignificand;
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
+    bool aIsLargerSignificand;
 
     aIsQuietNaN = floatx80_is_quiet_nan( a );
     aIsSignalingNaN = floatx80_is_signaling_nan( a );
@@ -1032,8 +1032,8 @@ static float128 commonNaNToFloat128( commonNaNT a 
STATUS_PARAM)
 
 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
 {
-    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
-    flag aIsLargerSignificand;
+    bool aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
+    bool aIsLargerSignificand;
 
     aIsQuietNaN = float128_is_quiet_nan( a );
     aIsSignalingNaN = float128_is_signaling_nan( a );
diff --git a/fpu/softfloat.c b/fpu/softfloat.c
index e71a3c2..d5e2f8d 100644
--- a/fpu/softfloat.c
+++ b/fpu/softfloat.c
@@ -96,7 +96,7 @@ INLINE int_fast16_t extractFloat16Exp(float16 a)
 | Returns the sign bit of the single-precision floating-point value `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE flag extractFloat16Sign(float16 a)
+INLINE bool extractFloat16Sign(float16 a)
 {
     return float16_val(a)>>15;
 }
@@ -112,10 +112,10 @@ INLINE flag extractFloat16Sign(float16 a)
 | positive or negative integer is returned.
 *----------------------------------------------------------------------------*/
 
-static int_fast32_t roundAndPackInt32(flag zSign, uint64_t absZ STATUS_PARAM)
+static int_fast32_t roundAndPackInt32(bool zSign, uint64_t absZ STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven;
+    bool roundNearestEven;
     int_fast8_t roundIncrement, roundBits;
     int_fast32_t z;
 
@@ -162,10 +162,10 @@ static int_fast32_t roundAndPackInt32(flag zSign, 
uint64_t absZ STATUS_PARAM)
 | returned.
 *----------------------------------------------------------------------------*/
 
-static int_fast64_t roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t 
absZ1 STATUS_PARAM)
+static int_fast64_t roundAndPackInt64(bool zSign, uint64_t absZ0, uint64_t 
absZ1 STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven, increment;
+    bool roundNearestEven, increment;
     int_fast64_t z;
 
     roundingMode = STATUS(float_rounding_mode);
@@ -229,7 +229,7 @@ INLINE int_fast16_t extractFloat32Exp(float32 a)
 | Returns the sign bit of the single-precision floating-point value `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE flag extractFloat32Sign( float32 a )
+INLINE bool extractFloat32Sign( float32 a )
 {
 
     return float32_val(a)>>31;
@@ -280,7 +280,7 @@ static void
 | significand.
 *----------------------------------------------------------------------------*/
 
-INLINE float32 packFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig)
+INLINE float32 packFloat32(bool zSign, int_fast16_t zExp, uint32_t zSig)
 {
 
     return make_float32(
@@ -310,12 +310,12 @@ INLINE float32 packFloat32(flag zSign, int_fast16_t zExp, 
uint32_t zSig)
 | Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float32 roundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t 
zSig STATUS_PARAM)
+static float32 roundAndPackFloat32(bool zSign, int_fast16_t zExp, uint32_t 
zSig STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven;
+    bool roundNearestEven;
     int_fast8_t roundIncrement, roundBits;
-    flag isTiny;
+    bool isTiny;
 
     roundingMode = STATUS(float_rounding_mode);
     roundNearestEven = ( roundingMode == float_round_nearest_even );
@@ -376,7 +376,7 @@ static float32 roundAndPackFloat32(flag zSign, int_fast16_t 
zExp, uint32_t zSig
 *----------------------------------------------------------------------------*/
 
 static float32
- normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig 
STATUS_PARAM)
+ normalizeRoundAndPackFloat32(bool zSign, int_fast16_t zExp, uint32_t zSig 
STATUS_PARAM)
 {
     int_fast8_t shiftCount;
 
@@ -411,7 +411,7 @@ INLINE int_fast16_t extractFloat64Exp(float64 a)
 | Returns the sign bit of the double-precision floating-point value `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE flag extractFloat64Sign( float64 a )
+INLINE bool extractFloat64Sign( float64 a )
 {
 
     return float64_val(a)>>63;
@@ -462,7 +462,7 @@ static void
 | significand.
 *----------------------------------------------------------------------------*/
 
-INLINE float64 packFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig)
+INLINE float64 packFloat64(bool zSign, int_fast16_t zExp, uint64_t zSig)
 {
 
     return make_float64(
@@ -492,12 +492,12 @@ INLINE float64 packFloat64(flag zSign, int_fast16_t zExp, 
uint64_t zSig)
 | Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float64 roundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t 
zSig STATUS_PARAM)
+static float64 roundAndPackFloat64(bool zSign, int_fast16_t zExp, uint64_t 
zSig STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven;
+    bool roundNearestEven;
     int_fast16_t roundIncrement, roundBits;
-    flag isTiny;
+    bool isTiny;
 
     roundingMode = STATUS(float_rounding_mode);
     roundNearestEven = ( roundingMode == float_round_nearest_even );
@@ -558,7 +558,7 @@ static float64 roundAndPackFloat64(flag zSign, int_fast16_t 
zExp, uint64_t zSig
 *----------------------------------------------------------------------------*/
 
 static float64
- normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig 
STATUS_PARAM)
+ normalizeRoundAndPackFloat64(bool zSign, int_fast16_t zExp, uint64_t zSig 
STATUS_PARAM)
 {
     int_fast8_t shiftCount;
 
@@ -596,7 +596,7 @@ INLINE int_fast32_t extractFloatx80Exp(floatx80 a)
 | `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE flag extractFloatx80Sign( floatx80 a )
+INLINE bool extractFloatx80Sign( floatx80 a )
 {
 
     return a.high>>15;
@@ -626,7 +626,7 @@ static void
 | extended double-precision floating-point value, returning the result.
 *----------------------------------------------------------------------------*/
 
-INLINE floatx80 packFloatx80(flag zSign, int_fast32_t zExp, uint64_t zSig)
+INLINE floatx80 packFloatx80(bool zSign, int_fast32_t zExp, uint64_t zSig)
 {
     floatx80 z;
 
@@ -662,11 +662,11 @@ INLINE floatx80 packFloatx80(flag zSign, int_fast32_t 
zExp, uint64_t zSig)
 
 static floatx80
  roundAndPackFloatx80(
-     int_fast8_t roundingPrecision, flag zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
+     int_fast8_t roundingPrecision, bool zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
  STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven, increment, isTiny;
+    bool roundNearestEven, increment, isTiny;
     int_fast64_t roundIncrement, roundMask, roundBits;
 
     roundingMode = STATUS(float_rounding_mode);
@@ -834,7 +834,7 @@ static floatx80
 
 static floatx80
  normalizeRoundAndPackFloatx80(
-     int_fast8_t roundingPrecision, flag zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
+     int_fast8_t roundingPrecision, bool zSign, int_fast32_t zExp, uint64_t 
zSig0, uint64_t zSig1
  STATUS_PARAM)
 {
     int_fast8_t shiftCount;
@@ -892,7 +892,7 @@ INLINE int_fast32_t extractFloat128Exp(float128 a)
 | Returns the sign bit of the quadruple-precision floating-point value `a'.
 *----------------------------------------------------------------------------*/
 
-INLINE flag extractFloat128Sign( float128 a )
+INLINE bool extractFloat128Sign(float128 a)
 {
 
     return a.high>>63;
@@ -954,7 +954,7 @@ static void
 *----------------------------------------------------------------------------*/
 
 INLINE float128
- packFloat128(flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1)
+ packFloat128(bool zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1)
 {
     float128 z;
 
@@ -987,10 +987,10 @@ INLINE float128
 
 static float128
  roundAndPackFloat128(
-     flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1, uint64_t 
zSig2 STATUS_PARAM)
+     bool zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1, uint64_t 
zSig2 STATUS_PARAM)
 {
     int_fast8_t roundingMode;
-    flag roundNearestEven, increment, isTiny;
+    bool roundNearestEven, increment, isTiny;
 
     roundingMode = STATUS(float_rounding_mode);
     roundNearestEven = ( roundingMode == float_round_nearest_even );
@@ -1091,7 +1091,7 @@ static float128
 
 static float128
  normalizeRoundAndPackFloat128(
-     flag zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1 
STATUS_PARAM)
+     bool zSign, int_fast32_t zExp, uint64_t zSig0, uint64_t zSig1 
STATUS_PARAM)
 {
     int_fast8_t shiftCount;
     uint64_t zSig2;
@@ -1123,7 +1123,7 @@ static float128
 
 float32 int32_to_float32(int_fast32_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
 
     if ( a == 0 ) return float32_zero;
     if ( a == (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
@@ -1140,7 +1140,7 @@ float32 int32_to_float32(int_fast32_t a STATUS_PARAM)
 
 float64 int32_to_float64(int_fast32_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast32_t absA;
     int_fast8_t shiftCount;
     uint64_t zSig;
@@ -1163,7 +1163,7 @@ float64 int32_to_float64(int_fast32_t a STATUS_PARAM)
 
 floatx80 int32_to_floatx80(int_fast32_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast32_t absA;
     int_fast8_t shiftCount;
     uint64_t zSig;
@@ -1185,7 +1185,7 @@ floatx80 int32_to_floatx80(int_fast32_t a STATUS_PARAM)
 
 float128 int32_to_float128(int_fast32_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast32_t absA;
     int_fast8_t shiftCount;
     uint64_t zSig0;
@@ -1207,7 +1207,7 @@ float128 int32_to_float128(int_fast32_t a STATUS_PARAM)
 
 float32 int64_to_float32(int_fast64_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast64_t absA;
     int_fast8_t shiftCount;
 
@@ -1260,7 +1260,7 @@ float32 uint64_to_float32(uint_fast64_t a STATUS_PARAM)
 
 float64 int64_to_float64(int_fast64_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
 
     if ( a == 0 ) return float64_zero;
     if ( a == (int64_t) LIT64( 0x8000000000000000 ) ) {
@@ -1287,7 +1287,7 @@ float64 uint64_to_float64(uint_fast64_t a STATUS_PARAM)
 
 floatx80 int64_to_floatx80(int_fast64_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast64_t absA;
     int_fast8_t shiftCount;
 
@@ -1307,7 +1307,7 @@ floatx80 int64_to_floatx80(int_fast64_t a STATUS_PARAM)
 
 float128 int64_to_float128(int_fast64_t a STATUS_PARAM)
 {
-    flag zSign;
+    bool zSign;
     uint_fast64_t absA;
     int_fast8_t shiftCount;
     int_fast32_t zExp;
@@ -1344,7 +1344,7 @@ float128 int64_to_float128(int_fast64_t a STATUS_PARAM)
 
 int_fast32_t float32_to_int32(float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
     uint64_t aSig64;
@@ -1375,7 +1375,7 @@ int_fast32_t float32_to_int32(float32 a STATUS_PARAM)
 
 int_fast32_t float32_to_int32_round_to_zero(float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
     int_fast32_t z;
@@ -1418,7 +1418,7 @@ int_fast32_t float32_to_int32_round_to_zero(float32 a 
STATUS_PARAM)
 
 int_fast16_t float32_to_int16_round_to_zero(float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
     int_fast32_t z;
@@ -1467,7 +1467,7 @@ int_fast16_t float32_to_int16_round_to_zero(float32 a 
STATUS_PARAM)
 
 int_fast64_t float32_to_int64(float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
     uint64_t aSig64, aSigExtra;
@@ -1504,7 +1504,7 @@ int_fast64_t float32_to_int64(float32 a STATUS_PARAM)
 
 int_fast64_t float32_to_int64_round_to_zero(float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint32_t aSig;
     uint64_t aSig64;
@@ -1548,7 +1548,7 @@ int_fast64_t float32_to_int64_round_to_zero(float32 a 
STATUS_PARAM)
 
 float64 float32_to_float64( float32 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
     a = float32_squash_input_denormal(a STATUS_VAR);
@@ -1578,7 +1578,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM )
 
 floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
 
@@ -1608,7 +1608,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
 
 float128 float32_to_float128( float32 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
 
@@ -1638,7 +1638,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM )
 
 float32 float32_round_to_int( float32 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
@@ -1697,7 +1697,7 @@ float32 float32_round_to_int( float32 a STATUS_PARAM)
 | Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
+static float32 addFloat32Sigs(float32 a, float32 b, bool zSign STATUS_PARAM)
 {
     int_fast16_t aExp, bExp, zExp;
     uint32_t aSig, bSig, zSig;
@@ -1776,7 +1776,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag 
zSign STATUS_PARAM)
 | Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
+static float32 subFloat32Sigs(float32 a, float32 b, bool zSign STATUS_PARAM)
 {
     int_fast16_t aExp, bExp, zExp;
     uint32_t aSig, bSig, zSig;
@@ -1851,7 +1851,7 @@ static float32 subFloat32Sigs( float32 a, float32 b, flag 
zSign STATUS_PARAM)
 
 float32 float32_add( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
 
@@ -1874,7 +1874,7 @@ float32 float32_add( float32 a, float32 b STATUS_PARAM )
 
 float32 float32_sub( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
 
@@ -1897,7 +1897,7 @@ float32 float32_sub( float32 a, float32 b STATUS_PARAM )
 
 float32 float32_mul( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast16_t aExp, bExp, zExp;
     uint32_t aSig, bSig;
     uint64_t zSig64;
@@ -1960,7 +1960,7 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM )
 
 float32 float32_div( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast16_t aExp, bExp, zExp;
     uint32_t aSig, bSig, zSig;
     a = float32_squash_input_denormal(a STATUS_VAR);
@@ -2024,7 +2024,7 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM )
 
 float32 float32_rem( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast16_t aExp, bExp, expDiff;
     uint32_t aSig, bSig;
     uint32_t q;
@@ -2130,14 +2130,14 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
 
 float32 float32_muladd(float32 a, float32 b, float32 c, int flags STATUS_PARAM)
 {
-    flag aSign, bSign, cSign, zSign;
+    bool aSign, bSign, cSign, zSign;
     int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
     uint32_t aSig, bSig, cSig;
-    flag pInf, pZero, pSign;
+    bool pInf, pZero, pSign;
     uint64_t pSig64, cSig64, zSig64;
     uint32_t pSig;
     int shiftcount;
-    flag signflip, infzero;
+    bool signflip, infzero;
 
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
@@ -2332,7 +2332,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, 
int flags STATUS_PARAM)
 
 float32 float32_sqrt( float32 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, zExp;
     uint32_t aSig, zSig;
     uint64_t rem, term;
@@ -2418,7 +2418,7 @@ static const float64 float32_exp2_coefficients[15] =
 
 float32 float32_exp2( float32 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
     float64 r, x, xn;
@@ -2466,7 +2466,7 @@ float32 float32_exp2( float32 a STATUS_PARAM )
 *----------------------------------------------------------------------------*/
 float32 float32_log2( float32 a STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast16_t aExp;
     uint32_t aSig, zSig, i;
 
@@ -2540,7 +2540,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM )
 
 int float32_le( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint32_t av, bv;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
@@ -2569,7 +2569,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM )
 
 int float32_lt( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint32_t av, bv;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
@@ -2643,7 +2643,7 @@ int float32_eq_quiet( float32 a, float32 b STATUS_PARAM )
 
 int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint32_t av, bv;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
@@ -2674,7 +2674,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
 
 int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint32_t av, bv;
     a = float32_squash_input_denormal(a STATUS_VAR);
     b = float32_squash_input_denormal(b STATUS_VAR);
@@ -2731,7 +2731,7 @@ int float32_unordered_quiet( float32 a, float32 b 
STATUS_PARAM )
 
 int_fast32_t float64_to_int32(float64 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig;
     a = float64_squash_input_denormal(a STATUS_VAR);
@@ -2759,7 +2759,7 @@ int_fast32_t float64_to_int32(float64 a STATUS_PARAM)
 
 int_fast32_t float64_to_int32_round_to_zero(float64 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig, savedASig;
     int_fast32_t z;
@@ -2806,7 +2806,7 @@ int_fast32_t float64_to_int32_round_to_zero(float64 a 
STATUS_PARAM)
 
 int_fast16_t float64_to_int16_round_to_zero(float64 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig, savedASig;
     int_fast32_t z;
@@ -2857,7 +2857,7 @@ int_fast16_t float64_to_int16_round_to_zero(float64 a 
STATUS_PARAM)
 
 int_fast64_t float64_to_int64(float64 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig, aSigExtra;
     a = float64_squash_input_denormal(a STATUS_VAR);
@@ -2900,7 +2900,7 @@ int_fast64_t float64_to_int64(float64 a STATUS_PARAM)
 
 int_fast64_t float64_to_int64_round_to_zero(float64 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, shiftCount;
     uint64_t aSig;
     int_fast64_t z;
@@ -2950,7 +2950,7 @@ int_fast64_t float64_to_int64_round_to_zero(float64 a 
STATUS_PARAM)
 
 float32 float64_to_float32( float64 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint64_t aSig;
     uint32_t zSig;
@@ -2984,7 +2984,7 @@ float32 float64_to_float32( float64 a STATUS_PARAM )
 | than the desired result exponent whenever `zSig' is a complete, normalized
 | significand.
 *----------------------------------------------------------------------------*/
-static float16 packFloat16(flag zSign, int_fast16_t zExp, uint16_t zSig)
+static float16 packFloat16(bool zSign, int_fast16_t zExp, uint16_t zSig)
 {
     return make_float16(
         (((uint32_t)zSign) << 15) + (((uint32_t)zExp) << 10) + zSig);
@@ -2993,9 +2993,9 @@ static float16 packFloat16(flag zSign, int_fast16_t zExp, 
uint16_t zSig)
 /* Half precision floats come in two formats: standard IEEE and "ARM" format.
    The latter gains extra exponent range by omitting the NaN/Inf encodings.  */
 
-float32 float16_to_float32(float16 a, flag ieee STATUS_PARAM)
+float32 float16_to_float32(float16 a, bool ieee STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
 
@@ -3023,9 +3023,9 @@ float32 float16_to_float32(float16 a, flag ieee 
STATUS_PARAM)
     return packFloat32( aSign, aExp + 0x70, aSig << 13);
 }
 
-float16 float32_to_float16(float32 a, flag ieee STATUS_PARAM)
+float16 float32_to_float16(float32 a, bool ieee STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint32_t aSig;
     uint32_t mask;
@@ -3126,7 +3126,7 @@ float16 float32_to_float16(float32 a, flag ieee 
STATUS_PARAM)
 
 floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint64_t aSig;
 
@@ -3157,7 +3157,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
 
 float128 float64_to_float128( float64 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint64_t aSig, zSig0, zSig1;
 
@@ -3188,7 +3188,7 @@ float128 float64_to_float128( float64 a STATUS_PARAM )
 
 float64 float64_round_to_int( float64 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint64_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
@@ -3260,7 +3260,7 @@ float64 float64_trunc_to_int( float64 a STATUS_PARAM)
 | Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
+static float64 addFloat64Sigs(float64 a, float64 b, bool zSign STATUS_PARAM)
 {
     int_fast16_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig;
@@ -3339,7 +3339,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag 
zSign STATUS_PARAM )
 | Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
+static float64 subFloat64Sigs(float64 a, float64 b, bool zSign STATUS_PARAM)
 {
     int_fast16_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig;
@@ -3414,7 +3414,7 @@ static float64 subFloat64Sigs( float64 a, float64 b, flag 
zSign STATUS_PARAM )
 
 float64 float64_add( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
 
@@ -3437,7 +3437,7 @@ float64 float64_add( float64 a, float64 b STATUS_PARAM )
 
 float64 float64_sub( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
 
@@ -3460,7 +3460,7 @@ float64 float64_sub( float64 a, float64 b STATUS_PARAM )
 
 float64 float64_mul( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast16_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
 
@@ -3521,7 +3521,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM )
 
 float64 float64_div( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast16_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig;
     uint64_t rem0, rem1;
@@ -3593,7 +3593,7 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM )
 
 float64 float64_rem( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast16_t aExp, bExp, expDiff;
     uint64_t aSig, bSig;
     uint64_t q, alternateASig;
@@ -3684,13 +3684,13 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM )
 
 float64 float64_muladd(float64 a, float64 b, float64 c, int flags STATUS_PARAM)
 {
-    flag aSign, bSign, cSign, zSign;
+    bool aSign, bSign, cSign, zSign;
     int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
     uint64_t aSig, bSig, cSig;
-    flag pInf, pZero, pSign;
+    bool pInf, pZero, pSign;
     uint64_t pSig0, pSig1, cSig0, cSig1, zSig0, zSig1;
     int shiftcount;
-    flag signflip, infzero;
+    bool signflip, infzero;
 
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
@@ -3899,7 +3899,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, 
int flags STATUS_PARAM)
 
 float64 float64_sqrt( float64 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp, zExp;
     uint64_t aSig, zSig, doubleZSig;
     uint64_t rem0, rem1, term0, term1;
@@ -3950,7 +3950,7 @@ float64 float64_sqrt( float64 a STATUS_PARAM )
 *----------------------------------------------------------------------------*/
 float64 float64_log2( float64 a STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast16_t aExp;
     uint64_t aSig, aSig0, aSig1, zSig, i;
     a = float64_squash_input_denormal(a STATUS_VAR);
@@ -4024,7 +4024,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
 
 int float64_le( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint64_t av, bv;
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
@@ -4053,7 +4053,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM )
 
 int float64_lt( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint64_t av, bv;
 
     a = float64_squash_input_denormal(a STATUS_VAR);
@@ -4130,7 +4130,7 @@ int float64_eq_quiet( float64 a, float64 b STATUS_PARAM )
 
 int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint64_t av, bv;
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
@@ -4161,7 +4161,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
 
 int float64_lt_quiet( float64 a, float64 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
     uint64_t av, bv;
     a = float64_squash_input_denormal(a STATUS_VAR);
     b = float64_squash_input_denormal(b STATUS_VAR);
@@ -4218,7 +4218,7 @@ int float64_unordered_quiet( float64 a, float64 b 
STATUS_PARAM )
 
 int_fast32_t floatx80_to_int32(floatx80 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig;
 
@@ -4245,7 +4245,7 @@ int_fast32_t floatx80_to_int32(floatx80 a STATUS_PARAM)
 
 int_fast32_t floatx80_to_int32_round_to_zero(floatx80 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig, savedASig;
     int_fast32_t z;
@@ -4290,7 +4290,7 @@ int_fast32_t floatx80_to_int32_round_to_zero(floatx80 a 
STATUS_PARAM)
 
 int_fast64_t floatx80_to_int64(floatx80 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig, aSigExtra;
 
@@ -4330,7 +4330,7 @@ int_fast64_t floatx80_to_int64(floatx80 a STATUS_PARAM)
 
 int_fast64_t floatx80_to_int64_round_to_zero(floatx80 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig;
     int_fast64_t z;
@@ -4371,7 +4371,7 @@ int_fast64_t floatx80_to_int64_round_to_zero(floatx80 a 
STATUS_PARAM)
 
 float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t aSig;
 
@@ -4399,7 +4399,7 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
 
 float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t aSig, zSig;
 
@@ -4427,7 +4427,7 @@ float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
 
 float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast16_t aExp;
     uint64_t aSig, zSig0, zSig1;
 
@@ -4451,7 +4451,7 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
 
 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
@@ -4523,7 +4523,7 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
 | Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign 
STATUS_PARAM)
+static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, bool zSign 
STATUS_PARAM)
 {
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
@@ -4589,7 +4589,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, 
flag zSign STATUS_PARAM
 | Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign 
STATUS_PARAM )
+static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, bool zSign 
STATUS_PARAM)
 {
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
@@ -4657,7 +4657,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, 
flag zSign STATUS_PARAM
 
 floatx80 floatx80_add( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     aSign = extractFloatx80Sign( a );
     bSign = extractFloatx80Sign( b );
@@ -4678,7 +4678,7 @@ floatx80 floatx80_add( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 floatx80 floatx80_sub( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     aSign = extractFloatx80Sign( a );
     bSign = extractFloatx80Sign( b );
@@ -4699,7 +4699,7 @@ floatx80 floatx80_sub( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
     floatx80 z;
@@ -4758,7 +4758,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig, bSig, zSig0, zSig1;
     uint64_t rem0, rem1, rem2, term0, term1, term2;
@@ -4838,7 +4838,7 @@ floatx80 floatx80_div( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast32_t aExp, bExp, expDiff;
     uint64_t aSig0, aSig1, bSig;
     uint64_t q, term0, term1, alternateASig0, alternateASig1;
@@ -4934,7 +4934,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, zExp;
     uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0;
     uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
@@ -5033,7 +5033,7 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
 
 int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
               && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5066,7 +5066,7 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
 
 int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
               && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5148,7 +5148,7 @@ int floatx80_eq_quiet( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
               && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5184,7 +5184,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
               && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
@@ -5245,7 +5245,7 @@ int floatx80_unordered_quiet( floatx80 a, floatx80 b 
STATUS_PARAM )
 
 int_fast32_t float128_to_int32(float128 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
 
@@ -5274,7 +5274,7 @@ int_fast32_t float128_to_int32(float128 a STATUS_PARAM)
 
 int_fast32_t float128_to_int32_round_to_zero(float128 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1, savedASig;
     int_fast32_t z;
@@ -5322,7 +5322,7 @@ int_fast32_t float128_to_int32_round_to_zero(float128 a 
STATUS_PARAM)
 
 int_fast64_t float128_to_int64(float128 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
 
@@ -5365,7 +5365,7 @@ int_fast64_t float128_to_int64(float128 a STATUS_PARAM)
 
 int_fast64_t float128_to_int64_round_to_zero(float128 a STATUS_PARAM)
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, shiftCount;
     uint64_t aSig0, aSig1;
     int_fast64_t z;
@@ -5423,7 +5423,7 @@ int_fast64_t float128_to_int64_round_to_zero(float128 a 
STATUS_PARAM)
 
 float32 float128_to_float32( float128 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t aSig0, aSig1;
     uint32_t zSig;
@@ -5458,7 +5458,7 @@ float32 float128_to_float32( float128 a STATUS_PARAM )
 
 float64 float128_to_float64( float128 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t aSig0, aSig1;
 
@@ -5491,7 +5491,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM )
 
 floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t aSig0, aSig1;
 
@@ -5526,7 +5526,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
 
 float128 float128_round_to_int( float128 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp;
     uint64_t lastBitMask, roundBitsMask;
     int_fast8_t roundingMode;
@@ -5628,7 +5628,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
 | Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float128 addFloat128Sigs( float128 a, float128 b, flag zSign 
STATUS_PARAM)
+static float128 addFloat128Sigs(float128 a, float128 b, bool zSign 
STATUS_PARAM)
 {
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
@@ -5714,7 +5714,7 @@ static float128 addFloat128Sigs( float128 a, float128 b, 
flag zSign STATUS_PARAM
 | Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*/
 
-static float128 subFloat128Sigs( float128 a, float128 b, flag zSign 
STATUS_PARAM)
+static float128 subFloat128Sigs(float128 a, float128 b, bool zSign 
STATUS_PARAM)
 {
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
@@ -5798,7 +5798,7 @@ static float128 subFloat128Sigs( float128 a, float128 b, 
flag zSign STATUS_PARAM
 
 float128 float128_add( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     aSign = extractFloat128Sign( a );
     bSign = extractFloat128Sign( b );
@@ -5819,7 +5819,7 @@ float128 float128_add( float128 a, float128 b 
STATUS_PARAM )
 
 float128 float128_sub( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     aSign = extractFloat128Sign( a );
     bSign = extractFloat128Sign( b );
@@ -5840,7 +5840,7 @@ float128 float128_sub( float128 a, float128 b 
STATUS_PARAM )
 
 float128 float128_mul( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     int_fast32_t aExp, bExp, zExp;
     uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3;
     float128 z;
@@ -5904,7 +5904,7 @@ float128 float128_mul( float128 a, float128 b 
STATUS_PARAM )
 
 float128 float128_div( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign, zSign;
+    bool aSign, bSign, zSign;
     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;
@@ -5988,7 +5988,7 @@ float128 float128_div( float128 a, float128 b 
STATUS_PARAM )
 
 float128 float128_rem( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, zSign;
+    bool aSign, zSign;
     int_fast32_t aExp, bExp, expDiff;
     uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;
     uint64_t allZero, alternateASig0, alternateASig1, sigMean1;
@@ -6097,7 +6097,7 @@ float128 float128_rem( float128 a, float128 b 
STATUS_PARAM )
 
 float128 float128_sqrt( float128 a STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int_fast32_t aExp, zExp;
     uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;
     uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
@@ -6194,7 +6194,7 @@ int float128_eq( float128 a, float128 b STATUS_PARAM )
 
 int float128_le( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6227,7 +6227,7 @@ int float128_le( float128 a, float128 b STATUS_PARAM )
 
 int float128_lt( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6310,7 +6310,7 @@ int float128_eq_quiet( float128 a, float128 b 
STATUS_PARAM )
 
 int float128_le_quiet( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6346,7 +6346,7 @@ int float128_le_quiet( float128 a, float128 b 
STATUS_PARAM )
 
 int float128_lt_quiet( float128 a, float128 b STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
@@ -6542,7 +6542,7 @@ uint64_t float64_to_uint64_round_to_zero (float64 a 
STATUS_PARAM)
 INLINE int float ## s ## _compare_internal( float ## s a, float ## s b,      \
                                       int is_quiet STATUS_PARAM )            \
 {                                                                            \
-    flag aSign, bSign;                                                       \
+    bool aSign, bSign;                                                       \
     uint ## s ## _t av, bv;                                                  \
     a = float ## s ## _squash_input_denormal(a STATUS_VAR);                  \
     b = float ## s ## _squash_input_denormal(b STATUS_VAR);                  \
@@ -6594,7 +6594,7 @@ COMPARE(64, 0x7ff)
 INLINE int floatx80_compare_internal( floatx80 a, floatx80 b,
                                       int is_quiet STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (( ( extractFloatx80Exp( a ) == 0x7fff ) &&
           ( extractFloatx80Frac( a )<<1 ) ) ||
@@ -6640,7 +6640,7 @@ int floatx80_compare_quiet( floatx80 a, floatx80 b 
STATUS_PARAM )
 INLINE int float128_compare_internal( float128 a, float128 b,
                                       int is_quiet STATUS_PARAM )
 {
-    flag aSign, bSign;
+    bool aSign, bSign;
 
     if (( ( extractFloat128Exp( a ) == 0x7fff ) &&
           ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) ) ||
@@ -6689,7 +6689,7 @@ int float128_compare_quiet( float128 a, float128 b 
STATUS_PARAM )
 INLINE float ## s float ## s ## _minmax(float ## s a, float ## s b,     \
                                         int ismin STATUS_PARAM )        \
 {                                                                       \
-    flag aSign, bSign;                                                  \
+    bool aSign, bSign;                                                  \
     uint ## s ## _t av, bv;                                             \
     a = float ## s ## _squash_input_denormal(a STATUS_VAR);             \
     b = float ## s ## _squash_input_denormal(b STATUS_VAR);             \
@@ -6733,7 +6733,7 @@ MINMAX(64, 0x7ff)
 /* Multiply A by 2 raised to the power N.  */
 float32 float32_scalbn( float32 a, int n STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int16_t aExp;
     uint32_t aSig;
 
@@ -6766,7 +6766,7 @@ float32 float32_scalbn( float32 a, int n STATUS_PARAM )
 
 float64 float64_scalbn( float64 a, int n STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int16_t aExp;
     uint64_t aSig;
 
@@ -6799,7 +6799,7 @@ float64 float64_scalbn( float64 a, int n STATUS_PARAM )
 
 floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int32_t aExp;
     uint64_t aSig;
 
@@ -6830,7 +6830,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM )
 
 float128 float128_scalbn( float128 a, int n STATUS_PARAM )
 {
-    flag aSign;
+    bool aSign;
     int32_t aExp;
     uint64_t aSig0, aSig1;
 
diff --git a/fpu/softfloat.h b/fpu/softfloat.h
index 0c43436..257733d 100644
--- a/fpu/softfloat.h
+++ b/fpu/softfloat.h
@@ -43,19 +43,10 @@ these four paragraphs for those parts of this code that are 
retained.
 #endif
 
 #include <inttypes.h>
+#include <stdbool.h>
 #include "config-host.h"
 #include "osdep.h"
 
-/*----------------------------------------------------------------------------
-| Each of the following `typedef's defines the most convenient type that holds
-| integers of at least as many bits as specified.  For example, `uint8' should
-| 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;
-
 #define LIT64( a ) a##LL
 #define INLINE static inline
 
@@ -166,10 +157,10 @@ typedef struct float_status {
     signed char float_exception_flags;
     signed char floatx80_rounding_precision;
     /* should denormalised results go to zero and set the inexact flag? */
-    flag flush_to_zero;
+    bool flush_to_zero;
     /* should denormalised inputs go to zero and set the input_denormal flag? 
*/
-    flag flush_inputs_to_zero;
-    flag default_nan_mode;
+    bool flush_inputs_to_zero;
+    bool default_nan_mode;
 } float_status;
 
 void set_float_rounding_mode(int val STATUS_PARAM);
@@ -178,15 +169,15 @@ INLINE void set_float_detect_tininess(int val 
STATUS_PARAM)
 {
     STATUS(float_detect_tininess) = val;
 }
-INLINE void set_flush_to_zero(flag val STATUS_PARAM)
+INLINE void set_flush_to_zero(bool val STATUS_PARAM)
 {
     STATUS(flush_to_zero) = val;
 }
-INLINE void set_flush_inputs_to_zero(flag val STATUS_PARAM)
+INLINE void set_flush_inputs_to_zero(bool val STATUS_PARAM)
 {
     STATUS(flush_inputs_to_zero) = val;
 }
-INLINE void set_default_nan_mode(flag val STATUS_PARAM)
+INLINE void set_default_nan_mode(bool val STATUS_PARAM)
 {
     STATUS(default_nan_mode) = val;
 }
@@ -233,8 +224,8 @@ float128 int64_to_float128(int_fast64_t STATUS_PARAM);
 /*----------------------------------------------------------------------------
 | Software half-precision conversion routines.
 *----------------------------------------------------------------------------*/
-float16 float32_to_float16( float32, flag STATUS_PARAM );
-float32 float16_to_float32( float16, flag STATUS_PARAM );
+float16 float32_to_float16(float32, bool STATUS_PARAM);
+float32 float16_to_float32(float16, bool STATUS_PARAM);
 
 /*----------------------------------------------------------------------------
 | Software half-precision operations.
-- 
1.7.7




reply via email to

[Prev in Thread] Current Thread [Next in Thread]