yuzu-emu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2024-10-19 22:08:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

softfloat: Fix warn about implicit conversion from int to int8_t

Browse Source 
Change the flag type to 'uint8_t' to fix the implicit conversion error.

Backports commit dfd607671037ff46d5b16ade10e10efdf0d260be from qemu
This commit is contained in:
Pranith Kumar 2018-02-25 22:54:32 -05:00 committed by Lioncash
parent 4c880fba9d
commit 1b19fe260a
No known key found for this signature in database
GPG Key ID: 4E3C3CC1031BA9C7
3 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
qemu/fpu/softfloat-specialize.h
View File

@ -196,7 +196,7 @@ float128 float128_default_nan(float_status *status)
| should be simply `float_exception_flags |= flags;'.
*----------------------------------------------------------------------------*/
void float_raise(int8_t flags, float_status *status)
void float_raise(uint8_t flags, float_status *status)
{
status->float_exception_flags |= flags;
}

96
qemu/fpu/softfloat.c
View File

@ -175,7 +175,7 @@ static int32_t roundAndPackInt32( flag zSign, uint64_t absZ, float_status *statu
z = (int32_t)absZ;
if ( zSign ) z = - z;
if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( roundBits ) status->float_exception_flags |= float_flag_inexact;
@ -229,7 +229,7 @@ static int64_t roundAndPackInt64( flag zSign, uint64_t absZ0, uint64_t absZ1, fl
if ( zSign ) z = - z;
if ( z && ( ( z < 0 ) ^ zSign ) ) {
overflow:
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return
zSign ? (int64_t) LIT64( 0x8000000000000000 )
: LIT64( 0x7FFFFFFFFFFFFFFF );
@ -434,12 +434,12 @@ static float32 roundAndPackFloat32(flag zSign, int zExp, uint32_t zSig, float_st
|| ( ( zExp == 0xFD )
&& ( (int32_t) ( zSig + roundIncrement ) < 0 ) )
) {
float_raise( float_flag_overflow | float_flag_inexact, status);
float_raise(float_flag_overflow | float_flag_inexact, status);
return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 ));
}
if ( zExp < 0 ) {
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloat32(zSign, 0, 0);
}
isTiny =
@ -620,12 +620,12 @@ static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, float_st
|| ( ( zExp == 0x7FD )
&& ( (int64_t) ( zSig + roundIncrement ) < 0 ) )
) {
float_raise( float_flag_overflow | float_flag_inexact, status);
float_raise(float_flag_overflow | float_flag_inexact, status);
return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 ));
}
if ( zExp < 0 ) {
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloat64(zSign, 0, 0);
}
isTiny =
@ -636,7 +636,7 @@ static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig, float_st
zExp = 0;
roundBits = zSig & 0x3FF;
if (isTiny && roundBits) {
float_raise( float_flag_underflow, status);
float_raise(float_flag_underflow, status);
}
}
}
@ -809,7 +809,7 @@ static floatx80
}
if ( zExp <= 0 ) {
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloatx80(zSign, 0, 0);
}
isTiny =
@ -873,7 +873,7 @@ static floatx80
) {
roundMask = 0;
overflow:
float_raise( float_flag_overflow | float_flag_inexact, status);
float_raise(float_flag_overflow | float_flag_inexact, status);
if ( ( roundingMode == float_round_to_zero )
|| ( zSign && ( roundingMode == float_round_up ) )
|| ( ! zSign && ( roundingMode == float_round_down ) )
@ -1138,7 +1138,7 @@ static float128
&& increment
)
) {
float_raise( float_flag_overflow | float_flag_inexact, status);
float_raise(float_flag_overflow | float_flag_inexact, status);
if ( ( roundingMode == float_round_to_zero )
|| ( zSign && ( roundingMode == float_round_up ) )
|| ( ! zSign && ( roundingMode == float_round_down ) )
@ -1155,7 +1155,7 @@ static float128
}
if ( zExp < 0 ) {
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloat128(zSign, 0, 0, 0);
}
isTiny =
@ -1561,7 +1561,7 @@ int32_t float32_to_int32_round_to_zero(float32 a, float_status *status)
shiftCount = aExp - 0x9E;
if ( 0 <= shiftCount ) {
if ( float32_val(a) != 0xCF000000 ) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
}
return (int32_t) 0x80000000;
@ -1604,7 +1604,7 @@ int16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
shiftCount = aExp - 0x8E;
if ( 0 <= shiftCount ) {
if ( float32_val(a) != 0xC7000000 ) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return 0x7FFF;
}
@ -1654,7 +1654,7 @@ int64_t float32_to_int64(float32 a, float_status *status)
aSign = extractFloat32Sign( a );
shiftCount = 0xBE - aExp;
if ( shiftCount < 0 ) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@ -1762,7 +1762,7 @@ int64_t float32_to_int64_round_to_zero(float32 a, float_status *status)
shiftCount = aExp - 0xBE;
if ( 0 <= shiftCount ) {
if ( float32_val(a) != 0xDF000000 ) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@ -2022,7 +2022,7 @@ static float32 addFloat32Sigs(float32 a, float32 b, flag zSign, float_status *st
if ( aExp == 0 ) {
if (status->flush_to_zero) {
if (aSig | bSig) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
}
return packFloat32(zSign, 0, 0);
}
@ -2071,7 +2071,7 @@ static float32 subFloat32Sigs(float32 a, float32 b, flag zSign, float_status *st
if (aSig | bSig) {
return propagateFloat32NaN(a, b, status);
}
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return float32_default_nan(status);
}
if ( aExp == 0 ) {
@ -2504,7 +2504,7 @@ float32 float32_muladd(float32 a, float32 b, float32 c, int flags, float_status
}
/* Exact zero plus a denorm */
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloat32(cSign ^ signflip, 0, 0);
}
}
@ -2749,7 +2749,7 @@ float32 float32_exp2(float32 a, float_status *status)
if (aSig == 0) return float32_one;
}
float_raise( float_flag_inexact, status);
float_raise(float_flag_inexact, status);
/* ******************************* */
/* using float64 for approximation */
@ -2918,7 +2918,7 @@ int float32_unordered(float32 a, float32 b, float_status *status)
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 1;
}
return 0;
@ -3106,7 +3106,7 @@ int32_t float64_to_int32_round_to_zero(float64 a, float_status *status)
if ( aSign ) z = - z;
if ( ( z < 0 ) ^ aSign ) {
invalid:
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( ( aSig<<shiftCount ) != savedASig ) {
@ -3812,7 +3812,7 @@ static float64 addFloat64Sigs(float64 a, float64 b, flag zSign, float_status *st
if ( aExp == 0 ) {
if (status->flush_to_zero) {
if (aSig | bSig) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
}
return packFloat64(zSign, 0, 0);
}
@ -4286,7 +4286,7 @@ float64 float64_muladd(float64 a, float64 b, float64 c, int flags, float_status
}
/* Exact zero plus a denorm */
if (status->flush_to_zero) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
return packFloat64(cSign ^ signflip, 0, 0);
}
}
@ -4555,7 +4555,7 @@ int float64_eq(float64 a, float64 b, float_status *status)
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
av = float64_val(a);
@ -4581,7 +4581,7 @@ int float64_le(float64 a, float64 b, float_status *status)
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat64Sign( a );
@ -4610,7 +4610,7 @@ int float64_lt(float64 a, float64 b, float_status *status)
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat64Sign( a );
@ -4637,7 +4637,7 @@ int float64_unordered(float64 a, float64 b, float_status *status)
if ( ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
|| ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 1;
}
return 0;
@ -4661,7 +4661,7 @@ int float64_eq_quiet(float64 a, float64 b, float_status *status)
) {
if (float64_is_signaling_nan(a, status)
|| float64_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 0;
}
@ -4690,7 +4690,7 @@ int float64_le_quiet(float64 a, float64 b, float_status *status)
) {
if (float64_is_signaling_nan(a, status)
|| float64_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 0;
}
@ -4722,7 +4722,7 @@ int float64_lt_quiet(float64 a, float64 b, float_status *status)
) {
if (float64_is_signaling_nan(a, status)
|| float64_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 0;
}
@ -4752,7 +4752,7 @@ int float64_unordered_quiet(float64 a, float64 b, float_status *status)
) {
if (float64_is_signaling_nan(a, status)
|| float64_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 1;
}
@ -5218,7 +5218,7 @@ static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign, float_status
if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
return propagateFloatx80NaN( a, b, status );
}
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return floatx80_default_nan(status);
}
if ( aExp == 0 ) {
@ -5343,7 +5343,7 @@ floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
if ( ( aExp | aSig ) == 0 ) {
invalid:
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return floatx80_default_nan(status);
}
return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
@ -5633,7 +5633,7 @@ int floatx80_eq(floatx80 a, floatx80 b, float_status *status)
|| (extractFloatx80Exp(b) == 0x7FFF
&& (uint64_t) (extractFloatx80Frac(b) << 1))
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
return
@ -5663,7 +5663,7 @@ int floatx80_le(floatx80 a, floatx80 b, float_status *status)
|| (extractFloatx80Exp(b) == 0x7FFF
&& (uint64_t) (extractFloatx80Frac(b) << 1))
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloatx80Sign( a );
@ -5697,7 +5697,7 @@ int floatx80_lt(floatx80 a, floatx80 b, float_status *status)
|| (extractFloatx80Exp(b) == 0x7FFF
&& (uint64_t) (extractFloatx80Frac(b) << 1))
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloatx80Sign( a );
@ -5728,7 +5728,7 @@ int floatx80_unordered(floatx80 a, floatx80 b, float_status *status)
|| (extractFloatx80Exp(b) == 0x7FFF
&& (uint64_t) (extractFloatx80Frac(b) << 1))
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 1;
}
return 0;
@ -5755,7 +5755,7 @@ int floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *status)
) {
if (floatx80_is_signaling_nan(a, status)
|| floatx80_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 0;
}
@ -5790,7 +5790,7 @@ int floatx80_le_quiet(floatx80 a, floatx80 b, float_status *status)
) {
if (floatx80_is_signaling_nan(a, status)
|| floatx80_is_signaling_nan(b, status)) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
}
return 0;
}
@ -5941,7 +5941,7 @@ int32_t float128_to_int32_round_to_zero(float128 a, float_status *status)
if ( aSign ) z = - z;
if ( ( z < 0 ) ^ aSign ) {
invalid:
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
}
if ( ( aSig0<<shiftCount ) != savedASig ) {
@ -6025,7 +6025,7 @@ int64_t float128_to_int64_round_to_zero(float128 a, float_status *status)
if ( aSig1 ) status->float_exception_flags |= float_flag_inexact;
}
else {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
return LIT64( 0x7FFFFFFFFFFFFFFF );
}
@ -6358,7 +6358,7 @@ static float128 addFloat128Sigs(float128 a, float128 b, flag zSign, float_status
if ( aExp == 0 ) {
if (status->flush_to_zero) {
if (zSig0 | zSig1) {
float_raise((int8_t)float_flag_output_denormal, status);
float_raise(float_flag_output_denormal, status);
}
return packFloat128(zSign, 0, 0, 0);
}
@ -6607,7 +6607,7 @@ float128 float128_div(float128 a, float128 b, float_status *status)
float_raise(float_flag_invalid, status);
return float128_default_nan(status);
}
float_raise( float_flag_divbyzero, status);
float_raise(float_flag_divbyzero, status);
return packFloat128( zSign, 0x7FFF, 0, 0 );
}
normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );
@ -6834,7 +6834,7 @@ int float128_eq(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
return
@ -6862,7 +6862,7 @@ int float128_le(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat128Sign( a );
@ -6895,7 +6895,7 @@ int float128_lt(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 0;
}
aSign = extractFloat128Sign( a );
@ -6926,7 +6926,7 @@ int float128_unordered(float128 a, float128 b, float_status *status)
|| ( ( extractFloat128Exp( b ) == 0x7FFF )
&& ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
) {
float_raise( float_flag_invalid, status);
float_raise(float_flag_invalid, status);
return 1;
}
return 0;
@ -7332,7 +7332,7 @@ static inline int float ## s ## _compare_internal(float ## s a, float ## s b,
if (!is_quiet || \
float ## s ## _is_signaling_nan(a, status) || \
float ## s ## _is_signaling_nan(b, status)) { \
float_raise( float_flag_invalid, status); \
float_raise(float_flag_invalid, status); \
} \
return float_relation_unordered; \
} \

4
qemu/include/fpu/softfloat.h
View File

@ -206,7 +206,7 @@ enum {
typedef struct float_status {
signed char float_detect_tininess;
signed char float_rounding_mode;
signed char float_exception_flags;
uint8_t float_exception_flags;
signed char floatx80_rounding_precision;
/* should denormalised results go to zero and set the inexact flag? */
flag flush_to_zero;
@ -281,7 +281,7 @@ static inline flag get_default_nan_mode(float_status *status)
| Routine to raise any or all of the software IEC/IEEE floating-point
| exception flags.
*----------------------------------------------------------------------------*/
void float_raise( int8_t flags, float_status *status);
void float_raise(uint8_t flags, float_status *status);
/*----------------------------------------------------------------------------
| If `a' is denormal and we are in flush-to-zero mode then set the