Skip to content

Q
qemu

openeuler / qemu

通知 10
Star 0
Fork 0
Q
qemu
提交 bb98fe42 编写于 作者: A Andreas Färber 提交者： Aurelien Jarno
浏览文件
操作

softfloat: Drop [s]bits{8, 16, 32, 64} types in favor of [u]int{8, 16, 32, 64}_t 

They are defined with the same semantics as the POSIX types,
so prefer those for consistency. Suggested by Peter Maydell.

Cc: Peter Maydell <peter.maydell@linaro.org>
Cc: Aurelien Jarno <aurelien@aurel32.net>
Signed-off-by: NAndreas Färber <andreas.faerber@web.de>
Signed-off-by: NAurelien Jarno <aurelien@aurel32.net>
上级 87b8cc3c
隐藏空白更改
内联 并排
Showing with 417 addition and 432 deletion
fpu/softfloat-macros.h
浏览文件 @ bb98fe42
...@@ -44,9 +44,9 @@ these four paragraphs for those parts of this code that are retained. ...@@ -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'. | The result is stored in the location pointed to by `zPtr'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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;
if ( count == 0 ) { if ( count == 0 ) {
z = a; z = a;
...@@ -70,9 +70,9 @@ INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr ) ...@@ -70,9 +70,9 @@ INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
| The result is stored in the location pointed to by `zPtr'. | The result is stored in the location pointed to by `zPtr'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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;
if ( count == 0 ) { if ( count == 0 ) {
z = a; z = a;
...@@ -106,9 +106,9 @@ INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr ) ...@@ -106,9 +106,9 @@ INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr )
INLINE void INLINE void
shift64ExtraRightJamming( shift64ExtraRightJamming(
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
bits64 z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8 negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
...@@ -143,9 +143,9 @@ INLINE void ...@@ -143,9 +143,9 @@ INLINE void
INLINE void INLINE void
shift128Right( shift128Right(
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
bits64 z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8 negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
...@@ -178,9 +178,9 @@ INLINE void ...@@ -178,9 +178,9 @@ INLINE void
INLINE void INLINE void
shift128RightJamming( shift128RightJamming(
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
bits64 z0, z1; uint64_t z0, z1;
int8 negCount = ( - count ) & 63; int8 negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
...@@ -229,16 +229,16 @@ INLINE void ...@@ -229,16 +229,16 @@ INLINE void
INLINE void INLINE void
shift128ExtraRightJamming( shift128ExtraRightJamming(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 a2, uint64_t a2,
int16 count, int16 count,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr uint64_t *z2Ptr
) )
{ {
bits64 z0, z1, z2; uint64_t z0, z1, z2;
int8 negCount = ( - count ) & 63; int8 negCount = ( - count ) & 63;
if ( count == 0 ) { if ( count == 0 ) {
...@@ -287,7 +287,7 @@ INLINE void ...@@ -287,7 +287,7 @@ INLINE void
INLINE void INLINE void
shortShift128Left( shortShift128Left(
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
*z1Ptr = a1<<count; *z1Ptr = a1<<count;
...@@ -306,16 +306,16 @@ INLINE void ...@@ -306,16 +306,16 @@ INLINE void
INLINE void INLINE void
shortShift192Left( shortShift192Left(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 a2, uint64_t a2,
int16 count, int16 count,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr uint64_t *z2Ptr
) )
{ {
bits64 z0, z1, z2; uint64_t z0, z1, z2;
int8 negCount; int8 negCount;
z2 = a2<<count; z2 = a2<<count;
...@@ -341,9 +341,9 @@ INLINE void ...@@ -341,9 +341,9 @@ INLINE void
INLINE void INLINE void
add128( add128(
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
bits64 z1; uint64_t z1;
z1 = a1 + b1; z1 = a1 + b1;
*z1Ptr = z1; *z1Ptr = z1;
...@@ -361,18 +361,18 @@ INLINE void ...@@ -361,18 +361,18 @@ INLINE void
INLINE void INLINE void
add192( add192(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 a2, uint64_t a2,
bits64 b0, uint64_t b0,
bits64 b1, uint64_t b1,
bits64 b2, uint64_t b2,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr uint64_t *z2Ptr
) )
{ {
bits64 z0, z1, z2; uint64_t z0, z1, z2;
int8 carry0, carry1; int8 carry0, carry1;
z2 = a2 + b2; z2 = a2 + b2;
...@@ -399,7 +399,7 @@ INLINE void ...@@ -399,7 +399,7 @@ INLINE void
INLINE void INLINE void
sub128( sub128(
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr ) uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
*z1Ptr = a1 - b1; *z1Ptr = a1 - b1;
...@@ -417,18 +417,18 @@ INLINE void ...@@ -417,18 +417,18 @@ INLINE void
INLINE void INLINE void
sub192( sub192(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 a2, uint64_t a2,
bits64 b0, uint64_t b0,
bits64 b1, uint64_t b1,
bits64 b2, uint64_t b2,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr uint64_t *z2Ptr
) )
{ {
bits64 z0, z1, z2; uint64_t z0, z1, z2;
int8 borrow0, borrow1; int8 borrow0, borrow1;
z2 = a2 - b2; z2 = a2 - b2;
...@@ -451,21 +451,21 @@ INLINE void ...@@ -451,21 +451,21 @@ INLINE void
| `z0Ptr' and `z1Ptr'. | `z0Ptr' and `z1Ptr'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr ) INLINE void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
{ {
bits32 aHigh, aLow, bHigh, bLow; uint32_t aHigh, aLow, bHigh, bLow;
bits64 z0, zMiddleA, zMiddleB, z1; uint64_t z0, zMiddleA, zMiddleB, z1;
aLow = a; aLow = a;
aHigh = a>>32; aHigh = a>>32;
bLow = b; bLow = b;
bHigh = b>>32; bHigh = b>>32;
z1 = ( (bits64) aLow ) * bLow; z1 = ( (uint64_t) aLow ) * bLow;
zMiddleA = ( (bits64) aLow ) * bHigh; zMiddleA = ( (uint64_t) aLow ) * bHigh;
zMiddleB = ( (bits64) aHigh ) * bLow; zMiddleB = ( (uint64_t) aHigh ) * bLow;
z0 = ( (bits64) aHigh ) * bHigh; z0 = ( (uint64_t) aHigh ) * bHigh;
zMiddleA += zMiddleB; zMiddleA += zMiddleB;
z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 ); z0 += ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
zMiddleA <<= 32; zMiddleA <<= 32;
z1 += zMiddleA; z1 += zMiddleA;
z0 += ( z1 < zMiddleA ); z0 += ( z1 < zMiddleA );
...@@ -483,15 +483,15 @@ INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr ) ...@@ -483,15 +483,15 @@ INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )
INLINE void INLINE void
mul128By64To192( mul128By64To192(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 b, uint64_t b,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr uint64_t *z2Ptr
) )
{ {
bits64 z0, z1, z2, more1; uint64_t z0, z1, z2, more1;
mul64To128( a1, b, &z1, &z2 ); mul64To128( a1, b, &z1, &z2 );
mul64To128( a0, b, &z0, &more1 ); mul64To128( a0, b, &z0, &more1 );
...@@ -511,18 +511,18 @@ INLINE void ...@@ -511,18 +511,18 @@ INLINE void
INLINE void INLINE void
mul128To256( mul128To256(
bits64 a0, uint64_t a0,
bits64 a1, uint64_t a1,
bits64 b0, uint64_t b0,
bits64 b1, uint64_t b1,
bits64 *z0Ptr, uint64_t *z0Ptr,
bits64 *z1Ptr, uint64_t *z1Ptr,
bits64 *z2Ptr, uint64_t *z2Ptr,
bits64 *z3Ptr uint64_t *z3Ptr
) )
{ {
bits64 z0, z1, z2, z3; uint64_t z0, z1, z2, z3;
bits64 more1, more2; uint64_t more1, more2;
mul64To128( a1, b1, &z2, &z3 ); mul64To128( a1, b1, &z2, &z3 );
mul64To128( a1, b0, &z1, &more2 ); mul64To128( a1, b0, &z1, &more2 );
...@@ -548,18 +548,18 @@ INLINE void ...@@ -548,18 +548,18 @@ INLINE void
| unsigned integer is returned. | unsigned integer is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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; uint64_t b0, b1;
bits64 rem0, rem1, term0, term1; uint64_t rem0, rem1, term0, term1;
bits64 z; uint64_t z;
if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF ); if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
b0 = b>>32; b0 = b>>32;
z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32; z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
mul64To128( b, z, &term0, &term1 ); mul64To128( b, z, &term0, &term1 );
sub128( a0, a1, term0, term1, &rem0, &rem1 ); sub128( a0, a1, term0, term1, &rem0, &rem1 );
while ( ( (sbits64) rem0 ) < 0 ) { while ( ( (int64_t) rem0 ) < 0 ) {
z -= LIT64( 0x100000000 ); z -= LIT64( 0x100000000 );
b1 = b<<32; b1 = b<<32;
add128( rem0, rem1, b0, b1, &rem0, &rem1 ); add128( rem0, rem1, b0, b1, &rem0, &rem1 );
...@@ -580,18 +580,18 @@ static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b ) ...@@ -580,18 +580,18 @@ static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )
| value. | value.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static bits32 estimateSqrt32( int16 aExp, bits32 a ) static uint32_t estimateSqrt32( int16 aExp, uint32_t a )
{ {
static const bits16 sqrtOddAdjustments[] = { static const uint16_t sqrtOddAdjustments[] = {
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
}; };
static const bits16 sqrtEvenAdjustments[] = { static const uint16_t sqrtEvenAdjustments[] = {
0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
}; };
int8 index; int8 index;
bits32 z; uint32_t z;
index = ( a>>27 ) & 15; index = ( a>>27 ) & 15;
if ( aExp & 1 ) { if ( aExp & 1 ) {
...@@ -603,9 +603,9 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a ) ...@@ -603,9 +603,9 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a )
z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ]; z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ];
z = a / z + z; z = a / z + z;
z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 ); z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 ); if ( z <= 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 );
} }
...@@ -614,7 +614,7 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a ) ...@@ -614,7 +614,7 @@ static bits32 estimateSqrt32( int16 aExp, bits32 a )
| `a'. If `a' is zero, 32 is returned. | `a'. If `a' is zero, 32 is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int8 countLeadingZeros32( bits32 a ) static int8 countLeadingZeros32( uint32_t a )
{ {
static const int8 countLeadingZerosHigh[] = { static const int8 countLeadingZerosHigh[] = {
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 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 ) ...@@ -655,12 +655,12 @@ static int8 countLeadingZeros32( bits32 a )
| `a'. If `a' is zero, 64 is returned. | `a'. If `a' is zero, 64 is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int8 countLeadingZeros64( bits64 a ) static int8 countLeadingZeros64( uint64_t a )
{ {
int8 shiftCount; int8 shiftCount;
shiftCount = 0; shiftCount = 0;
if ( a < ( (bits64) 1 )<<32 ) { if ( a < ( (uint64_t) 1 )<<32 ) {
shiftCount += 32; shiftCount += 32;
} }
else { else {
...@@ -677,7 +677,7 @@ static int8 countLeadingZeros64( bits64 a ) ...@@ -677,7 +677,7 @@ static int8 countLeadingZeros64( bits64 a )
| Otherwise, returns 0. | Otherwise, returns 0.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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 )
{ {
return ( a0 == b0 ) && ( a1 == b1 ); return ( a0 == b0 ) && ( a1 == b1 );
...@@ -690,7 +690,7 @@ INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) ...@@ -690,7 +690,7 @@ INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
| Otherwise, returns 0. | Otherwise, returns 0.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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 )
{ {
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) ); return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
...@@ -703,7 +703,7 @@ INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) ...@@ -703,7 +703,7 @@ INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
| returns 0. | returns 0.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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 )
{ {
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) ); return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
...@@ -716,7 +716,7 @@ INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 ) ...@@ -716,7 +716,7 @@ INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
| Otherwise, returns 0. | Otherwise, returns 0.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
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 )
{ {
return ( a0 != b0 ) || ( a1 != b1 ); return ( a0 != b0 ) || ( a1 != b1 );
......
fpu/softfloat-native.c
浏览文件 @ bb98fe42
...@@ -418,7 +418,7 @@ int float64_is_quiet_nan( float64 a1 ) ...@@ -418,7 +418,7 @@ int float64_is_quiet_nan( float64 a1 )
u.f = a1; u.f = a1;
a = u.i; a = u.i;
return ( LIT64( 0xFFF0000000000000 ) < (bits64) ( a<<1 ) ); return ( LIT64( 0xFFF0000000000000 ) < (uint64_t) ( a<<1 ) );
} }
...@@ -500,7 +500,7 @@ int floatx80_is_signaling_nan( floatx80 a1) ...@@ -500,7 +500,7 @@ int floatx80_is_signaling_nan( floatx80 a1)
aLow = u.i.low & ~ LIT64( 0x4000000000000000 ); aLow = u.i.low & ~ LIT64( 0x4000000000000000 );
return return
( ( u.i.high & 0x7FFF ) == 0x7FFF ) ( ( u.i.high & 0x7FFF ) == 0x7FFF )
&& (bits64) ( aLow<<1 ) && (uint64_t) ( aLow<<1 )
&& ( u.i.low == aLow ); && ( u.i.low == aLow );
} }
...@@ -508,7 +508,7 @@ int floatx80_is_quiet_nan( floatx80 a1 ) ...@@ -508,7 +508,7 @@ int floatx80_is_quiet_nan( floatx80 a1 )
{ {
floatx80u u; floatx80u u;
u.f = a1; u.f = a1;
return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( u.i.low<<1 ); return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (uint64_t) ( u.i.low<<1 );
} }
#endif #endif
fpu/softfloat-specialize.h
浏览文件 @ bb98fe42
...@@ -52,7 +52,7 @@ void float_raise( int8 flags STATUS_PARAM ) ...@@ -52,7 +52,7 @@ void float_raise( int8 flags STATUS_PARAM )
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
typedef struct { typedef struct {
flag sign; flag sign;
bits64 high, low; uint64_t high, low;
} commonNaNT; } commonNaNT;
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
...@@ -120,7 +120,7 @@ static commonNaNT float16ToCommonNaN( float16 a STATUS_PARAM ) ...@@ -120,7 +120,7 @@ static commonNaNT float16ToCommonNaN( float16 a STATUS_PARAM )
if ( float16_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR ); if ( float16_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
z.sign = float16_val(a) >> 15; z.sign = float16_val(a) >> 15;
z.low = 0; z.low = 0;
z.high = ((bits64) float16_val(a))<<54; z.high = ((uint64_t) float16_val(a))<<54;
return z; return z;
} }
...@@ -156,7 +156,7 @@ int float32_is_quiet_nan( float32 a_ ) ...@@ -156,7 +156,7 @@ int float32_is_quiet_nan( float32 a_ )
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
#else #else
return ( 0xFF800000 <= (bits32) ( a<<1 ) ); return ( 0xFF800000 <= (uint32_t) ( a<<1 ) );
#endif #endif
} }
...@@ -169,7 +169,7 @@ int float32_is_signaling_nan( float32 a_ ) ...@@ -169,7 +169,7 @@ int float32_is_signaling_nan( float32 a_ )
{ {
uint32_t a = float32_val(a_); uint32_t a = float32_val(a_);
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return ( 0xFF800000 <= (bits32) ( a<<1 ) ); return ( 0xFF800000 <= (uint32_t) ( a<<1 ) );
#else #else
return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
#endif #endif
...@@ -190,7 +190,7 @@ float32 float32_maybe_silence_nan( float32 a_ ) ...@@ -190,7 +190,7 @@ float32 float32_maybe_silence_nan( float32 a_ )
# error Rules for silencing a signaling NaN are target-specific # error Rules for silencing a signaling NaN are target-specific
# endif # endif
#else #else
bits32 a = float32_val(a_); uint32_t a = float32_val(a_);
a |= (1 << 22); a |= (1 << 22);
return make_float32(a); return make_float32(a);
#endif #endif
...@@ -211,7 +211,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM ) ...@@ -211,7 +211,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR ); if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
z.sign = float32_val(a)>>31; z.sign = float32_val(a)>>31;
z.low = 0; z.low = 0;
z.high = ( (bits64) float32_val(a) )<<41; z.high = ( (uint64_t) float32_val(a) )<<41;
return z; return z;
} }
...@@ -222,7 +222,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM ) ...@@ -222,7 +222,7 @@ static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM) static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM)
{ {
bits32 mantissa = a.high>>41; uint32_t mantissa = a.high>>41;
if ( STATUS(default_nan_mode) ) { if ( STATUS(default_nan_mode) ) {
return float32_default_nan; return float32_default_nan;
...@@ -230,7 +230,7 @@ static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM) ...@@ -230,7 +230,7 @@ static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM)
if ( mantissa ) if ( mantissa )
return make_float32( return make_float32(
( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) ); ( ( (uint32_t) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
else else
return float32_default_nan; return float32_default_nan;
} }
...@@ -357,7 +357,7 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) ...@@ -357,7 +357,7 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
{ {
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN; flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand; flag aIsLargerSignificand;
bits32 av, bv; uint32_t av, bv;
aIsQuietNaN = float32_is_quiet_nan( a ); aIsQuietNaN = float32_is_quiet_nan( a );
aIsSignalingNaN = float32_is_signaling_nan( a ); aIsSignalingNaN = float32_is_signaling_nan( a );
...@@ -371,9 +371,9 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) ...@@ -371,9 +371,9 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
if ( STATUS(default_nan_mode) ) if ( STATUS(default_nan_mode) )
return float32_default_nan; return float32_default_nan;
if ((bits32)(av<<1) < (bits32)(bv<<1)) { if ((uint32_t)(av<<1) < (uint32_t)(bv<<1)) {
aIsLargerSignificand = 0; aIsLargerSignificand = 0;
} else if ((bits32)(bv<<1) < (bits32)(av<<1)) { } else if ((uint32_t)(bv<<1) < (uint32_t)(av<<1)) {
aIsLargerSignificand = 1; aIsLargerSignificand = 1;
} else { } else {
aIsLargerSignificand = (av < bv) ? 1 : 0; aIsLargerSignificand = (av < bv) ? 1 : 0;
...@@ -394,13 +394,13 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) ...@@ -394,13 +394,13 @@ static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
int float64_is_quiet_nan( float64 a_ ) int float64_is_quiet_nan( float64 a_ )
{ {
bits64 a = float64_val(a_); uint64_t a = float64_val(a_);
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return return
( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
&& ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
#else #else
return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) ); return ( LIT64( 0xFFF0000000000000 ) <= (uint64_t) ( a<<1 ) );
#endif #endif
} }
...@@ -411,9 +411,9 @@ int float64_is_quiet_nan( float64 a_ ) ...@@ -411,9 +411,9 @@ int float64_is_quiet_nan( float64 a_ )
int float64_is_signaling_nan( float64 a_ ) int float64_is_signaling_nan( float64 a_ )
{ {
bits64 a = float64_val(a_); uint64_t a = float64_val(a_);
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) ); return ( LIT64( 0xFFF0000000000000 ) <= (uint64_t) ( a<<1 ) );
#else #else
return return
( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
...@@ -436,7 +436,7 @@ float64 float64_maybe_silence_nan( float64 a_ ) ...@@ -436,7 +436,7 @@ float64 float64_maybe_silence_nan( float64 a_ )
# error Rules for silencing a signaling NaN are target-specific # error Rules for silencing a signaling NaN are target-specific
# endif # endif
#else #else
bits64 a = float64_val(a_); uint64_t a = float64_val(a_);
a |= LIT64( 0x0008000000000000 ); a |= LIT64( 0x0008000000000000 );
return make_float64(a); return make_float64(a);
#endif #endif
...@@ -468,7 +468,7 @@ static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM) ...@@ -468,7 +468,7 @@ static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM) static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
{ {
bits64 mantissa = a.high>>12; uint64_t mantissa = a.high>>12;
if ( STATUS(default_nan_mode) ) { if ( STATUS(default_nan_mode) ) {
return float64_default_nan; return float64_default_nan;
...@@ -476,7 +476,7 @@ static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM) ...@@ -476,7 +476,7 @@ static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
if ( mantissa ) if ( mantissa )
return make_float64( return make_float64(
( ( (bits64) a.sign )<<63 ) ( ( (uint64_t) a.sign )<<63 )
| LIT64( 0x7FF0000000000000 ) | LIT64( 0x7FF0000000000000 )
| ( a.high>>12 )); | ( a.high>>12 ));
else else
...@@ -493,7 +493,7 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) ...@@ -493,7 +493,7 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
{ {
flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN; flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
flag aIsLargerSignificand; flag aIsLargerSignificand;
bits64 av, bv; uint64_t av, bv;
aIsQuietNaN = float64_is_quiet_nan( a ); aIsQuietNaN = float64_is_quiet_nan( a );
aIsSignalingNaN = float64_is_signaling_nan( a ); aIsSignalingNaN = float64_is_signaling_nan( a );
...@@ -507,9 +507,9 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) ...@@ -507,9 +507,9 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
if ( STATUS(default_nan_mode) ) if ( STATUS(default_nan_mode) )
return float64_default_nan; return float64_default_nan;
if ((bits64)(av<<1) < (bits64)(bv<<1)) { if ((uint64_t)(av<<1) < (uint64_t)(bv<<1)) {
aIsLargerSignificand = 0; aIsLargerSignificand = 0;
} else if ((bits64)(bv<<1) < (bits64)(av<<1)) { } else if ((uint64_t)(bv<<1) < (uint64_t)(av<<1)) {
aIsLargerSignificand = 1; aIsLargerSignificand = 1;
} else { } else {
aIsLargerSignificand = (av < bv) ? 1 : 0; aIsLargerSignificand = (av < bv) ? 1 : 0;
...@@ -534,16 +534,16 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) ...@@ -534,16 +534,16 @@ static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
int floatx80_is_quiet_nan( floatx80 a ) int floatx80_is_quiet_nan( floatx80 a )
{ {
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
bits64 aLow; uint64_t aLow;
aLow = a.low & ~ LIT64( 0x4000000000000000 ); aLow = a.low & ~ LIT64( 0x4000000000000000 );
return return
( ( a.high & 0x7FFF ) == 0x7FFF ) ( ( a.high & 0x7FFF ) == 0x7FFF )
&& (bits64) ( aLow<<1 ) && (uint64_t) ( aLow<<1 )
&& ( a.low == aLow ); && ( a.low == aLow );
#else #else
return ( ( a.high & 0x7FFF ) == 0x7FFF ) return ( ( a.high & 0x7FFF ) == 0x7FFF )
&& (LIT64( 0x8000000000000000 ) <= ((bits64) ( a.low<<1 ))); && (LIT64( 0x8000000000000000 ) <= ((uint64_t) ( a.low<<1 )));
#endif #endif
} }
...@@ -557,14 +557,14 @@ int floatx80_is_signaling_nan( floatx80 a ) ...@@ -557,14 +557,14 @@ int floatx80_is_signaling_nan( floatx80 a )
{ {
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return ( ( a.high & 0x7FFF ) == 0x7FFF ) return ( ( a.high & 0x7FFF ) == 0x7FFF )
&& (LIT64( 0x8000000000000000 ) <= ((bits64) ( a.low<<1 ))); && (LIT64( 0x8000000000000000 ) <= ((uint64_t) ( a.low<<1 )));
#else #else
bits64 aLow; uint64_t aLow;
aLow = a.low & ~ LIT64( 0x4000000000000000 ); aLow = a.low & ~ LIT64( 0x4000000000000000 );
return return
( ( a.high & 0x7FFF ) == 0x7FFF ) ( ( a.high & 0x7FFF ) == 0x7FFF )
&& (bits64) ( aLow<<1 ) && (uint64_t) ( aLow<<1 )
&& ( a.low == aLow ); && ( a.low == aLow );
#endif #endif
} }
...@@ -628,7 +628,7 @@ static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM) ...@@ -628,7 +628,7 @@ static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM)
z.low = a.high; z.low = a.high;
else else
z.low = floatx80_default_nan_low; z.low = floatx80_default_nan_low;
z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF; z.high = ( ( (uint16_t) a.sign )<<15 ) | 0x7FFF;
return z; return z;
} }
...@@ -689,7 +689,7 @@ int float128_is_quiet_nan( float128 a ) ...@@ -689,7 +689,7 @@ int float128_is_quiet_nan( float128 a )
&& ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
#else #else
return return
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) ( LIT64( 0xFFFE000000000000 ) <= (uint64_t) ( a.high<<1 ) )
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
#endif #endif
} }
...@@ -703,7 +703,7 @@ int float128_is_signaling_nan( float128 a ) ...@@ -703,7 +703,7 @@ int float128_is_signaling_nan( float128 a )
{ {
#if SNAN_BIT_IS_ONE #if SNAN_BIT_IS_ONE
return return
( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) ( LIT64( 0xFFFE000000000000 ) <= (uint64_t) ( a.high<<1 ) )
&& ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
#else #else
return return
...@@ -767,7 +767,7 @@ static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM) ...@@ -767,7 +767,7 @@ static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM)
} }
shift128Right( a.high, a.low, 16, &z.high, &z.low ); shift128Right( a.high, a.low, 16, &z.high, &z.low );
z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 ); z.high |= ( ( (uint64_t) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
return z; return z;
} }
......
fpu/softfloat.c
浏览文件 @ bb98fe42
...@@ -109,7 +109,7 @@ INLINE flag extractFloat16Sign(float16 a) ...@@ -109,7 +109,7 @@ INLINE flag extractFloat16Sign(float16 a)
| positive or negative integer is returned. | positive or negative integer is returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM) static int32 roundAndPackInt32( flag zSign, uint64_t absZ STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
flag roundNearestEven; flag roundNearestEven;
...@@ -140,7 +140,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM) ...@@ -140,7 +140,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM)
if ( zSign ) z = - z; if ( zSign ) z = - z;
if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) { if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
} }
if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact; if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
return z; return z;
...@@ -159,7 +159,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM) ...@@ -159,7 +159,7 @@ static int32 roundAndPackInt32( flag zSign, bits64 absZ STATUS_PARAM)
| returned. | returned.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PARAM) static int64 roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1 STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
flag roundNearestEven, increment; flag roundNearestEven, increment;
...@@ -167,7 +167,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA ...@@ -167,7 +167,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA
roundingMode = STATUS(float_rounding_mode); roundingMode = STATUS(float_rounding_mode);
roundNearestEven = ( roundingMode == float_round_nearest_even ); roundNearestEven = ( roundingMode == float_round_nearest_even );
increment = ( (sbits64) absZ1 < 0 ); increment = ( (int64_t) absZ1 < 0 );
if ( ! roundNearestEven ) { if ( ! roundNearestEven ) {
if ( roundingMode == float_round_to_zero ) { if ( roundingMode == float_round_to_zero ) {
increment = 0; increment = 0;
...@@ -184,7 +184,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA ...@@ -184,7 +184,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA
if ( increment ) { if ( increment ) {
++absZ0; ++absZ0;
if ( absZ0 == 0 ) goto overflow; if ( absZ0 == 0 ) goto overflow;
absZ0 &= ~ ( ( (bits64) ( absZ1<<1 ) == 0 ) & roundNearestEven ); absZ0 &= ~ ( ( (uint64_t) ( absZ1<<1 ) == 0 ) & roundNearestEven );
} }
z = absZ0; z = absZ0;
if ( zSign ) z = - z; if ( zSign ) z = - z;
...@@ -192,7 +192,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA ...@@ -192,7 +192,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA
overflow: overflow:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return return
zSign ? (sbits64) LIT64( 0x8000000000000000 ) zSign ? (int64_t) LIT64( 0x8000000000000000 )
: LIT64( 0x7FFFFFFFFFFFFFFF ); : LIT64( 0x7FFFFFFFFFFFFFFF );
} }
if ( absZ1 ) STATUS(float_exception_flags) |= float_flag_inexact; if ( absZ1 ) STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -204,7 +204,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA ...@@ -204,7 +204,7 @@ static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 STATUS_PA
| Returns the fraction bits of the single-precision floating-point value `a'. | Returns the fraction bits of the single-precision floating-point value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE bits32 extractFloat32Frac( float32 a ) INLINE uint32_t extractFloat32Frac( float32 a )
{ {
return float32_val(a) & 0x007FFFFF; return float32_val(a) & 0x007FFFFF;
...@@ -256,7 +256,7 @@ static float32 float32_squash_input_denormal(float32 a STATUS_PARAM) ...@@ -256,7 +256,7 @@ static float32 float32_squash_input_denormal(float32 a STATUS_PARAM)
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static void static void
normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr ) normalizeFloat32Subnormal( uint32_t aSig, int16 *zExpPtr, uint32_t *zSigPtr )
{ {
int8 shiftCount; int8 shiftCount;
...@@ -277,11 +277,11 @@ static void ...@@ -277,11 +277,11 @@ static void
| significand. | significand.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig ) INLINE float32 packFloat32( flag zSign, int16 zExp, uint32_t zSig )
{ {
return make_float32( return make_float32(
( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig); ( ( (uint32_t) zSign )<<31 ) + ( ( (uint32_t) zExp )<<23 ) + zSig);
} }
...@@ -307,7 +307,7 @@ INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig ) ...@@ -307,7 +307,7 @@ INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
| Binary Floating-Point Arithmetic. | Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_PARAM) static float32 roundAndPackFloat32( flag zSign, int16 zExp, uint32_t zSig STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
flag roundNearestEven; flag roundNearestEven;
...@@ -332,10 +332,10 @@ static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_P ...@@ -332,10 +332,10 @@ static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_P
} }
} }
roundBits = zSig & 0x7F; roundBits = zSig & 0x7F;
if ( 0xFD <= (bits16) zExp ) { if ( 0xFD <= (uint16_t) zExp ) {
if ( ( 0xFD < zExp ) if ( ( 0xFD < zExp )
|| ( ( zExp == 0xFD ) || ( ( zExp == 0xFD )
&& ( (sbits32) ( zSig + roundIncrement ) < 0 ) ) && ( (int32_t) ( zSig + roundIncrement ) < 0 ) )
) { ) {
float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR); float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR);
return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 )); return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 ));
...@@ -370,7 +370,7 @@ static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_P ...@@ -370,7 +370,7 @@ static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_P
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float32 static float32
normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig STATUS_PARAM) normalizeRoundAndPackFloat32( flag zSign, int16 zExp, uint32_t zSig STATUS_PARAM)
{ {
int8 shiftCount; int8 shiftCount;
...@@ -383,7 +383,7 @@ static float32 ...@@ -383,7 +383,7 @@ static float32
| Returns the fraction bits of the double-precision floating-point value `a'. | Returns the fraction bits of the double-precision floating-point value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE bits64 extractFloat64Frac( float64 a ) INLINE uint64_t extractFloat64Frac( float64 a )
{ {
return float64_val(a) & LIT64( 0x000FFFFFFFFFFFFF ); return float64_val(a) & LIT64( 0x000FFFFFFFFFFFFF );
...@@ -435,7 +435,7 @@ static float64 float64_squash_input_denormal(float64 a STATUS_PARAM) ...@@ -435,7 +435,7 @@ static float64 float64_squash_input_denormal(float64 a STATUS_PARAM)
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static void static void
normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr ) normalizeFloat64Subnormal( uint64_t aSig, int16 *zExpPtr, uint64_t *zSigPtr )
{ {
int8 shiftCount; int8 shiftCount;
...@@ -456,11 +456,11 @@ static void ...@@ -456,11 +456,11 @@ static void
| significand. | significand.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig ) INLINE float64 packFloat64( flag zSign, int16 zExp, uint64_t zSig )
{ {
return make_float64( return make_float64(
( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig); ( ( (uint64_t) zSign )<<63 ) + ( ( (uint64_t) zExp )<<52 ) + zSig);
} }
...@@ -486,7 +486,7 @@ INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig ) ...@@ -486,7 +486,7 @@ INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
| Binary Floating-Point Arithmetic. | Binary Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_PARAM) static float64 roundAndPackFloat64( flag zSign, int16 zExp, uint64_t zSig STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
flag roundNearestEven; flag roundNearestEven;
...@@ -511,10 +511,10 @@ static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_P ...@@ -511,10 +511,10 @@ static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_P
} }
} }
roundBits = zSig & 0x3FF; roundBits = zSig & 0x3FF;
if ( 0x7FD <= (bits16) zExp ) { if ( 0x7FD <= (uint16_t) zExp ) {
if ( ( 0x7FD < zExp ) if ( ( 0x7FD < zExp )
|| ( ( zExp == 0x7FD ) || ( ( zExp == 0x7FD )
&& ( (sbits64) ( zSig + roundIncrement ) < 0 ) ) && ( (int64_t) ( zSig + roundIncrement ) < 0 ) )
) { ) {
float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR); float_raise( float_flag_overflow | float_flag_inexact STATUS_VAR);
return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 )); return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 ));
...@@ -549,7 +549,7 @@ static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_P ...@@ -549,7 +549,7 @@ static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_P
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float64 static float64
normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig STATUS_PARAM) normalizeRoundAndPackFloat64( flag zSign, int16 zExp, uint64_t zSig STATUS_PARAM)
{ {
int8 shiftCount; int8 shiftCount;
...@@ -565,7 +565,7 @@ static float64 ...@@ -565,7 +565,7 @@ static float64
| value `a'. | value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE bits64 extractFloatx80Frac( floatx80 a ) INLINE uint64_t extractFloatx80Frac( floatx80 a )
{ {
return a.low; return a.low;
...@@ -604,7 +604,7 @@ INLINE flag extractFloatx80Sign( floatx80 a ) ...@@ -604,7 +604,7 @@ INLINE flag extractFloatx80Sign( floatx80 a )
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static void static void
normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr ) normalizeFloatx80Subnormal( uint64_t aSig, int32 *zExpPtr, uint64_t *zSigPtr )
{ {
int8 shiftCount; int8 shiftCount;
...@@ -619,12 +619,12 @@ static void ...@@ -619,12 +619,12 @@ static void
| extended double-precision floating-point value, returning the result. | extended double-precision floating-point value, returning the result.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig ) INLINE floatx80 packFloatx80( flag zSign, int32 zExp, uint64_t zSig )
{ {
floatx80 z; floatx80 z;
z.low = zSig; z.low = zSig;
z.high = ( ( (bits16) zSign )<<15 ) + zExp; z.high = ( ( (uint16_t) zSign )<<15 ) + zExp;
return z; return z;
} }
...@@ -655,7 +655,7 @@ INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig ) ...@@ -655,7 +655,7 @@ INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
static floatx80 static floatx80
roundAndPackFloatx80( roundAndPackFloatx80(
int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1
STATUS_PARAM) STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
...@@ -692,7 +692,7 @@ static floatx80 ...@@ -692,7 +692,7 @@ static floatx80
} }
} }
roundBits = zSig0 & roundMask; roundBits = zSig0 & roundMask;
if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) { if ( 0x7FFD <= (uint32_t) ( zExp - 1 ) ) {
if ( ( 0x7FFE < zExp ) if ( ( 0x7FFE < zExp )
|| ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) ) || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )
) { ) {
...@@ -710,7 +710,7 @@ static floatx80 ...@@ -710,7 +710,7 @@ static floatx80
if ( isTiny && roundBits ) float_raise( float_flag_underflow STATUS_VAR); if ( isTiny && roundBits ) float_raise( float_flag_underflow STATUS_VAR);
if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact; if ( roundBits ) STATUS(float_exception_flags) |= float_flag_inexact;
zSig0 += roundIncrement; zSig0 += roundIncrement;
if ( (sbits64) zSig0 < 0 ) zExp = 1; if ( (int64_t) zSig0 < 0 ) zExp = 1;
roundIncrement = roundMask + 1; roundIncrement = roundMask + 1;
if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) { if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
roundMask |= roundIncrement; roundMask |= roundIncrement;
...@@ -733,7 +733,7 @@ static floatx80 ...@@ -733,7 +733,7 @@ static floatx80
if ( zSig0 == 0 ) zExp = 0; if ( zSig0 == 0 ) zExp = 0;
return packFloatx80( zSign, zExp, zSig0 ); return packFloatx80( zSign, zExp, zSig0 );
precision80: precision80:
increment = ( (sbits64) zSig1 < 0 ); increment = ( (int64_t) zSig1 < 0 );
if ( ! roundNearestEven ) { if ( ! roundNearestEven ) {
if ( roundingMode == float_round_to_zero ) { if ( roundingMode == float_round_to_zero ) {
increment = 0; increment = 0;
...@@ -747,7 +747,7 @@ static floatx80 ...@@ -747,7 +747,7 @@ static floatx80
} }
} }
} }
if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) { if ( 0x7FFD <= (uint32_t) ( zExp - 1 ) ) {
if ( ( 0x7FFE < zExp ) if ( ( 0x7FFE < zExp )
|| ( ( zExp == 0x7FFE ) || ( ( zExp == 0x7FFE )
&& ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) ) && ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) )
...@@ -776,7 +776,7 @@ static floatx80 ...@@ -776,7 +776,7 @@ static floatx80
if ( isTiny && zSig1 ) float_raise( float_flag_underflow STATUS_VAR); if ( isTiny && zSig1 ) float_raise( float_flag_underflow STATUS_VAR);
if ( zSig1 ) STATUS(float_exception_flags) |= float_flag_inexact; if ( zSig1 ) STATUS(float_exception_flags) |= float_flag_inexact;
if ( roundNearestEven ) { if ( roundNearestEven ) {
increment = ( (sbits64) zSig1 < 0 ); increment = ( (int64_t) zSig1 < 0 );
} }
else { else {
if ( zSign ) { if ( zSign ) {
...@@ -789,8 +789,8 @@ static floatx80 ...@@ -789,8 +789,8 @@ static floatx80
if ( increment ) { if ( increment ) {
++zSig0; ++zSig0;
zSig0 &= zSig0 &=
~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven ); ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
if ( (sbits64) zSig0 < 0 ) zExp = 1; if ( (int64_t) zSig0 < 0 ) zExp = 1;
} }
return packFloatx80( zSign, zExp, zSig0 ); return packFloatx80( zSign, zExp, zSig0 );
} }
...@@ -803,7 +803,7 @@ static floatx80 ...@@ -803,7 +803,7 @@ static floatx80
zSig0 = LIT64( 0x8000000000000000 ); zSig0 = LIT64( 0x8000000000000000 );
} }
else { else {
zSig0 &= ~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven ); zSig0 &= ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
} }
} }
else { else {
...@@ -824,7 +824,7 @@ static floatx80 ...@@ -824,7 +824,7 @@ static floatx80
static floatx80 static floatx80
normalizeRoundAndPackFloatx80( normalizeRoundAndPackFloatx80(
int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 int8 roundingPrecision, flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1
STATUS_PARAM) STATUS_PARAM)
{ {
int8 shiftCount; int8 shiftCount;
...@@ -851,7 +851,7 @@ static floatx80 ...@@ -851,7 +851,7 @@ static floatx80
| floating-point value `a'. | floating-point value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE bits64 extractFloat128Frac1( float128 a ) INLINE uint64_t extractFloat128Frac1( float128 a )
{ {
return a.low; return a.low;
...@@ -863,7 +863,7 @@ INLINE bits64 extractFloat128Frac1( float128 a ) ...@@ -863,7 +863,7 @@ INLINE bits64 extractFloat128Frac1( float128 a )
| floating-point value `a'. | floating-point value `a'.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE bits64 extractFloat128Frac0( float128 a ) INLINE uint64_t extractFloat128Frac0( float128 a )
{ {
return a.high & LIT64( 0x0000FFFFFFFFFFFF ); return a.high & LIT64( 0x0000FFFFFFFFFFFF );
...@@ -905,11 +905,11 @@ INLINE flag extractFloat128Sign( float128 a ) ...@@ -905,11 +905,11 @@ INLINE flag extractFloat128Sign( float128 a )
static void static void
normalizeFloat128Subnormal( normalizeFloat128Subnormal(
bits64 aSig0, uint64_t aSig0,
bits64 aSig1, uint64_t aSig1,
int32 *zExpPtr, int32 *zExpPtr,
bits64 *zSig0Ptr, uint64_t *zSig0Ptr,
bits64 *zSig1Ptr uint64_t *zSig1Ptr
) )
{ {
int8 shiftCount; int8 shiftCount;
...@@ -948,12 +948,12 @@ static void ...@@ -948,12 +948,12 @@ static void
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
INLINE float128 INLINE float128
packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 ) packFloat128( flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1 )
{ {
float128 z; float128 z;
z.low = zSig1; z.low = zSig1;
z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0; z.high = ( ( (uint64_t) zSign )<<63 ) + ( ( (uint64_t) zExp )<<48 ) + zSig0;
return z; return z;
} }
...@@ -981,14 +981,14 @@ INLINE float128 ...@@ -981,14 +981,14 @@ INLINE float128
static float128 static float128
roundAndPackFloat128( roundAndPackFloat128(
flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 STATUS_PARAM) flag zSign, int32 zExp, uint64_t zSig0, uint64_t zSig1, uint64_t zSig2 STATUS_PARAM)
{ {
int8 roundingMode; int8 roundingMode;
flag roundNearestEven, increment, isTiny; flag roundNearestEven, increment, isTiny;
roundingMode = STATUS(float_rounding_mode); roundingMode = STATUS(float_rounding_mode);
roundNearestEven = ( roundingMode == float_round_nearest_even ); roundNearestEven = ( roundingMode == float_round_nearest_even );
increment = ( (sbits64) zSig2 < 0 ); increment = ( (int64_t) zSig2 < 0 );
if ( ! roundNearestEven ) { if ( ! roundNearestEven ) {
if ( roundingMode == float_round_to_zero ) { if ( roundingMode == float_round_to_zero ) {
increment = 0; increment = 0;
...@@ -1002,7 +1002,7 @@ static float128 ...@@ -1002,7 +1002,7 @@ static float128
} }
} }
} }
if ( 0x7FFD <= (bits32) zExp ) { if ( 0x7FFD <= (uint32_t) zExp ) {
if ( ( 0x7FFD < zExp ) if ( ( 0x7FFD < zExp )
|| ( ( zExp == 0x7FFD ) || ( ( zExp == 0x7FFD )
&& eq128( && eq128(
...@@ -1046,7 +1046,7 @@ static float128 ...@@ -1046,7 +1046,7 @@ static float128
zExp = 0; zExp = 0;
if ( isTiny && zSig2 ) float_raise( float_flag_underflow STATUS_VAR); if ( isTiny && zSig2 ) float_raise( float_flag_underflow STATUS_VAR);
if ( roundNearestEven ) { if ( roundNearestEven ) {
increment = ( (sbits64) zSig2 < 0 ); increment = ( (int64_t) zSig2 < 0 );
} }
else { else {
if ( zSign ) { if ( zSign ) {
...@@ -1082,10 +1082,10 @@ static float128 ...@@ -1082,10 +1082,10 @@ static float128
static float128 static float128
normalizeRoundAndPackFloat128( 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; int8 shiftCount;
bits64 zSig2; uint64_t zSig2;
if ( zSig0 == 0 ) { if ( zSig0 == 0 ) {
zSig0 = zSig1; zSig0 = zSig1;
...@@ -1119,7 +1119,7 @@ float32 int32_to_float32( int32 a STATUS_PARAM ) ...@@ -1119,7 +1119,7 @@ float32 int32_to_float32( int32 a STATUS_PARAM )
flag zSign; flag zSign;
if ( a == 0 ) return float32_zero; if ( a == 0 ) return float32_zero;
if ( a == (sbits32) 0x80000000 ) return packFloat32( 1, 0x9E, 0 ); if ( a == (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
zSign = ( a < 0 ); zSign = ( a < 0 );
return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a STATUS_VAR ); return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a STATUS_VAR );
...@@ -1136,7 +1136,7 @@ float64 int32_to_float64( int32 a STATUS_PARAM ) ...@@ -1136,7 +1136,7 @@ float64 int32_to_float64( int32 a STATUS_PARAM )
flag zSign; flag zSign;
uint32 absA; uint32 absA;
int8 shiftCount; int8 shiftCount;
bits64 zSig; uint64_t zSig;
if ( a == 0 ) return float64_zero; if ( a == 0 ) return float64_zero;
zSign = ( a < 0 ); zSign = ( a < 0 );
...@@ -1161,7 +1161,7 @@ floatx80 int32_to_floatx80( int32 a STATUS_PARAM ) ...@@ -1161,7 +1161,7 @@ floatx80 int32_to_floatx80( int32 a STATUS_PARAM )
flag zSign; flag zSign;
uint32 absA; uint32 absA;
int8 shiftCount; int8 shiftCount;
bits64 zSig; uint64_t zSig;
if ( a == 0 ) return packFloatx80( 0, 0, 0 ); if ( a == 0 ) return packFloatx80( 0, 0, 0 );
zSign = ( a < 0 ); zSign = ( a < 0 );
...@@ -1187,7 +1187,7 @@ float128 int32_to_float128( int32 a STATUS_PARAM ) ...@@ -1187,7 +1187,7 @@ float128 int32_to_float128( int32 a STATUS_PARAM )
flag zSign; flag zSign;
uint32 absA; uint32 absA;
int8 shiftCount; int8 shiftCount;
bits64 zSig0; uint64_t zSig0;
if ( a == 0 ) return packFloat128( 0, 0, 0, 0 ); if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
zSign = ( a < 0 ); zSign = ( a < 0 );
...@@ -1264,7 +1264,7 @@ float64 int64_to_float64( int64 a STATUS_PARAM ) ...@@ -1264,7 +1264,7 @@ float64 int64_to_float64( int64 a STATUS_PARAM )
flag zSign; flag zSign;
if ( a == 0 ) return float64_zero; if ( a == 0 ) return float64_zero;
if ( a == (sbits64) LIT64( 0x8000000000000000 ) ) { if ( a == (int64_t) LIT64( 0x8000000000000000 ) ) {
return packFloat64( 1, 0x43E, 0 ); return packFloat64( 1, 0x43E, 0 );
} }
zSign = ( a < 0 ); zSign = ( a < 0 );
...@@ -1318,7 +1318,7 @@ float128 int64_to_float128( int64 a STATUS_PARAM ) ...@@ -1318,7 +1318,7 @@ float128 int64_to_float128( int64 a STATUS_PARAM )
uint64 absA; uint64 absA;
int8 shiftCount; int8 shiftCount;
int32 zExp; int32 zExp;
bits64 zSig0, zSig1; uint64_t zSig0, zSig1;
if ( a == 0 ) return packFloat128( 0, 0, 0, 0 ); if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
zSign = ( a < 0 ); zSign = ( a < 0 );
...@@ -1355,8 +1355,8 @@ int32 float32_to_int32( float32 a STATUS_PARAM ) ...@@ -1355,8 +1355,8 @@ int32 float32_to_int32( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits32 aSig; uint32_t aSig;
bits64 aSig64; uint64_t aSig64;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1386,7 +1386,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1386,7 +1386,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits32 aSig; uint32_t aSig;
int32 z; int32 z;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
...@@ -1399,7 +1399,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1399,7 +1399,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF; if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
} }
return (sbits32) 0x80000000; return (int32_t) 0x80000000;
} }
else if ( aExp <= 0x7E ) { else if ( aExp <= 0x7E ) {
if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact; if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -1407,7 +1407,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1407,7 +1407,7 @@ int32 float32_to_int32_round_to_zero( float32 a STATUS_PARAM )
} }
aSig = ( aSig | 0x00800000 )<<8; aSig = ( aSig | 0x00800000 )<<8;
z = aSig>>( - shiftCount ); z = aSig>>( - shiftCount );
if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) { if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
if ( aSign ) z = - z; if ( aSign ) z = - z;
...@@ -1429,7 +1429,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1429,7 +1429,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits32 aSig; uint32_t aSig;
int32 z; int32 z;
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1443,7 +1443,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1443,7 +1443,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM )
return 0x7FFF; return 0x7FFF;
} }
} }
return (sbits32) 0xffff8000; return (int32_t) 0xffff8000;
} }
else if ( aExp <= 0x7E ) { else if ( aExp <= 0x7E ) {
if ( aExp | aSig ) { if ( aExp | aSig ) {
...@@ -1454,7 +1454,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1454,7 +1454,7 @@ int16 float32_to_int16_round_to_zero( float32 a STATUS_PARAM )
shiftCount -= 0x10; shiftCount -= 0x10;
aSig = ( aSig | 0x00800000 )<<8; aSig = ( aSig | 0x00800000 )<<8;
z = aSig>>( - shiftCount ); z = aSig>>( - shiftCount );
if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) { if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
if ( aSign ) { if ( aSign ) {
...@@ -1478,8 +1478,8 @@ int64 float32_to_int64( float32 a STATUS_PARAM ) ...@@ -1478,8 +1478,8 @@ int64 float32_to_int64( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits32 aSig; uint32_t aSig;
bits64 aSig64, aSigExtra; uint64_t aSig64, aSigExtra;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1491,7 +1491,7 @@ int64 float32_to_int64( float32 a STATUS_PARAM ) ...@@ -1491,7 +1491,7 @@ int64 float32_to_int64( float32 a STATUS_PARAM )
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) { if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
if ( aExp ) aSig |= 0x00800000; if ( aExp ) aSig |= 0x00800000;
aSig64 = aSig; aSig64 = aSig;
...@@ -1515,8 +1515,8 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1515,8 +1515,8 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits32 aSig; uint32_t aSig;
bits64 aSig64; uint64_t aSig64;
int64 z; int64 z;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
...@@ -1531,7 +1531,7 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1531,7 +1531,7 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM )
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
else if ( aExp <= 0x7E ) { else if ( aExp <= 0x7E ) {
if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact; if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -1540,7 +1540,7 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM ) ...@@ -1540,7 +1540,7 @@ int64 float32_to_int64_round_to_zero( float32 a STATUS_PARAM )
aSig64 = aSig | 0x00800000; aSig64 = aSig | 0x00800000;
aSig64 <<= 40; aSig64 <<= 40;
z = aSig64>>( - shiftCount ); z = aSig64>>( - shiftCount );
if ( (bits64) ( aSig64<<( shiftCount & 63 ) ) ) { if ( (uint64_t) ( aSig64<<( shiftCount & 63 ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
if ( aSign ) z = - z; if ( aSign ) z = - z;
...@@ -1559,7 +1559,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM ) ...@@ -1559,7 +1559,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1574,7 +1574,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM ) ...@@ -1574,7 +1574,7 @@ float64 float32_to_float64( float32 a STATUS_PARAM )
normalizeFloat32Subnormal( aSig, &aExp, &aSig ); normalizeFloat32Subnormal( aSig, &aExp, &aSig );
--aExp; --aExp;
} }
return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 ); return packFloat64( aSign, aExp + 0x380, ( (uint64_t) aSig )<<29 );
} }
...@@ -1591,7 +1591,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM ) ...@@ -1591,7 +1591,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1606,7 +1606,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM ) ...@@ -1606,7 +1606,7 @@ floatx80 float32_to_floatx80( float32 a STATUS_PARAM )
normalizeFloat32Subnormal( aSig, &aExp, &aSig ); normalizeFloat32Subnormal( aSig, &aExp, &aSig );
} }
aSig |= 0x00800000; aSig |= 0x00800000;
return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 ); return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );
} }
...@@ -1625,7 +1625,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM ) ...@@ -1625,7 +1625,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1640,7 +1640,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM ) ...@@ -1640,7 +1640,7 @@ float128 float32_to_float128( float32 a STATUS_PARAM )
normalizeFloat32Subnormal( aSig, &aExp, &aSig ); normalizeFloat32Subnormal( aSig, &aExp, &aSig );
--aExp; --aExp;
} }
return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 ); return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, 0 );
} }
...@@ -1657,9 +1657,9 @@ float32 float32_round_to_int( float32 a STATUS_PARAM) ...@@ -1657,9 +1657,9 @@ float32 float32_round_to_int( float32 a STATUS_PARAM)
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 lastBitMask, roundBitsMask; uint32_t lastBitMask, roundBitsMask;
int8 roundingMode; int8 roundingMode;
bits32 z; uint32_t z;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aExp = extractFloat32Exp( a ); aExp = extractFloat32Exp( a );
...@@ -1670,7 +1670,7 @@ float32 float32_round_to_int( float32 a STATUS_PARAM) ...@@ -1670,7 +1670,7 @@ float32 float32_round_to_int( float32 a STATUS_PARAM)
return a; return a;
} }
if ( aExp <= 0x7E ) { if ( aExp <= 0x7E ) {
if ( (bits32) ( float32_val(a)<<1 ) == 0 ) return a; if ( (uint32_t) ( float32_val(a)<<1 ) == 0 ) return a;
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
aSign = extractFloat32Sign( a ); aSign = extractFloat32Sign( a );
switch ( STATUS(float_rounding_mode) ) { switch ( STATUS(float_rounding_mode) ) {
...@@ -1717,7 +1717,7 @@ float32 float32_round_to_int( float32 a STATUS_PARAM) ...@@ -1717,7 +1717,7 @@ float32 float32_round_to_int( float32 a STATUS_PARAM)
static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM) static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
{ {
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits32 aSig, bSig, zSig; uint32_t aSig, bSig, zSig;
int16 expDiff; int16 expDiff;
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1771,7 +1771,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM) ...@@ -1771,7 +1771,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
aSig |= 0x20000000; aSig |= 0x20000000;
zSig = ( aSig + bSig )<<1; zSig = ( aSig + bSig )<<1;
--zExp; --zExp;
if ( (sbits32) zSig < 0 ) { if ( (int32_t) zSig < 0 ) {
zSig = aSig + bSig; zSig = aSig + bSig;
++zExp; ++zExp;
} }
...@@ -1791,7 +1791,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM) ...@@ -1791,7 +1791,7 @@ static float32 addFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM) static float32 subFloat32Sigs( float32 a, float32 b, flag zSign STATUS_PARAM)
{ {
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits32 aSig, bSig, zSig; uint32_t aSig, bSig, zSig;
int16 expDiff; int16 expDiff;
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -1911,9 +1911,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM ) ...@@ -1911,9 +1911,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits32 aSig, bSig; uint32_t aSig, bSig;
bits64 zSig64; uint64_t zSig64;
bits32 zSig; uint32_t zSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -1954,9 +1954,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM ) ...@@ -1954,9 +1954,9 @@ float32 float32_mul( float32 a, float32 b STATUS_PARAM )
zExp = aExp + bExp - 0x7F; zExp = aExp + bExp - 0x7F;
aSig = ( aSig | 0x00800000 )<<7; aSig = ( aSig | 0x00800000 )<<7;
bSig = ( bSig | 0x00800000 )<<8; bSig = ( bSig | 0x00800000 )<<8;
shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 ); shift64RightJamming( ( (uint64_t) aSig ) * bSig, 32, &zSig64 );
zSig = zSig64; zSig = zSig64;
if ( 0 <= (sbits32) ( zSig<<1 ) ) { if ( 0 <= (int32_t) ( zSig<<1 ) ) {
zSig <<= 1; zSig <<= 1;
--zExp; --zExp;
} }
...@@ -1974,7 +1974,7 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM ) ...@@ -1974,7 +1974,7 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits32 aSig, bSig, zSig; uint32_t aSig, bSig, zSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2020,9 +2020,9 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM ) ...@@ -2020,9 +2020,9 @@ float32 float32_div( float32 a, float32 b STATUS_PARAM )
aSig >>= 1; aSig >>= 1;
++zExp; ++zExp;
} }
zSig = ( ( (bits64) aSig )<<32 ) / bSig; zSig = ( ( (uint64_t) aSig )<<32 ) / bSig;
if ( ( zSig & 0x3F ) == 0 ) { if ( ( zSig & 0x3F ) == 0 ) {
zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 ); zSig |= ( (uint64_t) bSig * zSig != ( (uint64_t) aSig )<<32 );
} }
return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR ); return roundAndPackFloat32( zSign, zExp, zSig STATUS_VAR );
...@@ -2038,11 +2038,11 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM ) ...@@ -2038,11 +2038,11 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int16 aExp, bExp, expDiff; int16 aExp, bExp, expDiff;
bits32 aSig, bSig; uint32_t aSig, bSig;
bits32 q; uint32_t q;
bits64 aSig64, bSig64, q64; uint64_t aSig64, bSig64, q64;
bits32 alternateASig; uint32_t alternateASig;
sbits32 sigMean; int32_t sigMean;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2086,7 +2086,7 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM ) ...@@ -2086,7 +2086,7 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
q = ( bSig <= aSig ); q = ( bSig <= aSig );
if ( q ) aSig -= bSig; if ( q ) aSig -= bSig;
if ( 0 < expDiff ) { if ( 0 < expDiff ) {
q = ( ( (bits64) aSig )<<32 ) / bSig; q = ( ( (uint64_t) aSig )<<32 ) / bSig;
q >>= 32 - expDiff; q >>= 32 - expDiff;
bSig >>= 2; bSig >>= 2;
aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q; aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
...@@ -2098,8 +2098,8 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM ) ...@@ -2098,8 +2098,8 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
} }
else { else {
if ( bSig <= aSig ) aSig -= bSig; if ( bSig <= aSig ) aSig -= bSig;
aSig64 = ( (bits64) aSig )<<40; aSig64 = ( (uint64_t) aSig )<<40;
bSig64 = ( (bits64) bSig )<<40; bSig64 = ( (uint64_t) bSig )<<40;
expDiff -= 64; expDiff -= 64;
while ( 0 < expDiff ) { while ( 0 < expDiff ) {
q64 = estimateDiv128To64( aSig64, 0, bSig64 ); q64 = estimateDiv128To64( aSig64, 0, bSig64 );
...@@ -2118,12 +2118,12 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM ) ...@@ -2118,12 +2118,12 @@ float32 float32_rem( float32 a, float32 b STATUS_PARAM )
alternateASig = aSig; alternateASig = aSig;
++q; ++q;
aSig -= bSig; aSig -= bSig;
} while ( 0 <= (sbits32) aSig ); } while ( 0 <= (int32_t) aSig );
sigMean = aSig + alternateASig; sigMean = aSig + alternateASig;
if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) { if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {
aSig = alternateASig; aSig = alternateASig;
} }
zSign = ( (sbits32) aSig < 0 ); zSign = ( (int32_t) aSig < 0 );
if ( zSign ) aSig = - aSig; if ( zSign ) aSig = - aSig;
return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR ); return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR );
...@@ -2139,8 +2139,8 @@ float32 float32_sqrt( float32 a STATUS_PARAM ) ...@@ -2139,8 +2139,8 @@ float32 float32_sqrt( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, zExp; int16 aExp, zExp;
bits32 aSig, zSig; uint32_t aSig, zSig;
bits64 rem, term; uint64_t rem, term;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -2170,11 +2170,11 @@ float32 float32_sqrt( float32 a STATUS_PARAM ) ...@@ -2170,11 +2170,11 @@ float32 float32_sqrt( float32 a STATUS_PARAM )
goto roundAndPack; goto roundAndPack;
} }
aSig >>= aExp & 1; aSig >>= aExp & 1;
term = ( (bits64) zSig ) * zSig; term = ( (uint64_t) zSig ) * zSig;
rem = ( ( (bits64) aSig )<<32 ) - term; rem = ( ( (uint64_t) aSig )<<32 ) - term;
while ( (sbits64) rem < 0 ) { while ( (int64_t) rem < 0 ) {
--zSig; --zSig;
rem += ( ( (bits64) zSig )<<1 ) | 1; rem += ( ( (uint64_t) zSig )<<1 ) | 1;
} }
zSig |= ( rem != 0 ); zSig |= ( rem != 0 );
} }
...@@ -2225,7 +2225,7 @@ float32 float32_exp2( float32 a STATUS_PARAM ) ...@@ -2225,7 +2225,7 @@ float32 float32_exp2( float32 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
float64 r, x, xn; float64 r, x, xn;
int i; int i;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
...@@ -2273,7 +2273,7 @@ float32 float32_log2( float32 a STATUS_PARAM ) ...@@ -2273,7 +2273,7 @@ float32 float32_log2( float32 a STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int16 aExp; int16 aExp;
bits32 aSig, zSig, i; uint32_t aSig, zSig, i;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -2299,7 +2299,7 @@ float32 float32_log2( float32 a STATUS_PARAM ) ...@@ -2299,7 +2299,7 @@ float32 float32_log2( float32 a STATUS_PARAM )
zSig = aExp << 23; zSig = aExp << 23;
for (i = 1 << 22; i > 0; i >>= 1) { for (i = 1 << 22; i > 0; i >>= 1) {
aSig = ( (bits64)aSig * aSig ) >> 23; aSig = ( (uint64_t)aSig * aSig ) >> 23;
if ( aSig & 0x01000000 ) { if ( aSig & 0x01000000 ) {
aSig >>= 1; aSig >>= 1;
zSig |= i; zSig |= i;
...@@ -2332,7 +2332,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM ) ...@@ -2332,7 +2332,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM )
return 0; return 0;
} }
return ( float32_val(a) == float32_val(b) ) || return ( float32_val(a) == float32_val(b) ) ||
( (bits32) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 ); ( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 );
} }
...@@ -2346,7 +2346,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM ) ...@@ -2346,7 +2346,7 @@ int float32_eq( float32 a, float32 b STATUS_PARAM )
int float32_le( float32 a, float32 b STATUS_PARAM ) int float32_le( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits32 av, bv; uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2360,7 +2360,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM ) ...@@ -2360,7 +2360,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM )
bSign = extractFloat32Sign( b ); bSign = extractFloat32Sign( b );
av = float32_val(a); av = float32_val(a);
bv = float32_val(b); bv = float32_val(b);
if ( aSign != bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 ) == 0 ); if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
return ( av == bv ) || ( aSign ^ ( av < bv ) ); return ( av == bv ) || ( aSign ^ ( av < bv ) );
} }
...@@ -2374,7 +2374,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM ) ...@@ -2374,7 +2374,7 @@ int float32_le( float32 a, float32 b STATUS_PARAM )
int float32_lt( float32 a, float32 b STATUS_PARAM ) int float32_lt( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits32 av, bv; uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2388,7 +2388,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM ) ...@@ -2388,7 +2388,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM )
bSign = extractFloat32Sign( b ); bSign = extractFloat32Sign( b );
av = float32_val(a); av = float32_val(a);
bv = float32_val(b); bv = float32_val(b);
if ( aSign != bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 ) != 0 ); if ( aSign != bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<1 ) != 0 );
return ( av != bv ) && ( aSign ^ ( av < bv ) ); return ( av != bv ) && ( aSign ^ ( av < bv ) );
} }
...@@ -2402,7 +2402,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM ) ...@@ -2402,7 +2402,7 @@ int float32_lt( float32 a, float32 b STATUS_PARAM )
int float32_eq_signaling( float32 a, float32 b STATUS_PARAM ) int float32_eq_signaling( float32 a, float32 b STATUS_PARAM )
{ {
bits32 av, bv; uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2414,7 +2414,7 @@ int float32_eq_signaling( float32 a, float32 b STATUS_PARAM ) ...@@ -2414,7 +2414,7 @@ int float32_eq_signaling( float32 a, float32 b STATUS_PARAM )
} }
av = float32_val(a); av = float32_val(a);
bv = float32_val(b); bv = float32_val(b);
return ( av == bv ) || ( (bits32) ( ( av | bv )<<1 ) == 0 ); return ( av == bv ) || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
} }
...@@ -2428,7 +2428,7 @@ int float32_eq_signaling( float32 a, float32 b STATUS_PARAM ) ...@@ -2428,7 +2428,7 @@ int float32_eq_signaling( float32 a, float32 b STATUS_PARAM )
int float32_le_quiet( float32 a, float32 b STATUS_PARAM ) int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits32 av, bv; uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2444,7 +2444,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM ) ...@@ -2444,7 +2444,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
bSign = extractFloat32Sign( b ); bSign = extractFloat32Sign( b );
av = float32_val(a); av = float32_val(a);
bv = float32_val(b); bv = float32_val(b);
if ( aSign != bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 ) == 0 ); if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
return ( av == bv ) || ( aSign ^ ( av < bv ) ); return ( av == bv ) || ( aSign ^ ( av < bv ) );
} }
...@@ -2459,7 +2459,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM ) ...@@ -2459,7 +2459,7 @@ int float32_le_quiet( float32 a, float32 b STATUS_PARAM )
int float32_lt_quiet( float32 a, float32 b STATUS_PARAM ) int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits32 av, bv; uint32_t av, bv;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
b = float32_squash_input_denormal(b STATUS_VAR); b = float32_squash_input_denormal(b STATUS_VAR);
...@@ -2475,7 +2475,7 @@ int float32_lt_quiet( float32 a, float32 b STATUS_PARAM ) ...@@ -2475,7 +2475,7 @@ int float32_lt_quiet( float32 a, float32 b STATUS_PARAM )
bSign = extractFloat32Sign( b ); bSign = extractFloat32Sign( b );
av = float32_val(a); av = float32_val(a);
bv = float32_val(b); bv = float32_val(b);
if ( aSign != bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 ) != 0 ); if ( aSign != bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<1 ) != 0 );
return ( av != bv ) && ( aSign ^ ( av < bv ) ); return ( av != bv ) && ( aSign ^ ( av < bv ) );
} }
...@@ -2494,7 +2494,7 @@ int32 float64_to_int32( float64 a STATUS_PARAM ) ...@@ -2494,7 +2494,7 @@ int32 float64_to_int32( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits64 aSig; uint64_t aSig;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2522,7 +2522,7 @@ int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2522,7 +2522,7 @@ int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits64 aSig, savedASig; uint64_t aSig, savedASig;
int32 z; int32 z;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
...@@ -2546,7 +2546,7 @@ int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2546,7 +2546,7 @@ int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
if ( ( z < 0 ) ^ aSign ) { if ( ( z < 0 ) ^ aSign ) {
invalid: invalid:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
} }
if ( ( aSig<<shiftCount ) != savedASig ) { if ( ( aSig<<shiftCount ) != savedASig ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -2569,7 +2569,7 @@ int16 float64_to_int16_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2569,7 +2569,7 @@ int16 float64_to_int16_round_to_zero( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits64 aSig, savedASig; uint64_t aSig, savedASig;
int32 z; int32 z;
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2598,7 +2598,7 @@ int16 float64_to_int16_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2598,7 +2598,7 @@ int16 float64_to_int16_round_to_zero( float64 a STATUS_PARAM )
if ( ( (int16_t)z < 0 ) ^ aSign ) { if ( ( (int16_t)z < 0 ) ^ aSign ) {
invalid: invalid:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return aSign ? (sbits32) 0xffff8000 : 0x7FFF; return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
} }
if ( ( aSig<<shiftCount ) != savedASig ) { if ( ( aSig<<shiftCount ) != savedASig ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -2620,7 +2620,7 @@ int64 float64_to_int64( float64 a STATUS_PARAM ) ...@@ -2620,7 +2620,7 @@ int64 float64_to_int64( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits64 aSig, aSigExtra; uint64_t aSig, aSigExtra;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2637,7 +2637,7 @@ int64 float64_to_int64( float64 a STATUS_PARAM ) ...@@ -2637,7 +2637,7 @@ int64 float64_to_int64( float64 a STATUS_PARAM )
) { ) {
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
aSigExtra = 0; aSigExtra = 0;
aSig <<= - shiftCount; aSig <<= - shiftCount;
...@@ -2663,7 +2663,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2663,7 +2663,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, shiftCount; int16 aExp, shiftCount;
bits64 aSig; uint64_t aSig;
int64 z; int64 z;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
...@@ -2683,7 +2683,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2683,7 +2683,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM )
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
z = aSig<<shiftCount; z = aSig<<shiftCount;
} }
...@@ -2693,7 +2693,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM ) ...@@ -2693,7 +2693,7 @@ int64 float64_to_int64_round_to_zero( float64 a STATUS_PARAM )
return 0; return 0;
} }
z = aSig>>( - shiftCount ); z = aSig>>( - shiftCount );
if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) { if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
} }
...@@ -2713,8 +2713,8 @@ float32 float64_to_float32( float64 a STATUS_PARAM ) ...@@ -2713,8 +2713,8 @@ float32 float64_to_float32( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig; uint64_t aSig;
bits32 zSig; uint32_t zSig;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2745,10 +2745,10 @@ float32 float64_to_float32( float64 a STATUS_PARAM ) ...@@ -2745,10 +2745,10 @@ float32 float64_to_float32( float64 a STATUS_PARAM )
| than the desired result exponent whenever `zSig' is a complete, normalized | than the desired result exponent whenever `zSig' is a complete, normalized
| significand. | significand.
*----------------------------------------------------------------------------*/ *----------------------------------------------------------------------------*/
static float16 packFloat16(flag zSign, int16 zExp, bits16 zSig) static float16 packFloat16(flag zSign, int16 zExp, uint16_t zSig)
{ {
return make_float16( return make_float16(
(((bits32)zSign) << 15) + (((bits32)zExp) << 10) + zSig); (((uint32_t)zSign) << 15) + (((uint32_t)zExp) << 10) + zSig);
} }
/* Half precision floats come in two formats: standard IEEE and "ARM" format. /* Half precision floats come in two formats: standard IEEE and "ARM" format.
...@@ -2758,7 +2758,7 @@ float32 float16_to_float32(float16 a, flag ieee STATUS_PARAM) ...@@ -2758,7 +2758,7 @@ float32 float16_to_float32(float16 a, flag ieee STATUS_PARAM)
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
aSign = extractFloat16Sign(a); aSign = extractFloat16Sign(a);
aExp = extractFloat16Exp(a); aExp = extractFloat16Exp(a);
...@@ -2788,9 +2788,9 @@ float16 float32_to_float16(float32 a, flag ieee STATUS_PARAM) ...@@ -2788,9 +2788,9 @@ float16 float32_to_float16(float32 a, flag ieee STATUS_PARAM)
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
bits32 mask; uint32_t mask;
bits32 increment; uint32_t increment;
int8 roundingMode; int8 roundingMode;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
...@@ -2891,7 +2891,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARAM ) ...@@ -2891,7 +2891,7 @@ floatx80 float64_to_floatx80( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig; uint64_t aSig;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2926,7 +2926,7 @@ float128 float64_to_float128( float64 a STATUS_PARAM ) ...@@ -2926,7 +2926,7 @@ float128 float64_to_float128( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig, zSig0, zSig1; uint64_t aSig, zSig0, zSig1;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -2959,9 +2959,9 @@ float64 float64_round_to_int( float64 a STATUS_PARAM ) ...@@ -2959,9 +2959,9 @@ float64 float64_round_to_int( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 lastBitMask, roundBitsMask; uint64_t lastBitMask, roundBitsMask;
int8 roundingMode; int8 roundingMode;
bits64 z; uint64_t z;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aExp = extractFloat64Exp( a ); aExp = extractFloat64Exp( a );
...@@ -2972,7 +2972,7 @@ float64 float64_round_to_int( float64 a STATUS_PARAM ) ...@@ -2972,7 +2972,7 @@ float64 float64_round_to_int( float64 a STATUS_PARAM )
return a; return a;
} }
if ( aExp < 0x3FF ) { if ( aExp < 0x3FF ) {
if ( (bits64) ( float64_val(a)<<1 ) == 0 ) return a; if ( (uint64_t) ( float64_val(a)<<1 ) == 0 ) return a;
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
aSign = extractFloat64Sign( a ); aSign = extractFloat64Sign( a );
switch ( STATUS(float_rounding_mode) ) { switch ( STATUS(float_rounding_mode) ) {
...@@ -3032,7 +3032,7 @@ float64 float64_trunc_to_int( float64 a STATUS_PARAM) ...@@ -3032,7 +3032,7 @@ float64 float64_trunc_to_int( float64 a STATUS_PARAM)
static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM ) static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
{ {
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits64 aSig, bSig, zSig; uint64_t aSig, bSig, zSig;
int16 expDiff; int16 expDiff;
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -3086,7 +3086,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM ) ...@@ -3086,7 +3086,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
aSig |= LIT64( 0x2000000000000000 ); aSig |= LIT64( 0x2000000000000000 );
zSig = ( aSig + bSig )<<1; zSig = ( aSig + bSig )<<1;
--zExp; --zExp;
if ( (sbits64) zSig < 0 ) { if ( (int64_t) zSig < 0 ) {
zSig = aSig + bSig; zSig = aSig + bSig;
++zExp; ++zExp;
} }
...@@ -3106,7 +3106,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM ) ...@@ -3106,7 +3106,7 @@ static float64 addFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM ) static float64 subFloat64Sigs( float64 a, float64 b, flag zSign STATUS_PARAM )
{ {
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits64 aSig, bSig, zSig; uint64_t aSig, bSig, zSig;
int16 expDiff; int16 expDiff;
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -3226,7 +3226,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM ) ...@@ -3226,7 +3226,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits64 aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3269,7 +3269,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM ) ...@@ -3269,7 +3269,7 @@ float64 float64_mul( float64 a, float64 b STATUS_PARAM )
bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11; bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
mul64To128( aSig, bSig, &zSig0, &zSig1 ); mul64To128( aSig, bSig, &zSig0, &zSig1 );
zSig0 |= ( zSig1 != 0 ); zSig0 |= ( zSig1 != 0 );
if ( 0 <= (sbits64) ( zSig0<<1 ) ) { if ( 0 <= (int64_t) ( zSig0<<1 ) ) {
zSig0 <<= 1; zSig0 <<= 1;
--zExp; --zExp;
} }
...@@ -3287,9 +3287,9 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM ) ...@@ -3287,9 +3287,9 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int16 aExp, bExp, zExp; int16 aExp, bExp, zExp;
bits64 aSig, bSig, zSig; uint64_t aSig, bSig, zSig;
bits64 rem0, rem1; uint64_t rem0, rem1;
bits64 term0, term1; uint64_t term0, term1;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3339,7 +3339,7 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM ) ...@@ -3339,7 +3339,7 @@ float64 float64_div( float64 a, float64 b STATUS_PARAM )
if ( ( zSig & 0x1FF ) <= 2 ) { if ( ( zSig & 0x1FF ) <= 2 ) {
mul64To128( bSig, zSig, &term0, &term1 ); mul64To128( bSig, zSig, &term0, &term1 );
sub128( aSig, 0, term0, term1, &rem0, &rem1 ); sub128( aSig, 0, term0, term1, &rem0, &rem1 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig; --zSig;
add128( rem0, rem1, 0, bSig, &rem0, &rem1 ); add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
} }
...@@ -3359,9 +3359,9 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM ) ...@@ -3359,9 +3359,9 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int16 aExp, bExp, expDiff; int16 aExp, bExp, expDiff;
bits64 aSig, bSig; uint64_t aSig, bSig;
bits64 q, alternateASig; uint64_t q, alternateASig;
sbits64 sigMean; int64_t sigMean;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3424,12 +3424,12 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM ) ...@@ -3424,12 +3424,12 @@ float64 float64_rem( float64 a, float64 b STATUS_PARAM )
alternateASig = aSig; alternateASig = aSig;
++q; ++q;
aSig -= bSig; aSig -= bSig;
} while ( 0 <= (sbits64) aSig ); } while ( 0 <= (int64_t) aSig );
sigMean = aSig + alternateASig; sigMean = aSig + alternateASig;
if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) { if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {
aSig = alternateASig; aSig = alternateASig;
} }
zSign = ( (sbits64) aSig < 0 ); zSign = ( (int64_t) aSig < 0 );
if ( zSign ) aSig = - aSig; if ( zSign ) aSig = - aSig;
return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR ); return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR );
...@@ -3445,8 +3445,8 @@ float64 float64_sqrt( float64 a STATUS_PARAM ) ...@@ -3445,8 +3445,8 @@ float64 float64_sqrt( float64 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp, zExp; int16 aExp, zExp;
bits64 aSig, zSig, doubleZSig; uint64_t aSig, zSig, doubleZSig;
bits64 rem0, rem1, term0, term1; uint64_t rem0, rem1, term0, term1;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -3476,7 +3476,7 @@ float64 float64_sqrt( float64 a STATUS_PARAM ) ...@@ -3476,7 +3476,7 @@ float64 float64_sqrt( float64 a STATUS_PARAM )
doubleZSig = zSig<<1; doubleZSig = zSig<<1;
mul64To128( zSig, zSig, &term0, &term1 ); mul64To128( zSig, zSig, &term0, &term1 );
sub128( aSig, 0, term0, term1, &rem0, &rem1 ); sub128( aSig, 0, term0, term1, &rem0, &rem1 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig; --zSig;
doubleZSig -= 2; doubleZSig -= 2;
add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 ); add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 );
...@@ -3496,7 +3496,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) ...@@ -3496,7 +3496,7 @@ float64 float64_log2( float64 a STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int16 aExp; int16 aExp;
bits64 aSig, aSig0, aSig1, zSig, i; uint64_t aSig, aSig0, aSig1, zSig, i;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -3519,7 +3519,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) ...@@ -3519,7 +3519,7 @@ float64 float64_log2( float64 a STATUS_PARAM )
aExp -= 0x3FF; aExp -= 0x3FF;
aSig |= LIT64( 0x0010000000000000 ); aSig |= LIT64( 0x0010000000000000 );
zSign = aExp < 0; zSign = aExp < 0;
zSig = (bits64)aExp << 52; zSig = (uint64_t)aExp << 52;
for (i = 1LL << 51; i > 0; i >>= 1) { for (i = 1LL << 51; i > 0; i >>= 1) {
mul64To128( aSig, aSig, &aSig0, &aSig1 ); mul64To128( aSig, aSig, &aSig0, &aSig1 );
aSig = ( aSig0 << 12 ) | ( aSig1 >> 52 ); aSig = ( aSig0 << 12 ) | ( aSig1 >> 52 );
...@@ -3542,7 +3542,7 @@ float64 float64_log2( float64 a STATUS_PARAM ) ...@@ -3542,7 +3542,7 @@ float64 float64_log2( float64 a STATUS_PARAM )
int float64_eq( float64 a, float64 b STATUS_PARAM ) int float64_eq( float64 a, float64 b STATUS_PARAM )
{ {
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3556,7 +3556,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM ) ...@@ -3556,7 +3556,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
} }
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
return ( av == bv ) || ( (bits64) ( ( av | bv )<<1 ) == 0 ); return ( av == bv ) || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
} }
...@@ -3570,7 +3570,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM ) ...@@ -3570,7 +3570,7 @@ int float64_eq( float64 a, float64 b STATUS_PARAM )
int float64_le( float64 a, float64 b STATUS_PARAM ) int float64_le( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3584,7 +3584,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM ) ...@@ -3584,7 +3584,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM )
bSign = extractFloat64Sign( b ); bSign = extractFloat64Sign( b );
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
if ( aSign != bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 ) == 0 ); if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
return ( av == bv ) || ( aSign ^ ( av < bv ) ); return ( av == bv ) || ( aSign ^ ( av < bv ) );
} }
...@@ -3598,7 +3598,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM ) ...@@ -3598,7 +3598,7 @@ int float64_le( float64 a, float64 b STATUS_PARAM )
int float64_lt( float64 a, float64 b STATUS_PARAM ) int float64_lt( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3612,7 +3612,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM ) ...@@ -3612,7 +3612,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM )
bSign = extractFloat64Sign( b ); bSign = extractFloat64Sign( b );
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
if ( aSign != bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 ) != 0 ); if ( aSign != bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<1 ) != 0 );
return ( av != bv ) && ( aSign ^ ( av < bv ) ); return ( av != bv ) && ( aSign ^ ( av < bv ) );
} }
...@@ -3626,7 +3626,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM ) ...@@ -3626,7 +3626,7 @@ int float64_lt( float64 a, float64 b STATUS_PARAM )
int float64_eq_signaling( float64 a, float64 b STATUS_PARAM ) int float64_eq_signaling( float64 a, float64 b STATUS_PARAM )
{ {
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3638,7 +3638,7 @@ int float64_eq_signaling( float64 a, float64 b STATUS_PARAM ) ...@@ -3638,7 +3638,7 @@ int float64_eq_signaling( float64 a, float64 b STATUS_PARAM )
} }
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
return ( av == bv ) || ( (bits64) ( ( av | bv )<<1 ) == 0 ); return ( av == bv ) || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
} }
...@@ -3652,7 +3652,7 @@ int float64_eq_signaling( float64 a, float64 b STATUS_PARAM ) ...@@ -3652,7 +3652,7 @@ int float64_eq_signaling( float64 a, float64 b STATUS_PARAM )
int float64_le_quiet( float64 a, float64 b STATUS_PARAM ) int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3668,7 +3668,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM ) ...@@ -3668,7 +3668,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
bSign = extractFloat64Sign( b ); bSign = extractFloat64Sign( b );
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
if ( aSign != bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 ) == 0 ); if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
return ( av == bv ) || ( aSign ^ ( av < bv ) ); return ( av == bv ) || ( aSign ^ ( av < bv ) );
} }
...@@ -3683,7 +3683,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM ) ...@@ -3683,7 +3683,7 @@ int float64_le_quiet( float64 a, float64 b STATUS_PARAM )
int float64_lt_quiet( float64 a, float64 b STATUS_PARAM ) int float64_lt_quiet( float64 a, float64 b STATUS_PARAM )
{ {
flag aSign, bSign; flag aSign, bSign;
bits64 av, bv; uint64_t av, bv;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
b = float64_squash_input_denormal(b STATUS_VAR); b = float64_squash_input_denormal(b STATUS_VAR);
...@@ -3699,7 +3699,7 @@ int float64_lt_quiet( float64 a, float64 b STATUS_PARAM ) ...@@ -3699,7 +3699,7 @@ int float64_lt_quiet( float64 a, float64 b STATUS_PARAM )
bSign = extractFloat64Sign( b ); bSign = extractFloat64Sign( b );
av = float64_val(a); av = float64_val(a);
bv = float64_val(b); bv = float64_val(b);
if ( aSign != bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 ) != 0 ); if ( aSign != bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<1 ) != 0 );
return ( av != bv ) && ( aSign ^ ( av < bv ) ); return ( av != bv ) && ( aSign ^ ( av < bv ) );
} }
...@@ -3720,12 +3720,12 @@ int32 floatx80_to_int32( floatx80 a STATUS_PARAM ) ...@@ -3720,12 +3720,12 @@ int32 floatx80_to_int32( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig; uint64_t aSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0; if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
shiftCount = 0x4037 - aExp; shiftCount = 0x4037 - aExp;
if ( shiftCount <= 0 ) shiftCount = 1; if ( shiftCount <= 0 ) shiftCount = 1;
shift64RightJamming( aSig, shiftCount, &aSig ); shift64RightJamming( aSig, shiftCount, &aSig );
...@@ -3747,14 +3747,14 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM ) ...@@ -3747,14 +3747,14 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig, savedASig; uint64_t aSig, savedASig;
int32 z; int32 z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( 0x401E < aExp ) { if ( 0x401E < aExp ) {
if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0; if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
goto invalid; goto invalid;
} }
else if ( aExp < 0x3FFF ) { else if ( aExp < 0x3FFF ) {
...@@ -3769,7 +3769,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM ) ...@@ -3769,7 +3769,7 @@ int32 floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM )
if ( ( z < 0 ) ^ aSign ) { if ( ( z < 0 ) ^ aSign ) {
invalid: invalid:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
} }
if ( ( aSig<<shiftCount ) != savedASig ) { if ( ( aSig<<shiftCount ) != savedASig ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -3792,7 +3792,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM ) ...@@ -3792,7 +3792,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig, aSigExtra; uint64_t aSig, aSigExtra;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
...@@ -3807,7 +3807,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM ) ...@@ -3807,7 +3807,7 @@ int64 floatx80_to_int64( floatx80 a STATUS_PARAM )
) { ) {
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
aSigExtra = 0; aSigExtra = 0;
} }
...@@ -3832,7 +3832,7 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM ) ...@@ -3832,7 +3832,7 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig; uint64_t aSig;
int64 z; int64 z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
...@@ -3847,14 +3847,14 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM ) ...@@ -3847,14 +3847,14 @@ int64 floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM )
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
else if ( aExp < 0x3FFF ) { else if ( aExp < 0x3FFF ) {
if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact; if ( aExp | aSig ) STATUS(float_exception_flags) |= float_flag_inexact;
return 0; return 0;
} }
z = aSig>>( - shiftCount ); z = aSig>>( - shiftCount );
if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) { if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
if ( aSign ) z = - z; if ( aSign ) z = - z;
...@@ -3873,13 +3873,13 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM ) ...@@ -3873,13 +3873,13 @@ float32 floatx80_to_float32( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig; uint64_t aSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) { if ( (uint64_t) ( aSig<<1 ) ) {
return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); return commonNaNToFloat32( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat32( aSign, 0xFF, 0 ); return packFloat32( aSign, 0xFF, 0 );
...@@ -3901,13 +3901,13 @@ float64 floatx80_to_float64( floatx80 a STATUS_PARAM ) ...@@ -3901,13 +3901,13 @@ float64 floatx80_to_float64( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig, zSig; uint64_t aSig, zSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) { if ( (uint64_t) ( aSig<<1 ) ) {
return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); return commonNaNToFloat64( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
return packFloat64( aSign, 0x7FF, 0 ); return packFloat64( aSign, 0x7FF, 0 );
...@@ -3931,12 +3931,12 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM ) ...@@ -3931,12 +3931,12 @@ float128 floatx80_to_float128( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig, zSig0, zSig1; uint64_t aSig, zSig0, zSig1;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) { if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) {
return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR ); return commonNaNToFloat128( floatx80ToCommonNaN( a STATUS_VAR ) STATUS_VAR );
} }
shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 ); shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
...@@ -3957,27 +3957,27 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM ) ...@@ -3957,27 +3957,27 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 lastBitMask, roundBitsMask; uint64_t lastBitMask, roundBitsMask;
int8 roundingMode; int8 roundingMode;
floatx80 z; floatx80 z;
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
if ( 0x403E <= aExp ) { if ( 0x403E <= aExp ) {
if ( ( aExp == 0x7FFF ) && (bits64) ( extractFloatx80Frac( a )<<1 ) ) { if ( ( aExp == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) {
return propagateFloatx80NaN( a, a STATUS_VAR ); return propagateFloatx80NaN( a, a STATUS_VAR );
} }
return a; return a;
} }
if ( aExp < 0x3FFF ) { if ( aExp < 0x3FFF ) {
if ( ( aExp == 0 ) if ( ( aExp == 0 )
&& ( (bits64) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) { && ( (uint64_t) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {
return a; return a;
} }
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
switch ( STATUS(float_rounding_mode) ) { switch ( STATUS(float_rounding_mode) ) {
case float_round_nearest_even: case float_round_nearest_even:
if ( ( aExp == 0x3FFE ) && (bits64) ( extractFloatx80Frac( a )<<1 ) if ( ( aExp == 0x3FFE ) && (uint64_t) ( extractFloatx80Frac( a )<<1 )
) { ) {
return return
packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) ); packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
...@@ -4030,7 +4030,7 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM ) ...@@ -4030,7 +4030,7 @@ floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM )
static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM) static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM)
{ {
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
int32 expDiff; int32 expDiff;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
...@@ -4040,7 +4040,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4040,7 +4040,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
expDiff = aExp - bExp; expDiff = aExp - bExp;
if ( 0 < expDiff ) { if ( 0 < expDiff ) {
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
return a; return a;
} }
if ( bExp == 0 ) --expDiff; if ( bExp == 0 ) --expDiff;
...@@ -4049,7 +4049,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4049,7 +4049,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
} }
else if ( expDiff < 0 ) { else if ( expDiff < 0 ) {
if ( bExp == 0x7FFF ) { if ( bExp == 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( 0x8000000000000000 ) ); return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( aExp == 0 ) ++expDiff; if ( aExp == 0 ) ++expDiff;
...@@ -4058,7 +4058,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4058,7 +4058,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
} }
else { else {
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( ( aSig | bSig )<<1 ) ) { if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
return propagateFloatx80NaN( a, b STATUS_VAR ); return propagateFloatx80NaN( a, b STATUS_VAR );
} }
return a; return a;
...@@ -4073,7 +4073,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4073,7 +4073,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
goto shiftRight1; goto shiftRight1;
} }
zSig0 = aSig + bSig; zSig0 = aSig + bSig;
if ( (sbits64) zSig0 < 0 ) goto roundAndPack; if ( (int64_t) zSig0 < 0 ) goto roundAndPack;
shiftRight1: shiftRight1:
shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 ); shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 );
zSig0 |= LIT64( 0x8000000000000000 ); zSig0 |= LIT64( 0x8000000000000000 );
...@@ -4096,7 +4096,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4096,7 +4096,7 @@ static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ) static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM )
{ {
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
int32 expDiff; int32 expDiff;
floatx80 z; floatx80 z;
...@@ -4108,7 +4108,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4108,7 +4108,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
if ( 0 < expDiff ) goto aExpBigger; if ( 0 < expDiff ) goto aExpBigger;
if ( expDiff < 0 ) goto bExpBigger; if ( expDiff < 0 ) goto bExpBigger;
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( ( aSig | bSig )<<1 ) ) { if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
return propagateFloatx80NaN( a, b STATUS_VAR ); return propagateFloatx80NaN( a, b STATUS_VAR );
} }
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
...@@ -4126,7 +4126,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4126,7 +4126,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
return packFloatx80( STATUS(float_rounding_mode) == float_round_down, 0, 0 ); return packFloatx80( STATUS(float_rounding_mode) == float_round_down, 0, 0 );
bExpBigger: bExpBigger:
if ( bExp == 0x7FFF ) { if ( bExp == 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 ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( aExp == 0 ) ++expDiff; if ( aExp == 0 ) ++expDiff;
...@@ -4138,7 +4138,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM ...@@ -4138,7 +4138,7 @@ static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign STATUS_PARAM
goto normalizeRoundAndPack; goto normalizeRoundAndPack;
aExpBigger: aExpBigger:
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
return a; return a;
} }
if ( bExp == 0 ) --expDiff; if ( bExp == 0 ) --expDiff;
...@@ -4205,7 +4205,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4205,7 +4205,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
floatx80 z; floatx80 z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
...@@ -4216,15 +4216,15 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4216,15 +4216,15 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
bSign = extractFloatx80Sign( b ); bSign = extractFloatx80Sign( b );
zSign = aSign ^ bSign; zSign = aSign ^ bSign;
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) if ( (uint64_t) ( aSig<<1 )
|| ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) { || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
return propagateFloatx80NaN( a, b STATUS_VAR ); return propagateFloatx80NaN( a, b STATUS_VAR );
} }
if ( ( bExp | bSig ) == 0 ) goto invalid; if ( ( bExp | bSig ) == 0 ) goto invalid;
return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( bExp == 0x7FFF ) { if ( bExp == 0x7FFF ) {
if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
if ( ( aExp | aSig ) == 0 ) { if ( ( aExp | aSig ) == 0 ) {
invalid: invalid:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
...@@ -4244,7 +4244,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4244,7 +4244,7 @@ floatx80 floatx80_mul( floatx80 a, floatx80 b STATUS_PARAM )
} }
zExp = aExp + bExp - 0x3FFE; zExp = aExp + bExp - 0x3FFE;
mul64To128( aSig, bSig, &zSig0, &zSig1 ); mul64To128( aSig, bSig, &zSig0, &zSig1 );
if ( 0 < (sbits64) zSig0 ) { if ( 0 < (int64_t) zSig0 ) {
shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 ); shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
--zExp; --zExp;
} }
...@@ -4264,8 +4264,8 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4264,8 +4264,8 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig, bSig, zSig0, zSig1; uint64_t aSig, bSig, zSig0, zSig1;
bits64 rem0, rem1, rem2, term0, term1, term2; uint64_t rem0, rem1, rem2, term0, term1, term2;
floatx80 z; floatx80 z;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
...@@ -4276,15 +4276,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4276,15 +4276,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
bSign = extractFloatx80Sign( b ); bSign = extractFloatx80Sign( b );
zSign = aSign ^ bSign; zSign = aSign ^ bSign;
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
if ( bExp == 0x7FFF ) { if ( bExp == 0x7FFF ) {
if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
goto invalid; goto invalid;
} }
return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
} }
if ( bExp == 0x7FFF ) { if ( bExp == 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, 0, 0 ); return packFloatx80( zSign, 0, 0 );
} }
if ( bExp == 0 ) { if ( bExp == 0 ) {
...@@ -4314,15 +4314,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4314,15 +4314,15 @@ floatx80 floatx80_div( floatx80 a, floatx80 b STATUS_PARAM )
zSig0 = estimateDiv128To64( aSig, rem1, bSig ); zSig0 = estimateDiv128To64( aSig, rem1, bSig );
mul64To128( bSig, zSig0, &term0, &term1 ); mul64To128( bSig, zSig0, &term0, &term1 );
sub128( aSig, rem1, term0, term1, &rem0, &rem1 ); sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig0; --zSig0;
add128( rem0, rem1, 0, bSig, &rem0, &rem1 ); add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
} }
zSig1 = estimateDiv128To64( rem1, 0, bSig ); zSig1 = estimateDiv128To64( rem1, 0, bSig );
if ( (bits64) ( zSig1<<1 ) <= 8 ) { if ( (uint64_t) ( zSig1<<1 ) <= 8 ) {
mul64To128( bSig, zSig1, &term1, &term2 ); mul64To128( bSig, zSig1, &term1, &term2 );
sub128( rem1, 0, term1, term2, &rem1, &rem2 ); sub128( rem1, 0, term1, term2, &rem1, &rem2 );
while ( (sbits64) rem1 < 0 ) { while ( (int64_t) rem1 < 0 ) {
--zSig1; --zSig1;
add128( rem1, rem2, 0, bSig, &rem1, &rem2 ); add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
} }
...@@ -4344,8 +4344,8 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4344,8 +4344,8 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int32 aExp, bExp, expDiff; int32 aExp, bExp, expDiff;
bits64 aSig0, aSig1, bSig; uint64_t aSig0, aSig1, bSig;
bits64 q, term0, term1, alternateASig0, alternateASig1; uint64_t q, term0, term1, alternateASig0, alternateASig1;
floatx80 z; floatx80 z;
aSig0 = extractFloatx80Frac( a ); aSig0 = extractFloatx80Frac( a );
...@@ -4354,14 +4354,14 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4354,14 +4354,14 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
bSig = extractFloatx80Frac( b ); bSig = extractFloatx80Frac( b );
bExp = extractFloatx80Exp( b ); bExp = extractFloatx80Exp( b );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig0<<1 ) if ( (uint64_t) ( aSig0<<1 )
|| ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) { || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
return propagateFloatx80NaN( a, b STATUS_VAR ); return propagateFloatx80NaN( a, b STATUS_VAR );
} }
goto invalid; goto invalid;
} }
if ( bExp == 0x7FFF ) { if ( bExp == 0x7FFF ) {
if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR ); if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b STATUS_VAR );
return a; return a;
} }
if ( bExp == 0 ) { if ( bExp == 0 ) {
...@@ -4375,7 +4375,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4375,7 +4375,7 @@ floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM )
normalizeFloatx80Subnormal( bSig, &bExp, &bSig ); normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
} }
if ( aExp == 0 ) { if ( aExp == 0 ) {
if ( (bits64) ( aSig0<<1 ) == 0 ) return a; if ( (uint64_t) ( aSig0<<1 ) == 0 ) return a;
normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 ); normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
} }
bSig |= LIT64( 0x8000000000000000 ); bSig |= LIT64( 0x8000000000000000 );
...@@ -4440,15 +4440,15 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) ...@@ -4440,15 +4440,15 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, zExp; int32 aExp, zExp;
bits64 aSig0, aSig1, zSig0, zSig1, doubleZSig0; uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0;
bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
floatx80 z; floatx80 z;
aSig0 = extractFloatx80Frac( a ); aSig0 = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
aSign = extractFloatx80Sign( a ); aSign = extractFloatx80Sign( a );
if ( aExp == 0x7FFF ) { if ( aExp == 0x7FFF ) {
if ( (bits64) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a STATUS_VAR ); if ( (uint64_t) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a STATUS_VAR );
if ( ! aSign ) return a; if ( ! aSign ) return a;
goto invalid; goto invalid;
} }
...@@ -4471,7 +4471,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) ...@@ -4471,7 +4471,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
doubleZSig0 = zSig0<<1; doubleZSig0 = zSig0<<1;
mul64To128( zSig0, zSig0, &term0, &term1 ); mul64To128( zSig0, zSig0, &term0, &term1 );
sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 ); sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig0; --zSig0;
doubleZSig0 -= 2; doubleZSig0 -= 2;
add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 ); add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );
...@@ -4483,7 +4483,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM ) ...@@ -4483,7 +4483,7 @@ floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM )
sub128( rem1, 0, term1, term2, &rem1, &rem2 ); sub128( rem1, 0, term1, term2, &rem1, &rem2 );
mul64To128( zSig1, zSig1, &term2, &term3 ); mul64To128( zSig1, zSig1, &term2, &term3 );
sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 ); sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );
while ( (sbits64) rem1 < 0 ) { while ( (int64_t) rem1 < 0 ) {
--zSig1; --zSig1;
shortShift128Left( 0, zSig1, 1, &term2, &term3 ); shortShift128Left( 0, zSig1, 1, &term2, &term3 );
term3 |= 1; term3 |= 1;
...@@ -4511,9 +4511,9 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4511,9 +4511,9 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
{ {
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
if ( floatx80_is_signaling_nan( a ) if ( floatx80_is_signaling_nan( a )
|| floatx80_is_signaling_nan( b ) ) { || floatx80_is_signaling_nan( b ) ) {
...@@ -4525,7 +4525,7 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4525,7 +4525,7 @@ int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM )
( a.low == b.low ) ( a.low == b.low )
&& ( ( a.high == b.high ) && ( ( a.high == b.high )
|| ( ( a.low == 0 ) || ( ( a.low == 0 )
&& ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) ) && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
); );
} }
...@@ -4542,9 +4542,9 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4542,9 +4542,9 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
flag aSign, bSign; flag aSign, bSign;
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return 0; return 0;
...@@ -4554,7 +4554,7 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4554,7 +4554,7 @@ int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
|| ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
== 0 ); == 0 );
} }
return return
...@@ -4575,9 +4575,9 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4575,9 +4575,9 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
flag aSign, bSign; flag aSign, bSign;
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return 0; return 0;
...@@ -4587,7 +4587,7 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4587,7 +4587,7 @@ int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
&& ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
!= 0 ); != 0 );
} }
return return
...@@ -4607,9 +4607,9 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4607,9 +4607,9 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM )
{ {
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return 0; return 0;
...@@ -4618,7 +4618,7 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4618,7 +4618,7 @@ int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM )
( a.low == b.low ) ( a.low == b.low )
&& ( ( a.high == b.high ) && ( ( a.high == b.high )
|| ( ( a.low == 0 ) || ( ( a.low == 0 )
&& ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) ) && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
); );
} }
...@@ -4635,9 +4635,9 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4635,9 +4635,9 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM )
flag aSign, bSign; flag aSign, bSign;
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
if ( floatx80_is_signaling_nan( a ) if ( floatx80_is_signaling_nan( a )
|| floatx80_is_signaling_nan( b ) ) { || floatx80_is_signaling_nan( b ) ) {
...@@ -4650,7 +4650,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4650,7 +4650,7 @@ int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
|| ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
== 0 ); == 0 );
} }
return return
...@@ -4671,9 +4671,9 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4671,9 +4671,9 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM )
flag aSign, bSign; flag aSign, bSign;
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF ) if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( a )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF ) || ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (bits64) ( extractFloatx80Frac( b )<<1 ) ) && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) { ) {
if ( floatx80_is_signaling_nan( a ) if ( floatx80_is_signaling_nan( a )
|| floatx80_is_signaling_nan( b ) ) { || floatx80_is_signaling_nan( b ) ) {
...@@ -4686,7 +4686,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM ) ...@@ -4686,7 +4686,7 @@ int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
&& ( ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
!= 0 ); != 0 );
} }
return return
...@@ -4713,7 +4713,7 @@ int32 float128_to_int32( float128 a STATUS_PARAM ) ...@@ -4713,7 +4713,7 @@ int32 float128_to_int32( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
...@@ -4742,7 +4742,7 @@ int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM ) ...@@ -4742,7 +4742,7 @@ int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig0, aSig1, savedASig; uint64_t aSig0, aSig1, savedASig;
int32 z; int32 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -4767,7 +4767,7 @@ int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM ) ...@@ -4767,7 +4767,7 @@ int32 float128_to_int32_round_to_zero( float128 a STATUS_PARAM )
if ( ( z < 0 ) ^ aSign ) { if ( ( z < 0 ) ^ aSign ) {
invalid: invalid:
float_raise( float_flag_invalid STATUS_VAR); float_raise( float_flag_invalid STATUS_VAR);
return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF; return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
} }
if ( ( aSig0<<shiftCount ) != savedASig ) { if ( ( aSig0<<shiftCount ) != savedASig ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
...@@ -4790,7 +4790,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM ) ...@@ -4790,7 +4790,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
...@@ -4808,7 +4808,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM ) ...@@ -4808,7 +4808,7 @@ int64 float128_to_int64( float128 a STATUS_PARAM )
) { ) {
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
shortShift128Left( aSig0, aSig1, - shiftCount, &aSig0, &aSig1 ); shortShift128Left( aSig0, aSig1, - shiftCount, &aSig0, &aSig1 );
} }
...@@ -4833,7 +4833,7 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM ) ...@@ -4833,7 +4833,7 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, shiftCount; int32 aExp, shiftCount;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
int64 z; int64 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -4855,10 +4855,10 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM ) ...@@ -4855,10 +4855,10 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
return LIT64( 0x7FFFFFFFFFFFFFFF ); return LIT64( 0x7FFFFFFFFFFFFFFF );
} }
} }
return (sbits64) LIT64( 0x8000000000000000 ); return (int64_t) LIT64( 0x8000000000000000 );
} }
z = ( aSig0<<shiftCount ) | ( aSig1>>( ( - shiftCount ) & 63 ) ); z = ( aSig0<<shiftCount ) | ( aSig1>>( ( - shiftCount ) & 63 ) );
if ( (bits64) ( aSig1<<shiftCount ) ) { if ( (uint64_t) ( aSig1<<shiftCount ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
} }
...@@ -4871,7 +4871,7 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM ) ...@@ -4871,7 +4871,7 @@ int64 float128_to_int64_round_to_zero( float128 a STATUS_PARAM )
} }
z = aSig0>>( - shiftCount ); z = aSig0>>( - shiftCount );
if ( aSig1 if ( aSig1
|| ( shiftCount && (bits64) ( aSig0<<( shiftCount & 63 ) ) ) ) { || ( shiftCount && (uint64_t) ( aSig0<<( shiftCount & 63 ) ) ) ) {
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
} }
} }
...@@ -4891,8 +4891,8 @@ float32 float128_to_float32( float128 a STATUS_PARAM ) ...@@ -4891,8 +4891,8 @@ float32 float128_to_float32( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
bits32 zSig; uint32_t zSig;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
...@@ -4926,7 +4926,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM ) ...@@ -4926,7 +4926,7 @@ float64 float128_to_float64( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
...@@ -4961,7 +4961,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM ) ...@@ -4961,7 +4961,7 @@ floatx80 float128_to_floatx80( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
...@@ -4998,7 +4998,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM ) ...@@ -4998,7 +4998,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 lastBitMask, roundBitsMask; uint64_t lastBitMask, roundBitsMask;
int8 roundingMode; int8 roundingMode;
float128 z; float128 z;
...@@ -5023,9 +5023,9 @@ float128 float128_round_to_int( float128 a STATUS_PARAM ) ...@@ -5023,9 +5023,9 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask; if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask;
} }
else { else {
if ( (sbits64) z.low < 0 ) { if ( (int64_t) z.low < 0 ) {
++z.high; ++z.high;
if ( (bits64) ( z.low<<1 ) == 0 ) z.high &= ~1; if ( (uint64_t) ( z.low<<1 ) == 0 ) z.high &= ~1;
} }
} }
} }
...@@ -5039,7 +5039,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM ) ...@@ -5039,7 +5039,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
} }
else { else {
if ( aExp < 0x3FFF ) { if ( aExp < 0x3FFF ) {
if ( ( ( (bits64) ( a.high<<1 ) ) | a.low ) == 0 ) return a; if ( ( ( (uint64_t) ( a.high<<1 ) ) | a.low ) == 0 ) return a;
STATUS(float_exception_flags) |= float_flag_inexact; STATUS(float_exception_flags) |= float_flag_inexact;
aSign = extractFloat128Sign( a ); aSign = extractFloat128Sign( a );
switch ( STATUS(float_rounding_mode) ) { switch ( STATUS(float_rounding_mode) ) {
...@@ -5101,7 +5101,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM ) ...@@ -5101,7 +5101,7 @@ float128 float128_round_to_int( float128 a STATUS_PARAM )
static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM) static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM)
{ {
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
int32 expDiff; int32 expDiff;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -5182,7 +5182,7 @@ static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM ...@@ -5182,7 +5182,7 @@ static float128 addFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM
static float128 subFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM) static float128 subFloat128Sigs( float128 a, float128 b, flag zSign STATUS_PARAM)
{ {
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
int32 expDiff; int32 expDiff;
float128 z; float128 z;
...@@ -5307,7 +5307,7 @@ float128 float128_mul( float128 a, float128 b STATUS_PARAM ) ...@@ -5307,7 +5307,7 @@ float128 float128_mul( float128 a, float128 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; 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; float128 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -5371,8 +5371,8 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM ) ...@@ -5371,8 +5371,8 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM )
{ {
flag aSign, bSign, zSign; flag aSign, bSign, zSign;
int32 aExp, bExp, zExp; int32 aExp, bExp, zExp;
bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2; uint64_t aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
float128 z; float128 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -5426,7 +5426,7 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM ) ...@@ -5426,7 +5426,7 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM )
zSig0 = estimateDiv128To64( aSig0, aSig1, bSig0 ); zSig0 = estimateDiv128To64( aSig0, aSig1, bSig0 );
mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 ); mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 );
sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 ); sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig0; --zSig0;
add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 ); add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 );
} }
...@@ -5434,7 +5434,7 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM ) ...@@ -5434,7 +5434,7 @@ float128 float128_div( float128 a, float128 b STATUS_PARAM )
if ( ( zSig1 & 0x3FFF ) <= 4 ) { if ( ( zSig1 & 0x3FFF ) <= 4 ) {
mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 ); mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 );
sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 ); sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 );
while ( (sbits64) rem1 < 0 ) { while ( (int64_t) rem1 < 0 ) {
--zSig1; --zSig1;
add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &rem3 ); add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &rem3 );
} }
...@@ -5455,9 +5455,9 @@ float128 float128_rem( float128 a, float128 b STATUS_PARAM ) ...@@ -5455,9 +5455,9 @@ float128 float128_rem( float128 a, float128 b STATUS_PARAM )
{ {
flag aSign, zSign; flag aSign, zSign;
int32 aExp, bExp, expDiff; int32 aExp, bExp, expDiff;
bits64 aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2; uint64_t aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;
bits64 allZero, alternateASig0, alternateASig1, sigMean1; uint64_t allZero, alternateASig0, alternateASig1, sigMean1;
sbits64 sigMean0; int64_t sigMean0;
float128 z; float128 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -5539,15 +5539,15 @@ float128 float128_rem( float128 a, float128 b STATUS_PARAM ) ...@@ -5539,15 +5539,15 @@ float128 float128_rem( float128 a, float128 b STATUS_PARAM )
alternateASig1 = aSig1; alternateASig1 = aSig1;
++q; ++q;
sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 ); sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 );
} while ( 0 <= (sbits64) aSig0 ); } while ( 0 <= (int64_t) aSig0 );
add128( add128(
aSig0, aSig1, alternateASig0, alternateASig1, (bits64 *)&sigMean0, &sigMean1 ); aSig0, aSig1, alternateASig0, alternateASig1, (uint64_t *)&sigMean0, &sigMean1 );
if ( ( sigMean0 < 0 ) if ( ( sigMean0 < 0 )
|| ( ( ( sigMean0 | sigMean1 ) == 0 ) && ( q & 1 ) ) ) { || ( ( ( sigMean0 | sigMean1 ) == 0 ) && ( q & 1 ) ) ) {
aSig0 = alternateASig0; aSig0 = alternateASig0;
aSig1 = alternateASig1; aSig1 = alternateASig1;
} }
zSign = ( (sbits64) aSig0 < 0 ); zSign = ( (int64_t) aSig0 < 0 );
if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 ); if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );
return return
normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 STATUS_VAR ); normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 STATUS_VAR );
...@@ -5564,8 +5564,8 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) ...@@ -5564,8 +5564,8 @@ float128 float128_sqrt( float128 a STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp, zExp; int32 aExp, zExp;
bits64 aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0; uint64_t aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;
bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3; uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
float128 z; float128 z;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
...@@ -5597,7 +5597,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) ...@@ -5597,7 +5597,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM )
doubleZSig0 = zSig0<<1; doubleZSig0 = zSig0<<1;
mul64To128( zSig0, zSig0, &term0, &term1 ); mul64To128( zSig0, zSig0, &term0, &term1 );
sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 ); sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );
while ( (sbits64) rem0 < 0 ) { while ( (int64_t) rem0 < 0 ) {
--zSig0; --zSig0;
doubleZSig0 -= 2; doubleZSig0 -= 2;
add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 ); add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );
...@@ -5609,7 +5609,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM ) ...@@ -5609,7 +5609,7 @@ float128 float128_sqrt( float128 a STATUS_PARAM )
sub128( rem1, 0, term1, term2, &rem1, &rem2 ); sub128( rem1, 0, term1, term2, &rem1, &rem2 );
mul64To128( zSig1, zSig1, &term2, &term3 ); mul64To128( zSig1, zSig1, &term2, &term3 );
sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 ); sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );
while ( (sbits64) rem1 < 0 ) { while ( (int64_t) rem1 < 0 ) {
--zSig1; --zSig1;
shortShift128Left( 0, zSig1, 1, &term2, &term3 ); shortShift128Left( 0, zSig1, 1, &term2, &term3 );
term3 |= 1; term3 |= 1;
...@@ -5647,7 +5647,7 @@ int float128_eq( float128 a, float128 b STATUS_PARAM ) ...@@ -5647,7 +5647,7 @@ int float128_eq( float128 a, float128 b STATUS_PARAM )
( a.low == b.low ) ( a.low == b.low )
&& ( ( a.high == b.high ) && ( ( a.high == b.high )
|| ( ( a.low == 0 ) || ( ( a.low == 0 )
&& ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) ) && ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
); );
} }
...@@ -5676,7 +5676,7 @@ int float128_le( float128 a, float128 b STATUS_PARAM ) ...@@ -5676,7 +5676,7 @@ int float128_le( float128 a, float128 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
|| ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) || ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
== 0 ); == 0 );
} }
return return
...@@ -5708,7 +5708,7 @@ int float128_lt( float128 a, float128 b STATUS_PARAM ) ...@@ -5708,7 +5708,7 @@ int float128_lt( float128 a, float128 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
&& ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) && ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
!= 0 ); != 0 );
} }
return return
...@@ -5739,7 +5739,7 @@ int float128_eq_signaling( float128 a, float128 b STATUS_PARAM ) ...@@ -5739,7 +5739,7 @@ int float128_eq_signaling( float128 a, float128 b STATUS_PARAM )
( a.low == b.low ) ( a.low == b.low )
&& ( ( a.high == b.high ) && ( ( a.high == b.high )
|| ( ( a.low == 0 ) || ( ( a.low == 0 )
&& ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) ) && ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
); );
} }
...@@ -5771,7 +5771,7 @@ int float128_le_quiet( float128 a, float128 b STATUS_PARAM ) ...@@ -5771,7 +5771,7 @@ int float128_le_quiet( float128 a, float128 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
|| ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) || ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
== 0 ); == 0 );
} }
return return
...@@ -5807,7 +5807,7 @@ int float128_lt_quiet( float128 a, float128 b STATUS_PARAM ) ...@@ -5807,7 +5807,7 @@ int float128_lt_quiet( float128 a, float128 b STATUS_PARAM )
if ( aSign != bSign ) { if ( aSign != bSign ) {
return return
aSign aSign
&& ( ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low ) && ( ( ( (uint64_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
!= 0 ); != 0 );
} }
return return
...@@ -5965,7 +5965,7 @@ INLINE int float ## s ## _compare_internal( float ## s a, float ## s b, \ ...@@ -5965,7 +5965,7 @@ INLINE int float ## s ## _compare_internal( float ## s a, float ## s b, \
int is_quiet STATUS_PARAM ) \ int is_quiet STATUS_PARAM ) \
{ \ { \
flag aSign, bSign; \ flag aSign, bSign; \
bits ## s av, bv; \ uint ## s ## _t av, bv; \
a = float ## s ## _squash_input_denormal(a STATUS_VAR); \ a = float ## s ## _squash_input_denormal(a STATUS_VAR); \
b = float ## s ## _squash_input_denormal(b STATUS_VAR); \ b = float ## s ## _squash_input_denormal(b STATUS_VAR); \
\ \
...@@ -5985,7 +5985,7 @@ INLINE int float ## s ## _compare_internal( float ## s a, float ## s b, \ ...@@ -5985,7 +5985,7 @@ INLINE int float ## s ## _compare_internal( float ## s a, float ## s b, \
av = float ## s ## _val(a); \ av = float ## s ## _val(a); \
bv = float ## s ## _val(b); \ bv = float ## s ## _val(b); \
if ( aSign != bSign ) { \ if ( aSign != bSign ) { \
if ( (bits ## s) ( ( av | bv )<<1 ) == 0 ) { \ if ( (uint ## s ## _t) ( ( av | bv )<<1 ) == 0 ) { \
/* zero case */ \ /* zero case */ \
return float_relation_equal; \ return float_relation_equal; \
} else { \ } else { \
...@@ -6062,7 +6062,7 @@ float32 float32_scalbn( float32 a, int n STATUS_PARAM ) ...@@ -6062,7 +6062,7 @@ float32 float32_scalbn( float32 a, int n STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits32 aSig; uint32_t aSig;
a = float32_squash_input_denormal(a STATUS_VAR); a = float32_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat32Frac( a ); aSig = extractFloat32Frac( a );
...@@ -6086,7 +6086,7 @@ float64 float64_scalbn( float64 a, int n STATUS_PARAM ) ...@@ -6086,7 +6086,7 @@ float64 float64_scalbn( float64 a, int n STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig; uint64_t aSig;
a = float64_squash_input_denormal(a STATUS_VAR); a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a ); aSig = extractFloat64Frac( a );
...@@ -6111,7 +6111,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM ) ...@@ -6111,7 +6111,7 @@ floatx80 floatx80_scalbn( floatx80 a, int n STATUS_PARAM )
{ {
flag aSign; flag aSign;
int16 aExp; int16 aExp;
bits64 aSig; uint64_t aSig;
aSig = extractFloatx80Frac( a ); aSig = extractFloatx80Frac( a );
aExp = extractFloatx80Exp( a ); aExp = extractFloatx80Exp( a );
...@@ -6134,7 +6134,7 @@ float128 float128_scalbn( float128 a, int n STATUS_PARAM ) ...@@ -6134,7 +6134,7 @@ float128 float128_scalbn( float128 a, int n STATUS_PARAM )
{ {
flag aSign; flag aSign;
int32 aExp; int32 aExp;
bits64 aSig0, aSig1; uint64_t aSig0, aSig1;
aSig1 = extractFloat128Frac1( a ); aSig1 = extractFloat128Frac1( a );
aSig0 = extractFloat128Frac0( a ); aSig0 = extractFloat128Frac0( a );
......
fpu/softfloat.h
浏览文件 @ bb98fe42
...@@ -65,21 +65,6 @@ typedef signed int int32; ...@@ -65,21 +65,6 @@ typedef signed int int32;
typedef uint64_t uint64; typedef uint64_t uint64;
typedef int64_t int64; typedef int64_t int64;
/*----------------------------------------------------------------------------
| 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'), respectively.
*----------------------------------------------------------------------------*/
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 LIT64( a ) a##LL
#define INLINE static inline #define INLINE static inline
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或