Lines Matching defs:aSig
257 by the denormalized significand `aSig'. The normalized exponent and
263 normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
267 shiftCount = countLeadingZeros32( aSig ) - 8;
268 *zSigPtr = aSig<<shiftCount;
426 by the denormalized significand `aSig'. The normalized exponent and
432 normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
436 shiftCount = countLeadingZeros64( aSig ) - 11;
437 *zSigPtr = aSig<<shiftCount;
603 represented by the denormalized significand `aSig'. The normalized exponent
609 normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
613 shiftCount = countLeadingZeros64( aSig );
614 *zSigPtr = aSig<<shiftCount;
1396 bits32 aSig;
1399 aSig
1402 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1403 if ( aExp ) aSig |= 0x00800000;
1405 aSig64 = aSig;
1428 bits32 aSig;
1431 aSig = extractFloat32Frac( a );
1438 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1443 if ( aExp | aSig ) set_float_exception_inexact_flag();
1446 aSig = ( aSig | 0x00800000 )<<8;
1447 z = aSig>>( - shiftCount );
1448 if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
1472 bits32 aSig;
1475 aSig = extractFloat32Frac( a );
1481 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1486 if ( aExp ) aSig |= 0x00800000;
1487 aSig64 = aSig;
1509 bits32 aSig;
1513 aSig = extractFloat32Frac( a );
1520 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1527 if ( aExp | aSig ) set_float_exception_inexact_flag();
1530 aSig64 = aSig | 0x00800000;
1554 bits32 aSig;
1556 aSig = extractFloat32Frac( a );
1560 if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
1564 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1565 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1568 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1586 bits32 aSig;
1588 aSig = extractFloat32Frac( a );
1592 if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
1596 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1597 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1599 aSig |= 0x00800000;
1600 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1620 bits32 aSig;
1622 aSig = extractFloat32Frac( a );
1626 if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a ) );
1630 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1631 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1634 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1716 bits32 aSig, bSig, zSig;
1719 aSig = extractFloat32Frac( a );
1724 aSig <<= 6;
1728 if ( aSig ) return propagateFloat32NaN( a, b );
1749 aSig |= 0x20000000;
1751 shift32RightJamming( aSig, - expDiff, &aSig );
1756 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1759 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1760 zSig = 0x40000000 + aSig + bSig;
1764 aSig |= 0x20000000;
1765 zSig = ( aSig + bSig )<<1;
1768 zSig = aSig + bSig;
1788 bits32 aSig, bSig, zSig;
1791 aSig = extractFloat32Frac( a );
1796 aSig <<= 7;
1801 if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1809 if ( bSig < aSig ) goto aBigger;
1810 if ( aSig < bSig ) goto bBigger;
1821 aSig |= 0x40000000;
1823 shift32RightJamming( aSig, - expDiff, &aSig );
1826 zSig = bSig - aSig;
1832 if ( aSig ) return propagateFloat32NaN( a, b );
1842 aSig |= 0x40000000;
1844 zSig = aSig - bSig;
1907 bits32 aSig, bSig;
1911 aSig = extractFloat32Frac( a );
1919 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1930 if ( ( aExp | aSig ) == 0 ) {
1937 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1938 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1945 aSig = ( aSig | 0x00800000 )<<7;
1947 shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1968 bits32 aSig, bSig, zSig;
1970 aSig = extractFloat32Frac( a );
1978 if ( aSig ) return propagateFloat32NaN( a, b );
1992 if ( ( aExp | aSig ) == 0 ) {
2002 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
2003 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2006 aSig = ( aSig | 0x00800000 )<<7;
2008 if ( bSig <= ( aSig + aSig ) ) {
2009 aSig >>= 1;
2012 zSig = (bits32)((((bits64) aSig) << 32) / bSig);
2014 zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
2032 bits32 aSig, bSig;
2038 aSig = extractFloat32Frac( a );
2045 if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
2063 if ( aSig == 0 ) return a;
2064 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2067 aSig |= 0x00800000;
2070 aSig <<= 8;
2074 aSig >>= 1;
2076 q = ( bSig <= aSig );
2077 if ( q ) aSig -= bSig;
2079 q = ( ( (bits64) aSig )<<32 ) / bSig;
2082 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2085 aSig >>= 2;
2090 if ( bSig <= aSig ) aSig -= bSig;
2091 aSig64 = ( (bits64) aSig )<<40;
2105 aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
2108 alternateASig = aSig;
2110 aSig -= bSig;
2111 } while ( 0 <= (sbits32) aSig );
2112 sigMean = aSig + alternateASig;
2114 aSig = alternateASig;
2116 zSign = ( (sbits32) aSig < 0 );
2117 if ( zSign ) aSig = - aSig;
2118 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2135 bits32 aSig, zSig;
2138 aSig = extractFloat32Frac( a );
2142 if ( aSig ) return propagateFloat32NaN( a, 0 );
2148 if ( ( aExp | aSig ) == 0 ) return a;
2153 if ( aSig == 0 ) return 0;
2154 normalizeFloat32Subnormal( aSig, &aExp, &aSig );
2157 aSig = ( aSig | 0x00800000 )<<8;
2158 zSig = estimateSqrt32( aExp, aSig ) + 2;
2164 aSig >>= aExp & 1;
2166 rem = ( ( (bits64) aSig )<<32 ) - term;
2344 bits64 aSig;
2346 aSig = extractFloat64Frac( a );
2349 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2350 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2352 if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
2353 return roundAndPackInt32( aSign, aSig );
2373 bits64 aSig, savedASig;
2376 aSig = extractFloat64Frac( a );
2380 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2384 if ( aExp || aSig ) set_float_exception_inexact_flag();
2387 aSig |= LIT64( 0x0010000000000000 );
2389 savedASig = aSig;
2390 aSig >>= shiftCount;
2391 z = (int32)aSig;
2398 if ( ( aSig<<shiftCount ) != savedASig ) {
2421 bits64 aSig, aSigExtra;
2423 aSig = extractFloat64Frac( a );
2426 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2433 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2440 aSig <<= - shiftCount;
2443 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
2445 return roundAndPackInt64( aSign, aSig, aSigExtra );
2464 bits64 aSig;
2467 aSig = extractFloat64Frac( a );
2470 if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
2478 && ( aSig != LIT64( 0x0010000000000000 ) ) )
2485 z = aSig<<shiftCount;
2489 if ( aExp | aSig ) set_float_exception_inexact_flag();
2492 z = aSig>>( - shiftCount );
2493 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
2515 bits64 aSig;
2518 aSig = extractFloat64Frac( a );
2522 if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
2525 shift64RightJamming( aSig, 22, &aSig );
2526 zSig = (bits32)aSig;
2549 bits64 aSig;
2551 aSig = extractFloat64Frac( a );
2555 if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
2559 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2560 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2564 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2584 bits64 aSig, zSig0, zSig1;
2586 aSig = extractFloat64Frac( a );
2590 if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a ) );
2594 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2595 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2598 shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
2682 bits64 aSig, bSig, zSig;
2685 aSig = extractFloat64Frac( a );
2690 aSig <<= 9;
2694 if ( aSig ) return propagateFloat64NaN( a, b );
2715 aSig |= LIT64( 0x2000000000000000 );
2717 shift64RightJamming( aSig, - expDiff, &aSig );
2722 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2725 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2726 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2730 aSig |= LIT64( 0x2000000000000000 );
2731 zSig = ( aSig + bSig )<<1;
2734 zSig = aSig + bSig;
2754 bits64 aSig, bSig, zSig;
2757 aSig = extractFloat64Frac( a );
2762 aSig <<= 10;
2767 if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2775 if ( bSig < aSig ) goto aBigger;
2776 if ( aSig < bSig ) goto bBigger;
2787 aSig |= LIT64( 0x4000000000000000 );
2789 shift64RightJamming( aSig, - expDiff, &aSig );
2792 zSig = bSig - aSig;
2798 if ( aSig ) return propagateFloat64NaN( a, b );
2808 aSig |= LIT64( 0x4000000000000000 );
2810 zSig = aSig - bSig;
2873 bits64 aSig, bSig, zSig0, zSig1;
2875 aSig = extractFloat64Frac( a );
2883 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2894 if ( ( aExp | aSig ) == 0 ) {
2901 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2902 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2909 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2911 mul64To128( aSig, bSig, &zSig0, &zSig1 );
2932 bits64 aSig, bSig, zSig;
2936 aSig = extractFloat64Frac( a );
2944 if ( aSig ) return propagateFloat64NaN( a, b );
2958 if ( ( aExp | aSig ) == 0 ) {
2968 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2969 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
2972 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
2974 if ( bSig <= ( aSig + aSig ) ) {
2975 aSig >>= 1;
2978 zSig = estimateDiv128To64( aSig, 0, bSig );
2981 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3004 bits64 aSig, bSig;
3008 aSig = extractFloat64Frac( a );
3015 if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3033 if ( aSig == 0 ) return a;
3034 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3037 aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
3041 aSig >>= 1;
3043 q = ( bSig <= aSig );
3044 if ( q ) aSig -= bSig;
3047 q = estimateDiv128To64( aSig, 0, bSig );
3049 aSig = - ( ( bSig>>2 ) * q );
3054 q = estimateDiv128To64( aSig, 0, bSig );
3058 aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
3061 aSig >>= 2;
3065 alternateASig = aSig;
3067 aSig -= bSig;
3068 } while ( 0 <= (sbits64) aSig );
3069 sigMean = aSig + alternateASig;
3071 aSig = alternateASig;
3073 zSign = ( (sbits64) aSig < 0 );
3074 if ( zSign ) aSig = - aSig;
3075 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3090 bits64 aSig, zSig, doubleZSig;
3093 aSig = extractFloat64Frac( a );
3097 if ( aSig ) return propagateFloat64NaN( a, a );
3103 if ( ( aExp | aSig ) == 0 ) return a;
3108 if ( aSig == 0 ) return 0;
3109 normalizeFloat64Subnormal( aSig, &aExp, &aSig );
3112 aSig |= LIT64( 0x0010000000000000 );
3113 zSig = estimateSqrt32( aExp, aSig>>21 );
3114 aSig <<= 9 - ( aExp & 1 );
3115 zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
3119 sub128( aSig, 0, term0, term1, &rem0, &rem1 );
3346 bits64 aSig;
3348 aSig = extractFloatx80Frac( a );
3351 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3354 shift64RightJamming( aSig, shiftCount, &aSig );
3355 return roundAndPackInt32( aSign, aSig );
3374 bits64 aSig, savedASig;
3377 aSig = extractFloatx80Frac( a );
3381 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3385 if ( aExp || aSig ) set_float_exception_inexact_flag();
3389 savedASig = aSig;
3390 aSig >>= shiftCount;
3391 z = aSig;
3398 if ( ( aSig<<shiftCount ) != savedASig ) {
3420 bits64 aSig, aSigExtra;
3422 aSig = extractFloatx80Frac( a );
3431 && ( aSig != LIT64( 0x8000000000000000 ) ) )
3440 shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
3442 return roundAndPackInt64( aSign, aSig, aSigExtra );
3461 bits64 aSig;
3464 aSig = extractFloatx80Frac( a );
3469 aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
3470 if ( ( (a.high>>X80SHIFT) != 0xC03E ) || aSig ) {
3472 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3479 if ( aExp | aSig ) set_float_exception_inexact_flag();
3482 z = aSig>>( - shiftCount );
3483 if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
3503 bits64 aSig;
3505 aSig = extractFloatx80Frac( a );
3509 if ( (bits64) ( aSig<<1 ) ) {
3514 shift64RightJamming( aSig, 33, &aSig );
3515 if ( aExp || aSig ) aExp -= 0x3F81;
3516 return roundAndPackFloat32( aSign, aExp, aSig );
3532 bits64 aSig, zSig;
3534 aSig = extractFloatx80Frac( a );
3538 if ( (bits64) ( aSig<<1 ) ) {
3543 shift64RightJamming( aSig, 1, &zSig );
3544 if ( aExp || aSig ) aExp -= 0x3C01;
3563 bits64 aSig, zSig0, zSig1;
3565 aSig = extractFloatx80Frac( a );
3568 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
3571 shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
3667 bits64 aSig, bSig, zSig0, zSig1;
3670 aSig = extractFloatx80Frac( a );
3677 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3690 shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3695 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3701 zSig0 = aSig + bSig;
3709 zSig0 = aSig + bSig;
3734 bits64 aSig, bSig, zSig0, zSig1;
3738 aSig = extractFloatx80Frac( a );
3746 if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3759 if ( bSig < aSig ) goto aBigger;
3760 if ( aSig < bSig ) goto bBigger;
3768 shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
3770 sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3776 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3782 sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3846 bits64 aSig, bSig, zSig0, zSig1;
3849 aSig = extractFloatx80Frac( a );
3857 if ( (bits64) ( aSig<<1 )
3866 if ( ( aExp | aSig ) == 0 ) {
3876 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3877 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3884 mul64To128( aSig, bSig, &zSig0, &zSig1 );
3906 bits64 aSig, bSig, zSig0, zSig1;
3910 aSig = extractFloatx80Frac( a );
3918 if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
3931 if ( ( aExp | aSig ) == 0 ) {
3944 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3945 normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3949 if ( bSig <= aSig ) {
3950 shift128Right( aSig, 0, 1, &aSig, &rem1 );
3953 zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3955 sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
5571 bits64 aSig, savedASig;
5574 aSig = extractFloat64Frac( a );
5588 if ( aExp || aSig ) set_float_exception_inexact_flag();
5591 aSig |= LIT64( 0x0010000000000000 );
5593 savedASig = aSig;
5594 aSig >>= shiftCount;
5595 z = (uint32)aSig;
5596 if ( ( aSig<<shiftCount ) != savedASig ) {
5617 bits32 aSig;
5620 aSig = extractFloat32Frac( a );
5634 if ( aExp | aSig ) set_float_exception_inexact_flag();
5637 aSig = ( aSig | 0x800000 )<<8;
5638 z = aSig>>( - shiftCount );
5639 if ( aSig<<( shiftCount & 31 ) ) {
Indexes created Tue Sep 30 17:09:57 GMT 2025