Received: from [140.186.70.92] (port=59764 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1PTzco-0008D5-Ae for qemu-devel@nongnu.org; Sat, 18 Dec 2010 11:27:21 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1PTzch-0003dB-88 for qemu-devel@nongnu.org; Sat, 18 Dec 2010 11:27:14 -0500 Received: from fmmailgate02.web.de ([217.72.192.227]:44669) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1PTzcc-0003bz-0O for qemu-devel@nongnu.org; Sat, 18 Dec 2010 11:27:07 -0500 From: =?UTF-8?q?Andreas=20F=C3=A4rber?= Date: Sat, 18 Dec 2010 17:25:29 +0100 Message-Id: <1292689531-18763-5-git-send-email-andreas.faerber@web.de> In-Reply-To: <1292689531-18763-4-git-send-email-andreas.faerber@web.de> References: <1292625556-24825-1-git-send-email-andreas.faerber@web.de> <1292689531-18763-1-git-send-email-andreas.faerber@web.de> <1292689531-18763-2-git-send-email-andreas.faerber@web.de> <1292689531-18763-3-git-send-email-andreas.faerber@web.de> <1292689531-18763-4-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 v3 5/7] 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?= They are defined with the same semantics as the POSIX types, so prefer those for consistency. Suggested by Peter Maydell. v3: * Initial. Cc: Peter Maydell 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 7838228..e007039 100644 --- a/fpu/softfloat-macros.h +++ b/fpu/softfloat-macros.h @@ -39,9 +39,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; @@ -65,9 +65,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; @@ -101,9 +101,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 ) { @@ -138,9 +138,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 ) { @@ -173,9 +173,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 ) { @@ -224,16 +224,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 ) { @@ -282,7 +282,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 ); @@ -478,15 +478,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 ); @@ -506,18 +506,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 ); @@ -543,18 +543,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 ); @@ -575,18 +575,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 ) { @@ -598,9 +598,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 @@ -609,7 +609,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, @@ -650,12 +650,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 { @@ -672,7 +672,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 ); @@ -685,7 +685,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 ) ); @@ -698,7 +698,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 ) ); @@ -711,7 +711,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 049c830..edbbe7d 100644 --- a/fpu/softfloat-native.c +++ b/fpu/softfloat-native.c @@ -418,7 +418,7 @@ int float64_is_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_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 0746878..b6d236f 100644 --- a/fpu/softfloat-specialize.h +++ b/fpu/softfloat-specialize.h @@ -53,7 +53,7 @@ void float_raise( int8 flags STATUS_PARAM ) *-----------------------------------------------------------------------= -----*/ typedef struct { flag sign; - bits64 high, low; + uint64_t high, low; } commonNaNT; =20 /*----------------------------------------------------------------------= ------ @@ -82,7 +82,7 @@ int float32_is_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 @@ -95,7 +95,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 @@ -133,7 +133,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 @@ -144,10 +144,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; } @@ -161,7 +161,7 @@ static float32 commonNaNToFloat32( commonNaNT a ) static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) { flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; - bits32 av, bv, res; + uint32_t av, bv, res; =20 if ( STATUS(default_nan_mode) ) return float32_default_nan; @@ -189,9 +189,9 @@ static float32 propagateFloat32NaN( float32 a, float3= 2 b STATUS_PARAM) res =3D av; else { returnLargerSignificand: - if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) ) + if ( (uint32_t) ( av<<1 ) < (uint32_t) ( bv<<1 ) ) res =3D bv; - else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) ) + else if ( (uint32_t) ( bv<<1 ) < (uint32_t) ( av<<1 ) ) res =3D av; else res =3D ( av < bv ) ? av : bv; @@ -225,13 +225,13 @@ static float32 propagateFloat32NaN( float32 a, floa= t32 b STATUS_PARAM) =20 int float64_is_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 @@ -242,9 +242,9 @@ int float64_is_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 ) @@ -260,7 +260,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 @@ -295,11 +295,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 @@ -315,7 +315,7 @@ static float64 commonNaNToFloat64( commonNaNT a ) static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) { flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; - bits64 av, bv, res; + uint64_t av, bv, res; =20 if ( STATUS(default_nan_mode) ) return float64_default_nan; @@ -343,9 +343,9 @@ static float64 propagateFloat64NaN( float64 a, float6= 4 b STATUS_PARAM) res =3D av; else { returnLargerSignificand: - if ( (bits64) ( av<<1 ) < (bits64) ( bv<<1 ) ) + if ( (uint64_t) ( av<<1 ) < (uint64_t) ( bv<<1 ) ) res =3D bv; - else if ( (bits64) ( bv<<1 ) < (bits64) ( av<<1 ) ) + else if ( (uint64_t) ( bv<<1 ) < (uint64_t) ( av<<1 ) ) res =3D av; else res =3D ( av < bv ) ? av : bv; @@ -380,15 +380,15 @@ static float64 propagateFloat64NaN( float64 a, floa= t64 b STATUS_PARAM) int floatx80_is_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 @@ -400,14 +400,14 @@ int floatx80_is_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 } @@ -442,7 +442,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 @@ -519,7 +519,7 @@ int float128_is_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 } @@ -533,7 +533,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 @@ -568,7 +568,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 6f5b05d..8eaff14 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -79,7 +79,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; @@ -110,7 +110,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; @@ -129,7 +129,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; @@ -137,7 +137,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; @@ -154,7 +154,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; @@ -162,7 +162,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; @@ -174,7 +174,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; @@ -211,7 +211,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 @@ -232,11 +232,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 @@ -262,7 +262,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; @@ -287,10 +287,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= )); @@ -325,7 +325,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 @@ -338,7 +338,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 ); @@ -375,7 +375,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 @@ -396,11 +396,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 @@ -426,7 +426,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; @@ -451,10 +451,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 )); @@ -489,7 +489,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 @@ -505,7 +505,7 @@ static float64 | value `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloatx80Frac( floatx80 a ) +INLINE uint64_t extractFloatx80Frac( floatx80 a ) { =20 return a.low; @@ -544,7 +544,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 @@ -559,12 +559,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 } @@ -595,7 +595,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; @@ -632,7 +632,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 ) ) ) { @@ -650,7 +650,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; @@ -673,7 +673,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; @@ -687,7 +687,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 ) ) @@ -716,7 +716,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 ) { @@ -729,8 +729,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 ); } @@ -743,7 +743,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 { @@ -764,7 +764,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; @@ -791,7 +791,7 @@ static floatx80 | floating-point value `a'. *-----------------------------------------------------------------------= -----*/ =20 -INLINE bits64 extractFloat128Frac1( float128 a ) +INLINE uint64_t extractFloat128Frac1( float128 a ) { =20 return a.low; @@ -803,7 +803,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 ); @@ -845,11 +845,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; @@ -888,12 +888,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 } @@ -921,14 +921,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; @@ -942,7 +942,7 @@ static float128 } } } - if ( 0x7FFD <=3D (bits32) zExp ) { + if ( 0x7FFD <=3D (uint32_t) zExp ) { if ( ( 0x7FFD < zExp ) || ( ( zExp =3D=3D 0x7FFD ) && eq128( @@ -986,7 +986,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 ) { @@ -1022,10 +1022,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; @@ -1059,7 +1059,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 @@ -1076,7 +1076,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 ); @@ -1101,7 +1101,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 ); @@ -1127,7 +1127,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 ); @@ -1204,7 +1204,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 ); @@ -1258,7 +1258,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 ); @@ -1295,8 +1295,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 ); @@ -1325,7 +1325,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 ); @@ -1337,7 +1337,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; @@ -1345,7 +1345,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; @@ -1367,7 +1367,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 ); @@ -1381,7 +1381,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 ) { @@ -1392,7 +1392,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 ) { @@ -1416,8 +1416,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 ); @@ -1428,7 +1428,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; @@ -1452,8 +1452,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 ); @@ -1467,7 +1467,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; @@ -1476,7 +1476,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; @@ -1495,7 +1495,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 ); @@ -1509,7 +1509,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 @@ -1526,7 +1526,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 ); @@ -1540,7 +1540,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 @@ -1559,7 +1559,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 ); @@ -1573,7 +1573,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 @@ -1590,9 +1590,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 ) { @@ -1602,7 +1602,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) ) { @@ -1649,7 +1649,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 ); @@ -1703,7 +1703,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; } @@ -1723,7 +1723,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 ); @@ -1839,9 +1839,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 ); @@ -1879,9 +1879,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; } @@ -1899,7 +1899,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 ); @@ -1943,9 +1943,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 @@ -1961,11 +1961,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 ); @@ -2007,7 +2007,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; @@ -2019,8 +2019,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 ); @@ -2039,12 +2039,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 @@ -2060,8 +2060,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 ); @@ -2090,11 +2090,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 ); } @@ -2145,7 +2145,7 @@ float32 float32_exp2( float32 a STATUS_PARAM ) { flag aSign; int16 aExp; - bits32 aSig; + uint32_t aSig; float64 r, x, xn; int i; =20 @@ -2192,7 +2192,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 ); @@ -2217,7 +2217,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; @@ -2248,7 +2248,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 @@ -2262,7 +2262,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 ) ) @@ -2274,7 +2274,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 } @@ -2288,7 +2288,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 ) ) @@ -2300,7 +2300,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 } @@ -2314,7 +2314,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 ) ) @@ -2324,7 +2324,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 @@ -2338,7 +2338,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 ) ) @@ -2352,7 +2352,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 } @@ -2367,7 +2367,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 ) ) @@ -2381,7 +2381,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 } @@ -2400,7 +2400,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 ); @@ -2427,7 +2427,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 ); @@ -2450,7 +2450,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; } } @@ -2615,8 +2615,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 ); @@ -2646,19 +2646,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; @@ -2686,13 +2686,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 ); @@ -2786,7 +2786,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 ); @@ -2820,7 +2820,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 ); @@ -2852,9 +2852,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 ) { @@ -2864,7 +2864,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) ) { @@ -2924,7 +2924,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 ); @@ -2978,7 +2978,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; } @@ -2998,7 +2998,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 ); @@ -3114,7 +3114,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 ); @@ -3154,7 +3154,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; } @@ -3172,9 +3172,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 ); @@ -3222,7 +3222,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 ); } @@ -3242,9 +3242,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 ); @@ -3305,12 +3305,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 @@ -3326,8 +3326,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 ); @@ -3356,7 +3356,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 )= ; @@ -3376,7 +3376,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 ); @@ -3398,7 +3398,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 ); @@ -3421,7 +3421,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 ) ) @@ -3433,7 +3433,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 @@ -3447,7 +3447,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 ) ) @@ -3459,7 +3459,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 } @@ -3473,7 +3473,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 ) ) @@ -3485,7 +3485,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 } @@ -3499,7 +3499,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 ) ) @@ -3509,7 +3509,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 @@ -3523,7 +3523,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 ) ) @@ -3537,7 +3537,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 } @@ -3552,7 +3552,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 ) ) @@ -3566,7 +3566,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 } @@ -3587,12 +3587,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 ); @@ -3614,14 +3614,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 ) { @@ -3636,7 +3636,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; @@ -3740,13 +3740,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 ); @@ -3768,13 +3768,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 ); @@ -3798,12 +3798,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 ); @@ -3824,27 +3824,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 ) ); @@ -3897,7 +3897,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 ); @@ -3907,7 +3907,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; @@ -3916,7 +3916,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; @@ -3925,7 +3925,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; @@ -3940,7 +3940,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 ); @@ -3963,7 +3963,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 @@ -3975,7 +3975,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); @@ -3993,7 +3993,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; @@ -4005,7 +4005,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; @@ -4072,7 +4072,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 ); @@ -4083,15 +4083,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); @@ -4111,7 +4111,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; } @@ -4131,8 +4131,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 ); @@ -4143,15 +4143,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 ) { @@ -4181,15 +4181,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 ); } @@ -4211,8 +4211,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 ); @@ -4221,14 +4221,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 ) { @@ -4242,7 +4242,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 ); @@ -4307,15 +4307,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; } @@ -4338,7 +4338,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 ); @@ -4350,7 +4350,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; @@ -4378,9 +4378,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 ) ) { @@ -4392,7 +4392,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 } @@ -4409,9 +4409,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; @@ -4421,7 +4421,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 @@ -4442,9 +4442,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; @@ -4454,7 +4454,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 @@ -4474,9 +4474,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; @@ -4485,7 +4485,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 } @@ -4502,9 +4502,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 ) ) { @@ -4517,7 +4517,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 @@ -4538,9 +4538,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 ) ) { @@ -4553,7 +4553,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 @@ -4580,7 +4580,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 ); @@ -4609,7 +4609,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 ); @@ -4634,7 +4634,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; } } @@ -4758,8 +4758,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 ); @@ -4793,7 +4793,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 ); @@ -4828,7 +4828,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 ); @@ -4865,7 +4865,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 @@ -4890,9 +4890,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; } } } @@ -4906,7 +4906,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) ) { @@ -4968,7 +4968,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 ); @@ -5049,7 +5049,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 @@ -5174,7 +5174,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 ); @@ -5238,8 +5238,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 ); @@ -5293,7 +5293,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 )= ; } @@ -5301,7 +5301,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 ); } @@ -5322,9 +5322,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 ); @@ -5406,15 +5406,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 ); @@ -5431,8 +5431,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 ); @@ -5464,7 +5464,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 ); @@ -5476,7 +5476,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; @@ -5514,7 +5514,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 } @@ -5543,7 +5543,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 @@ -5575,7 +5575,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 @@ -5606,7 +5606,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 } @@ -5638,7 +5638,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 @@ -5674,7 +5674,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 @@ -5832,7 +5832,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 ) ) || = \ @@ -5850,7 +5850,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 { = \ @@ -5927,7 +5927,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 ); @@ -5950,7 +5950,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 ); @@ -5974,7 +5974,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 ); @@ -5997,7 +5997,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 c62e769..c7854ed 100644 --- a/fpu/softfloat.h +++ b/fpu/softfloat.h @@ -59,21 +59,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 @@ -245,8 +230,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