jcs.org / qemu
qemu with hax to log dma reads & writes jcs.org/2018/11/12/vfio
fork atom

softfloat: use floatx80_infinity in softfloat

Since f3218a8 ("softfloat: add floatx80 constants")
floatx80_infinity is defined but never used.

This patch updates floatx80 functions to use
this definition.

This allows to define a different default Infinity
value on m68k: the m68k FPU defines infinity with
all bits set to zero in the mantissa.

Signed-off-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20180224201802.911-4-laurent@vivier.eu>

Laurent Vivier 0f605c88 591596b7

+50 -16
+14
fpu/softfloat-specialize.h
··· 178 178 } 179 179 180 180 /*---------------------------------------------------------------------------- 181 + | The pattern for a default generated extended double-precision inf. 182 + *----------------------------------------------------------------------------*/ 183 + 184 + #define floatx80_infinity_high 0x7FFF 185 + #if defined(TARGET_M68K) 186 + #define floatx80_infinity_low LIT64(0x0000000000000000) 187 + #else 188 + #define floatx80_infinity_low LIT64(0x8000000000000000) 189 + #endif 190 + 191 + const floatx80 floatx80_infinity 192 + = make_floatx80_init(floatx80_infinity_high, floatx80_infinity_low); 193 + 194 + /*---------------------------------------------------------------------------- 181 195 | The pattern for a default generated quadruple-precision NaN. 182 196 *----------------------------------------------------------------------------*/ 183 197 float128 float128_default_nan(float_status *status)
+25 -14
fpu/softfloat.c
··· 2636 2636 ) { 2637 2637 return packFloatx80( zSign, 0x7FFE, ~ roundMask ); 2638 2638 } 2639 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 2639 + return packFloatx80(zSign, 2640 + floatx80_infinity_high, 2641 + floatx80_infinity_low); 2640 2642 } 2641 2643 if ( zExp <= 0 ) { 2642 2644 isTiny = ··· 3182 3184 if (aSig) { 3183 3185 return commonNaNToFloatx80(float32ToCommonNaN(a, status), status); 3184 3186 } 3185 - return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 3187 + return packFloatx80(aSign, 3188 + floatx80_infinity_high, 3189 + floatx80_infinity_low); 3186 3190 } 3187 3191 if ( aExp == 0 ) { 3188 3192 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 ); ··· 4037 4041 if (aSig) { 4038 4042 return commonNaNToFloatx80(float64ToCommonNaN(a, status), status); 4039 4043 } 4040 - return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 4044 + return packFloatx80(aSign, 4045 + floatx80_infinity_high, 4046 + floatx80_infinity_low); 4041 4047 } 4042 4048 if ( aExp == 0 ) { 4043 4049 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 ); ··· 4549 4555 if ( shiftCount <= 0 ) { 4550 4556 if ( shiftCount ) { 4551 4557 float_raise(float_flag_invalid, status); 4552 - if ( ! aSign 4553 - || ( ( aExp == 0x7FFF ) 4554 - && ( aSig != LIT64( 0x8000000000000000 ) ) ) 4555 - ) { 4558 + if (!aSign || floatx80_is_any_nan(a)) { 4556 4559 return LIT64( 0x7FFFFFFFFFFFFFFF ); 4557 4560 } 4558 4561 return (int64_t) LIT64( 0x8000000000000000 ); ··· 4858 4861 if ((uint64_t)(bSig << 1)) { 4859 4862 return propagateFloatx80NaN(a, b, status); 4860 4863 } 4861 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 4864 + return packFloatx80(zSign, 4865 + floatx80_infinity_high, 4866 + floatx80_infinity_low); 4862 4867 } 4863 4868 if ( aExp == 0 ) ++expDiff; 4864 4869 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 ); ··· 4933 4938 if ((uint64_t)(bSig << 1)) { 4934 4939 return propagateFloatx80NaN(a, b, status); 4935 4940 } 4936 - return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) ); 4941 + return packFloatx80(zSign ^ 1, floatx80_infinity_high, 4942 + floatx80_infinity_low); 4937 4943 } 4938 4944 if ( aExp == 0 ) ++expDiff; 4939 4945 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 ); ··· 5038 5044 return propagateFloatx80NaN(a, b, status); 5039 5045 } 5040 5046 if ( ( bExp | bSig ) == 0 ) goto invalid; 5041 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 5047 + return packFloatx80(zSign, floatx80_infinity_high, 5048 + floatx80_infinity_low); 5042 5049 } 5043 5050 if ( bExp == 0x7FFF ) { 5044 5051 if ((uint64_t)(bSig << 1)) { ··· 5049 5056 float_raise(float_flag_invalid, status); 5050 5057 return floatx80_default_nan(status); 5051 5058 } 5052 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 5059 + return packFloatx80(zSign, floatx80_infinity_high, 5060 + floatx80_infinity_low); 5053 5061 } 5054 5062 if ( aExp == 0 ) { 5055 5063 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 ); ··· 5103 5111 } 5104 5112 goto invalid; 5105 5113 } 5106 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 5114 + return packFloatx80(zSign, floatx80_infinity_high, 5115 + floatx80_infinity_low); 5107 5116 } 5108 5117 if ( bExp == 0x7FFF ) { 5109 5118 if ((uint64_t)(bSig << 1)) { ··· 5119 5128 return floatx80_default_nan(status); 5120 5129 } 5121 5130 float_raise(float_flag_divbyzero, status); 5122 - return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 5131 + return packFloatx80(zSign, floatx80_infinity_high, 5132 + floatx80_infinity_low); 5123 5133 } 5124 5134 normalizeFloatx80Subnormal( bSig, &bExp, &bSig ); 5125 5135 } ··· 5942 5952 if ( aSig0 | aSig1 ) { 5943 5953 return commonNaNToFloatx80(float128ToCommonNaN(a, status), status); 5944 5954 } 5945 - return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) ); 5955 + return packFloatx80(aSign, floatx80_infinity_high, 5956 + floatx80_infinity_low); 5946 5957 } 5947 5958 if ( aExp == 0 ) { 5948 5959 if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
+11 -2
include/fpu/softfloat.h
··· 573 573 float128 floatx80_to_float128(floatx80, float_status *status); 574 574 575 575 /*---------------------------------------------------------------------------- 576 + | The pattern for an extended double-precision inf. 577 + *----------------------------------------------------------------------------*/ 578 + extern const floatx80 floatx80_infinity; 579 + 580 + /*---------------------------------------------------------------------------- 576 581 | Software IEC/IEEE extended double-precision operations. 577 582 *----------------------------------------------------------------------------*/ 578 583 floatx80 floatx80_round(floatx80 a, float_status *status); ··· 612 617 613 618 static inline int floatx80_is_infinity(floatx80 a) 614 619 { 615 - return (a.high & 0x7fff) == 0x7fff && a.low == 0x8000000000000000LL; 620 + #if defined(TARGET_M68K) 621 + return (a.high & 0x7fff) == floatx80_infinity.high && !(a.low << 1); 622 + #else 623 + return (a.high & 0x7fff) == floatx80_infinity.high && 624 + a.low == floatx80_infinity.low; 625 + #endif 616 626 } 617 627 618 628 static inline int floatx80_is_neg(floatx80 a) ··· 655 665 #define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL) 656 666 #define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL) 657 667 #define floatx80_half make_floatx80(0x3ffe, 0x8000000000000000LL) 658 - #define floatx80_infinity make_floatx80(0x7fff, 0x8000000000000000LL) 659 668 660 669 /*---------------------------------------------------------------------------- 661 670 | Returns the fraction bits of the extended double-precision floating-point