softfloat/bits64/softfloat.c

1387     flag aSign;
1394     aSign = extractFloat32Sign( a );
1395     if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1401     return roundAndPackInt32( aSign, aSig64 );
1419     flag aSign;
1426     aSign = extractFloat32Sign( a );
1431             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1444     if ( aSign ) z = - z;
1463     flag aSign;
1470     aSign = extractFloat32Sign( a );
1474         if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1483     return roundAndPackInt64( aSign, aSig64, aSigExtra );
1500     flag aSign;
1508     aSign = extractFloat32Sign( a );
1513             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1529     if ( aSign ) z = - z;
1545     flag aSign;
1551     aSign = extractFloat32Sign( a );
1554         return packFloat64( aSign, 0x7FF, 0 );
1557         if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1561     return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1577     flag aSign;
1583     aSign = extractFloat32Sign( a );
1586         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
1589         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1593     return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1611     flag aSign;
1617     aSign = extractFloat32Sign( a );
1620         return packFloat128( aSign, 0x7FFF, 0, 0 );
1623         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1627     return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1644     flag aSign;
1660         aSign = extractFloat32Sign( a );
1664                 return packFloat32( aSign, 0x7F, 0 );
1670             return aSign ? 0xBF800000 : 0;
1672             return aSign ? 0x80000000 : 0x3F800000;
1674         return packFloat32( aSign, 0, 0 );
1854     flag aSign, bSign;
1856     aSign = extractFloat32Sign( a );
1858     if ( aSign == bSign ) {
1859         return addFloat32Sigs( a, b, aSign );
1862         return subFloat32Sigs( a, b, aSign );
1876     flag aSign, bSign;
1878     aSign = extractFloat32Sign( a );
1880     if ( aSign == bSign ) {
1881         return subFloat32Sigs( a, b, aSign );
1884         return addFloat32Sigs( a, b, aSign );
1898     flag aSign, bSign, zSign;
1906     aSign = extractFloat32Sign( a );
1910     zSign = aSign ^ bSign;
1959     flag aSign, bSign, zSign;
1965     aSign = extractFloat32Sign( a );
1969     zSign = aSign ^ bSign;
2023     flag aSign, bSign, zSign;
2033     aSign = extractFloat32Sign( a );
2111     return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2126     flag aSign;
2133     aSign = extractFloat32Sign( a );
2136         if ( ! aSign ) return a;
2140     if ( aSign ) {
2205     flag aSign, bSign;
2213     aSign = extractFloat32Sign( a );
2215     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2216     return ( a == b ) || ( aSign ^ ( a < b ) );
2229     flag aSign, bSign;
2237     aSign = extractFloat32Sign( a );
2239     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2240     return ( a != b ) && ( aSign ^ ( a < b ) );
2276     flag aSign, bSign;
2286     aSign = extractFloat32Sign( a );
2288     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2289     return ( a == b ) || ( aSign ^ ( a < b ) );
2303     flag aSign, bSign;
2313     aSign = extractFloat32Sign( a );
2315     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2316     return ( a != b ) && ( aSign ^ ( a < b ) );
2335     flag aSign;
2341     aSign = extractFloat64Sign( a );
2342     if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2346     return roundAndPackInt32( aSign, aSig );
2364     flag aSign;
2371     aSign = extractFloat64Sign( a );
2373         if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2385     if ( aSign ) z = - z;
2386     if ( ( z < 0 ) ^ aSign ) {
2389         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
2412     flag aSign;
2418     aSign = extractFloat64Sign( a );
2424             if (    ! aSign
2438     return roundAndPackInt64( aSign, aSig, aSigExtra );
2455     flag aSign;
2462     aSign = extractFloat64Sign( a );
2469                 if (    ! aSign
2490     if ( aSign ) z = - z;
2506     flag aSign;
2513     aSign = extractFloat64Sign( a );
2516         return packFloat32( aSign, 0xFF, 0 );
2524     return roundAndPackFloat32( aSign, aExp, zSig );
2540     flag aSign;
2546     aSign = extractFloat64Sign( a );
2549         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2552         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2557             aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2575     flag aSign;
2581     aSign = extractFloat64Sign( a );
2584         return packFloat128( aSign, 0x7FFF, 0, 0 );
2587         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2592     return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
2609     flag aSign;
2625         aSign = extractFloat64Sign( a );
2629                 return packFloat64( aSign, 0x3FF, 0 );
2635             return aSign ? LIT64( 0xBFF0000000000000 ) : 0;
2638             aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 );
2640         return packFloat64( aSign, 0, 0 );
2820     flag aSign, bSign;
2822     aSign = extractFloat64Sign( a );
2824     if ( aSign == bSign ) {
2825         return addFloat64Sigs( a, b, aSign );
2828         return subFloat64Sigs( a, b, aSign );
2842     flag aSign, bSign;
2844     aSign = extractFloat64Sign( a );
2846     if ( aSign == bSign ) {
2847         return subFloat64Sigs( a, b, aSign );
2850         return addFloat64Sigs( a, b, aSign );
2864     flag aSign, bSign, zSign;
2870     aSign = extractFloat64Sign( a );
2874     zSign = aSign ^ bSign;
2923     flag aSign, bSign, zSign;
2931     aSign = extractFloat64Sign( a );
2935     zSign = aSign ^ bSign;
2995     flag aSign, bSign, zSign;
3003     aSign = extractFloat64Sign( a );
3068     return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3081     flag aSign;
3088     aSign = extractFloat64Sign( a );
3091         if ( ! aSign ) return a;
3095     if ( aSign ) {
3158     flag aSign, bSign;
3166     aSign = extractFloat64Sign( a );
3168     if ( aSign != bSign )
3169 	return aSign ||
3173 	( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
3186     flag aSign, bSign;
3194     aSign = extractFloat64Sign( a );
3196     if ( aSign != bSign )
3197 	return aSign &&
3201 	( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
3237     flag aSign, bSign;
3247     aSign = extractFloat64Sign( a );
3249     if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );
3250     return ( a == b ) || ( aSign ^ ( a < b ) );
3264     flag aSign, bSign;
3274     aSign = extractFloat64Sign( a );
3276     if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );
3277     return ( a != b ) && ( aSign ^ ( a < b ) );
3297     flag aSign;
3303     aSign = extractFloatx80Sign( a );
3304     if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3308     return roundAndPackInt32( aSign, aSig );
3325     flag aSign;
3332     aSign = extractFloatx80Sign( a );
3334         if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3345     if ( aSign ) z = - z;
3346     if ( ( z < 0 ) ^ aSign ) {
3349         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
3371     flag aSign;
3377     aSign = extractFloatx80Sign( a );
3382             if (    ! aSign
3395     return roundAndPackInt64( aSign, aSig, aSigExtra );
3412     flag aSign;
3419     aSign = extractFloatx80Sign( a );
3425             if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3439     if ( aSign ) z = - z;
3454     flag aSign;
3460     aSign = extractFloatx80Sign( a );
3465         return packFloat32( aSign, 0xFF, 0 );
3469     return roundAndPackFloat32( aSign, aExp, aSig );
3483     flag aSign;
3489     aSign = extractFloatx80Sign( a );
3494         return packFloat64( aSign, 0x7FF, 0 );
3498     return roundAndPackFloat64( aSign, aExp, zSig );
3514     flag aSign;
3520     aSign = extractFloatx80Sign( a );
3525     return packFloat128( aSign, aExp, zSig0, zSig1 );
3541     flag aSign;
3560         aSign = extractFloatx80Sign( a );
3566                     packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3573                   aSign ?
3578                   aSign ? packFloatx80( 1, 0, 0 )
3581         return packFloatx80( aSign, 0, 0 );
3752     flag aSign, bSign;
3754     aSign = extractFloatx80Sign( a );
3756     if ( aSign == bSign ) {
3757         return addFloatx80Sigs( a, b, aSign );
3760         return subFloatx80Sigs( a, b, aSign );
3774     flag aSign, bSign;
3776     aSign = extractFloatx80Sign( a );
3778     if ( aSign == bSign ) {
3779         return subFloatx80Sigs( a, b, aSign );
3782         return addFloatx80Sigs( a, b, aSign );
3796     flag aSign, bSign, zSign;
3803     aSign = extractFloatx80Sign( a );
3807     zSign = aSign ^ bSign;
3856     flag aSign, bSign, zSign;
3864     aSign = extractFloatx80Sign( a );
3868     zSign = aSign ^ bSign;
3937     flag aSign, bSign, zSign;
3945     aSign = extractFloatx80Sign( a );
3975     zSign = aSign;
4035     flag aSign;
4043     aSign = extractFloatx80Sign( a );
4046         if ( ! aSign ) return a;
4049     if ( aSign ) {
4138     flag aSign, bSign;
4148     aSign = extractFloatx80Sign( a );
4150     if ( aSign != bSign ) {
4152                aSign
4157           aSign ? le128( b.high, b.low, a.high, a.low )
4172     flag aSign, bSign;
4182     aSign = extractFloatx80Sign( a );
4184     if ( aSign != bSign ) {
4186                aSign
4191           aSign ? lt128( b.high, b.low, a.high, a.low )
4234     flag aSign, bSign;
4247     aSign = extractFloatx80Sign( a );
4249     if ( aSign != bSign ) {
4251                aSign
4256           aSign ? le128( b.high, b.low, a.high, a.low )
4271     flag aSign, bSign;
4284     aSign = extractFloatx80Sign( a );
4286     if ( aSign != bSign ) {
4288                aSign
4293           aSign ? lt128( b.high, b.low, a.high, a.low )
4315     flag aSign;
4322     aSign = extractFloat128Sign( a );
4323     if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
4328     return roundAndPackInt32( aSign, aSig0 );
4345     flag aSign;
4353     aSign = extractFloat128Sign( a );
4356         if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
4368     if ( aSign ) z = - z;
4369     if ( ( z < 0 ) ^ aSign ) {
4372         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
4394     flag aSign;
4401     aSign = extractFloat128Sign( a );
4407             if (    ! aSign
4421     return roundAndPackInt64( aSign, aSig0, aSig1 );
4438     flag aSign;
4446     aSign = extractFloat128Sign( a );
4458                 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
4482     if ( aSign ) z = - z;
4494     flag aSign;
4502     aSign = extractFloat128Sign( a );
4534     if ( aSign ) z = - z;
4550     flag aSign;
4558     aSign = extractFloat128Sign( a );
4563         return packFloat32( aSign, 0xFF, 0 );
4572     return roundAndPackFloat32( aSign, aExp, zSig );
4586     flag aSign;
4593     aSign = extractFloat128Sign( a );
4598         return packFloat64( aSign, 0x7FF, 0 );
4606     return roundAndPackFloat64( aSign, aExp, aSig0 );
4622     flag aSign;
4629     aSign = extractFloat128Sign( a );
4634         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
4637         if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
4644     return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 );
4660     flag aSign;
4705             aSign = extractFloat128Sign( a );
4712                     return packFloat128( aSign, 0x3FFF, 0, 0 );
4719                       aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
4723                       aSign ? packFloat128( 1, 0, 0, 0 )
4726             return packFloat128( aSign, 0, 0, 0 );
4929     flag aSign, bSign;
4931     aSign = extractFloat128Sign( a );
4933     if ( aSign == bSign ) {
4934         return addFloat128Sigs( a, b, aSign );
4937         return subFloat128Sigs( a, b, aSign );
4951     flag aSign, bSign;
4953     aSign = extractFloat128Sign( a );
4955     if ( aSign == bSign ) {
4956         return subFloat128Sigs( a, b, aSign );
4959         return addFloat128Sigs( a, b, aSign );
4973     flag aSign, bSign, zSign;
4981     aSign = extractFloat128Sign( a );
4986     zSign = aSign ^ bSign;
5038     flag aSign, bSign, zSign;
5047     aSign = extractFloat128Sign( a );
5052     zSign = aSign ^ bSign;
5123     flag aSign, bSign, zSign;
5133     aSign = extractFloat128Sign( a );
5221         normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
5234     flag aSign;
5243     aSign = extractFloat128Sign( a );
5246         if ( ! aSign ) return a;
5249     if ( aSign ) {
5335     flag aSign, bSign;
5345     aSign = extractFloat128Sign( a );
5347     if ( aSign != bSign ) {
5349                aSign
5354           aSign ? le128( b.high, b.low, a.high, a.low )
5368     flag aSign, bSign;
5378     aSign = extractFloat128Sign( a );
5380     if ( aSign != bSign ) {
5382                aSign
5387           aSign ? lt128( b.high, b.low, a.high, a.low )
5430     flag aSign, bSign;
5443     aSign = extractFloat128Sign( a );
5445     if ( aSign != bSign ) {
5447                aSign
5452           aSign ? le128( b.high, b.low, a.high, a.low )
5467     flag aSign, bSign;
5480     aSign = extractFloat128Sign( a );
5482     if ( aSign != bSign ) {
5484                aSign
5489           aSign ? lt128( b.high, b.low, a.high, a.low )
5522     flag aSign;
5529     aSign = extractFloat64Sign( a );
5531     if (aSign) {
5568     flag aSign;
5575     aSign = extractFloat32Sign( a );
5578     if (aSign) {