Lines Matching refs:aSig
141 by the denormalized significand `aSig'. The normalized exponent and
147 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
151 shiftCount = countLeadingZeros32( aSig ) - 8;
152 *zSigPtr = aSig<<shiftCount;
302 by the denormalized significand `aSig'. The normalized exponent and
308 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
312 shiftCount = countLeadingZeros64( aSig ) - 11;
313 *zSigPtr = aSig<<shiftCount;
478 represented by the denormalized significand `aSig'. The normalized exponent
484 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
488 shiftCount = countLeadingZeros64( aSig );
489 *zSigPtr = aSig<<shiftCount;
811 bits32 aSig;
814 aSig = extractFloat32Frac( a );
817 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
818 if ( aExp ) aSig |= 0x00800000;
820 zSig = aSig;
842 bits32 aSig;
845 aSig = extractFloat32Frac( a );
852 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
856 if ( aExp | aSig ) float_raise( float_flag_inexact );
859 aSig = ( aSig | 0x00800000 )<<8;
860 z = aSig>>( - shiftCount );
861 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
880 bits32 aSig;
882 aSig = extractFloat32Frac( a );
886 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
890 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
891 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
894 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
912 bits32 aSig;
914 aSig = extractFloat32Frac( a );
918 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
922 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
923 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
925 aSig |= 0x00800000;
926 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1004 bits32 aSig, bSig, zSig;
1007 aSig = extractFloat32Frac( a );
1012 aSig <<= 6;
1016 if ( aSig ) return propagateFloat32NaN( a, b );
1037 aSig |= 0x20000000;
1039 shift32RightJamming( aSig, - expDiff, &aSig );
1044 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1047 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1048 zSig = 0x40000000 + aSig + bSig;
1052 aSig |= 0x20000000;
1053 zSig = ( aSig + bSig )<<1;
1056 zSig = aSig + bSig;
1076 bits32 aSig, bSig, zSig;
1079 aSig = extractFloat32Frac( a );
1084 aSig <<= 7;
1089 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1097 if ( bSig < aSig ) goto aBigger;
1098 if ( aSig < bSig ) goto bBigger;
1109 aSig |= 0x40000000;
1111 shift32RightJamming( aSig, - expDiff, &aSig );
1114 zSig = bSig - aSig;
1120 if ( aSig ) return propagateFloat32NaN( a, b );
1130 aSig |= 0x40000000;
1132 zSig = aSig - bSig;
1195 bits32 aSig, bSig;
1199 aSig = extractFloat32Frac( a );
1207 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1218 if ( ( aExp | aSig ) == 0 ) {
1225 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1226 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1233 aSig = ( aSig | 0x00800000 )<<7;
1235 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1256 bits32 aSig, bSig, zSig;
1258 aSig = extractFloat32Frac( a );
1266 if ( aSig ) return propagateFloat32NaN( a, b );
1280 if ( ( aExp | aSig ) == 0 ) {
1290 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1291 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1294 aSig = ( aSig | 0x00800000 )<<7;
1296 if ( bSig <= ( aSig + aSig ) ) {
1297 aSig >>= 1;
1301 bits64 tmp = ( (bits64) aSig )<<32;
1306 zSig |= ( ( (bits64) bSig ) * zSig != ( (bits64) aSig )<<32 );
1323 bits32 aSig, bSig;
1329 aSig = extractFloat32Frac( a );
1336 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1354 if ( aSig == 0 ) return a;
1355 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1358 aSig |= 0x00800000;
1361 aSig <<= 8;
1365 aSig >>= 1;
1367 q = ( bSig <= aSig );
1368 if ( q ) aSig -= bSig;
1370 bits64 tmp = ( (bits64) aSig )<<32;
1375 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
1378 aSig >>= 2;
1383 if ( bSig <= aSig ) aSig -= bSig;
1384 aSig64 = ( (bits64) aSig )<<40;
1398 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
1401 alternateASig = aSig;
1403 aSig -= bSig;
1404 } while ( 0 <= (sbits32) aSig );
1405 sigMean = aSig + alternateASig;
1407 aSig = alternateASig;
1409 zSign = ( (sbits32) aSig < 0 );
1410 if ( zSign ) aSig = - aSig;
1411 return normalizeRoundAndPackFloat32( roundData, aSign ^ zSign, bExp, aSig );
1426 bits32 aSig, zSig;
1429 aSig = extractFloat32Frac( a );
1433 if ( aSig ) return propagateFloat32NaN( a, 0 );
1439 if ( ( aExp | aSig ) == 0 ) return a;
1444 if ( aSig == 0 ) return 0;
1445 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1448 aSig = ( aSig | 0x00800000 )<<8;
1449 zSig = estimateSqrt32( aExp, aSig ) + 2;
1455 aSig >>= aExp & 1;
1457 rem = ( ( (bits64) aSig )<<32 ) - term;
1628 bits64 aSig;
1630 aSig = extractFloat64Frac( a );
1633 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1634 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
1636 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
1637 return roundAndPackInt32( roundData, aSign, aSig );
1656 bits64 aSig, savedASig;
1659 aSig = extractFloat64Frac( a );
1664 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1668 if ( aExp || aSig ) float_raise( float_flag_inexact );
1671 aSig |= LIT64( 0x0010000000000000 );
1672 savedASig = aSig;
1673 aSig >>= shiftCount;
1674 z = aSig;
1681 if ( ( aSig<<shiftCount ) != savedASig ) {
1703 bits64 aSig;
1705 aSig = extractFloat64Frac( a );
1708 //if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1709 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
1711 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
1712 return roundAndPackInt32( roundData, aSign, aSig );
1729 bits64 aSig, savedASig;
1732 aSig = extractFloat64Frac( a );
1737 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1741 if ( aExp || aSig ) float_raise( float_flag_inexact );
1744 aSig |= LIT64( 0x0010000000000000 );
1745 savedASig = aSig;
1746 aSig >>= shiftCount;
1747 z = aSig;
1754 if ( ( aSig<<shiftCount ) != savedASig ) {
1772 bits64 aSig;
1775 aSig = extractFloat64Frac( a );
1779 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
1782 shift64RightJamming( aSig, 22, &aSig );
1783 zSig = aSig;
1806 bits64 aSig;
1808 aSig = extractFloat64Frac( a );
1812 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
1816 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1817 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
1821 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
1900 bits64 aSig, bSig, zSig;
1903 aSig = extractFloat64Frac( a );
1908 aSig <<= 9;
1912 if ( aSig ) return propagateFloat64NaN( a, b );
1933 aSig |= LIT64( 0x2000000000000000 );
1935 shift64RightJamming( aSig, - expDiff, &aSig );
1940 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
1943 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
1944 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
1948 aSig |= LIT64( 0x2000000000000000 );
1949 zSig = ( aSig + bSig )<<1;
1952 zSig = aSig + bSig;
1972 bits64 aSig, bSig, zSig;
1975 aSig = extractFloat64Frac( a );
1980 aSig <<= 10;
1985 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
1993 if ( bSig < aSig ) goto aBigger;
1994 if ( aSig < bSig ) goto bBigger;
2005 aSig |= LIT64( 0x4000000000000000 );
2007 shift64RightJamming( aSig, - expDiff, &aSig );
2010 zSig = bSig - aSig;
2016 if ( aSig ) return propagateFloat64NaN( a, b );
2026 aSig |= LIT64( 0x4000000000000000 );
2028 zSig = aSig - bSig;
2091 bits64 aSig, bSig, zSig0, zSig1;
2093 aSig = extractFloat64Frac( a );
2101 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2112 if ( ( aExp | aSig ) == 0 ) {
2119 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2120 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2127 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2129 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2150 bits64 aSig, bSig, zSig;
2154 aSig = extractFloat64Frac( a );
2162 if ( aSig ) return propagateFloat64NaN( a, b );
2176 if ( ( aExp | aSig ) == 0 ) {
2186 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2187 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2190 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2192 if ( bSig <= ( aSig + aSig ) ) {
2193 aSig >>= 1;
2196 zSig = estimateDiv128To64( aSig, 0, bSig );
2199 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2221 bits64 aSig, bSig;
2225 aSig = extractFloat64Frac( a );
2232 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2250 if ( aSig == 0 ) return a;
2251 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2254 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
2258 aSig >>= 1;
2260 q = ( bSig <= aSig );
2261 if ( q ) aSig -= bSig;
2264 q = estimateDiv128To64( aSig, 0, bSig );
2266 aSig = - ( ( bSig>>2 ) * q );
2271 q = estimateDiv128To64( aSig, 0, bSig );
2275 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2278 aSig >>= 2;
2282 alternateASig = aSig;
2284 aSig -= bSig;
2285 } while ( 0 <= (sbits64) aSig );
2286 sigMean = aSig + alternateASig;
2288 aSig = alternateASig;
2290 zSign = ( (sbits64) aSig < 0 );
2291 if ( zSign ) aSig = - aSig;
2292 return normalizeRoundAndPackFloat64( roundData, aSign ^ zSign, bExp, aSig );
2307 bits64 aSig, zSig;
2311 aSig = extractFloat64Frac( a );
2315 if ( aSig ) return propagateFloat64NaN( a, a );
2321 if ( ( aExp | aSig ) == 0 ) return a;
2326 if ( aSig == 0 ) return 0;
2327 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2330 aSig |= LIT64( 0x0010000000000000 );
2331 zSig = estimateSqrt32( aExp, aSig>>21 );
2333 aSig <<= 9 - ( aExp & 1 );
2334 zSig = estimateDiv128To64( aSig, 0, zSig ) + zSig + 2;
2340 aSig <<= 2;
2342 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2517 bits64 aSig;
2519 aSig = extractFloatx80Frac( a );
2522 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
2525 shift64RightJamming( aSig, shiftCount, &aSig );
2526 return roundAndPackInt32( roundData, aSign, aSig );
2545 bits64 aSig, savedASig;
2548 aSig = extractFloatx80Frac( a );
2553 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
2557 if ( aExp || aSig ) float_raise( float_flag_inexact );
2560 savedASig = aSig;
2561 aSig >>= shiftCount;
2562 z = aSig;
2569 if ( ( aSig<<shiftCount ) != savedASig ) {
2588 bits64 aSig;
2590 aSig = extractFloatx80Frac( a );
2594 if ( (bits64) ( aSig<<1 ) ) {
2599 shift64RightJamming( aSig, 33, &aSig );
2600 if ( aExp || aSig ) aExp -= 0x3F81;
2601 return roundAndPackFloat32( roundData, aSign, aExp, aSig );
2617 bits64 aSig, zSig;
2619 aSig = extractFloatx80Frac( a );
2623 if ( (bits64) ( aSig<<1 ) ) {
2628 shift64RightJamming( aSig, 1, &zSig );
2629 if ( aExp || aSig ) aExp -= 0x3C01;
2720 bits64 aSig, bSig, zSig0, zSig1;
2723 aSig = extractFloatx80Frac( a );
2730 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
2743 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2748 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2754 zSig0 = aSig + bSig;
2763 zSig0 = aSig + bSig;
2789 bits64 aSig, bSig, zSig0, zSig1;
2793 aSig = extractFloatx80Frac( a );
2801 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2815 if ( bSig < aSig ) goto aBigger;
2816 if ( aSig < bSig ) goto bBigger;
2824 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2826 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
2832 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
2838 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
2902 bits64 aSig, bSig, zSig0, zSig1;
2905 aSig = extractFloatx80Frac( a );
2913 if ( (bits64) ( aSig<<1 )
2922 if ( ( aExp | aSig ) == 0 ) {
2933 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2934 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2941 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2963 bits64 aSig, bSig, zSig0, zSig1;
2967 aSig = extractFloatx80Frac( a );
2975 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
2988 if ( ( aExp | aSig ) == 0 ) {
3002 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3003 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3007 if ( bSig <= aSig ) {
3008 shift128Right( aSig, 0, 1, &aSig, &rem1 );
3011 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3013 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );