Received: from [140.186.70.92] (port=59930 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1PaCj9-0001Lt-Io for qemu-devel@nongnu.org; Tue, 04 Jan 2011 14:39:35 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1PaCj2-0004oB-Jg for qemu-devel@nongnu.org; Tue, 04 Jan 2011 14:39:27 -0500 Received: from fmmailgate01.web.de ([217.72.192.221]:44814) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1PaCiz-0004nX-2S for qemu-devel@nongnu.org; Tue, 04 Jan 2011 14:39:20 -0500 From: =?UTF-8?q?Andreas=20F=C3=A4rber?= Date: Tue, 4 Jan 2011 20:39:09 +0100 Message-Id: <1294169951-5153-3-git-send-email-andreas.faerber@web.de> In-Reply-To: <1294169951-5153-2-git-send-email-andreas.faerber@web.de> References: <1294169951-5153-1-git-send-email-andreas.faerber@web.de> <1294169951-5153-2-git-send-email-andreas.faerber@web.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: andreas.faerber@web.de Content-Transfer-Encoding: quoted-printable Subject: [Qemu-devel] [PATCH v4 3/5] softfloat: Drop [s]bits{8, 16, 32, 64} types in favor of [u]int{8, 16, 32, 64}_t List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Peter Maydell , =?UTF-8?q?Andreas=20F=C3=A4rber?= , Aurelien Jarno They are defined with the same semantics as the POSIX types, so prefer those for consistency. Suggested by Peter Maydell. v4: * Rebased. v3: * Initial. Cc: Peter Maydell Cc: Aurelien Jarno Signed-off-by: Andreas F=C3=A4rber --- fpu/softfloat-macros.h | 182 +++++++------- fpu/softfloat-native.c | 6 +- fpu/softfloat-specialize.h | 58 +++--- fpu/softfloat.c | 588 ++++++++++++++++++++++----------------= ------ fpu/softfloat.h | 19 +-- 5 files changed, 419 insertions(+), 434 deletions(-) diff --git a/fpu/softfloat-macros.h b/fpu/softfloat-macros.h index 54c0bad..3128e60 100644 --- a/fpu/softfloat-macros.h +++ b/fpu/softfloat-macros.h @@ -44,9 +44,9 @@ these four paragraphs for those parts of this code that= are retained. | The result is stored in the location pointed to by `zPtr'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr ) +INLINE void shift32RightJamming( uint32_t a, int16 count, uint32_t *zPtr= ) { - bits32 z; + uint32_t z; =20 if ( count =3D=3D 0 ) { z =3D a; @@ -70,9 +70,9 @@ INLINE void shift32RightJamming( bits32 a, int16 count,= bits32 *zPtr ) | The result is stored in the location pointed to by `zPtr'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr ) +INLINE void shift64RightJamming( uint64_t a, int16 count, uint64_t *zPtr= ) { - bits64 z; + uint64_t z; =20 if ( count =3D=3D 0 ) { z =3D a; @@ -106,9 +106,9 @@ INLINE void shift64RightJamming( bits64 a, int16 coun= t, bits64 *zPtr ) =20 INLINE void shift64ExtraRightJamming( - bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) + uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z= 1Ptr ) { - bits64 z0, z1; + uint64_t z0, z1; int8 negCount =3D ( - count ) & 63; =20 if ( count =3D=3D 0 ) { @@ -143,9 +143,9 @@ INLINE void =20 INLINE void shift128Right( - bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) + uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z= 1Ptr ) { - bits64 z0, z1; + uint64_t z0, z1; int8 negCount =3D ( - count ) & 63; =20 if ( count =3D=3D 0 ) { @@ -178,9 +178,9 @@ INLINE void =20 INLINE void shift128RightJamming( - bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) + uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z= 1Ptr ) { - bits64 z0, z1; + uint64_t z0, z1; int8 negCount =3D ( - count ) & 63; =20 if ( count =3D=3D 0 ) { @@ -229,16 +229,16 @@ INLINE void =20 INLINE void shift128ExtraRightJamming( - bits64 a0, - bits64 a1, - bits64 a2, + uint64_t a0, + uint64_t a1, + uint64_t a2, int16 count, - bits64 *z0Ptr, - bits64 *z1Ptr, - bits64 *z2Ptr + uint64_t *z0Ptr, + uint64_t *z1Ptr, + uint64_t *z2Ptr ) { - bits64 z0, z1, z2; + uint64_t z0, z1, z2; int8 negCount =3D ( - count ) & 63; =20 if ( count =3D=3D 0 ) { @@ -287,7 +287,7 @@ INLINE void =20 INLINE void shortShift128Left( - bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) + uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z= 1Ptr ) { =20 *z1Ptr =3D a1<>32; bLow =3D b; bHigh =3D b>>32; - z1 =3D ( (bits64) aLow ) * bLow; - zMiddleA =3D ( (bits64) aLow ) * bHigh; - zMiddleB =3D ( (bits64) aHigh ) * bLow; - z0 =3D ( (bits64) aHigh ) * bHigh; + z1 =3D ( (uint64_t) aLow ) * bLow; + zMiddleA =3D ( (uint64_t) aLow ) * bHigh; + zMiddleB =3D ( (uint64_t) aHigh ) * bLow; + z0 =3D ( (uint64_t) aHigh ) * bHigh; zMiddleA +=3D zMiddleB; - z0 +=3D ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>3= 2 ); + z0 +=3D ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>= >32 ); zMiddleA <<=3D 32; z1 +=3D zMiddleA; z0 +=3D ( z1 < zMiddleA ); @@ -483,15 +483,15 @@ INLINE void mul64To128( bits64 a, bits64 b, bits64 = *z0Ptr, bits64 *z1Ptr ) =20 INLINE void mul128By64To192( - bits64 a0, - bits64 a1, - bits64 b, - bits64 *z0Ptr, - bits64 *z1Ptr, - bits64 *z2Ptr + uint64_t a0, + uint64_t a1, + uint64_t b, + uint64_t *z0Ptr, + uint64_t *z1Ptr, + uint64_t *z2Ptr ) { - bits64 z0, z1, z2, more1; + uint64_t z0, z1, z2, more1; =20 mul64To128( a1, b, &z1, &z2 ); mul64To128( a0, b, &z0, &more1 ); @@ -511,18 +511,18 @@ INLINE void =20 INLINE void mul128To256( - bits64 a0, - bits64 a1, - bits64 b0, - bits64 b1, - bits64 *z0Ptr, - bits64 *z1Ptr, - bits64 *z2Ptr, - bits64 *z3Ptr + uint64_t a0, + uint64_t a1, + uint64_t b0, + uint64_t b1, + uint64_t *z0Ptr, + uint64_t *z1Ptr, + uint64_t *z2Ptr, + uint64_t *z3Ptr ) { - bits64 z0, z1, z2, z3; - bits64 more1, more2; + uint64_t z0, z1, z2, z3; + uint64_t more1, more2; =20 mul64To128( a1, b1, &z2, &z3 ); mul64To128( a1, b0, &z1, &more2 ); @@ -548,18 +548,18 @@ INLINE void | unsigned integer is returned. *-----------------------------------------------------------------------= -----*/ =20 -static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b ) +static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b= ) { - bits64 b0, b1; - bits64 rem0, rem1, term0, term1; - bits64 z; + uint64_t b0, b1; + uint64_t rem0, rem1, term0, term1; + uint64_t z; =20 if ( b <=3D a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF ); b0 =3D b>>32; z =3D ( b0<<32 <=3D a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )= <<32; mul64To128( b, z, &term0, &term1 ); sub128( a0, a1, term0, term1, &rem0, &rem1 ); - while ( ( (sbits64) rem0 ) < 0 ) { + while ( ( (int64_t) rem0 ) < 0 ) { z -=3D LIT64( 0x100000000 ); b1 =3D b<<32; add128( rem0, rem1, b0, b1, &rem0, &rem1 ); @@ -580,18 +580,18 @@ static bits64 estimateDiv128To64( bits64 a0, bits64= a1, bits64 b ) | value. *-----------------------------------------------------------------------= -----*/ =20 -static bits32 estimateSqrt32( int16 aExp, bits32 a ) +static uint32_t estimateSqrt32( int16 aExp, uint32_t a ) { - static const bits16 sqrtOddAdjustments[] =3D { + static const uint16_t sqrtOddAdjustments[] =3D { 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 }; - static const bits16 sqrtEvenAdjustments[] =3D { + static const uint16_t sqrtEvenAdjustments[] =3D { 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 }; int8 index; - bits32 z; + uint32_t z; =20 index =3D ( a>>27 ) & 15; if ( aExp & 1 ) { @@ -603,9 +603,9 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a ) z =3D 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ]; z =3D a / z + z; z =3D ( 0x20000 <=3D z ) ? 0xFFFF8000 : ( z<<15 ); - if ( z <=3D a ) return (bits32) ( ( (sbits32) a )>>1 ); + if ( z <=3D a ) return (uint32_t) ( ( (int32_t) a )>>1 ); } - return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 ); + return ( (uint32_t) ( ( ( (uint64_t) a )<<31 ) / z ) ) + ( z>>1 ); =20 } =20 @@ -614,7 +614,7 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a ) | `a'. If `a' is zero, 32 is returned. *-----------------------------------------------------------------------= -----*/ =20 -static int8 countLeadingZeros32( bits32 a ) +static int8 countLeadingZeros32( uint32_t a ) { static const int8 countLeadingZerosHigh[] =3D { 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, @@ -655,12 +655,12 @@ static int8 countLeadingZeros32( bits32 a ) | `a'. If `a' is zero, 64 is returned. *-----------------------------------------------------------------------= -----*/ =20 -static int8 countLeadingZeros64( bits64 a ) +static int8 countLeadingZeros64( uint64_t a ) { int8 shiftCount; =20 shiftCount =3D 0; - if ( a < ( (bits64) 1 )<<32 ) { + if ( a < ( (uint64_t) 1 )<<32 ) { shiftCount +=3D 32; } else { @@ -677,7 +677,7 @@ static int8 countLeadingZeros64( bits64 a ) | Otherwise, returns 0. *-----------------------------------------------------------------------= -----*/ =20 -INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) +INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 ) { =20 return ( a0 =3D=3D b0 ) && ( a1 =3D=3D b1 ); @@ -690,7 +690,7 @@ INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, b= its64 b1 ) | Otherwise, returns 0. *-----------------------------------------------------------------------= -----*/ =20 -INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) +INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 ) { =20 return ( a0 < b0 ) || ( ( a0 =3D=3D b0 ) && ( a1 <=3D b1 ) ); @@ -703,7 +703,7 @@ INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, b= its64 b1 ) | returns 0. *-----------------------------------------------------------------------= -----*/ =20 -INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) +INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 ) { =20 return ( a0 < b0 ) || ( ( a0 =3D=3D b0 ) && ( a1 < b1 ) ); @@ -716,7 +716,7 @@ INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, b= its64 b1 ) | Otherwise, returns 0. *-----------------------------------------------------------------------= -----*/ =20 -INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) +INLINE flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 ) { =20 return ( a0 !=3D b0 ) || ( a1 !=3D b1 ); diff --git a/fpu/softfloat-native.c b/fpu/softfloat-native.c index 008bb53..50355a4 100644 --- a/fpu/softfloat-native.c +++ b/fpu/softfloat-native.c @@ -418,7 +418,7 @@ int float64_is_quiet_nan( float64 a1 ) u.f =3D a1; a =3D u.i; =20 - return ( LIT64( 0xFFF0000000000000 ) < (bits64) ( a<<1 ) ); + return ( LIT64( 0xFFF0000000000000 ) < (uint64_t) ( a<<1 ) ); =20 } =20 @@ -500,7 +500,7 @@ int floatx80_is_signaling_nan( floatx80 a1) aLow =3D u.i.low & ~ LIT64( 0x4000000000000000 ); return ( ( u.i.high & 0x7FFF ) =3D=3D 0x7FFF ) - && (bits64) ( aLow<<1 ) + && (uint64_t) ( aLow<<1 ) && ( u.i.low =3D=3D aLow ); } =20 @@ -508,7 +508,7 @@ int floatx80_is_quiet_nan( floatx80 a1 ) { floatx80u u; u.f =3D a1; - return ( ( u.i.high & 0x7FFF ) =3D=3D 0x7FFF ) && (bits64) ( u.i.low= <<1 ); + return ( ( u.i.high & 0x7FFF ) =3D=3D 0x7FFF ) && (uint64_t) ( u.i.l= ow<<1 ); } =20 #endif diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h index 2915418..9b182e6 100644 --- a/fpu/softfloat-specialize.h +++ b/fpu/softfloat-specialize.h @@ -58,7 +58,7 @@ void float_raise( int8 flags STATUS_PARAM ) *-----------------------------------------------------------------------= -----*/ typedef struct { flag sign; - bits64 high, low; + uint64_t high, low; } commonNaNT; =20 /*----------------------------------------------------------------------= ------ @@ -87,7 +87,7 @@ int float32_is_quiet_nan( float32 a_ ) #if SNAN_BIT_IS_ONE return ( ( ( a>>22 ) & 0x1FF ) =3D=3D 0x1FE ) && ( a & 0x003FFFFF ); #else - return ( 0xFF800000 <=3D (bits32) ( a<<1 ) ); + return ( 0xFF800000 <=3D (uint32_t) ( a<<1 ) ); #endif } =20 @@ -100,7 +100,7 @@ int float32_is_signaling_nan( float32 a_ ) { uint32_t a =3D float32_val(a_); #if SNAN_BIT_IS_ONE - return ( 0xFF800000 <=3D (bits32) ( a<<1 ) ); + return ( 0xFF800000 <=3D (uint32_t) ( a<<1 ) ); #else return ( ( ( a>>22 ) & 0x1FF ) =3D=3D 0x1FE ) && ( a & 0x003FFFFF ); #endif @@ -138,7 +138,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATU= S_PARAM ) if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid= STATUS_VAR ); z.sign =3D float32_val(a)>>31; z.low =3D 0; - z.high =3D ( (bits64) float32_val(a) )<<41; + z.high =3D ( (uint64_t) float32_val(a) )<<41; return z; } =20 @@ -149,10 +149,10 @@ static commonNaNT float32ToCommonNaN( float32 a STA= TUS_PARAM ) =20 static float32 commonNaNToFloat32( commonNaNT a ) { - bits32 mantissa =3D a.high>>41; + uint32_t mantissa =3D a.high>>41; if ( mantissa ) return make_float32( - ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) ); + ( ( (uint32_t) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) = ); else return float32_default_nan; } @@ -235,7 +235,7 @@ static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag b= IsQNaN, flag bIsSNaN, static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) { flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN, aIsLargerSign= ificand; - bits32 av, bv, res; + uint32_t av, bv, res; =20 if ( STATUS(default_nan_mode) ) return float32_default_nan; @@ -255,9 +255,9 @@ static float32 propagateFloat32NaN( float32 a, float3= 2 b STATUS_PARAM) #endif if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_inv= alid STATUS_VAR); =20 - if ((bits32)(av<<1) < (bits32)(bv<<1)) { + if ((uint32_t)(av<<1) < (uint32_t)(bv<<1)) { aIsLargerSignificand =3D 0; - } else if ((bits32)(bv<<1) < (bits32)(av<<1)) { + } else if ((uint32_t)(bv<<1) < (uint32_t)(av<<1)) { aIsLargerSignificand =3D 1; } else { aIsLargerSignificand =3D (av < bv) ? 1 : 0; @@ -295,13 +295,13 @@ static float32 propagateFloat32NaN( float32 a, floa= t32 b STATUS_PARAM) =20 int float64_is_quiet_nan( float64 a_ ) { - bits64 a =3D float64_val(a_); + uint64_t a =3D float64_val(a_); #if SNAN_BIT_IS_ONE return ( ( ( a>>51 ) & 0xFFF ) =3D=3D 0xFFE ) && ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); #else - return ( LIT64( 0xFFF0000000000000 ) <=3D (bits64) ( a<<1 ) ); + return ( LIT64( 0xFFF0000000000000 ) <=3D (uint64_t) ( a<<1 ) ); #endif } =20 @@ -312,9 +312,9 @@ int float64_is_quiet_nan( float64 a_ ) =20 int float64_is_signaling_nan( float64 a_ ) { - bits64 a =3D float64_val(a_); + uint64_t a =3D float64_val(a_); #if SNAN_BIT_IS_ONE - return ( LIT64( 0xFFF0000000000000 ) <=3D (bits64) ( a<<1 ) ); + return ( LIT64( 0xFFF0000000000000 ) <=3D (uint64_t) ( a<<1 ) ); #else return ( ( ( a>>51 ) & 0xFFF ) =3D=3D 0xFFE ) @@ -330,7 +330,7 @@ int float64_is_signaling_nan( float64 a_ ) float64 float64_maybe_silence_nan( float64 a_ ) { if (float64_is_signaling_nan(a_)) { - bits64 a =3D float64_val(a_); + uint64_t a =3D float64_val(a_); #if SNAN_BIT_IS_ONE a &=3D ~LIT64( 0x0008000000000000 ); #else @@ -365,11 +365,11 @@ static commonNaNT float64ToCommonNaN( float64 a STA= TUS_PARAM) =20 static float64 commonNaNToFloat64( commonNaNT a ) { - bits64 mantissa =3D a.high>>12; + uint64_t mantissa =3D a.high>>12; =20 if ( mantissa ) return make_float64( - ( ( (bits64) a.sign )<<63 ) + ( ( (uint64_t) a.sign )<<63 ) | LIT64( 0x7FF0000000000000 ) | ( a.high>>12 )); else @@ -385,7 +385,7 @@ static float64 commonNaNToFloat64( commonNaNT a ) static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) { flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN, aIsLargerSign= ificand; - bits64 av, bv, res; + uint64_t av, bv, res; =20 if ( STATUS(default_nan_mode) ) return float64_default_nan; @@ -405,9 +405,9 @@ static float64 propagateFloat64NaN( float64 a, float6= 4 b STATUS_PARAM) #endif if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_inv= alid STATUS_VAR); =20 - if ((bits64)(av<<1) < (bits64)(bv<<1)) { + if ((uint64_t)(av<<1) < (uint64_t)(bv<<1)) { aIsLargerSignificand =3D 0; - } else if ((bits64)(bv<<1) < (bits64)(av<<1)) { + } else if ((uint64_t)(bv<<1) < (uint64_t)(av<<1)) { aIsLargerSignificand =3D 1; } else { aIsLargerSignificand =3D (av < bv) ? 1 : 0; @@ -446,15 +446,15 @@ static float64 propagateFloat64NaN( float64 a, floa= t64 b STATUS_PARAM) int floatx80_is_quiet_nan( floatx80 a ) { #if SNAN_BIT_IS_ONE - bits64 aLow; + uint64_t aLow; =20 aLow =3D a.low & ~ LIT64( 0x4000000000000000 ); return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) - && (bits64) ( aLow<<1 ) + && (uint64_t) ( aLow<<1 ) && ( a.low =3D=3D aLow ); #else - return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) && (bits64) ( a.low<<1 = ); + return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) && (uint64_t) ( a.low<<= 1 ); #endif } =20 @@ -466,14 +466,14 @@ int floatx80_is_quiet_nan( floatx80 a ) int floatx80_is_signaling_nan( floatx80 a ) { #if SNAN_BIT_IS_ONE - return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) && (bits64) ( a.low<<1 = ); + return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) && (uint64_t) ( a.low<<= 1 ); #else - bits64 aLow; + uint64_t aLow; =20 aLow =3D a.low & ~ LIT64( 0x4000000000000000 ); return ( ( a.high & 0x7FFF ) =3D=3D 0x7FFF ) - && (bits64) ( aLow<<1 ) + && (uint64_t) ( aLow<<1 ) && ( a.low =3D=3D aLow ); #endif } @@ -508,7 +508,7 @@ static floatx80 commonNaNToFloatx80( commonNaNT a ) z.low =3D a.high; else z.low =3D floatx80_default_nan_low; - z.high =3D ( ( (bits16) a.sign )<<15 ) | 0x7FFF; + z.high =3D ( ( (uint16_t) a.sign )<<15 ) | 0x7FFF; return z; } =20 @@ -586,7 +586,7 @@ int float128_is_quiet_nan( float128 a ) && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); #else return - ( LIT64( 0xFFFE000000000000 ) <=3D (bits64) ( a.high<<1 ) ) + ( LIT64( 0xFFFE000000000000 ) <=3D (uint64_t) ( a.high<<1 ) ) && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); #endif } @@ -600,7 +600,7 @@ int float128_is_signaling_nan( float128 a ) { #if SNAN_BIT_IS_ONE return - ( LIT64( 0xFFFE000000000000 ) <=3D (bits64) ( a.high<<1 ) ) + ( LIT64( 0xFFFE000000000000 ) <=3D (uint64_t) ( a.high<<1 ) ) && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); #else return @@ -635,7 +635,7 @@ static float128 commonNaNToFloat128( commonNaNT a ) float128 z; =20 shift128Right( a.high, a.low, 16, &z.high, &z.low ); - z.high |=3D ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 = ); + z.high |=3D ( ( (uint64_t) a.sign )<<63 ) | LIT64( 0x7FFF00000000000= 0 ); return z; } =20 diff --git a/fpu/softfloat.c b/fpu/softfloat.c index 01de8f1..547c698 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -84,7 +84,7 @@ void set_floatx80_rounding_precision(int val STATUS_PAR= AM) | positive or negative integer is returned. *-----------------------------------------------------------------------= -----*/ =20 -static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM) +static int32 roundAndPackInt32( flag zSign, uint64_t absZ STATUS_PARAM) { int8 roundingMode; flag roundNearestEven; @@ -115,7 +115,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 ab= sZ STATUS_PARAM) if ( zSign ) z =3D - z; if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) { float_raise( float_flag_invalid STATUS_VAR); - return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; + return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( roundBits ) STATUS(float_exception_flags) |=3D float_flag_inexa= ct; return z; @@ -134,7 +134,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 ab= sZ STATUS_PARAM) | returned. *-----------------------------------------------------------------------= -----*/ =20 -static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 S= TATUS_PARAM) +static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t abs= Z1 STATUS_PARAM) { int8 roundingMode; flag roundNearestEven, increment; @@ -142,7 +142,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 ab= sZ0, bits64 absZ1 STATUS_PA =20 roundingMode =3D STATUS(float_rounding_mode); roundNearestEven =3D ( roundingMode =3D=3D float_round_nearest_even = ); - increment =3D ( (sbits64) absZ1 < 0 ); + increment =3D ( (int64_t) absZ1 < 0 ); if ( ! roundNearestEven ) { if ( roundingMode =3D=3D float_round_to_zero ) { increment =3D 0; @@ -159,7 +159,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 ab= sZ0, bits64 absZ1 STATUS_PA if ( increment ) { ++absZ0; if ( absZ0 =3D=3D 0 ) goto overflow; - absZ0 &=3D ~ ( ( (bits64) ( absZ1<<1 ) =3D=3D 0 ) & roundNearest= Even ); + absZ0 &=3D ~ ( ( (uint64_t) ( absZ1<<1 ) =3D=3D 0 ) & roundNeare= stEven ); } z =3D absZ0; if ( zSign ) z =3D - z; @@ -167,7 +167,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 ab= sZ0, bits64 absZ1 STATUS_PA overflow: float_raise( float_flag_invalid STATUS_VAR); return - zSign ? (sbits64) LIT64( 0x8000000000000000 ) + zSign ? (int64_t) LIT64( 0x8000000000000000 ) : LIT64( 0x7FFFFFFFFFFFFFFF ); } if ( absZ1 ) STATUS(float_exception_flags) |=3D float_flag_inexact; @@ -179,7 +179,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 ab= sZ0, bits64 absZ1 STATUS_PA | Returns the fraction bits of the single-precision floating-point value= `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits32 extractFloat32Frac( float32 a ) +INLINE uint32_t extractFloat32Frac( float32 a ) { =20 return float32_val(a) & 0x007FFFFF; @@ -216,7 +216,7 @@ INLINE flag extractFloat32Sign( float32 a ) *-----------------------------------------------------------------------= -----*/ =20 static void - normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr= ) + normalizeFloat32Subnormal( uint32_t aSig, int16 *zExpPtr, uint32_t *zSi= gPtr ) { int8 shiftCount; =20 @@ -237,11 +237,11 @@ static void | significand. *-----------------------------------------------------------------------= -----*/ =20 -INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig ) +INLINE float32 packFloat32( flag zSign, int16 zExp, uint32_t zSig ) { =20 return make_float32( - ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig)= ; + ( ( (uint32_t) zSign )<<31 ) + ( ( (uint32_t) zExp )<<23 ) + z= Sig); =20 } =20 @@ -267,7 +267,7 @@ INLINE float32 packFloat32( flag zSign, int16 zExp, b= its32 zSig ) | Binary Floating-Point Arithmetic. *-----------------------------------------------------------------------= -----*/ =20 -static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig = STATUS_PARAM) +static float32 roundAndPackFloat32( flag zSign, int16 zExp, uint32_t zSi= g STATUS_PARAM) { int8 roundingMode; flag roundNearestEven; @@ -292,10 +292,10 @@ static float32 roundAndPackFloat32( flag zSign, int= 16 zExp, bits32 zSig STATUS_P } } roundBits =3D zSig & 0x7F; - if ( 0xFD <=3D (bits16) zExp ) { + if ( 0xFD <=3D (uint16_t) zExp ) { if ( ( 0xFD < zExp ) || ( ( zExp =3D=3D 0xFD ) - && ( (sbits32) ( zSig + roundIncrement ) < 0 ) ) + && ( (int32_t) ( zSig + roundIncrement ) < 0 ) ) ) { float_raise( float_flag_overflow | float_flag_inexact STATUS= _VAR); return packFloat32( zSign, 0xFF, - ( roundIncrement =3D=3D 0= )); @@ -330,7 +330,7 @@ static float32 roundAndPackFloat32( flag zSign, int16= zExp, bits32 zSig STATUS_P *-----------------------------------------------------------------------= -----*/ =20 static float32 - normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATU= S_PARAM) + normalizeRoundAndPackFloat32( flag zSign, int16 zExp, uint32_t zSig STA= TUS_PARAM) { int8 shiftCount; =20 @@ -343,7 +343,7 @@ static float32 | Returns the fraction bits of the double-precision floating-point value= `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloat64Frac( float64 a ) +INLINE uint64_t extractFloat64Frac( float64 a ) { =20 return float64_val(a) & LIT64( 0x000FFFFFFFFFFFFF ); @@ -380,7 +380,7 @@ INLINE flag extractFloat64Sign( float64 a ) *-----------------------------------------------------------------------= -----*/ =20 static void - normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr= ) + normalizeFloat64Subnormal( uint64_t aSig, int16 *zExpPtr, uint64_t *zSi= gPtr ) { int8 shiftCount; =20 @@ -401,11 +401,11 @@ static void | significand. *-----------------------------------------------------------------------= -----*/ =20 -INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig ) +INLINE float64 packFloat64( flag zSign, int16 zExp, uint64_t zSig ) { =20 return make_float64( - ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig); + ( ( (uint64_t) zSign )<<63 ) + ( ( (uint64_t) zExp )<<52 ) + zSi= g); =20 } =20 @@ -431,7 +431,7 @@ INLINE float64 packFloat64( flag zSign, int16 zExp, b= its64 zSig ) | Binary Floating-Point Arithmetic. *-----------------------------------------------------------------------= -----*/ =20 -static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig = STATUS_PARAM) +static float64 roundAndPackFloat64( flag zSign, int16 zExp, uint64_t zSi= g STATUS_PARAM) { int8 roundingMode; flag roundNearestEven; @@ -456,10 +456,10 @@ static float64 roundAndPackFloat64( flag zSign, int= 16 zExp, bits64 zSig STATUS_P } } roundBits =3D zSig & 0x3FF; - if ( 0x7FD <=3D (bits16) zExp ) { + if ( 0x7FD <=3D (uint16_t) zExp ) { if ( ( 0x7FD < zExp ) || ( ( zExp =3D=3D 0x7FD ) - && ( (sbits64) ( zSig + roundIncrement ) < 0 ) ) + && ( (int64_t) ( zSig + roundIncrement ) < 0 ) ) ) { float_raise( float_flag_overflow | float_flag_inexact STATUS= _VAR); return packFloat64( zSign, 0x7FF, - ( roundIncrement =3D=3D = 0 )); @@ -494,7 +494,7 @@ static float64 roundAndPackFloat64( flag zSign, int16= zExp, bits64 zSig STATUS_P *-----------------------------------------------------------------------= -----*/ =20 static float64 - normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATU= S_PARAM) + normalizeRoundAndPackFloat64( flag zSign, int16 zExp, uint64_t zSig STA= TUS_PARAM) { int8 shiftCount; =20 @@ -510,7 +510,7 @@ static float64 | value `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloatx80Frac( floatx80 a ) +INLINE uint64_t extractFloatx80Frac( floatx80 a ) { =20 return a.low; @@ -549,7 +549,7 @@ INLINE flag extractFloatx80Sign( floatx80 a ) *-----------------------------------------------------------------------= -----*/ =20 static void - normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPt= r ) + normalizeFloatx80Subnormal( uint64_t aSig, int32 *zExpPtr, uint64_t *zS= igPtr ) { int8 shiftCount; =20 @@ -564,12 +564,12 @@ static void | extended double-precision floating-point value, returning the result. *-----------------------------------------------------------------------= -----*/ =20 -INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig ) +INLINE floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig ) { floatx80 z; =20 z.low =3D zSig; - z.high =3D ( ( (bits16) zSign )<<15 ) + zExp; + z.high =3D ( ( (uint16_t) zSign )<<15 ) + zExp; return z; =20 } @@ -600,7 +600,7 @@ INLINE floatx80 packFloatx80( flag zSign, int32 zExp,= bits64 zSig ) =20 static floatx80 roundAndPackFloatx80( - int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits6= 4 zSig1 + int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uin= t64_t zSig1 STATUS_PARAM) { int8 roundingMode; @@ -637,7 +637,7 @@ static floatx80 } } roundBits =3D zSig0 & roundMask; - if ( 0x7FFD <=3D (bits32) ( zExp - 1 ) ) { + if ( 0x7FFD <=3D (uint32_t) ( zExp - 1 ) ) { if ( ( 0x7FFE < zExp ) || ( ( zExp =3D=3D 0x7FFE ) && ( zSig0 + roundIncrement < z= Sig0 ) ) ) { @@ -655,7 +655,7 @@ static floatx80 if ( isTiny && roundBits ) float_raise( float_flag_underflow= STATUS_VAR); if ( roundBits ) STATUS(float_exception_flags) |=3D float_fl= ag_inexact; zSig0 +=3D roundIncrement; - if ( (sbits64) zSig0 < 0 ) zExp =3D 1; + if ( (int64_t) zSig0 < 0 ) zExp =3D 1; roundIncrement =3D roundMask + 1; if ( roundNearestEven && ( roundBits<<1 =3D=3D roundIncremen= t ) ) { roundMask |=3D roundIncrement; @@ -678,7 +678,7 @@ static floatx80 if ( zSig0 =3D=3D 0 ) zExp =3D 0; return packFloatx80( zSign, zExp, zSig0 ); precision80: - increment =3D ( (sbits64) zSig1 < 0 ); + increment =3D ( (int64_t) zSig1 < 0 ); if ( ! roundNearestEven ) { if ( roundingMode =3D=3D float_round_to_zero ) { increment =3D 0; @@ -692,7 +692,7 @@ static floatx80 } } } - if ( 0x7FFD <=3D (bits32) ( zExp - 1 ) ) { + if ( 0x7FFD <=3D (uint32_t) ( zExp - 1 ) ) { if ( ( 0x7FFE < zExp ) || ( ( zExp =3D=3D 0x7FFE ) && ( zSig0 =3D=3D LIT64( 0xFFFFFFFFFFFFFFFF ) ) @@ -721,7 +721,7 @@ static floatx80 if ( isTiny && zSig1 ) float_raise( float_flag_underflow STA= TUS_VAR); if ( zSig1 ) STATUS(float_exception_flags) |=3D float_flag_i= nexact; if ( roundNearestEven ) { - increment =3D ( (sbits64) zSig1 < 0 ); + increment =3D ( (int64_t) zSig1 < 0 ); } else { if ( zSign ) { @@ -734,8 +734,8 @@ static floatx80 if ( increment ) { ++zSig0; zSig0 &=3D - ~ ( ( (bits64) ( zSig1<<1 ) =3D=3D 0 ) & roundNeares= tEven ); - if ( (sbits64) zSig0 < 0 ) zExp =3D 1; + ~ ( ( (uint64_t) ( zSig1<<1 ) =3D=3D 0 ) & roundNear= estEven ); + if ( (int64_t) zSig0 < 0 ) zExp =3D 1; } return packFloatx80( zSign, zExp, zSig0 ); } @@ -748,7 +748,7 @@ static floatx80 zSig0 =3D LIT64( 0x8000000000000000 ); } else { - zSig0 &=3D ~ ( ( (bits64) ( zSig1<<1 ) =3D=3D 0 ) & roundNea= restEven ); + zSig0 &=3D ~ ( ( (uint64_t) ( zSig1<<1 ) =3D=3D 0 ) & roundN= earestEven ); } } else { @@ -769,7 +769,7 @@ static floatx80 =20 static floatx80 normalizeRoundAndPackFloatx80( - int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits6= 4 zSig1 + int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uin= t64_t zSig1 STATUS_PARAM) { int8 shiftCount; @@ -796,7 +796,7 @@ static floatx80 | floating-point value `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloat128Frac1( float128 a ) +INLINE uint64_t extractFloat128Frac1( float128 a ) { =20 return a.low; @@ -808,7 +808,7 @@ INLINE bits64 extractFloat128Frac1( float128 a ) | floating-point value `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloat128Frac0( float128 a ) +INLINE uint64_t extractFloat128Frac0( float128 a ) { =20 return a.high & LIT64( 0x0000FFFFFFFFFFFF ); @@ -850,11 +850,11 @@ INLINE flag extractFloat128Sign( float128 a ) =20 static void normalizeFloat128Subnormal( - bits64 aSig0, - bits64 aSig1, + uint64_t aSig0, + uint64_t aSig1, int32 *zExpPtr, - bits64 *zSig0Ptr, - bits64 *zSig1Ptr + uint64_t *zSig0Ptr, + uint64_t *zSig1Ptr ) { int8 shiftCount; @@ -893,12 +893,12 @@ static void *-----------------------------------------------------------------------= -----*/ =20 INLINE float128 - packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 ) + packFloat128( flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 ) { float128 z; =20 z.low =3D zSig1; - z.high =3D ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + = zSig0; + z.high =3D ( ( (uint64_t) zSign )<<63 ) + ( ( (uint64_t) zExp )<<48 = ) + zSig0; return z; =20 } @@ -926,14 +926,14 @@ INLINE float128 =20 static float128 roundAndPackFloat128( - flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 ST= ATUS_PARAM) + flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1, uint64_t zS= ig2 STATUS_PARAM) { int8 roundingMode; flag roundNearestEven, increment, isTiny; =20 roundingMode =3D STATUS(float_rounding_mode); roundNearestEven =3D ( roundingMode =3D=3D float_round_nearest_even = ); - increment =3D ( (sbits64) zSig2 < 0 ); + increment =3D ( (int64_t) zSig2 < 0 ); if ( ! roundNearestEven ) { if ( roundingMode =3D=3D float_round_to_zero ) { increment =3D 0; @@ -947,7 +947,7 @@ static float128 } } } - if ( 0x7FFD <=3D (bits32) zExp ) { + if ( 0x7FFD <=3D (uint32_t) zExp ) { if ( ( 0x7FFD < zExp ) || ( ( zExp =3D=3D 0x7FFD ) && eq128( @@ -991,7 +991,7 @@ static float128 zExp =3D 0; if ( isTiny && zSig2 ) float_raise( float_flag_underflow STA= TUS_VAR); if ( roundNearestEven ) { - increment =3D ( (sbits64) zSig2 < 0 ); + increment =3D ( (int64_t) zSig2 < 0 ); } else { if ( zSign ) { @@ -1027,10 +1027,10 @@ static float128 =20 static float128 normalizeRoundAndPackFloat128( - flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 STATUS_PARAM) + flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 STATUS_PARAM= ) { int8 shiftCount; - bits64 zSig2; + uint64_t zSig2; =20 if ( zSig0 =3D=3D 0 ) { zSig0 =3D zSig1; @@ -1064,7 +1064,7 @@ float32 int32_to_float32( int32 a STATUS_PARAM ) flag zSign; =20 if ( a =3D=3D 0 ) return float32_zero; - if ( a =3D=3D (sbits32) 0x80000000 ) return packFloat32( 1, 0x9E, 0 = ); + if ( a =3D=3D (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 = ); zSign =3D ( a < 0 ); return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a ST= ATUS_VAR ); =20 @@ -1081,7 +1081,7 @@ float64 int32_to_float64( int32 a STATUS_PARAM ) flag zSign; uint32 absA; int8 shiftCount; - bits64 zSig; + uint64_t zSig; =20 if ( a =3D=3D 0 ) return float64_zero; zSign =3D ( a < 0 ); @@ -1106,7 +1106,7 @@ floatx80 int32_to_floatx80( int32 a STATUS_PARAM ) flag zSign; uint32 absA; int8 shiftCount; - bits64 zSig; + uint64_t zSig; =20 if ( a =3D=3D 0 ) return packFloatx80( 0, 0, 0 ); zSign =3D ( a < 0 ); @@ -1132,7 +1132,7 @@ float128 int32_to_float128( int32 a STATUS_PARAM ) flag zSign; uint32 absA; int8 shiftCount; - bits64 zSig0; + uint64_t zSig0; =20 if ( a =3D=3D 0 ) return packFloat128( 0, 0, 0, 0 ); zSign =3D ( a < 0 ); @@ -1209,7 +1209,7 @@ float64 int64_to_float64( int64 a STATUS_PARAM ) flag zSign; =20 if ( a =3D=3D 0 ) return float64_zero; - if ( a =3D=3D (sbits64) LIT64( 0x8000000000000000 ) ) { + if ( a =3D=3D (int64_t) LIT64( 0x8000000000000000 ) ) { return packFloat64( 1, 0x43E, 0 ); } zSign =3D ( a < 0 ); @@ -1263,7 +1263,7 @@ float128 int64_to_float128( int64 a STATUS_PARAM ) uint64 absA; int8 shiftCount; int32 zExp; - bits64 zSig0, zSig1; + uint64_t zSig0, zSig1; =20 if ( a =3D=3D 0 ) return packFloat128( 0, 0, 0, 0 ); zSign =3D ( a < 0 ); @@ -1300,8 +1300,8 @@ int32 float32_to_int32( float32 a STATUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits32 aSig; - bits64 aSig64; + uint32_t aSig; + uint64_t aSig64; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1330,7 +1330,7 @@ int32 float32_to_int32_round_to_zero( float32 a STA= TUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits32 aSig; + uint32_t aSig; int32 z; =20 aSig =3D extractFloat32Frac( a ); @@ -1342,7 +1342,7 @@ int32 float32_to_int32_round_to_zero( float32 a STA= TUS_PARAM ) float_raise( float_flag_invalid STATUS_VAR); if ( ! aSign || ( ( aExp =3D=3D 0xFF ) && aSig ) ) return 0x= 7FFFFFFF; } - return (sbits32) 0x80000000; + return (int32_t) 0x80000000; } else if ( aExp <=3D 0x7E ) { if ( aExp | aSig ) STATUS(float_exception_flags) |=3D float_flag= _inexact; @@ -1350,7 +1350,7 @@ int32 float32_to_int32_round_to_zero( float32 a STA= TUS_PARAM ) } aSig =3D ( aSig | 0x00800000 )<<8; z =3D aSig>>( - shiftCount ); - if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) { + if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } if ( aSign ) z =3D - z; @@ -1372,7 +1372,7 @@ int16 float32_to_int16_round_to_zero( float32 a STA= TUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits32 aSig; + uint32_t aSig; int32 z; =20 aSig =3D extractFloat32Frac( a ); @@ -1386,7 +1386,7 @@ int16 float32_to_int16_round_to_zero( float32 a STA= TUS_PARAM ) return 0x7FFF; } } - return (sbits32) 0xffff8000; + return (int32_t) 0xffff8000; } else if ( aExp <=3D 0x7E ) { if ( aExp | aSig ) { @@ -1397,7 +1397,7 @@ int16 float32_to_int16_round_to_zero( float32 a STA= TUS_PARAM ) shiftCount -=3D 0x10; aSig =3D ( aSig | 0x00800000 )<<8; z =3D aSig>>( - shiftCount ); - if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) { + if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } if ( aSign ) { @@ -1421,8 +1421,8 @@ int64 float32_to_int64( float32 a STATUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits32 aSig; - bits64 aSig64, aSigExtra; + uint32_t aSig; + uint64_t aSig64, aSigExtra; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1433,7 +1433,7 @@ int64 float32_to_int64( float32 a STATUS_PARAM ) if ( ! aSign || ( ( aExp =3D=3D 0xFF ) && aSig ) ) { return LIT64( 0x7FFFFFFFFFFFFFFF ); } - return (sbits64) LIT64( 0x8000000000000000 ); + return (int64_t) LIT64( 0x8000000000000000 ); } if ( aExp ) aSig |=3D 0x00800000; aSig64 =3D aSig; @@ -1457,8 +1457,8 @@ int64 float32_to_int64_round_to_zero( float32 a STA= TUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits32 aSig; - bits64 aSig64; + uint32_t aSig; + uint64_t aSig64; int64 z; =20 aSig =3D extractFloat32Frac( a ); @@ -1472,7 +1472,7 @@ int64 float32_to_int64_round_to_zero( float32 a STA= TUS_PARAM ) return LIT64( 0x7FFFFFFFFFFFFFFF ); } } - return (sbits64) LIT64( 0x8000000000000000 ); + return (int64_t) LIT64( 0x8000000000000000 ); } else if ( aExp <=3D 0x7E ) { if ( aExp | aSig ) STATUS(float_exception_flags) |=3D float_flag= _inexact; @@ -1481,7 +1481,7 @@ int64 float32_to_int64_round_to_zero( float32 a STA= TUS_PARAM ) aSig64 =3D aSig | 0x00800000; aSig64 <<=3D 40; z =3D aSig64>>( - shiftCount ); - if ( (bits64) ( aSig64<<( shiftCount & 63 ) ) ) { + if ( (uint64_t) ( aSig64<<( shiftCount & 63 ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } if ( aSign ) z =3D - z; @@ -1500,7 +1500,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM = ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1514,7 +1514,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM = ) normalizeFloat32Subnormal( aSig, &aExp, &aSig ); --aExp; } - return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 ); + return packFloat64( aSign, aExp + 0x380, ( (uint64_t) aSig )<<29 ); =20 } =20 @@ -1531,7 +1531,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARA= M ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1545,7 +1545,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARA= M ) normalizeFloat32Subnormal( aSig, &aExp, &aSig ); } aSig |=3D 0x00800000; - return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 ); + return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 )= ; =20 } =20 @@ -1564,7 +1564,7 @@ float128 float32_to_float128( float32 a STATUS_PARA= M ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1578,7 +1578,7 @@ float128 float32_to_float128( float32 a STATUS_PARA= M ) normalizeFloat32Subnormal( aSig, &aExp, &aSig ); --aExp; } - return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 = ); + return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, = 0 ); =20 } =20 @@ -1595,9 +1595,9 @@ float32 float32_round_to_int( float32 a STATUS_PARA= M) { flag aSign; int16 aExp; - bits32 lastBitMask, roundBitsMask; + uint32_t lastBitMask, roundBitsMask; int8 roundingMode; - bits32 z; + uint32_t z; =20 aExp =3D extractFloat32Exp( a ); if ( 0x96 <=3D aExp ) { @@ -1607,7 +1607,7 @@ float32 float32_round_to_int( float32 a STATUS_PARA= M) return a; } if ( aExp <=3D 0x7E ) { - if ( (bits32) ( float32_val(a)<<1 ) =3D=3D 0 ) return a; + if ( (uint32_t) ( float32_val(a)<<1 ) =3D=3D 0 ) return a; STATUS(float_exception_flags) |=3D float_flag_inexact; aSign =3D extractFloat32Sign( a ); switch ( STATUS(float_rounding_mode) ) { @@ -1654,7 +1654,7 @@ float32 float32_round_to_int( float32 a STATUS_PARA= M) static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_P= ARAM) { int16 aExp, bExp, zExp; - bits32 aSig, bSig, zSig; + uint32_t aSig, bSig, zSig; int16 expDiff; =20 aSig =3D extractFloat32Frac( a ); @@ -1708,7 +1708,7 @@ static float32 addFloat32Sigs( float32 a, float32 b= , flag zSign STATUS_PARAM) aSig |=3D 0x20000000; zSig =3D ( aSig + bSig )<<1; --zExp; - if ( (sbits32) zSig < 0 ) { + if ( (int32_t) zSig < 0 ) { zSig =3D aSig + bSig; ++zExp; } @@ -1728,7 +1728,7 @@ static float32 addFloat32Sigs( float32 a, float32 b= , flag zSign STATUS_PARAM) static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_P= ARAM) { int16 aExp, bExp, zExp; - bits32 aSig, bSig, zSig; + uint32_t aSig, bSig, zSig; int16 expDiff; =20 aSig =3D extractFloat32Frac( a ); @@ -1844,9 +1844,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PA= RAM ) { flag aSign, bSign, zSign; int16 aExp, bExp, zExp; - bits32 aSig, bSig; - bits64 zSig64; - bits32 zSig; + uint32_t aSig, bSig; + uint64_t zSig64; + uint32_t zSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1884,9 +1884,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PA= RAM ) zExp =3D aExp + bExp - 0x7F; aSig =3D ( aSig | 0x00800000 )<<7; bSig =3D ( bSig | 0x00800000 )<<8; - shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 ); + shift64RightJamming( ( (uint64_t) aSig ) * bSig, 32, &zSig64 ); zSig =3D zSig64; - if ( 0 <=3D (sbits32) ( zSig<<1 ) ) { + if ( 0 <=3D (int32_t) ( zSig<<1 ) ) { zSig <<=3D 1; --zExp; } @@ -1904,7 +1904,7 @@ float32 float32_div( float32 a, float32 b STATUS_PA= RAM ) { flag aSign, bSign, zSign; int16 aExp, bExp, zExp; - bits32 aSig, bSig, zSig; + uint32_t aSig, bSig, zSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -1948,9 +1948,9 @@ float32 float32_div( float32 a, float32 b STATUS_PA= RAM ) aSig >>=3D 1; ++zExp; } - zSig =3D ( ( (bits64) aSig )<<32 ) / bSig; + zSig =3D ( ( (uint64_t) aSig )<<32 ) / bSig; if ( ( zSig & 0x3F ) =3D=3D 0 ) { - zSig |=3D ( (bits64) bSig * zSig !=3D ( (bits64) aSig )<<32 ); + zSig |=3D ( (uint64_t) bSig * zSig !=3D ( (uint64_t) aSig )<<32 = ); } return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); =20 @@ -1966,11 +1966,11 @@ float32 float32_rem( float32 a, float32 b STATUS_= PARAM ) { flag aSign, zSign; int16 aExp, bExp, expDiff; - bits32 aSig, bSig; - bits32 q; - bits64 aSig64, bSig64, q64; - bits32 alternateASig; - sbits32 sigMean; + uint32_t aSig, bSig; + uint32_t q; + uint64_t aSig64, bSig64, q64; + uint32_t alternateASig; + int32_t sigMean; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -2012,7 +2012,7 @@ float32 float32_rem( float32 a, float32 b STATUS_PA= RAM ) q =3D ( bSig <=3D aSig ); if ( q ) aSig -=3D bSig; if ( 0 < expDiff ) { - q =3D ( ( (bits64) aSig )<<32 ) / bSig; + q =3D ( ( (uint64_t) aSig )<<32 ) / bSig; q >>=3D 32 - expDiff; bSig >>=3D 2; aSig =3D ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q; @@ -2024,8 +2024,8 @@ float32 float32_rem( float32 a, float32 b STATUS_PA= RAM ) } else { if ( bSig <=3D aSig ) aSig -=3D bSig; - aSig64 =3D ( (bits64) aSig )<<40; - bSig64 =3D ( (bits64) bSig )<<40; + aSig64 =3D ( (uint64_t) aSig )<<40; + bSig64 =3D ( (uint64_t) bSig )<<40; expDiff -=3D 64; while ( 0 < expDiff ) { q64 =3D estimateDiv128To64( aSig64, 0, bSig64 ); @@ -2044,12 +2044,12 @@ float32 float32_rem( float32 a, float32 b STATUS_= PARAM ) alternateASig =3D aSig; ++q; aSig -=3D bSig; - } while ( 0 <=3D (sbits32) aSig ); + } while ( 0 <=3D (int32_t) aSig ); sigMean =3D aSig + alternateASig; if ( ( sigMean < 0 ) || ( ( sigMean =3D=3D 0 ) && ( q & 1 ) ) ) { aSig =3D alternateASig; } - zSign =3D ( (sbits32) aSig < 0 ); + zSign =3D ( (int32_t) aSig < 0 ); if ( zSign ) aSig =3D - aSig; return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATU= S_VAR ); =20 @@ -2065,8 +2065,8 @@ float32 float32_sqrt( float32 a STATUS_PARAM ) { flag aSign; int16 aExp, zExp; - bits32 aSig, zSig; - bits64 rem, term; + uint32_t aSig, zSig; + uint64_t rem, term; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -2095,11 +2095,11 @@ float32 float32_sqrt( float32 a STATUS_PARAM ) goto roundAndPack; } aSig >>=3D aExp & 1; - term =3D ( (bits64) zSig ) * zSig; - rem =3D ( ( (bits64) aSig )<<32 ) - term; - while ( (sbits64) rem < 0 ) { + term =3D ( (uint64_t) zSig ) * zSig; + rem =3D ( ( (uint64_t) aSig )<<32 ) - term; + while ( (int64_t) rem < 0 ) { --zSig; - rem +=3D ( ( (bits64) zSig )<<1 ) | 1; + rem +=3D ( ( (uint64_t) zSig )<<1 ) | 1; } zSig |=3D ( rem !=3D 0 ); } @@ -2150,7 +2150,7 @@ float32 float32_exp2( float32 a STATUS_PARAM ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; float64 r, x, xn; int i; =20 @@ -2197,7 +2197,7 @@ float32 float32_log2( float32 a STATUS_PARAM ) { flag aSign, zSign; int16 aExp; - bits32 aSig, zSig, i; + uint32_t aSig, zSig, i; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -2222,7 +2222,7 @@ float32 float32_log2( float32 a STATUS_PARAM ) zSig =3D aExp << 23; =20 for (i =3D 1 << 22; i > 0; i >>=3D 1) { - aSig =3D ( (bits64)aSig * aSig ) >> 23; + aSig =3D ( (uint64_t)aSig * aSig ) >> 23; if ( aSig & 0x01000000 ) { aSig >>=3D 1; zSig |=3D i; @@ -2253,7 +2253,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM ) return 0; } return ( float32_val(a) =3D=3D float32_val(b) ) || - ( (bits32) ( ( float32_val(a) | float32_val(b) )<<1 ) =3D=3D= 0 ); + ( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) =3D=3D= 0 ); =20 } =20 @@ -2267,7 +2267,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM ) int float32_le( float32 a, float32 b STATUS_PARAM ) { flag aSign, bSign; - bits32 av, bv; + uint32_t av, bv; =20 if ( ( ( extractFloat32Exp( a ) =3D=3D 0xFF ) && extractFloat32Fr= ac( a ) ) || ( ( extractFloat32Exp( b ) =3D=3D 0xFF ) && extractFloat32Fr= ac( b ) ) @@ -2279,7 +2279,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM ) bSign =3D extractFloat32Sign( b ); av =3D float32_val(a); bv =3D float32_val(b); - if ( aSign !=3D bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 = ) =3D=3D 0 ); + if ( aSign !=3D bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<= 1 ) =3D=3D 0 ); return ( av =3D=3D bv ) || ( aSign ^ ( av < bv ) ); =20 } @@ -2293,7 +2293,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM ) int float32_lt( float32 a, float32 b STATUS_PARAM ) { flag aSign, bSign; - bits32 av, bv; + uint32_t av, bv; =20 if ( ( ( extractFloat32Exp( a ) =3D=3D 0xFF ) && extractFloat32Fr= ac( a ) ) || ( ( extractFloat32Exp( b ) =3D=3D 0xFF ) && extractFloat32Fr= ac( b ) ) @@ -2305,7 +2305,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM ) bSign =3D extractFloat32Sign( b ); av =3D float32_val(a); bv =3D float32_val(b); - if ( aSign !=3D bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 = ) !=3D 0 ); + if ( aSign !=3D bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<= 1 ) !=3D 0 ); return ( av !=3D bv ) && ( aSign ^ ( av < bv ) ); =20 } @@ -2319,7 +2319,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM ) =20 int float32_eq_signaling( float32 a, float32 b STATUS_PARAM ) { - bits32 av, bv; + uint32_t av, bv; =20 if ( ( ( extractFloat32Exp( a ) =3D=3D 0xFF ) && extractFloat32Fr= ac( a ) ) || ( ( extractFloat32Exp( b ) =3D=3D 0xFF ) && extractFloat32Fr= ac( b ) ) @@ -2329,7 +2329,7 @@ int float32_eq_signaling( float32 a, float32 b STAT= US_PARAM ) } av =3D float32_val(a); bv =3D float32_val(b); - return ( av =3D=3D bv ) || ( (bits32) ( ( av | bv )<<1 ) =3D=3D 0 ); + return ( av =3D=3D bv ) || ( (uint32_t) ( ( av | bv )<<1 ) =3D=3D 0 = ); =20 } =20 @@ -2343,7 +2343,7 @@ int float32_eq_signaling( float32 a, float32 b STAT= US_PARAM ) int float32_le_quiet( float32 a, float32 b STATUS_PARAM ) { flag aSign, bSign; - bits32 av, bv; + uint32_t av, bv; =20 if ( ( ( extractFloat32Exp( a ) =3D=3D 0xFF ) && extractFloat32Fr= ac( a ) ) || ( ( extractFloat32Exp( b ) =3D=3D 0xFF ) && extractFloat32Fr= ac( b ) ) @@ -2357,7 +2357,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_P= ARAM ) bSign =3D extractFloat32Sign( b ); av =3D float32_val(a); bv =3D float32_val(b); - if ( aSign !=3D bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 = ) =3D=3D 0 ); + if ( aSign !=3D bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<= 1 ) =3D=3D 0 ); return ( av =3D=3D bv ) || ( aSign ^ ( av < bv ) ); =20 } @@ -2372,7 +2372,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_P= ARAM ) int float32_lt_quiet( float32 a, float32 b STATUS_PARAM ) { flag aSign, bSign; - bits32 av, bv; + uint32_t av, bv; =20 if ( ( ( extractFloat32Exp( a ) =3D=3D 0xFF ) && extractFloat32Fr= ac( a ) ) || ( ( extractFloat32Exp( b ) =3D=3D 0xFF ) && extractFloat32Fr= ac( b ) ) @@ -2386,7 +2386,7 @@ int float32_lt_quiet( float32 a, float32 b STATUS_P= ARAM ) bSign =3D extractFloat32Sign( b ); av =3D float32_val(a); bv =3D float32_val(b); - if ( aSign !=3D bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 = ) !=3D 0 ); + if ( aSign !=3D bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<= 1 ) !=3D 0 ); return ( av !=3D bv ) && ( aSign ^ ( av < bv ) ); =20 } @@ -2405,7 +2405,7 @@ int32 float64_to_int32( float64 a STATUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -2432,7 +2432,7 @@ int32 float64_to_int32_round_to_zero( float64 a STA= TUS_PARAM ) { flag aSign; int16 aExp, shiftCount; - bits64 aSig, savedASig; + uint64_t aSig, savedASig; int32 z; =20 aSig =3D extractFloat64Frac( a ); @@ -2455,7 +2455,7 @@ int32 float64_to_int32_round_to_zero( float64 a STA= TUS_PARAM ) if ( ( z < 0 ) ^ aSign ) { invalid: float_raise( float_flag_invalid STATUS_VAR); - return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; + return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig<>( - shiftCount ); - if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) { + if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } } @@ -2620,8 +2620,8 @@ float32 float64_to_float32( float64 a STATUS_PARAM = ) { flag aSign; int16 aExp; - bits64 aSig; - bits32 zSig; + uint64_t aSig; + uint32_t zSig; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -2651,19 +2651,19 @@ float32 float64_to_float32( float64 a STATUS_PARA= M ) | than the desired result exponent whenever `zSig' is a complete, normal= ized | significand. *-----------------------------------------------------------------------= -----*/ -static bits16 packFloat16(flag zSign, int16 zExp, bits16 zSig) +static uint16_t packFloat16(flag zSign, int16 zExp, uint16_t zSig) { - return (((bits32)zSign) << 15) + (((bits32)zExp) << 10) + zSig; + return (((uint32_t)zSign) << 15) + (((uint32_t)zExp) << 10) + zSig; } =20 /* Half precision floats come in two formats: standard IEEE and "ARM" fo= rmat. The latter gains extra exponent range by omitting the NaN/Inf encodin= gs. */ =20 -float32 float16_to_float32( bits16 a, flag ieee STATUS_PARAM ) +float32 float16_to_float32( uint16_t a, flag ieee STATUS_PARAM ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; =20 aSign =3D a >> 15; aExp =3D (a >> 10) & 0x1f; @@ -2691,13 +2691,13 @@ float32 float16_to_float32( bits16 a, flag ieee S= TATUS_PARAM ) return packFloat32( aSign, aExp + 0x70, aSig << 13); } =20 -bits16 float32_to_float16( float32 a, flag ieee STATUS_PARAM) +uint16_t float32_to_float16( float32 a, flag ieee STATUS_PARAM) { flag aSign; int16 aExp; - bits32 aSig; - bits32 mask; - bits32 increment; + uint32_t aSig; + uint32_t mask; + uint32_t increment; int8 roundingMode; =20 aSig =3D extractFloat32Frac( a ); @@ -2791,7 +2791,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARA= M ) { flag aSign; int16 aExp; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -2825,7 +2825,7 @@ float128 float64_to_float128( float64 a STATUS_PARA= M ) { flag aSign; int16 aExp; - bits64 aSig, zSig0, zSig1; + uint64_t aSig, zSig0, zSig1; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -2857,9 +2857,9 @@ float64 float64_round_to_int( float64 a STATUS_PARA= M ) { flag aSign; int16 aExp; - bits64 lastBitMask, roundBitsMask; + uint64_t lastBitMask, roundBitsMask; int8 roundingMode; - bits64 z; + uint64_t z; =20 aExp =3D extractFloat64Exp( a ); if ( 0x433 <=3D aExp ) { @@ -2869,7 +2869,7 @@ float64 float64_round_to_int( float64 a STATUS_PARA= M ) return a; } if ( aExp < 0x3FF ) { - if ( (bits64) ( float64_val(a)<<1 ) =3D=3D 0 ) return a; + if ( (uint64_t) ( float64_val(a)<<1 ) =3D=3D 0 ) return a; STATUS(float_exception_flags) |=3D float_flag_inexact; aSign =3D extractFloat64Sign( a ); switch ( STATUS(float_rounding_mode) ) { @@ -2929,7 +2929,7 @@ float64 float64_trunc_to_int( float64 a STATUS_PARA= M) static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_P= ARAM ) { int16 aExp, bExp, zExp; - bits64 aSig, bSig, zSig; + uint64_t aSig, bSig, zSig; int16 expDiff; =20 aSig =3D extractFloat64Frac( a ); @@ -2983,7 +2983,7 @@ static float64 addFloat64Sigs( float64 a, float64 b= , flag zSign STATUS_PARAM ) aSig |=3D LIT64( 0x2000000000000000 ); zSig =3D ( aSig + bSig )<<1; --zExp; - if ( (sbits64) zSig < 0 ) { + if ( (int64_t) zSig < 0 ) { zSig =3D aSig + bSig; ++zExp; } @@ -3003,7 +3003,7 @@ static float64 addFloat64Sigs( float64 a, float64 b= , flag zSign STATUS_PARAM ) static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_P= ARAM ) { int16 aExp, bExp, zExp; - bits64 aSig, bSig, zSig; + uint64_t aSig, bSig, zSig; int16 expDiff; =20 aSig =3D extractFloat64Frac( a ); @@ -3119,7 +3119,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PA= RAM ) { flag aSign, bSign, zSign; int16 aExp, bExp, zExp; - bits64 aSig, bSig, zSig0, zSig1; + uint64_t aSig, bSig, zSig0, zSig1; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -3159,7 +3159,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PA= RAM ) bSig =3D ( bSig | LIT64( 0x0010000000000000 ) )<<11; mul64To128( aSig, bSig, &zSig0, &zSig1 ); zSig0 |=3D ( zSig1 !=3D 0 ); - if ( 0 <=3D (sbits64) ( zSig0<<1 ) ) { + if ( 0 <=3D (int64_t) ( zSig0<<1 ) ) { zSig0 <<=3D 1; --zExp; } @@ -3177,9 +3177,9 @@ float64 float64_div( float64 a, float64 b STATUS_PA= RAM ) { flag aSign, bSign, zSign; int16 aExp, bExp, zExp; - bits64 aSig, bSig, zSig; - bits64 rem0, rem1; - bits64 term0, term1; + uint64_t aSig, bSig, zSig; + uint64_t rem0, rem1; + uint64_t term0, term1; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -3227,7 +3227,7 @@ float64 float64_div( float64 a, float64 b STATUS_PA= RAM ) if ( ( zSig & 0x1FF ) <=3D 2 ) { mul64To128( bSig, zSig, &term0, &term1 ); sub128( aSig, 0, term0, term1, &rem0, &rem1 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig; add128( rem0, rem1, 0, bSig, &rem0, &rem1 ); } @@ -3247,9 +3247,9 @@ float64 float64_rem( float64 a, float64 b STATUS_PA= RAM ) { flag aSign, zSign; int16 aExp, bExp, expDiff; - bits64 aSig, bSig; - bits64 q, alternateASig; - sbits64 sigMean; + uint64_t aSig, bSig; + uint64_t q, alternateASig; + int64_t sigMean; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -3310,12 +3310,12 @@ float64 float64_rem( float64 a, float64 b STATUS_= PARAM ) alternateASig =3D aSig; ++q; aSig -=3D bSig; - } while ( 0 <=3D (sbits64) aSig ); + } while ( 0 <=3D (int64_t) aSig ); sigMean =3D aSig + alternateASig; if ( ( sigMean < 0 ) || ( ( sigMean =3D=3D 0 ) && ( q & 1 ) ) ) { aSig =3D alternateASig; } - zSign =3D ( (sbits64) aSig < 0 ); + zSign =3D ( (int64_t) aSig < 0 ); if ( zSign ) aSig =3D - aSig; return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATU= S_VAR ); =20 @@ -3331,8 +3331,8 @@ float64 float64_sqrt( float64 a STATUS_PARAM ) { flag aSign; int16 aExp, zExp; - bits64 aSig, zSig, doubleZSig; - bits64 rem0, rem1, term0, term1; + uint64_t aSig, zSig, doubleZSig; + uint64_t rem0, rem1, term0, term1; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -3361,7 +3361,7 @@ float64 float64_sqrt( float64 a STATUS_PARAM ) doubleZSig =3D zSig<<1; mul64To128( zSig, zSig, &term0, &term1 ); sub128( aSig, 0, term0, term1, &rem0, &rem1 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig; doubleZSig -=3D 2; add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 )= ; @@ -3381,7 +3381,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) { flag aSign, zSign; int16 aExp; - bits64 aSig, aSig0, aSig1, zSig, i; + uint64_t aSig, aSig0, aSig1, zSig, i; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -3403,7 +3403,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) aExp -=3D 0x3FF; aSig |=3D LIT64( 0x0010000000000000 ); zSign =3D aExp < 0; - zSig =3D (bits64)aExp << 52; + zSig =3D (uint64_t)aExp << 52; for (i =3D 1LL << 51; i > 0; i >>=3D 1) { mul64To128( aSig, aSig, &aSig0, &aSig1 ); aSig =3D ( aSig0 << 12 ) | ( aSig1 >> 52 ); @@ -3426,7 +3426,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) =20 int float64_eq( float64 a, float64 b STATUS_PARAM ) { - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3438,7 +3438,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM ) } av =3D float64_val(a); bv =3D float64_val(b); - return ( av =3D=3D bv ) || ( (bits64) ( ( av | bv )<<1 ) =3D=3D 0 ); + return ( av =3D=3D bv ) || ( (uint64_t) ( ( av | bv )<<1 ) =3D=3D 0 = ); =20 } =20 @@ -3452,7 +3452,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM ) int float64_le( float64 a, float64 b STATUS_PARAM ) { flag aSign, bSign; - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3464,7 +3464,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM ) bSign =3D extractFloat64Sign( b ); av =3D float64_val(a); bv =3D float64_val(b); - if ( aSign !=3D bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 = ) =3D=3D 0 ); + if ( aSign !=3D bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<= 1 ) =3D=3D 0 ); return ( av =3D=3D bv ) || ( aSign ^ ( av < bv ) ); =20 } @@ -3478,7 +3478,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM ) int float64_lt( float64 a, float64 b STATUS_PARAM ) { flag aSign, bSign; - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3490,7 +3490,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM ) bSign =3D extractFloat64Sign( b ); av =3D float64_val(a); bv =3D float64_val(b); - if ( aSign !=3D bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 = ) !=3D 0 ); + if ( aSign !=3D bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<= 1 ) !=3D 0 ); return ( av !=3D bv ) && ( aSign ^ ( av < bv ) ); =20 } @@ -3504,7 +3504,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM ) =20 int float64_eq_signaling( float64 a, float64 b STATUS_PARAM ) { - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3514,7 +3514,7 @@ int float64_eq_signaling( float64 a, float64 b STAT= US_PARAM ) } av =3D float64_val(a); bv =3D float64_val(b); - return ( av =3D=3D bv ) || ( (bits64) ( ( av | bv )<<1 ) =3D=3D 0 ); + return ( av =3D=3D bv ) || ( (uint64_t) ( ( av | bv )<<1 ) =3D=3D 0 = ); =20 } =20 @@ -3528,7 +3528,7 @@ int float64_eq_signaling( float64 a, float64 b STAT= US_PARAM ) int float64_le_quiet( float64 a, float64 b STATUS_PARAM ) { flag aSign, bSign; - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3542,7 +3542,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_P= ARAM ) bSign =3D extractFloat64Sign( b ); av =3D float64_val(a); bv =3D float64_val(b); - if ( aSign !=3D bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 = ) =3D=3D 0 ); + if ( aSign !=3D bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<= 1 ) =3D=3D 0 ); return ( av =3D=3D bv ) || ( aSign ^ ( av < bv ) ); =20 } @@ -3557,7 +3557,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_P= ARAM ) int float64_lt_quiet( float64 a, float64 b STATUS_PARAM ) { flag aSign, bSign; - bits64 av, bv; + uint64_t av, bv; =20 if ( ( ( extractFloat64Exp( a ) =3D=3D 0x7FF ) && extractFloat64F= rac( a ) ) || ( ( extractFloat64Exp( b ) =3D=3D 0x7FF ) && extractFloat64F= rac( b ) ) @@ -3571,7 +3571,7 @@ int float64_lt_quiet( float64 a, float64 b STATUS_P= ARAM ) bSign =3D extractFloat64Sign( b ); av =3D float64_val(a); bv =3D float64_val(b); - if ( aSign !=3D bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 = ) !=3D 0 ); + if ( aSign !=3D bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<= 1 ) !=3D 0 ); return ( av !=3D bv ) && ( aSign ^ ( av < bv ) ); =20 } @@ -3592,12 +3592,12 @@ int32 floatx80_to_int32( floatx80 a STATUS_PARAM = ) { flag aSign; int32 aExp, shiftCount; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); - if ( ( aExp =3D=3D 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign =3D 0; + if ( ( aExp =3D=3D 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign =3D 0; shiftCount =3D 0x4037 - aExp; if ( shiftCount <=3D 0 ) shiftCount =3D 1; shift64RightJamming( aSig, shiftCount, &aSig ); @@ -3619,14 +3619,14 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a= STATUS_PARAM ) { flag aSign; int32 aExp, shiftCount; - bits64 aSig, savedASig; + uint64_t aSig, savedASig; int32 z; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); if ( 0x401E < aExp ) { - if ( ( aExp =3D=3D 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign =3D = 0; + if ( ( aExp =3D=3D 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign =3D= 0; goto invalid; } else if ( aExp < 0x3FFF ) { @@ -3641,7 +3641,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a S= TATUS_PARAM ) if ( ( z < 0 ) ^ aSign ) { invalid: float_raise( float_flag_invalid STATUS_VAR); - return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; + return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig<>( - shiftCount ); - if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) { + if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } if ( aSign ) z =3D - z; @@ -3745,13 +3745,13 @@ float32 floatx80_to_float32( floatx80 a STATUS_PA= RAM ) { flag aSign; int32 aExp; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) ) { + if ( (uint64_t) ( aSig<<1 ) ) { return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR= ) ); } return packFloat32( aSign, 0xFF, 0 ); @@ -3773,13 +3773,13 @@ float64 floatx80_to_float64( floatx80 a STATUS_PA= RAM ) { flag aSign; int32 aExp; - bits64 aSig, zSig; + uint64_t aSig, zSig; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) ) { + if ( (uint64_t) ( aSig<<1 ) ) { return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR= ) ); } return packFloat64( aSign, 0x7FF, 0 ); @@ -3803,12 +3803,12 @@ float128 floatx80_to_float128( floatx80 a STATUS_= PARAM ) { flag aSign; int16 aExp; - bits64 aSig, zSig0, zSig1; + uint64_t aSig, zSig0, zSig1; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); - if ( ( aExp =3D=3D 0x7FFF ) && (bits64) ( aSig<<1 ) ) { + if ( ( aExp =3D=3D 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) { return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) = ); } shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 ); @@ -3829,27 +3829,27 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS= _PARAM ) { flag aSign; int32 aExp; - bits64 lastBitMask, roundBitsMask; + uint64_t lastBitMask, roundBitsMask; int8 roundingMode; floatx80 z; =20 aExp =3D extractFloatx80Exp( a ); if ( 0x403E <=3D aExp ) { - if ( ( aExp =3D=3D 0x7FFF ) && (bits64) ( extractFloatx80Frac( a= )<<1 ) ) { + if ( ( aExp =3D=3D 0x7FFF ) && (uint64_t) ( extractFloatx80Frac(= a )<<1 ) ) { return propagateFloatx80NaN( a, a STATUS_VAR ); } return a; } if ( aExp < 0x3FFF ) { if ( ( aExp =3D=3D 0 ) - && ( (bits64) ( extractFloatx80Frac( a )<<1 ) =3D=3D 0 ) ) = { + && ( (uint64_t) ( extractFloatx80Frac( a )<<1 ) =3D=3D 0 ) = ) { return a; } STATUS(float_exception_flags) |=3D float_flag_inexact; aSign =3D extractFloatx80Sign( a ); switch ( STATUS(float_rounding_mode) ) { case float_round_nearest_even: - if ( ( aExp =3D=3D 0x3FFE ) && (bits64) ( extractFloatx80Fra= c( a )<<1 ) + if ( ( aExp =3D=3D 0x3FFE ) && (uint64_t) ( extractFloatx80F= rac( a )<<1 ) ) { return packFloatx80( aSign, 0x3FFF, LIT64( 0x80000000000000= 00 ) ); @@ -3902,7 +3902,7 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_P= ARAM ) static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STAT= US_PARAM) { int32 aExp, bExp, zExp; - bits64 aSig, bSig, zSig0, zSig1; + uint64_t aSig, bSig, zSig0, zSig1; int32 expDiff; =20 aSig =3D extractFloatx80Frac( a ); @@ -3912,7 +3912,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM expDiff =3D aExp - bExp; if ( 0 < expDiff ) { if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, = b STATUS_VAR ); + if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a= , b STATUS_VAR ); return a; } if ( bExp =3D=3D 0 ) --expDiff; @@ -3921,7 +3921,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM } else if ( expDiff < 0 ) { if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, = b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a= , b STATUS_VAR ); return packFloatx80( zSign, 0x7FFF, LIT64( 0x800000000000000= 0 ) ); } if ( aExp =3D=3D 0 ) ++expDiff; @@ -3930,7 +3930,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM } else { if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( ( aSig | bSig )<<1 ) ) { + if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) { return propagateFloatx80NaN( a, b STATUS_VAR ); } return a; @@ -3945,7 +3945,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM goto shiftRight1; } zSig0 =3D aSig + bSig; - if ( (sbits64) zSig0 < 0 ) goto roundAndPack; + if ( (int64_t) zSig0 < 0 ) goto roundAndPack; shiftRight1: shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 ); zSig0 |=3D LIT64( 0x8000000000000000 ); @@ -3968,7 +3968,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STAT= US_PARAM ) { int32 aExp, bExp, zExp; - bits64 aSig, bSig, zSig0, zSig1; + uint64_t aSig, bSig, zSig0, zSig1; int32 expDiff; floatx80 z; =20 @@ -3980,7 +3980,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM if ( 0 < expDiff ) goto aExpBigger; if ( expDiff < 0 ) goto bExpBigger; if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( ( aSig | bSig )<<1 ) ) { + if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) { return propagateFloatx80NaN( a, b STATUS_VAR ); } float_raise( float_flag_invalid STATUS_VAR); @@ -3998,7 +3998,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM return packFloatx80( STATUS(float_rounding_mode) =3D=3D float_round_= down, 0, 0 ); bExpBigger: if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x800000000000000= 0 ) ); } if ( aExp =3D=3D 0 ) ++expDiff; @@ -4010,7 +4010,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx= 80 b, flag zSign STATUS_PARAM goto normalizeRoundAndPack; aExpBigger: if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); return a; } if ( bExp =3D=3D 0 ) --expDiff; @@ -4077,7 +4077,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATU= S_PARAM ) { flag aSign, bSign, zSign; int32 aExp, bExp, zExp; - bits64 aSig, bSig, zSig0, zSig1; + uint64_t aSig, bSig, zSig0, zSig1; floatx80 z; =20 aSig =3D extractFloatx80Frac( a ); @@ -4088,15 +4088,15 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STA= TUS_PARAM ) bSign =3D extractFloatx80Sign( b ); zSign =3D aSign ^ bSign; if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) - || ( ( bExp =3D=3D 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) { + if ( (uint64_t) ( aSig<<1 ) + || ( ( bExp =3D=3D 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) { return propagateFloatx80NaN( a, b STATUS_VAR ); } if ( ( bExp | bSig ) =3D=3D 0 ) goto invalid; return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) = ); } if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); if ( ( aExp | aSig ) =3D=3D 0 ) { invalid: float_raise( float_flag_invalid STATUS_VAR); @@ -4116,7 +4116,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATU= S_PARAM ) } zExp =3D aExp + bExp - 0x3FFE; mul64To128( aSig, bSig, &zSig0, &zSig1 ); - if ( 0 < (sbits64) zSig0 ) { + if ( 0 < (int64_t) zSig0 ) { shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 ); --zExp; } @@ -4136,8 +4136,8 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATU= S_PARAM ) { flag aSign, bSign, zSign; int32 aExp, bExp, zExp; - bits64 aSig, bSig, zSig0, zSig1; - bits64 rem0, rem1, rem2, term0, term1, term2; + uint64_t aSig, bSig, zSig0, zSig1; + uint64_t rem0, rem1, rem2, term0, term1, term2; floatx80 z; =20 aSig =3D extractFloatx80Frac( a ); @@ -4148,15 +4148,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STA= TUS_PARAM ) bSign =3D extractFloatx80Sign( b ); zSign =3D aSign ^ bSign; if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, = b STATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a= , b STATUS_VAR ); goto invalid; } return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) = ); } if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); return packFloatx80( zSign, 0, 0 ); } if ( bExp =3D=3D 0 ) { @@ -4186,15 +4186,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STA= TUS_PARAM ) zSig0 =3D estimateDiv128To64( aSig, rem1, bSig ); mul64To128( bSig, zSig0, &term0, &term1 ); sub128( aSig, rem1, term0, term1, &rem0, &rem1 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig0; add128( rem0, rem1, 0, bSig, &rem0, &rem1 ); } zSig1 =3D estimateDiv128To64( rem1, 0, bSig ); - if ( (bits64) ( zSig1<<1 ) <=3D 8 ) { + if ( (uint64_t) ( zSig1<<1 ) <=3D 8 ) { mul64To128( bSig, zSig1, &term1, &term2 ); sub128( rem1, 0, term1, term2, &rem1, &rem2 ); - while ( (sbits64) rem1 < 0 ) { + while ( (int64_t) rem1 < 0 ) { --zSig1; add128( rem1, rem2, 0, bSig, &rem1, &rem2 ); } @@ -4216,8 +4216,8 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATU= S_PARAM ) { flag aSign, zSign; int32 aExp, bExp, expDiff; - bits64 aSig0, aSig1, bSig; - bits64 q, term0, term1, alternateASig0, alternateASig1; + uint64_t aSig0, aSig1, bSig; + uint64_t q, term0, term1, alternateASig0, alternateASig1; floatx80 z; =20 aSig0 =3D extractFloatx80Frac( a ); @@ -4226,14 +4226,14 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STA= TUS_PARAM ) bSig =3D extractFloatx80Frac( b ); bExp =3D extractFloatx80Exp( b ); if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig0<<1 ) - || ( ( bExp =3D=3D 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) { + if ( (uint64_t) ( aSig0<<1 ) + || ( ( bExp =3D=3D 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) { return propagateFloatx80NaN( a, b STATUS_VAR ); } goto invalid; } if ( bExp =3D=3D 0x7FFF ) { - if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b ST= ATUS_VAR ); + if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b = STATUS_VAR ); return a; } if ( bExp =3D=3D 0 ) { @@ -4247,7 +4247,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATU= S_PARAM ) normalizeFloatx80Subnormal( bSig, &bExp, &bSig ); } if ( aExp =3D=3D 0 ) { - if ( (bits64) ( aSig0<<1 ) =3D=3D 0 ) return a; + if ( (uint64_t) ( aSig0<<1 ) =3D=3D 0 ) return a; normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 ); } bSig |=3D LIT64( 0x8000000000000000 ); @@ -4312,15 +4312,15 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) { flag aSign; int32 aExp, zExp; - bits64 aSig0, aSig1, zSig0, zSig1, doubleZSig0; - bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; + uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0; + uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; floatx80 z; =20 aSig0 =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); aSign =3D extractFloatx80Sign( a ); if ( aExp =3D=3D 0x7FFF ) { - if ( (bits64) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a S= TATUS_VAR ); + if ( (uint64_t) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a= STATUS_VAR ); if ( ! aSign ) return a; goto invalid; } @@ -4343,7 +4343,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) doubleZSig0 =3D zSig0<<1; mul64To128( zSig0, zSig0, &term0, &term1 ); sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig0; doubleZSig0 -=3D 2; add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 ); @@ -4355,7 +4355,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) sub128( rem1, 0, term1, term2, &rem1, &rem2 ); mul64To128( zSig1, zSig1, &term2, &term3 ); sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 ); - while ( (sbits64) rem1 < 0 ) { + while ( (int64_t) rem1 < 0 ) { --zSig1; shortShift128Left( 0, zSig1, 1, &term2, &term3 ); term3 |=3D 1; @@ -4383,9 +4383,9 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARA= M ) { =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { @@ -4397,7 +4397,7 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARA= M ) ( a.low =3D=3D b.low ) && ( ( a.high =3D=3D b.high ) || ( ( a.low =3D=3D 0 ) - && ( (bits16) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) ) + && ( (uint16_t) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) = ) ); =20 } @@ -4414,9 +4414,9 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARA= M ) flag aSign, bSign; =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { float_raise( float_flag_invalid STATUS_VAR); return 0; @@ -4426,7 +4426,7 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARA= M ) if ( aSign !=3D bSign ) { return aSign - || ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) =3D=3D 0 ); } return @@ -4447,9 +4447,9 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARA= M ) flag aSign, bSign; =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { float_raise( float_flag_invalid STATUS_VAR); return 0; @@ -4459,7 +4459,7 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARA= M ) if ( aSign !=3D bSign ) { return aSign - && ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) !=3D 0 ); } return @@ -4479,9 +4479,9 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b S= TATUS_PARAM ) { =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { float_raise( float_flag_invalid STATUS_VAR); return 0; @@ -4490,7 +4490,7 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b S= TATUS_PARAM ) ( a.low =3D=3D b.low ) && ( ( a.high =3D=3D b.high ) || ( ( a.low =3D=3D 0 ) - && ( (bits16) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) ) + && ( (uint16_t) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) = ) ); =20 } @@ -4507,9 +4507,9 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATU= S_PARAM ) flag aSign, bSign; =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { @@ -4522,7 +4522,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATU= S_PARAM ) if ( aSign !=3D bSign ) { return aSign - || ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) =3D=3D 0 ); } return @@ -4543,9 +4543,9 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATU= S_PARAM ) flag aSign, bSign; =20 if ( ( ( extractFloatx80Exp( a ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( a )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) || ( ( extractFloatx80Exp( b ) =3D=3D 0x7FFF ) - && (bits64) ( extractFloatx80Frac( b )<<1 ) ) + && (uint64_t) ( extractFloatx80Frac( b )<<1 ) ) ) { if ( floatx80_is_signaling_nan( a ) || floatx80_is_signaling_nan( b ) ) { @@ -4558,7 +4558,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATU= S_PARAM ) if ( aSign !=3D bSign ) { return aSign - && ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) !=3D 0 ); } return @@ -4585,7 +4585,7 @@ int32 float128_to_int32( float128 a STATUS_PARAM ) { flag aSign; int32 aExp, shiftCount; - bits64 aSig0, aSig1; + uint64_t aSig0, aSig1; =20 aSig1 =3D extractFloat128Frac1( a ); aSig0 =3D extractFloat128Frac0( a ); @@ -4614,7 +4614,7 @@ int32 float128_to_int32_round_to_zero( float128 a S= TATUS_PARAM ) { flag aSign; int32 aExp, shiftCount; - bits64 aSig0, aSig1, savedASig; + uint64_t aSig0, aSig1, savedASig; int32 z; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -4639,7 +4639,7 @@ int32 float128_to_int32_round_to_zero( float128 a S= TATUS_PARAM ) if ( ( z < 0 ) ^ aSign ) { invalid: float_raise( float_flag_invalid STATUS_VAR); - return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; + return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF; } if ( ( aSig0<>( ( - shiftCount ) & 63 )= ); - if ( (bits64) ( aSig1<>( - shiftCount ); if ( aSig1 - || ( shiftCount && (bits64) ( aSig0<<( shiftCount & 63 ) ) = ) ) { + || ( shiftCount && (uint64_t) ( aSig0<<( shiftCount & 63 ) = ) ) ) { STATUS(float_exception_flags) |=3D float_flag_inexact; } } @@ -4763,8 +4763,8 @@ float32 float128_to_float32( float128 a STATUS_PARA= M ) { flag aSign; int32 aExp; - bits64 aSig0, aSig1; - bits32 zSig; + uint64_t aSig0, aSig1; + uint32_t zSig; =20 aSig1 =3D extractFloat128Frac1( a ); aSig0 =3D extractFloat128Frac0( a ); @@ -4798,7 +4798,7 @@ float64 float128_to_float64( float128 a STATUS_PARA= M ) { flag aSign; int32 aExp; - bits64 aSig0, aSig1; + uint64_t aSig0, aSig1; =20 aSig1 =3D extractFloat128Frac1( a ); aSig0 =3D extractFloat128Frac0( a ); @@ -4833,7 +4833,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PA= RAM ) { flag aSign; int32 aExp; - bits64 aSig0, aSig1; + uint64_t aSig0, aSig1; =20 aSig1 =3D extractFloat128Frac1( a ); aSig0 =3D extractFloat128Frac0( a ); @@ -4870,7 +4870,7 @@ float128 float128_round_to_int( float128 a STATUS_P= ARAM ) { flag aSign; int32 aExp; - bits64 lastBitMask, roundBitsMask; + uint64_t lastBitMask, roundBitsMask; int8 roundingMode; float128 z; =20 @@ -4895,9 +4895,9 @@ float128 float128_round_to_int( float128 a STATUS_P= ARAM ) if ( ( z.low & roundBitsMask ) =3D=3D 0 ) z.low &=3D ~ l= astBitMask; } else { - if ( (sbits64) z.low < 0 ) { + if ( (int64_t) z.low < 0 ) { ++z.high; - if ( (bits64) ( z.low<<1 ) =3D=3D 0 ) z.high &=3D ~1= ; + if ( (uint64_t) ( z.low<<1 ) =3D=3D 0 ) z.high &=3D = ~1; } } } @@ -4911,7 +4911,7 @@ float128 float128_round_to_int( float128 a STATUS_P= ARAM ) } else { if ( aExp < 0x3FFF ) { - if ( ( ( (bits64) ( a.high<<1 ) ) | a.low ) =3D=3D 0 ) retur= n a; + if ( ( ( (uint64_t) ( a.high<<1 ) ) | a.low ) =3D=3D 0 ) ret= urn a; STATUS(float_exception_flags) |=3D float_flag_inexact; aSign =3D extractFloat128Sign( a ); switch ( STATUS(float_rounding_mode) ) { @@ -4973,7 +4973,7 @@ float128 float128_round_to_int( float128 a STATUS_P= ARAM ) static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STAT= US_PARAM) { int32 aExp, bExp, zExp; - bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; + uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; int32 expDiff; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -5054,7 +5054,7 @@ static float128 addFloat128Sigs( float128 a, float1= 28 b, flag zSign STATUS_PARAM static float128 subFloat128Sigs( float128 a, float128 b, flag zSign STAT= US_PARAM) { int32 aExp, bExp, zExp; - bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1; + uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1; int32 expDiff; float128 z; =20 @@ -5179,7 +5179,7 @@ float128 float128_mul( float128 a, float128 b STATU= S_PARAM ) { flag aSign, bSign, zSign; int32 aExp, bExp, zExp; - bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3; + uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3; float128 z; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -5243,8 +5243,8 @@ float128 float128_div( float128 a, float128 b STATU= S_PARAM ) { flag aSign, bSign, zSign; int32 aExp, bExp, zExp; - bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; - bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; + uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; + uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; float128 z; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -5298,7 +5298,7 @@ float128 float128_div( float128 a, float128 b STATU= S_PARAM ) zSig0 =3D estimateDiv128To64( aSig0, aSig1, bSig0 ); mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 ); sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig0; add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 )= ; } @@ -5306,7 +5306,7 @@ float128 float128_div( float128 a, float128 b STATU= S_PARAM ) if ( ( zSig1 & 0x3FFF ) <=3D 4 ) { mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 ); sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 = ); - while ( (sbits64) rem1 < 0 ) { + while ( (int64_t) rem1 < 0 ) { --zSig1; add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &re= m3 ); } @@ -5327,9 +5327,9 @@ float128 float128_rem( float128 a, float128 b STATU= S_PARAM ) { flag aSign, zSign; int32 aExp, bExp, expDiff; - bits64 aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2; - bits64 allZero, alternateASig0, alternateASig1, sigMean1; - sbits64 sigMean0; + uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2; + uint64_t allZero, alternateASig0, alternateASig1, sigMean1; + int64_t sigMean0; float128 z; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -5411,15 +5411,15 @@ float128 float128_rem( float128 a, float128 b STA= TUS_PARAM ) alternateASig1 =3D aSig1; ++q; sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 ); - } while ( 0 <=3D (sbits64) aSig0 ); + } while ( 0 <=3D (int64_t) aSig0 ); add128( - aSig0, aSig1, alternateASig0, alternateASig1, (bits64 *)&sigMean= 0, &sigMean1 ); + aSig0, aSig1, alternateASig0, alternateASig1, (uint64_t *)&sigMe= an0, &sigMean1 ); if ( ( sigMean0 < 0 ) || ( ( ( sigMean0 | sigMean1 ) =3D=3D 0 ) && ( q & 1 ) ) ) { aSig0 =3D alternateASig0; aSig1 =3D alternateASig1; } - zSign =3D ( (sbits64) aSig0 < 0 ); + zSign =3D ( (int64_t) aSig0 < 0 ); if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 ); return normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, a= Sig1 STATUS_VAR ); @@ -5436,8 +5436,8 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) { flag aSign; int32 aExp, zExp; - bits64 aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0; - bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; + uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0; + uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3; float128 z; =20 aSig1 =3D extractFloat128Frac1( a ); @@ -5469,7 +5469,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) doubleZSig0 =3D zSig0<<1; mul64To128( zSig0, zSig0, &term0, &term1 ); sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 ); - while ( (sbits64) rem0 < 0 ) { + while ( (int64_t) rem0 < 0 ) { --zSig0; doubleZSig0 -=3D 2; add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 ); @@ -5481,7 +5481,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) sub128( rem1, 0, term1, term2, &rem1, &rem2 ); mul64To128( zSig1, zSig1, &term2, &term3 ); sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 ); - while ( (sbits64) rem1 < 0 ) { + while ( (int64_t) rem1 < 0 ) { --zSig1; shortShift128Left( 0, zSig1, 1, &term2, &term3 ); term3 |=3D 1; @@ -5519,7 +5519,7 @@ int float128_eq( float128 a, float128 b STATUS_PARA= M ) ( a.low =3D=3D b.low ) && ( ( a.high =3D=3D b.high ) || ( ( a.low =3D=3D 0 ) - && ( (bits64) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) ) + && ( (uint64_t) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) = ) ); =20 } @@ -5548,7 +5548,7 @@ int float128_le( float128 a, float128 b STATUS_PARA= M ) if ( aSign !=3D bSign ) { return aSign - || ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + || ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) =3D=3D 0 ); } return @@ -5580,7 +5580,7 @@ int float128_lt( float128 a, float128 b STATUS_PARA= M ) if ( aSign !=3D bSign ) { return aSign - && ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + && ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) !=3D 0 ); } return @@ -5611,7 +5611,7 @@ int float128_eq_signaling( float128 a, float128 b S= TATUS_PARAM ) ( a.low =3D=3D b.low ) && ( ( a.high =3D=3D b.high ) || ( ( a.low =3D=3D 0 ) - && ( (bits64) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) ) + && ( (uint64_t) ( ( a.high | b.high )<<1 ) =3D=3D 0 ) = ) ); =20 } @@ -5643,7 +5643,7 @@ int float128_le_quiet( float128 a, float128 b STATU= S_PARAM ) if ( aSign !=3D bSign ) { return aSign - || ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + || ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) =3D=3D 0 ); } return @@ -5679,7 +5679,7 @@ int float128_lt_quiet( float128 a, float128 b STATU= S_PARAM ) if ( aSign !=3D bSign ) { return aSign - && ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | = b.low ) + && ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low = | b.low ) !=3D 0 ); } return @@ -5837,7 +5837,7 @@ INLINE int float ## s ## _compare_internal( float #= # s a, float ## s b, \ int is_quiet STATUS_PARAM ) = \ { = \ flag aSign, bSign; = \ - bits ## s av, bv; = \ + uint ## s ## _t av, bv; = \ = \ if (( ( extractFloat ## s ## Exp( a ) =3D=3D nan_exp ) && = \ extractFloat ## s ## Frac( a ) ) || = \ @@ -5855,7 +5855,7 @@ INLINE int float ## s ## _compare_internal( float #= # s a, float ## s b, \ av =3D float ## s ## _val(a); = \ bv =3D float ## s ## _val(b); = \ if ( aSign !=3D bSign ) { = \ - if ( (bits ## s) ( ( av | bv )<<1 ) =3D=3D 0 ) { = \ + if ( (uint ## s ## _t) ( ( av | bv )<<1 ) =3D=3D 0 ) { = \ /* zero case */ = \ return float_relation_equal; = \ } else { = \ @@ -5932,7 +5932,7 @@ float32 float32_scalbn( float32 a, int n STATUS_PAR= AM ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; =20 aSig =3D extractFloat32Frac( a ); aExp =3D extractFloat32Exp( a ); @@ -5955,7 +5955,7 @@ float64 float64_scalbn( float64 a, int n STATUS_PAR= AM ) { flag aSign; int16 aExp; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloat64Frac( a ); aExp =3D extractFloat64Exp( a ); @@ -5979,7 +5979,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n STATUS_= PARAM ) { flag aSign; int16 aExp; - bits64 aSig; + uint64_t aSig; =20 aSig =3D extractFloatx80Frac( a ); aExp =3D extractFloatx80Exp( a ); @@ -6002,7 +6002,7 @@ float128 float128_scalbn( float128 a, int n STATUS_= PARAM ) { flag aSign; int32 aExp; - bits64 aSig0, aSig1; + uint64_t aSig0, aSig1; =20 aSig1 =3D extractFloat128Frac1( a ); aSig0 =3D extractFloat128Frac0( a ); diff --git a/fpu/softfloat.h b/fpu/softfloat.h index cefd4fa..7bed60b 100644 --- a/fpu/softfloat.h +++ b/fpu/softfloat.h @@ -65,21 +65,6 @@ typedef signed int int32; typedef uint64_t uint64; typedef int64_t int64; =20 -/*----------------------------------------------------------------------= ------ -| Each of the following `typedef's defines a type that holds integers -| of _exactly_ the number of bits specified. For instance, for most -| implementation of C, `bits16' and `sbits16' should be `typedef'ed to -| `unsigned short int' and `signed short int' (or `short int'), respecti= vely. -*-----------------------------------------------------------------------= -----*/ -typedef uint8_t bits8; -typedef int8_t sbits8; -typedef uint16_t bits16; -typedef int16_t sbits16; -typedef uint32_t bits32; -typedef int32_t sbits32; -typedef uint64_t bits64; -typedef int64_t sbits64; - #define LIT64( a ) a##LL #define INLINE static inline =20 @@ -251,8 +236,8 @@ float128 int64_to_float128( int64 STATUS_PARAM ); /*----------------------------------------------------------------------= ------ | Software half-precision conversion routines. *-----------------------------------------------------------------------= -----*/ -bits16 float32_to_float16( float32, flag STATUS_PARAM ); -float32 float16_to_float32( bits16, flag STATUS_PARAM ); +uint16_t float32_to_float16( float32, flag STATUS_PARAM ); +float32 float16_to_float32( uint16_t, flag STATUS_PARAM ); =20 /*----------------------------------------------------------------------= ------ | Software IEC/IEEE single-precision conversion routines. --=20 1.7.3.4