softfloat/bits64/softfloat.c

264 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
267 together to form the result.  This means that any integer portion of `zSig'
270 than the desired result exponent whenever `zSig' is a complete, normalized
274 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
277     return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
284 and significand `zSig', and returns the proper single-precision floating-
294     The input significand `zSig' has its binary point between bits 30
296 significand must be normalized or smaller.  If `zSig' is not normalized,
298 and it must not require rounding.  In the usual case that `zSig' is
304 static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
328     roundBits = zSig & 0x7F;
332                   && ( (sbits32) ( zSig + roundIncrement ) < 0 ) )
341                 || ( zSig + roundIncrement < 0x80000000 );
342             shift32RightJamming( zSig, - zExp, &zSig );
344             roundBits = zSig & 0x7F;
349     zSig = ( zSig + roundIncrement )>>7;
350     zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
351     if ( zSig == 0 ) zExp = 0;
352     return packFloat32( zSign, zExp, zSig );
359 and significand `zSig', and returns the proper single-precision floating-
361 `roundAndPackFloat32' except that `zSig' does not have to be normalized.
362 Bit 31 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''
367  normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
371     shiftCount = countLeadingZeros32( zSig ) - 1;
372     return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount );
433 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
436 together to form the result.  This means that any integer portion of `zSig'
439 than the desired result exponent whenever `zSig' is a complete, normalized
443 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
447 			   ( ( (bits64) zExp )<<52 ) + zSig );
454 and significand `zSig', and returns the proper double-precision floating-
464     The input significand `zSig' has its binary point between bits 62
466 significand must be normalized or smaller.  If `zSig' is not normalized,
468 and it must not require rounding.  In the usual case that `zSig' is
474 static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
498     roundBits = zSig & 0x3FF;
502                   && ( (sbits64) ( zSig + roundIncrement ) < 0 ) )
513                 || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
514             shift64RightJamming( zSig, - zExp, &zSig );
516             roundBits = zSig & 0x3FF;
521     zSig = ( zSig + roundIncrement )>>10;
522     zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
523     if ( zSig == 0 ) zExp = 0;
524     return packFloat64( zSign, zExp, zSig );
531 and significand `zSig', and returns the proper double-precision floating-
533 `roundAndPackFloat64' except that `zSig' does not have to be normalized.
534 Bit 63 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''
539  normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
543     shiftCount = countLeadingZeros64( zSig ) - 1;
544     return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount );
610 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
614 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
618     z.low = zSig;
1152     bits64 zSig;
1158     zSig = absA;
1159     return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );
1167     bits64 zSig = a;
1171     return packFloat64( 0, 0x432 - shiftCount, zSig<<shiftCount );
1191     bits64 zSig;
1197     zSig = absA;
1198     return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
1205     bits64 zSig = a;
1209     return packFloatx80( 0, 0x403E - shiftCount, zSig<<shiftCount );
1709     bits32 aSig, bSig, zSig;
1753         zSig = 0x40000000 + aSig + bSig;
1758     zSig = ( aSig + bSig )<<1;
1760     if ( (sbits32) zSig < 0 ) {
1761         zSig = aSig + bSig;
1765     return roundAndPackFloat32( zSign, zExp, zSig );
1781     bits32 aSig, bSig, zSig;
1819     zSig = bSig - aSig;
1837     zSig = aSig - bSig;
1841     return normalizeRoundAndPackFloat32( zSign, zExp, zSig );
1902     bits32 zSig;
1941     zSig = zSig64;
1942     if ( 0 <= (sbits32) ( zSig<<1 ) ) {
1943         zSig <<= 1;
1946     return roundAndPackFloat32( zSign, zExp, zSig );
1961     bits32 aSig, bSig, zSig;
2005     zSig = ( ( (bits64) aSig )<<32 ) / bSig;
2006     if ( ( zSig & 0x3F ) == 0 ) {
2007         zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
2009     return roundAndPackFloat32( zSign, zExp, zSig );
2128     bits32 aSig, zSig;
2151     zSig = estimateSqrt32( aExp, aSig ) + 2;
2152     if ( ( zSig & 0x7F ) <= 5 ) {
2153         if ( zSig < 2 ) {
2154             zSig = 0x7FFFFFFF;
2158         term = ( (bits64) zSig ) * zSig;
2161             --zSig;
2162             rem += ( ( (bits64) zSig )<<1 ) | 1;
2164         zSig |= ( rem != 0 );
2166     shift32RightJamming( zSig, 1, &zSig );
2168     return roundAndPackFloat32( 0, zExp, zSig );
2509     bits32 zSig;
2519     zSig = aSig;
2520     if ( aExp || zSig ) {
2521         zSig |= 0x40000000;
2524     return roundAndPackFloat32( aSign, aExp, zSig );
2675     bits64 aSig, bSig, zSig;
2719         zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
2724     zSig = ( aSig + bSig )<<1;
2726     if ( (sbits64) zSig < 0 ) {
2727         zSig = aSig + bSig;
2731     return roundAndPackFloat64( zSign, zExp, zSig );
2747     bits64 aSig, bSig, zSig;
2785     zSig = bSig - aSig;
2803     zSig = aSig - bSig;
2807     return normalizeRoundAndPackFloat64( zSign, zExp, zSig );
2925     bits64 aSig, bSig, zSig;
2971     zSig = estimateDiv128To64( aSig, 0, bSig );
2972     if ( ( zSig & 0x1FF ) <= 2 ) {
2973         mul64To128( bSig, zSig, &term0, &term1 );
2976             --zSig;
2979         zSig |= ( rem1 != 0 );
2981     return roundAndPackFloat64( zSign, zExp, zSig );
3083     bits64 aSig, zSig, doubleZSig;
3106     zSig = estimateSqrt32( aExp, aSig>>21 );
3108     zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
3109     if ( ( zSig & 0x1FF ) <= 5 ) {
3110         doubleZSig = zSig<<1;
3111         mul64To128( zSig, zSig, &term0, &term1 );
3114             --zSig;
3116             add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 );
3118         zSig |= ( ( rem0 | rem1 ) != 0 );
3120     return roundAndPackFloat64( 0, zExp, zSig );
3485     bits64 aSig, zSig;
3496     shift64RightJamming( aSig, 1, &zSig );
3498     return roundAndPackFloat64( aSign, aExp, zSig );
4553     bits32 zSig;
4567     zSig = aSig0;
4568     if ( aExp || zSig ) {
4569         zSig |= 0x40000000;
4572     return roundAndPackFloat32( aSign, aExp, zSig );