softfloat/bits64/softfloat.c

1709     bits32 aSig, bSig, zSig;
1714     bSig = extractFloat32Frac( b );
1718     bSig <<= 6;
1728             bSig |= 0x20000000;
1730         shift32RightJamming( bSig, expDiff, &bSig );
1735             if ( bSig ) return propagateFloat32NaN( a, b );
1749             if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1752         if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1753         zSig = 0x40000000 + aSig + bSig;
1758     zSig = ( aSig + bSig )<<1;
1761         zSig = aSig + bSig;
1781     bits32 aSig, bSig, zSig;
1786     bSig = extractFloat32Frac( b );
1790     bSig <<= 7;
1794         if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1802     if ( bSig < aSig ) goto aBigger;
1803     if ( aSig < bSig ) goto bBigger;
1807         if ( bSig ) return propagateFloat32NaN( a, b );
1817     bSig |= 0x40000000;
1819     zSig = bSig - aSig;
1832         bSig |= 0x40000000;
1834     shift32RightJamming( bSig, expDiff, &bSig );
1837     zSig = aSig - bSig;
1900     bits32 aSig, bSig;
1907     bSig = extractFloat32Frac( b );
1912         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1915         if ( ( bExp | bSig ) == 0 ) {
1922         if ( bSig ) return propagateFloat32NaN( a, b );
1934         if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1935         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
1939     bSig = ( bSig | 0x00800000 )<<8;
1940     shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1961     bits32 aSig, bSig, zSig;
1966     bSig = extractFloat32Frac( b );
1973             if ( bSig ) return propagateFloat32NaN( a, b );
1980         if ( bSig ) return propagateFloat32NaN( a, b );
1984         if ( bSig == 0 ) {
1992         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
2000     bSig = ( bSig | 0x00800000 )<<8;
2001     if ( bSig <= ( aSig + aSig ) ) {
2005     zSig = ( ( (bits64) aSig )<<32 ) / bSig;
2007         zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
2025     bits32 aSig, bSig;
2034     bSig = extractFloat32Frac( b );
2038         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
2045         if ( bSig ) return propagateFloat32NaN( a, b );
2049         if ( bSig == 0 ) {
2053         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
2061     bSig |= 0x00800000;
2064         bSig <<= 8;
2069         q = ( bSig <= aSig );
2070         if ( q ) aSig -= bSig;
2072             q = ( ( (bits64) aSig )<<32 ) / bSig;
2074             bSig >>= 2;
2075             aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2079             bSig >>= 2;
2083         if ( bSig <= aSig ) aSig -= bSig;
2085         bSig64 = ( (bits64) bSig )<<40;
2090             aSig64 = - ( ( bSig * q64 )<<38 );
2097         bSig <<= 6;
2098         aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
2103         aSig -= bSig;
2675     bits64 aSig, bSig, zSig;
2680     bSig = extractFloat64Frac( b );
2684     bSig <<= 9;
2694             bSig |= LIT64( 0x2000000000000000 );
2696         shift64RightJamming( bSig, expDiff, &bSig );
2701             if ( bSig ) return propagateFloat64NaN( a, b );
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;
2724     zSig = ( aSig + bSig )<<1;
2727         zSig = aSig + bSig;
2747     bits64 aSig, bSig, zSig;
2752     bSig = extractFloat64Frac( b );
2756     bSig <<= 10;
2760         if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2768     if ( bSig < aSig ) goto aBigger;
2769     if ( aSig < bSig ) goto bBigger;
2773         if ( bSig ) return propagateFloat64NaN( a, b );
2783     bSig |= LIT64( 0x4000000000000000 );
2785     zSig = bSig - aSig;
2798         bSig |= LIT64( 0x4000000000000000 );
2800     shift64RightJamming( bSig, expDiff, &bSig );
2803     zSig = aSig - bSig;
2866     bits64 aSig, bSig, zSig0, zSig1;
2871     bSig = extractFloat64Frac( b );
2876         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2879         if ( ( bExp | bSig ) == 0 ) {
2886         if ( bSig ) return propagateFloat64NaN( a, b );
2898         if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2899         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2903     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
2904     mul64To128( aSig, bSig, &zSig0, &zSig1 );
2925     bits64 aSig, bSig, zSig;
2932     bSig = extractFloat64Frac( b );
2939             if ( bSig ) return propagateFloat64NaN( a, b );
2946         if ( bSig ) return propagateFloat64NaN( a, b );
2950         if ( bSig == 0 ) {
2958         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2966     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
2967     if ( bSig <= ( aSig + aSig ) ) {
2971     zSig = estimateDiv128To64( aSig, 0, bSig );
2973         mul64To128( bSig, zSig, &term0, &term1 );
2977             add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
2997     bits64 aSig, bSig;
3004     bSig = extractFloat64Frac( b );
3008         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3015         if ( bSig ) return propagateFloat64NaN( a, b );
3019         if ( bSig == 0 ) {
3023         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
3031     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
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 );
3050         bSig >>= 2;
3051         aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
3055         bSig >>= 2;
3060         aSig -= bSig;
3619     bits64 aSig, bSig, zSig0, zSig1;
3624     bSig = extractFloatx80Frac( b );
3633         shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
3638             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3647             if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3653         zSig0 = aSig + bSig;
3661     zSig0 = aSig + bSig;
3686     bits64 aSig, bSig, zSig0, zSig1;
3692     bSig = extractFloatx80Frac( b );
3698         if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3711     if ( bSig < aSig ) goto aBigger;
3712     if ( aSig < bSig ) goto bBigger;
3716         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3722     sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3732     shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
3734     sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3798     bits64 aSig, bSig, zSig0, zSig1;
3804     bSig = extractFloatx80Frac( b );
3810              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
3813         if ( ( bExp | bSig ) == 0 ) goto invalid;
3817         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3832         if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
3833         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3836     mul64To128( aSig, bSig, &zSig0, &zSig1 );
3858     bits64 aSig, bSig, zSig0, zSig1;
3865     bSig = extractFloatx80Frac( b );
3872             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3878         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3882         if ( bSig == 0 ) {
3893         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3901     if ( bSig <= aSig ) {
3905     zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3906     mul64To128( bSig, zSig0, &term0, &term1 );
3910         add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
3912     zSig1 = estimateDiv128To64( rem1, 0, bSig );
3914         mul64To128( bSig, zSig1, &term1, &term2 );
3918             add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
3939     bits64 aSig0, aSig1, bSig;
3946     bSig = extractFloatx80Frac( b );
3951              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
3957         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3961         if ( bSig == 0 ) {
3968         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3974     bSig |= LIT64( 0x8000000000000000 );
3983     q = ( bSig <= aSig0 );
3984     if ( q ) aSig0 -= bSig;
3987         q = estimateDiv128To64( aSig0, aSig1, bSig );
3989         mul64To128( bSig, q, &term0, &term1 );
3996         q = estimateDiv128To64( aSig0, aSig1, bSig );
3999         mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );
4001         shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
4009         term0 = bSig;