arm/nwfpe/softfloat.c

1032     bits32 aSig, bSig, zSig;
1037     bSig = extractFloat32Frac( b );
1041     bSig <<= 6;
1051             bSig |= 0x20000000;
1053         shift32RightJamming( bSig, expDiff, &bSig );
1058             if ( bSig ) return propagateFloat32NaN( a, b );
1072             if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1075         if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1076         zSig = 0x40000000 + aSig + bSig;
1081     zSig = ( aSig + bSig )<<1;
1084         zSig = aSig + bSig;
1104     bits32 aSig, bSig, zSig;
1109     bSig = extractFloat32Frac( b );
1113     bSig <<= 7;
1117         if ( aSig | bSig ) return propagateFloat32NaN( a, b );
1125     if ( bSig < aSig ) goto aBigger;
1126     if ( aSig < bSig ) goto bBigger;
1130         if ( bSig ) return propagateFloat32NaN( a, b );
1140     bSig |= 0x40000000;
1142     zSig = bSig - aSig;
1155         bSig |= 0x40000000;
1157     shift32RightJamming( bSig, expDiff, &bSig );
1160     zSig = aSig - bSig;
1223     bits32 aSig, bSig;
1230     bSig = extractFloat32Frac( b );
1235         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1238         if ( ( bExp | bSig ) == 0 ) {
1245         if ( bSig ) return propagateFloat32NaN( a, b );
1257         if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1258         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
1262     bSig = ( bSig | 0x00800000 )<<8;
1263     shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
1284     bits32 aSig, bSig, zSig;
1289     bSig = extractFloat32Frac( b );
1296             if ( bSig ) return propagateFloat32NaN( a, b );
1303         if ( bSig ) return propagateFloat32NaN( a, b );
1307         if ( bSig == 0 ) {
1315         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
1323     bSig = ( bSig | 0x00800000 )<<8;
1324     if ( bSig <= ( aSig + aSig ) ) {
1330         do_div( tmp, bSig );
1334         zSig |= ( ( (bits64) bSig ) * zSig != ( (bits64) aSig )<<32 );
1351     bits32 aSig, bSig;
1360     bSig = extractFloat32Frac( b );
1364         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
1371         if ( bSig ) return propagateFloat32NaN( a, b );
1375         if ( bSig == 0 ) {
1379         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
1387     bSig |= 0x00800000;
1390         bSig <<= 8;
1395         q = ( bSig <= aSig );
1396         if ( q ) aSig -= bSig;
1399             do_div( tmp, bSig );
1402             bSig >>= 2;
1403             aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
1407             bSig >>= 2;
1411         if ( bSig <= aSig ) aSig -= bSig;
1413         bSig64 = ( (bits64) bSig )<<40;
1418             aSig64 = - ( ( bSig * q64 )<<38 );
1425         bSig <<= 6;
1426         aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
1431         aSig -= bSig;
1928     bits64 aSig, bSig, zSig;
1933     bSig = extractFloat64Frac( b );
1937     bSig <<= 9;
1947             bSig |= LIT64( 0x2000000000000000 );
1949         shift64RightJamming( bSig, expDiff, &bSig );
1954             if ( bSig ) return propagateFloat64NaN( a, b );
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;
1977     zSig = ( aSig + bSig )<<1;
1980         zSig = aSig + bSig;
2000     bits64 aSig, bSig, zSig;
2005     bSig = extractFloat64Frac( b );
2009     bSig <<= 10;
2013         if ( aSig | bSig ) return propagateFloat64NaN( a, b );
2021     if ( bSig < aSig ) goto aBigger;
2022     if ( aSig < bSig ) goto bBigger;
2026         if ( bSig ) return propagateFloat64NaN( a, b );
2036     bSig |= LIT64( 0x4000000000000000 );
2038     zSig = bSig - aSig;
2051         bSig |= LIT64( 0x4000000000000000 );
2053     shift64RightJamming( bSig, expDiff, &bSig );
2056     zSig = aSig - bSig;
2119     bits64 aSig, bSig, zSig0, zSig1;
2124     bSig = extractFloat64Frac( b );
2129         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2132         if ( ( bExp | bSig ) == 0 ) {
2139         if ( bSig ) return propagateFloat64NaN( a, b );
2151         if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2152         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2156     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
2157     mul64To128( aSig, bSig, &zSig0, &zSig1 );
2178     bits64 aSig, bSig, zSig;
2185     bSig = extractFloat64Frac( b );
2192             if ( bSig ) return propagateFloat64NaN( a, b );
2199         if ( bSig ) return propagateFloat64NaN( a, b );
2203         if ( bSig == 0 ) {
2211         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2219     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
2220     if ( bSig <= ( aSig + aSig ) ) {
2224     zSig = estimateDiv128To64( aSig, 0, bSig );
2226         mul64To128( bSig, zSig, &term0, &term1 );
2230             add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
2249     bits64 aSig, bSig;
2256     bSig = extractFloat64Frac( b );
2260         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
2267         if ( bSig ) return propagateFloat64NaN( a, b );
2271         if ( bSig == 0 ) {
2275         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
2283     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
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 );
2302         bSig >>= 2;
2303         aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
2307         bSig >>= 2;
2312         aSig -= bSig;
2748     bits64 aSig, bSig, zSig0, zSig1;
2753     bSig = extractFloatx80Frac( b );
2762         shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
2767             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
2776             if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2782         zSig0 = aSig + bSig;
2791     zSig0 = aSig + bSig;
2817     bits64 aSig, bSig, zSig0, zSig1;
2823     bSig = extractFloatx80Frac( b );
2829         if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
2843     if ( bSig < aSig ) goto aBigger;
2844     if ( aSig < bSig ) goto bBigger;
2848         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
2854     sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
2864     shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
2866     sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
2930     bits64 aSig, bSig, zSig0, zSig1;
2936     bSig = extractFloatx80Frac( b );
2942              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
2945         if ( ( bExp | bSig ) == 0 ) goto invalid;
2949         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
2965         if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2966         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2969     mul64To128( aSig, bSig, &zSig0, &zSig1 );
2991     bits64 aSig, bSig, zSig0, zSig1;
2998     bSig = extractFloatx80Frac( b );
3005             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3011         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3015         if ( bSig == 0 ) {
3027         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3035     if ( bSig <= aSig ) {
3039     zSig0 = estimateDiv128To64( aSig, rem1, bSig );
3040     mul64To128( bSig, zSig0, &term0, &term1 );
3044         add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
3046     zSig1 = estimateDiv128To64( rem1, 0, bSig );
3048         mul64To128( bSig, zSig1, &term1, &term2 );
3052             add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
3073     bits64 aSig0, aSig1, bSig;
3080     bSig = extractFloatx80Frac( b );
3085              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
3091         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
3095         if ( bSig == 0 ) {
3103         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3109     bSig |= LIT64( 0x8000000000000000 );
3118     q = ( bSig <= aSig0 );
3119     if ( q ) aSig0 -= bSig;
3122         q = estimateDiv128To64( aSig0, aSig1, bSig );
3124         mul64To128( bSig, q, &term0, &term1 );
3131         q = estimateDiv128To64( aSig0, aSig1, bSig );
3134         mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );
3136         shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
3144         term0 = bSig;