lib/libkern/softfloat.c

1716     bits32 aSig, bSig, zSig;
1721     bSig = extractFloat32Frac( b );
1725     bSig <<= 6;
1735             bSig |= 0x20000000;
1737         shift32RightJamming( bSig, expDiff, &bSig );
1742             if ( bSig ) return propagateFloat32NaN( a, b );
1756             if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1759         if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1760         zSig = 0x40000000 + aSig + bSig;
1765     zSig = ( aSig + bSig )<<1;
1768         zSig = aSig + bSig;
1788     bits32 aSig, bSig, zSig;
1793     bSig = extractFloat32Frac( b );
1797     bSig <<= 7;
1801         if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1809     if ( bSig < aSig ) goto aBigger;
1810     if ( aSig < bSig ) goto bBigger;
1814         if ( bSig ) return propagateFloat32NaN( a, b );
1824     bSig |= 0x40000000;
1826     zSig = bSig - aSig;
1839         bSig |= 0x40000000;
1841     shift32RightJamming( bSig, expDiff, &bSig );
1844     zSig = aSig - bSig;
1907     bits32 aSig, bSig;
1914     bSig = extractFloat32Frac( b );
1919         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1922         if ( ( bExp | bSig ) == 0 ) {
1929         if ( bSig ) return propagateFloat32NaN( a, b );
1941         if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1942         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
1946     bSig = ( bSig | 0x00800000 )<<8;
1947     shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1968     bits32 aSig, bSig, zSig;
1973     bSig = extractFloat32Frac( b );
1980             if ( bSig ) return propagateFloat32NaN( a, b );
1987         if ( bSig ) return propagateFloat32NaN( a, b );
1991         if ( bSig == 0 ) {
1999         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
2007     bSig = ( bSig | 0x00800000 )<<8;
2008     if ( bSig <= ( aSig + aSig ) ) {
2012     zSig = ( ( (bits64) aSig )<<32 ) / bSig;
2014         zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
2032     bits32 aSig, bSig;
2041     bSig = extractFloat32Frac( b );
2045         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
2052         if ( bSig ) return propagateFloat32NaN( a, b );
2056         if ( bSig == 0 ) {
2060         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
2068     bSig |= 0x00800000;
2071         bSig <<= 8;
2076         q = ( bSig <= aSig );
2077         if ( q ) aSig -= bSig;
2079             q = ( ( (bits64) aSig )<<32 ) / bSig;
2081             bSig >>= 2;
2082             aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2086             bSig >>= 2;
2090         if ( bSig <= aSig ) aSig -= bSig;
2092         bSig64 = ( (bits64) bSig )<<40;
2097             aSig64 = - ( ( bSig * q64 )<<38 );
2104         bSig <<= 6;
2105         aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
2110         aSig -= bSig;
2718     bits64 aSig, bSig, zSig;
2723     bSig = extractFloat64Frac( b );
2727     bSig <<= 9;
2737             bSig |= LIT64( 0x2000000000000000 );
2739         shift64RightJamming( bSig, expDiff, &bSig );
2744             if ( bSig ) return propagateFloat64NaN( a, b );
2758             if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2761         if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2762         zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2767     zSig = ( aSig + bSig )<<1;
2770         zSig = aSig + bSig;
2790     bits64 aSig, bSig, zSig;
2795     bSig = extractFloat64Frac( b );
2799     bSig <<= 10;
2803         if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2811     if ( bSig < aSig ) goto aBigger;
2812     if ( aSig < bSig ) goto bBigger;
2816         if ( bSig ) return propagateFloat64NaN( a, b );
2826     bSig |= LIT64( 0x4000000000000000 );
2828     zSig = bSig - aSig;
2841         bSig |= LIT64( 0x4000000000000000 );
2843     shift64RightJamming( bSig, expDiff, &bSig );
2846     zSig = aSig - bSig;
2909     bits64 aSig, bSig, zSig0, zSig1;
2914     bSig = extractFloat64Frac( b );
2919         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2922         if ( ( bExp | bSig ) == 0 ) {
2929         if ( bSig ) return propagateFloat64NaN( a, b );
2941         if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2942         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2946     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
2947     mul64To128( aSig, bSig, &zSig0, &zSig1 );
2968     bits64 aSig, bSig, zSig;
2975     bSig = extractFloat64Frac( b );
2982             if ( bSig ) return propagateFloat64NaN( a, b );
2989         if ( bSig ) return propagateFloat64NaN( a, b );
2993         if ( bSig == 0 ) {
3001         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
3009     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
3010     if ( bSig <= ( aSig + aSig ) ) {
3014     zSig = estimateDiv128To64( aSig, 0, bSig );
3016         mul64To128( bSig, zSig, &term0, &term1 );
3020             add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
3040     bits64 aSig, bSig;
3047     bSig = extractFloat64Frac( b );
3051         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
3058         if ( bSig ) return propagateFloat64NaN( a, b );
3062         if ( bSig == 0 ) {
3066         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
3074     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
3079     q = ( bSig <= aSig );
3080     if ( q ) aSig -= bSig;
3083         q = estimateDiv128To64( aSig, 0, bSig );
3085         aSig = - ( ( bSig>>2 ) * q );
3090         q = estimateDiv128To64( aSig, 0, bSig );
3093         bSig >>= 2;
3094         aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
3098         bSig >>= 2;
3103         aSig -= bSig;
3660     bits64 aSig, bSig, zSig0, zSig1;
3665     bSig = extractFloatx80Frac( b );
3674         shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
3679             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3688             if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3694         zSig0 = aSig + bSig;
3702     zSig0 = aSig + bSig;
3727     bits64 aSig, bSig, zSig0, zSig1;
3733     bSig = extractFloatx80Frac( b );
3739         if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
3752     if ( bSig < aSig ) goto aBigger;
3753     if ( aSig < bSig ) goto bBigger;
3757         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3763     sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
3773     shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
3775     sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
3839     bits64 aSig, bSig, zSig0, zSig1;
3845     bSig = extractFloatx80Frac( b );
3851              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
3854         if ( ( bExp | bSig ) == 0 ) goto invalid;
3858         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3873         if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
3874         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3877     mul64To128( aSig, bSig, &zSig0, &zSig1 );
3899     bits64 aSig, bSig, zSig0, zSig1;
3906     bSig = extractFloatx80Frac( b );
3913             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3919         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3923         if ( bSig == 0 ) {
3934         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3942     if ( bSig <= aSig ) {
3946     zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3947     mul64To128( bSig, zSig0, &term0, &term1 );
3951         add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
3953     zSig1 = estimateDiv128To64( rem1, 0, bSig );
3955         mul64To128( bSig, zSig1, &term1, &term2 );
3959             add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
3980     bits64 aSig0, aSig1, bSig;
3987     bSig = extractFloatx80Frac( b );
3992              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
3998         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
4002         if ( bSig == 0 ) {
4009         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
4015     bSig |= LIT64( 0x8000000000000000 );
4024     q = ( bSig <= aSig0 );
4025     if ( q ) aSig0 -= bSig;
4028         q = estimateDiv128To64( aSig0, aSig1, bSig );
4030         mul64To128( bSig, q, &term0, &term1 );
4037         q = estimateDiv128To64( aSig0, aSig1, bSig );
4040         mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );
4042         shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
4050         term0 = bSig;