Lines Matching defs:aSig
246 by the denormalized significand `aSig'. The normalized exponent and
252 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
256 shiftCount = countLeadingZeros32( aSig ) - 8;
257 *zSigPtr = aSig<<shiftCount;
415 by the denormalized significand `aSig'. The normalized exponent and
421 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
425 shiftCount = countLeadingZeros64( aSig ) - 11;
426 *zSigPtr = aSig<<shiftCount;
592 represented by the denormalized significand `aSig'. The normalized exponent
598 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
602 shiftCount = countLeadingZeros64( aSig );
603 *zSigPtr = aSig<<shiftCount;
1389 bits32 aSig;
1392 aSig = extractFloat32Frac( a );
1395 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1396 if ( aExp ) aSig |= 0x00800000;
1398 aSig64 = aSig;
1421 bits32 aSig;
1424 aSig = extractFloat32Frac( a );
1431 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1436 if ( aExp | aSig ) float_exception_flags |= float_flag_inexact;
1439 aSig = ( aSig | 0x00800000 )<<8;
1440 z = aSig>>( - shiftCount );
1441 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
1465 bits32 aSig;
1468 aSig = extractFloat32Frac( a );
1474 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1479 if ( aExp ) aSig |= 0x00800000;
1480 aSig64 = aSig;
1502 bits32 aSig;
1506 aSig = extractFloat32Frac( a );
1513 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1520 if ( aExp | aSig ) float_exception_flags |= float_flag_inexact;
1523 aSig64 = aSig | 0x00800000;
1547 bits32 aSig;
1549 aSig = extractFloat32Frac( a );
1553 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
1557 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1558 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1561 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1579 bits32 aSig;
1581 aSig = extractFloat32Frac( a );
1585 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
1589 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1590 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1592 aSig |= 0x00800000;
1593 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1613 bits32 aSig;
1615 aSig = extractFloat32Frac( a );
1619 if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a ) );
1623 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1624 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1627 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1709 bits32 aSig, bSig, zSig;
1712 aSig = extractFloat32Frac( a );
1717 aSig <<= 6;
1721 if ( aSig ) return propagateFloat32NaN( a, b );
1742 aSig |= 0x20000000;
1744 shift32RightJamming( aSig, - expDiff, &aSig );
1749 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1752 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1753 zSig = 0x40000000 + aSig + bSig;
1757 aSig |= 0x20000000;
1758 zSig = ( aSig + bSig )<<1;
1761 zSig = aSig + bSig;
1781 bits32 aSig, bSig, zSig;
1784 aSig = extractFloat32Frac( a );
1789 aSig <<= 7;
1794 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1802 if ( bSig < aSig ) goto aBigger;
1803 if ( aSig < bSig ) goto bBigger;
1814 aSig |= 0x40000000;
1816 shift32RightJamming( aSig, - expDiff, &aSig );
1819 zSig = bSig - aSig;
1825 if ( aSig ) return propagateFloat32NaN( a, b );
1835 aSig |= 0x40000000;
1837 zSig = aSig - bSig;
1900 bits32 aSig, bSig;
1904 aSig = extractFloat32Frac( a );
1912 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1923 if ( ( aExp | aSig ) == 0 ) {
1930 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1931 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1938 aSig = ( aSig | 0x00800000 )<<7;
1940 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1961 bits32 aSig, bSig, zSig;
1963 aSig = extractFloat32Frac( a );
1971 if ( aSig ) return propagateFloat32NaN( a, b );
1985 if ( ( aExp | aSig ) == 0 ) {
1995 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1996 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1999 aSig = ( aSig | 0x00800000 )<<7;
2001 if ( bSig <= ( aSig + aSig ) ) {
2002 aSig >>= 1;
2005 zSig = ( ( (bits64) aSig )<<32 ) / bSig;
2007 zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
2025 bits32 aSig, bSig;
2031 aSig = extractFloat32Frac( a );
2038 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
2056 if ( aSig == 0 ) return a;
2057 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2060 aSig |= 0x00800000;
2063 aSig <<= 8;
2067 aSig >>= 1;
2069 q = ( bSig <= aSig );
2070 if ( q ) aSig -= bSig;
2072 q = ( ( (bits64) aSig )<<32 ) / bSig;
2075 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2078 aSig >>= 2;
2083 if ( bSig <= aSig ) aSig -= bSig;
2084 aSig64 = ( (bits64) aSig )<<40;
2098 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
2101 alternateASig = aSig;
2103 aSig -= bSig;
2104 } while ( 0 <= (sbits32) aSig );
2105 sigMean = aSig + alternateASig;
2107 aSig = alternateASig;
2109 zSign = ( (sbits32) aSig < 0 );
2110 if ( zSign ) aSig = - aSig;
2111 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2128 bits32 aSig, zSig;
2131 aSig = extractFloat32Frac( a );
2135 if ( aSig ) return propagateFloat32NaN( a, 0 );
2141 if ( ( aExp | aSig ) == 0 ) return a;
2146 if ( aSig == 0 ) return 0;
2147 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2150 aSig = ( aSig | 0x00800000 )<<8;
2151 zSig = estimateSqrt32( aExp, aSig ) + 2;
2157 aSig >>= aExp & 1;
2159 rem = ( ( (bits64) aSig )<<32 ) - term;
2337 bits64 aSig;
2339 aSig = extractFloat64Frac( a );
2342 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2343 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2345 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
2346 return roundAndPackInt32( aSign, aSig );
2366 bits64 aSig, savedASig;
2369 aSig = extractFloat64Frac( a );
2373 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2377 if ( aExp || aSig ) float_exception_flags |= float_flag_inexact;
2380 aSig |= LIT64( 0x0010000000000000 );
2382 savedASig = aSig;
2383 aSig >>= shiftCount;
2384 z = aSig;
2391 if ( ( aSig<<shiftCount ) != savedASig ) {
2414 bits64 aSig, aSigExtra;
2416 aSig = extractFloat64Frac( a );
2419 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2426 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2433 aSig <<= - shiftCount;
2436 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
2438 return roundAndPackInt64( aSign, aSig, aSigExtra );
2457 bits64 aSig;
2460 aSig = extractFloat64Frac( a );
2463 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2471 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2478 z = aSig<<shiftCount;
2482 if ( aExp | aSig ) float_exception_flags |= float_flag_inexact;
2485 z = aSig>>( - shiftCount );
2486 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
2508 bits64 aSig;
2511 aSig = extractFloat64Frac( a );
2515 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
2518 shift64RightJamming( aSig, 22, &aSig );
2519 zSig = aSig;
2542 bits64 aSig;
2544 aSig = extractFloat64Frac( a );
2548 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
2552 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2553 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2557 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2577 bits64 aSig, zSig0, zSig1;
2579 aSig = extractFloat64Frac( a );
2583 if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a ) );
2587 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2588 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2591 shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
2675 bits64 aSig, bSig, zSig;
2678 aSig = extractFloat64Frac( a );
2683 aSig <<= 9;
2687 if ( aSig ) return propagateFloat64NaN( a, b );
2708 aSig |= LIT64( 0x2000000000000000 );
2710 shift64RightJamming( aSig, - expDiff, &aSig );
2715 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2718 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2719 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2723 aSig |= LIT64( 0x2000000000000000 );
2724 zSig = ( aSig + bSig )<<1;
2727 zSig = aSig + bSig;
2747 bits64 aSig, bSig, zSig;
2750 aSig = extractFloat64Frac( a );
2755 aSig <<= 10;
2760 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2768 if ( bSig < aSig ) goto aBigger;
2769 if ( aSig < bSig ) goto bBigger;
2780 aSig |= LIT64( 0x4000000000000000 );
2782 shift64RightJamming( aSig, - expDiff, &aSig );
2785 zSig = bSig - aSig;
2791 if ( aSig ) return propagateFloat64NaN( a, b );
2801 aSig |= LIT64( 0x4000000000000000 );
2803 zSig = aSig - bSig;
2866 bits64 aSig, bSig, zSig0, zSig1;
2868 aSig = extractFloat64Frac( a );
2876 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2887 if ( ( aExp | aSig ) == 0 ) {
2894 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2895 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2902 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2904 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2925 bits64 aSig, bSig, zSig;
2929 aSig = extractFloat64Frac( a );
2937 if ( aSig ) return propagateFloat64NaN( a, b );
2951 if ( ( aExp | aSig ) == 0 ) {
2961 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2962 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2965 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2967 if ( bSig <= ( aSig + aSig ) ) {
2968 aSig >>= 1;
2971 zSig = estimateDiv128To64( aSig, 0, bSig );
2974 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
2997 bits64 aSig, bSig;
3001 aSig = extractFloat64Frac( a );
3008 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3026 if ( aSig == 0 ) return a;
3027 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3030 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
3034 aSig >>= 1;
3036 q = ( bSig <= aSig );
3037 if ( q ) aSig -= bSig;
3040 q = estimateDiv128To64( aSig, 0, bSig );
3042 aSig = - ( ( bSig>>2 ) * q );
3047 q = estimateDiv128To64( aSig, 0, bSig );
3051 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
3054 aSig >>= 2;
3058 alternateASig = aSig;
3060 aSig -= bSig;
3061 } while ( 0 <= (sbits64) aSig );
3062 sigMean = aSig + alternateASig;
3064 aSig = alternateASig;
3066 zSign = ( (sbits64) aSig < 0 );
3067 if ( zSign ) aSig = - aSig;
3068 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3083 bits64 aSig, zSig, doubleZSig;
3086 aSig = extractFloat64Frac( a );
3090 if ( aSig ) return propagateFloat64NaN( a, a );
3096 if ( ( aExp | aSig ) == 0 ) return a;
3101 if ( aSig == 0 ) return 0;
3102 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3105 aSig |= LIT64( 0x0010000000000000 );
3106 zSig = estimateSqrt32( aExp, aSig>>21 );
3107 aSig <<= 9 - ( aExp & 1 );
3108 zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
3112 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3299 bits64 aSig;
3301 aSig = extractFloatx80Frac( a );
3304 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3307 shift64RightJamming( aSig, shiftCount, &aSig );
3308 return roundAndPackInt32( aSign, aSig );
3327 bits64 aSig, savedASig;
3330 aSig = extractFloatx80Frac( a );
3334 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3338 if ( aExp || aSig ) float_exception_flags |= float_flag_inexact;
3342 savedASig = aSig;
3343 aSig >>= shiftCount;
3344 z = aSig;
3351 if ( ( aSig<<shiftCount ) != savedASig ) {
3373 bits64 aSig, aSigExtra;
3375 aSig = extractFloatx80Frac( a );
3384 && ( aSig != LIT64( 0x8000000000000000 ) ) )
3393 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
3395 return roundAndPackInt64( aSign, aSig, aSigExtra );
3414 bits64 aSig;
3417 aSig = extractFloatx80Frac( a );
3422 aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
3423 if ( ( a.high != 0xC03E ) || aSig ) {
3425 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3432 if ( aExp | aSig ) float_exception_flags |= float_flag_inexact;
3435 z = aSig>>( - shiftCount );
3436 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
3456 bits64 aSig;
3458 aSig = extractFloatx80Frac( a );
3462 if ( (bits64) ( aSig<<1 ) ) {
3467 shift64RightJamming( aSig, 33, &aSig );
3468 if ( aExp || aSig ) aExp -= 0x3F81;
3469 return roundAndPackFloat32( aSign, aExp, aSig );
3485 bits64 aSig, zSig;
3487 aSig = extractFloatx80Frac( a );
3491 if ( (bits64) ( aSig<<1 ) ) {
3496 shift64RightJamming( aSig, 1, &zSig );
3497 if ( aExp || aSig ) aExp -= 0x3C01;
3516 bits64 aSig, zSig0, zSig1;
3518 aSig = extractFloatx80Frac( a );
3521 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
3524 shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
3619 bits64 aSig, bSig, zSig0, zSig1;
3622 aSig = extractFloatx80Frac( a );
3629 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3642 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3647 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3653 zSig0 = aSig + bSig;
3661 zSig0 = aSig + bSig;
3686 bits64 aSig, bSig, zSig0, zSig1;
3690 aSig = extractFloatx80Frac( a );
3698 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3711 if ( bSig < aSig ) goto aBigger;
3712 if ( aSig < bSig ) goto bBigger;
3720 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3722 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3728 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3734 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3798 bits64 aSig, bSig, zSig0, zSig1;
3801 aSig = extractFloatx80Frac( a );
3809 if ( (bits64) ( aSig<<1 )
3818 if ( ( aExp | aSig ) == 0 ) {
3828 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3829 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3836 mul64To128( aSig, bSig, &zSig0, &zSig1 );
3858 bits64 aSig, bSig, zSig0, zSig1;
3862 aSig = extractFloatx80Frac( a );
3870 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3883 if ( ( aExp | aSig ) == 0 ) {
3896 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3897 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3901 if ( bSig <= aSig ) {
3902 shift128Right( aSig, 0, 1, &aSig, &rem1 );
3905 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3907 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
5524 bits64 aSig, savedASig;
5527 aSig = extractFloat64Frac( a );
5541 if ( aExp || aSig ) float_exception_flags |= float_flag_inexact;
5544 aSig |= LIT64( 0x0010000000000000 );
5546 savedASig = aSig;
5547 aSig >>= shiftCount;
5548 z = aSig;
5549 if ( ( aSig<<shiftCount ) != savedASig ) {
5570 bits32 aSig;
5573 aSig = extractFloat32Frac( a );
5587 if ( aExp | aSig ) float_exception_flags |= float_flag_inexact;
5590 aSig = ( aSig | 0x800000 )<<8;
5591 z = aSig>>( - shiftCount );
5592 if ( aSig<<( shiftCount & 31 ) ) {