Lines Matching refs:aSig
149 by the denormalized significand `aSig'. The normalized exponent and
155 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
159 shiftCount = countLeadingZeros32( aSig ) - 8;
160 *zSigPtr = aSig<<shiftCount;
330 by the denormalized significand `aSig'. The normalized exponent and
336 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
340 shiftCount = countLeadingZeros64( aSig ) - 11;
341 *zSigPtr = aSig<<shiftCount;
506 represented by the denormalized significand `aSig'. The normalized exponent
512 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
516 shiftCount = countLeadingZeros64( aSig );
517 *zSigPtr = aSig<<shiftCount;
839 bits32 aSig;
842 aSig = extractFloat32Frac( a );
845 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
846 if ( aExp ) aSig |= 0x00800000;
848 zSig = aSig;
870 bits32 aSig;
873 aSig = extractFloat32Frac( a );
880 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
884 if ( aExp | aSig ) float_raise( float_flag_inexact );
887 aSig = ( aSig | 0x00800000 )<<8;
888 z = aSig>>( - shiftCount );
889 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
908 bits32 aSig;
910 aSig = extractFloat32Frac( a );
914 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
918 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
919 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
922 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
940 bits32 aSig;
942 aSig = extractFloat32Frac( a );
946 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
950 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
951 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
953 aSig |= 0x00800000;
954 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1032 bits32 aSig, bSig, zSig;
1035 aSig = extractFloat32Frac( a );
1040 aSig <<= 6;
1044 if ( aSig ) return propagateFloat32NaN( a, b );
1065 aSig |= 0x20000000;
1067 shift32RightJamming( aSig, - expDiff, &aSig );
1072 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1075 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1076 zSig = 0x40000000 + aSig + bSig;
1080 aSig |= 0x20000000;
1081 zSig = ( aSig + bSig )<<1;
1084 zSig = aSig + bSig;
1104 bits32 aSig, bSig, zSig;
1107 aSig = extractFloat32Frac( a );
1112 aSig <<= 7;
1117 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1125 if ( bSig < aSig ) goto aBigger;
1126 if ( aSig < bSig ) goto bBigger;
1137 aSig |= 0x40000000;
1139 shift32RightJamming( aSig, - expDiff, &aSig );
1142 zSig = bSig - aSig;
1148 if ( aSig ) return propagateFloat32NaN( a, b );
1158 aSig |= 0x40000000;
1160 zSig = aSig - bSig;
1223 bits32 aSig, bSig;
1227 aSig = extractFloat32Frac( a );
1235 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1246 if ( ( aExp | aSig ) == 0 ) {
1253 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1254 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1261 aSig = ( aSig | 0x00800000 )<<7;
1263 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1284 bits32 aSig, bSig, zSig;
1286 aSig = extractFloat32Frac( a );
1294 if ( aSig ) return propagateFloat32NaN( a, b );
1308 if ( ( aExp | aSig ) == 0 ) {
1318 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1319 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1322 aSig = ( aSig | 0x00800000 )<<7;
1324 if ( bSig <= ( aSig + aSig ) ) {
1325 aSig >>= 1;
1329 bits64 tmp = ( (bits64) aSig )<<32;
1334 zSig |= ( ( (bits64) bSig ) * zSig != ( (bits64) aSig )<<32 );
1351 bits32 aSig, bSig;
1357 aSig = extractFloat32Frac( a );
1364 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1382 if ( aSig == 0 ) return a;
1383 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1386 aSig |= 0x00800000;
1389 aSig <<= 8;
1393 aSig >>= 1;
1395 q = ( bSig <= aSig );
1396 if ( q ) aSig -= bSig;
1398 bits64 tmp = ( (bits64) aSig )<<32;
1403 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
1406 aSig >>= 2;
1411 if ( bSig <= aSig ) aSig -= bSig;
1412 aSig64 = ( (bits64) aSig )<<40;
1426 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
1429 alternateASig = aSig;
1431 aSig -= bSig;
1432 } while ( 0 <= (sbits32) aSig );
1433 sigMean = aSig + alternateASig;
1435 aSig = alternateASig;
1437 zSign = ( (sbits32) aSig < 0 );
1438 if ( zSign ) aSig = - aSig;
1439 return normalizeRoundAndPackFloat32( roundData, aSign ^ zSign, bExp, aSig );
1454 bits32 aSig, zSig;
1457 aSig = extractFloat32Frac( a );
1461 if ( aSig ) return propagateFloat32NaN( a, 0 );
1467 if ( ( aExp | aSig ) == 0 ) return a;
1472 if ( aSig == 0 ) return 0;
1473 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1476 aSig = ( aSig | 0x00800000 )<<8;
1477 zSig = estimateSqrt32( aExp, aSig ) + 2;
1483 aSig >>= aExp & 1;
1485 rem = ( ( (bits64) aSig )<<32 ) - term;
1656 bits64 aSig;
1658 aSig = extractFloat64Frac( a );
1661 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1662 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
1664 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
1665 return roundAndPackInt32( roundData, aSign, aSig );
1684 bits64 aSig, savedASig;
1687 aSig = extractFloat64Frac( a );
1692 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1696 if ( aExp || aSig ) float_raise( float_flag_inexact );
1699 aSig |= LIT64( 0x0010000000000000 );
1700 savedASig = aSig;
1701 aSig >>= shiftCount;
1702 z = aSig;
1709 if ( ( aSig<<shiftCount ) != savedASig ) {
1731 bits64 aSig;
1733 aSig = extractFloat64Frac( a );
1736 //if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1737 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
1739 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
1740 return roundAndPackInt32( roundData, aSign, aSig );
1757 bits64 aSig, savedASig;
1760 aSig = extractFloat64Frac( a );
1765 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
1769 if ( aExp || aSig ) float_raise( float_flag_inexact );
1772 aSig |= LIT64( 0x0010000000000000 );
1773 savedASig = aSig;
1774 aSig >>= shiftCount;
1775 z = aSig;
1782 if ( ( aSig<<shiftCount ) != savedASig ) {
1800 bits64 aSig;
1803 aSig = extractFloat64Frac( a );
1807 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
1810 shift64RightJamming( aSig, 22, &aSig );
1811 zSig = aSig;
1834 bits64 aSig;
1836 aSig = extractFloat64Frac( a );
1840 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
1844 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1845 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
1849 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
1928 bits64 aSig, bSig, zSig;
1931 aSig = extractFloat64Frac( a );
1936 aSig <<= 9;
1940 if ( aSig ) return propagateFloat64NaN( a, b );
1961 aSig |= LIT64( 0x2000000000000000 );
1963 shift64RightJamming( aSig, - expDiff, &aSig );
1968 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
1971 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
1972 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
1976 aSig |= LIT64( 0x2000000000000000 );
1977 zSig = ( aSig + bSig )<<1;
1980 zSig = aSig + bSig;
2000 bits64 aSig, bSig, zSig;
2003 aSig = extractFloat64Frac( a );
2008 aSig <<= 10;
2013 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2021 if ( bSig < aSig ) goto aBigger;
2022 if ( aSig < bSig ) goto bBigger;
2033 aSig |= LIT64( 0x4000000000000000 );
2035 shift64RightJamming( aSig, - expDiff, &aSig );
2038 zSig = bSig - aSig;
2044 if ( aSig ) return propagateFloat64NaN( a, b );
2054 aSig |= LIT64( 0x4000000000000000 );
2056 zSig = aSig - bSig;
2119 bits64 aSig, bSig, zSig0, zSig1;
2121 aSig = extractFloat64Frac( a );
2129 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2140 if ( ( aExp | aSig ) == 0 ) {
2147 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2148 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2155 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2157 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2178 bits64 aSig, bSig, zSig;
2182 aSig = extractFloat64Frac( a );
2190 if ( aSig ) return propagateFloat64NaN( a, b );
2204 if ( ( aExp | aSig ) == 0 ) {
2214 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2215 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2218 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2220 if ( bSig <= ( aSig + aSig ) ) {
2221 aSig >>= 1;
2224 zSig = estimateDiv128To64( aSig, 0, bSig );
2227 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2249 bits64 aSig, bSig;
2253 aSig = extractFloat64Frac( a );
2260 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2278 if ( aSig == 0 ) return a;
2279 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2282 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
2286 aSig >>= 1;
2288 q = ( bSig <= aSig );
2289 if ( q ) aSig -= bSig;
2292 q = estimateDiv128To64( aSig, 0, bSig );
2294 aSig = - ( ( bSig>>2 ) * q );
2299 q = estimateDiv128To64( aSig, 0, bSig );
2303 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2306 aSig >>= 2;
2310 alternateASig = aSig;
2312 aSig -= bSig;
2313 } while ( 0 <= (sbits64) aSig );
2314 sigMean = aSig + alternateASig;
2316 aSig = alternateASig;
2318 zSign = ( (sbits64) aSig < 0 );
2319 if ( zSign ) aSig = - aSig;
2320 return normalizeRoundAndPackFloat64( roundData, aSign ^ zSign, bExp, aSig );
2335 bits64 aSig, zSig;
2339 aSig = extractFloat64Frac( a );
2343 if ( aSig ) return propagateFloat64NaN( a, a );
2349 if ( ( aExp | aSig ) == 0 ) return a;
2354 if ( aSig == 0 ) return 0;
2355 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2358 aSig |= LIT64( 0x0010000000000000 );
2359 zSig = estimateSqrt32( aExp, aSig>>21 );
2361 aSig <<= 9 - ( aExp & 1 );
2362 zSig = estimateDiv128To64( aSig, 0, zSig ) + zSig + 2;
2368 aSig <<= 2;
2370 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2545 bits64 aSig;
2547 aSig = extractFloatx80Frac( a );
2550 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
2553 shift64RightJamming( aSig, shiftCount, &aSig );
2554 return roundAndPackInt32( roundData, aSign, aSig );
2573 bits64 aSig, savedASig;
2576 aSig = extractFloatx80Frac( a );
2581 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
2585 if ( aExp || aSig ) float_raise( float_flag_inexact );
2588 savedASig = aSig;
2589 aSig >>= shiftCount;
2590 z = aSig;
2597 if ( ( aSig<<shiftCount ) != savedASig ) {
2616 bits64 aSig;
2618 aSig = extractFloatx80Frac( a );
2622 if ( (bits64) ( aSig<<1 ) ) {
2627 shift64RightJamming( aSig, 33, &aSig );
2628 if ( aExp || aSig ) aExp -= 0x3F81;
2629 return roundAndPackFloat32( roundData, aSign, aExp, aSig );
2645 bits64 aSig, zSig;
2647 aSig = extractFloatx80Frac( a );
2651 if ( (bits64) ( aSig<<1 ) ) {
2656 shift64RightJamming( aSig, 1, &zSig );
2657 if ( aExp || aSig ) aExp -= 0x3C01;
2748 bits64 aSig, bSig, zSig0, zSig1;
2751 aSig = extractFloatx80Frac( a );
2758 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
2771 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2776 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2782 zSig0 = aSig + bSig;
2791 zSig0 = aSig + bSig;
2817 bits64 aSig, bSig, zSig0, zSig1;
2821 aSig = extractFloatx80Frac( a );
2829 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2843 if ( bSig < aSig ) goto aBigger;
2844 if ( aSig < bSig ) goto bBigger;
2852 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2854 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
2860 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
2866 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
2930 bits64 aSig, bSig, zSig0, zSig1;
2933 aSig = extractFloatx80Frac( a );
2941 if ( (bits64) ( aSig<<1 )
2950 if ( ( aExp | aSig ) == 0 ) {
2961 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2962 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2969 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2991 bits64 aSig, bSig, zSig0, zSig1;
2995 aSig = extractFloatx80Frac( a );
3003 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3016 if ( ( aExp | aSig ) == 0 ) {
3030 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3031 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3035 if ( bSig <= aSig ) {
3036 shift128Right( aSig, 0, 1, &aSig, &rem1 );
3039 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3041 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );