Annotation of src/sys/lib/libkern/softfloat.c, revision 1.2

1.2     ! thorpej     1: /* $NetBSD: softfloat.c,v 1.1 2001/04/26 03:10:47 ross Exp $ */
1.1       ross        2: 
                      3: /*
                      4:  * This version hacked for use with gcc -msoft-float by bjh21.
                      5:  * (Mostly a case of #ifdefing out things GCC doesn't need or provides
                      6:  *  itself).
                      7:  */
                      8: 
                      9: /*
                     10:  * Things you may want to define:
                     11:  *
                     12:  * SOFTFLOAT_FOR_GCC - build only those functions necessary for GCC (with
                     13:  *   -msoft-float) to work.  Include "softfloat-for-gcc.h" to get them
                     14:  *   properly renamed.
                     15:  */
                     16: 
                     17: /*
                     18: ===============================================================================
                     19: 
                     20: This C source file is part of the SoftFloat IEC/IEEE Floating-point
                     21: Arithmetic Package, Release 2a.
                     22: 
                     23: Written by John R. Hauser.  This work was made possible in part by the
                     24: International Computer Science Institute, located at Suite 600, 1947 Center
                     25: Street, Berkeley, California 94704.  Funding was partially provided by the
                     26: National Science Foundation under grant MIP-9311980.  The original version
                     27: of this code was written as part of a project to build a fixed-point vector
                     28: processor in collaboration with the University of California at Berkeley,
                     29: overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
                     30: is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
                     31: arithmetic/SoftFloat.html'.
                     32: 
                     33: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
                     34: has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
                     35: TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
                     36: PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
                     37: AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
                     38: 
                     39: Derivative works are acceptable, even for commercial purposes, so long as
                     40: (1) they include prominent notice that the work is derivative, and (2) they
                     41: include prominent notice akin to these four paragraphs for those parts of
                     42: this code that are retained.
                     43: 
                     44: ===============================================================================
                     45: */
                     46: 
1.2     ! thorpej    47: /* If you need this in a boot program, you have bigger problems... */
        !            48: #ifndef _STANDALONE
        !            49: 
1.1       ross       50: #include <sys/cdefs.h>
                     51: #if defined(LIBC_SCCS) && !defined(lint)
1.2     ! thorpej    52: __RCSID("$NetBSD: softfloat.c,v 1.1 2001/04/26 03:10:47 ross Exp $");
1.1       ross       53: #endif /* LIBC_SCCS and not lint */
                     54: 
                     55: #ifdef SOFTFLOAT_FOR_GCC
                     56: #include "softfloat-for-gcc.h"
                     57: #endif
                     58: 
                     59: #include "milieu.h"
                     60: #include "softfloat.h"
                     61: 
                     62: /*
                     63:  * Conversions between floats as stored in memory and floats as
                     64:  * SoftFloat uses them
                     65:  */
                     66: #ifndef FLOAT64_DEMANGLE
                     67: #define FLOAT64_DEMANGLE(a)    (a)
                     68: #endif
                     69: #ifndef FLOAT64_MANGLE
                     70: #define FLOAT64_MANGLE(a)      (a)
                     71: #endif
                     72: 
                     73: /*
                     74: -------------------------------------------------------------------------------
                     75: Floating-point rounding mode, extended double-precision rounding precision,
                     76: and exception flags.
                     77: -------------------------------------------------------------------------------
                     78: */
                     79: 
                     80: /*
                     81:  * XXX: This may cause options-MULTIPROCESSOR or thread problems someday.
                     82:  *     Right now, it does not.  I've removed all other dynamic global
                     83:  *     variables. [ross]
                     84:  */
                     85: #ifdef FLOATX80
                     86: int8 floatx80_rounding_precision = 80;
                     87: #endif
                     88: 
                     89: /*
                     90: -------------------------------------------------------------------------------
                     91: Primitive arithmetic functions, including multi-word arithmetic, and
                     92: division and square root approximations.  (Can be specialized to target if
                     93: desired.)
                     94: -------------------------------------------------------------------------------
                     95: */
                     96: #include "softfloat-macros.h"
                     97: 
                     98: /*
                     99: -------------------------------------------------------------------------------
                    100: Functions and definitions to determine:  (1) whether tininess for underflow
                    101: is detected before or after rounding by default, (2) what (if anything)
                    102: happens when exceptions are raised, (3) how signaling NaNs are distinguished
                    103: from quiet NaNs, (4) the default generated quiet NaNs, and (5) how NaNs
                    104: are propagated from function inputs to output.  These details are target-
                    105: specific.
                    106: -------------------------------------------------------------------------------
                    107: */
                    108: #include "softfloat-specialize.h"
                    109: 
                    110: #ifndef SOFTFLOAT_FOR_GCC /* Not used */
                    111: /*
                    112: -------------------------------------------------------------------------------
                    113: Takes a 64-bit fixed-point value `absZ' with binary point between bits 6
                    114: and 7, and returns the properly rounded 32-bit integer corresponding to the
                    115: input.  If `zSign' is 1, the input is negated before being converted to an
                    116: integer.  Bit 63 of `absZ' must be zero.  Ordinarily, the fixed-point input
                    117: is simply rounded to an integer, with the inexact exception raised if the
                    118: input cannot be represented exactly as an integer.  However, if the fixed-
                    119: point input is too large, the invalid exception is raised and the largest
                    120: positive or negative integer is returned.
                    121: -------------------------------------------------------------------------------
                    122: */
                    123: static int32 roundAndPackInt32( flag zSign, bits64 absZ )
                    124: {
                    125:     int8 roundingMode;
                    126:     flag roundNearestEven;
                    127:     int8 roundIncrement, roundBits;
                    128:     int32 z;
                    129: 
                    130:     roundingMode = float_rounding_mode();
                    131:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                    132:     roundIncrement = 0x40;
                    133:     if ( ! roundNearestEven ) {
                    134:         if ( roundingMode == float_round_to_zero ) {
                    135:             roundIncrement = 0;
                    136:         }
                    137:         else {
                    138:             roundIncrement = 0x7F;
                    139:             if ( zSign ) {
                    140:                 if ( roundingMode == float_round_up ) roundIncrement = 0;
                    141:             }
                    142:             else {
                    143:                 if ( roundingMode == float_round_down ) roundIncrement = 0;
                    144:             }
                    145:         }
                    146:     }
                    147:     roundBits = absZ & 0x7F;
                    148:     absZ = ( absZ + roundIncrement )>>7;
                    149:     absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
                    150:     z = absZ;
                    151:     if ( zSign ) z = - z;
                    152:     if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
                    153:         float_raise( float_flag_invalid );
                    154:         return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
                    155:     }
                    156:     if ( roundBits ) float_set_inexact();
                    157:     return z;
                    158: 
                    159: }
                    160: 
                    161: /*
                    162: -------------------------------------------------------------------------------
                    163: Takes the 128-bit fixed-point value formed by concatenating `absZ0' and
                    164: `absZ1', with binary point between bits 63 and 64 (between the input words),
                    165: and returns the properly rounded 64-bit integer corresponding to the input.
                    166: If `zSign' is 1, the input is negated before being converted to an integer.
                    167: Ordinarily, the fixed-point input is simply rounded to an integer, with
                    168: the inexact exception raised if the input cannot be represented exactly as
                    169: an integer.  However, if the fixed-point input is too large, the invalid
                    170: exception is raised and the largest positive or negative integer is
                    171: returned.
                    172: -------------------------------------------------------------------------------
                    173: */
                    174: static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 )
                    175: {
                    176:     int8 roundingMode;
                    177:     flag roundNearestEven, increment;
                    178:     int64 z;
                    179: 
                    180:     roundingMode = float_rounding_mode();
                    181:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                    182:     increment = ( (sbits64) absZ1 < 0 );
                    183:     if ( ! roundNearestEven ) {
                    184:         if ( roundingMode == float_round_to_zero ) {
                    185:             increment = 0;
                    186:         }
                    187:         else {
                    188:             if ( zSign ) {
                    189:                 increment = ( roundingMode == float_round_down ) && absZ1;
                    190:             }
                    191:             else {
                    192:                 increment = ( roundingMode == float_round_up ) && absZ1;
                    193:             }
                    194:         }
                    195:     }
                    196:     if ( increment ) {
                    197:         ++absZ0;
                    198:         if ( absZ0 == 0 ) goto overflow;
                    199:         absZ0 &= ~ ( ( (bits64) ( absZ1<<1 ) == 0 ) & roundNearestEven );
                    200:     }
                    201:     z = absZ0;
                    202:     if ( zSign ) z = - z;
                    203:     if ( z && ( ( z < 0 ) ^ zSign ) ) {
                    204:  overflow:
                    205:         float_raise( float_flag_invalid );
                    206:         return
                    207:               zSign ? (sbits64) LIT64( 0x8000000000000000 )
                    208:             : LIT64( 0x7FFFFFFFFFFFFFFF );
                    209:     }
                    210:     if ( absZ1 ) float_set_inexact();
                    211:     return z;
                    212: 
                    213: }
                    214: #endif
                    215: 
                    216: /*
                    217: -------------------------------------------------------------------------------
                    218: Returns the fraction bits of the single-precision floating-point value `a'.
                    219: -------------------------------------------------------------------------------
                    220: */
                    221: INLINE bits32 extractFloat32Frac( float32 a )
                    222: {
                    223: 
                    224:     return a & 0x007FFFFF;
                    225: 
                    226: }
                    227: 
                    228: /*
                    229: -------------------------------------------------------------------------------
                    230: Returns the exponent bits of the single-precision floating-point value `a'.
                    231: -------------------------------------------------------------------------------
                    232: */
                    233: INLINE int16 extractFloat32Exp( float32 a )
                    234: {
                    235: 
                    236:     return ( a>>23 ) & 0xFF;
                    237: 
                    238: }
                    239: 
                    240: /*
                    241: -------------------------------------------------------------------------------
                    242: Returns the sign bit of the single-precision floating-point value `a'.
                    243: -------------------------------------------------------------------------------
                    244: */
                    245: INLINE flag extractFloat32Sign( float32 a )
                    246: {
                    247: 
                    248:     return a>>31;
                    249: 
                    250: }
                    251: 
                    252: /*
                    253: -------------------------------------------------------------------------------
                    254: Normalizes the subnormal single-precision floating-point value represented
                    255: by the denormalized significand `aSig'.  The normalized exponent and
                    256: significand are stored at the locations pointed to by `zExpPtr' and
                    257: `zSigPtr', respectively.
                    258: -------------------------------------------------------------------------------
                    259: */
                    260: static void
                    261:  normalizeFloat32Subnormal( bits32 aSig, int16 *zExpPtr, bits32 *zSigPtr )
                    262: {
                    263:     int8 shiftCount;
                    264: 
                    265:     shiftCount = countLeadingZeros32( aSig ) - 8;
                    266:     *zSigPtr = aSig<<shiftCount;
                    267:     *zExpPtr = 1 - shiftCount;
                    268: 
                    269: }
                    270: 
                    271: /*
                    272: -------------------------------------------------------------------------------
                    273: Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
                    274: single-precision floating-point value, returning the result.  After being
                    275: shifted into the proper positions, the three fields are simply added
                    276: together to form the result.  This means that any integer portion of `zSig'
                    277: will be added into the exponent.  Since a properly normalized significand
                    278: will have an integer portion equal to 1, the `zExp' input should be 1 less
                    279: than the desired result exponent whenever `zSig' is a complete, normalized
                    280: significand.
                    281: -------------------------------------------------------------------------------
                    282: */
                    283: INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
                    284: {
                    285: 
                    286:     return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
                    287: 
                    288: }
                    289: 
                    290: /*
                    291: -------------------------------------------------------------------------------
                    292: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    293: and significand `zSig', and returns the proper single-precision floating-
                    294: point value corresponding to the abstract input.  Ordinarily, the abstract
                    295: value is simply rounded and packed into the single-precision format, with
                    296: the inexact exception raised if the abstract input cannot be represented
                    297: exactly.  However, if the abstract value is too large, the overflow and
                    298: inexact exceptions are raised and an infinity or maximal finite value is
                    299: returned.  If the abstract value is too small, the input value is rounded to
                    300: a subnormal number, and the underflow and inexact exceptions are raised if
                    301: the abstract input cannot be represented exactly as a subnormal single-
                    302: precision floating-point number.
                    303:     The input significand `zSig' has its binary point between bits 30
                    304: and 29, which is 7 bits to the left of the usual location.  This shifted
                    305: significand must be normalized or smaller.  If `zSig' is not normalized,
                    306: `zExp' must be 0; in that case, the result returned is a subnormal number,
                    307: and it must not require rounding.  In the usual case that `zSig' is
                    308: normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.
                    309: The handling of underflow and overflow follows the IEC/IEEE Standard for
                    310: Binary Floating-Point Arithmetic.
                    311: -------------------------------------------------------------------------------
                    312: */
                    313: static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
                    314: {
                    315:     int8 roundingMode;
                    316:     flag roundNearestEven;
                    317:     int8 roundIncrement, roundBits;
                    318:     flag isTiny;
                    319: 
                    320:     roundingMode = float_rounding_mode();
                    321:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                    322:     roundIncrement = 0x40;
                    323:     if ( ! roundNearestEven ) {
                    324:         if ( roundingMode == float_round_to_zero ) {
                    325:             roundIncrement = 0;
                    326:         }
                    327:         else {
                    328:             roundIncrement = 0x7F;
                    329:             if ( zSign ) {
                    330:                 if ( roundingMode == float_round_up ) roundIncrement = 0;
                    331:             }
                    332:             else {
                    333:                 if ( roundingMode == float_round_down ) roundIncrement = 0;
                    334:             }
                    335:         }
                    336:     }
                    337:     roundBits = zSig & 0x7F;
                    338:     if ( 0xFD <= (bits16) zExp ) {
                    339:         if (    ( 0xFD < zExp )
                    340:              || (    ( zExp == 0xFD )
                    341:                   && ( (sbits32) ( zSig + roundIncrement ) < 0 ) )
                    342:            ) {
                    343:             float_raise( float_flag_overflow | float_flag_inexact );
                    344:             return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );
                    345:         }
                    346:         if ( zExp < 0 ) {
                    347:             isTiny =
                    348:                    ( float_detect_tininess == float_tininess_before_rounding )
                    349:                 || ( zExp < -1 )
                    350:                 || ( zSig + roundIncrement < 0x80000000 );
                    351:             shift32RightJamming( zSig, - zExp, &zSig );
                    352:             zExp = 0;
                    353:             roundBits = zSig & 0x7F;
                    354:             if ( isTiny && roundBits ) float_raise( float_flag_underflow );
                    355:         }
                    356:     }
                    357:     if ( roundBits ) float_set_inexact();
                    358:     zSig = ( zSig + roundIncrement )>>7;
                    359:     zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
                    360:     if ( zSig == 0 ) zExp = 0;
                    361:     return packFloat32( zSign, zExp, zSig );
                    362: 
                    363: }
                    364: 
                    365: /*
                    366: -------------------------------------------------------------------------------
                    367: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    368: and significand `zSig', and returns the proper single-precision floating-
                    369: point value corresponding to the abstract input.  This routine is just like
                    370: `roundAndPackFloat32' except that `zSig' does not have to be normalized.
                    371: Bit 31 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''
                    372: floating-point exponent.
                    373: -------------------------------------------------------------------------------
                    374: */
                    375: static float32
                    376:  normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
                    377: {
                    378:     int8 shiftCount;
                    379: 
                    380:     shiftCount = countLeadingZeros32( zSig ) - 1;
                    381:     return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount );
                    382: 
                    383: }
                    384: 
                    385: /*
                    386: -------------------------------------------------------------------------------
                    387: Returns the fraction bits of the double-precision floating-point value `a'.
                    388: -------------------------------------------------------------------------------
                    389: */
                    390: INLINE bits64 extractFloat64Frac( float64 a )
                    391: {
                    392: 
                    393:     return FLOAT64_DEMANGLE(a) & LIT64( 0x000FFFFFFFFFFFFF );
                    394: 
                    395: }
                    396: 
                    397: /*
                    398: -------------------------------------------------------------------------------
                    399: Returns the exponent bits of the double-precision floating-point value `a'.
                    400: -------------------------------------------------------------------------------
                    401: */
                    402: INLINE int16 extractFloat64Exp( float64 a )
                    403: {
                    404: 
                    405:     return ( FLOAT64_DEMANGLE(a)>>52 ) & 0x7FF;
                    406: 
                    407: }
                    408: 
                    409: /*
                    410: -------------------------------------------------------------------------------
                    411: Returns the sign bit of the double-precision floating-point value `a'.
                    412: -------------------------------------------------------------------------------
                    413: */
                    414: INLINE flag extractFloat64Sign( float64 a )
                    415: {
                    416: 
                    417:     return FLOAT64_DEMANGLE(a)>>63;
                    418: 
                    419: }
                    420: 
                    421: /*
                    422: -------------------------------------------------------------------------------
                    423: Normalizes the subnormal double-precision floating-point value represented
                    424: by the denormalized significand `aSig'.  The normalized exponent and
                    425: significand are stored at the locations pointed to by `zExpPtr' and
                    426: `zSigPtr', respectively.
                    427: -------------------------------------------------------------------------------
                    428: */
                    429: static void
                    430:  normalizeFloat64Subnormal( bits64 aSig, int16 *zExpPtr, bits64 *zSigPtr )
                    431: {
                    432:     int8 shiftCount;
                    433: 
                    434:     shiftCount = countLeadingZeros64( aSig ) - 11;
                    435:     *zSigPtr = aSig<<shiftCount;
                    436:     *zExpPtr = 1 - shiftCount;
                    437: 
                    438: }
                    439: 
                    440: /*
                    441: -------------------------------------------------------------------------------
                    442: Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
                    443: double-precision floating-point value, returning the result.  After being
                    444: shifted into the proper positions, the three fields are simply added
                    445: together to form the result.  This means that any integer portion of `zSig'
                    446: will be added into the exponent.  Since a properly normalized significand
                    447: will have an integer portion equal to 1, the `zExp' input should be 1 less
                    448: than the desired result exponent whenever `zSig' is a complete, normalized
                    449: significand.
                    450: -------------------------------------------------------------------------------
                    451: */
                    452: INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
                    453: {
                    454: 
                    455:     return FLOAT64_MANGLE( ( ( (bits64) zSign )<<63 ) +
                    456:                           ( ( (bits64) zExp )<<52 ) + zSig );
                    457: 
                    458: }
                    459: 
                    460: /*
                    461: -------------------------------------------------------------------------------
                    462: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    463: and significand `zSig', and returns the proper double-precision floating-
                    464: point value corresponding to the abstract input.  Ordinarily, the abstract
                    465: value is simply rounded and packed into the double-precision format, with
                    466: the inexact exception raised if the abstract input cannot be represented
                    467: exactly.  However, if the abstract value is too large, the overflow and
                    468: inexact exceptions are raised and an infinity or maximal finite value is
                    469: returned.  If the abstract value is too small, the input value is rounded to
                    470: a subnormal number, and the underflow and inexact exceptions are raised if
                    471: the abstract input cannot be represented exactly as a subnormal double-
                    472: precision floating-point number.
                    473:     The input significand `zSig' has its binary point between bits 62
                    474: and 61, which is 10 bits to the left of the usual location.  This shifted
                    475: significand must be normalized or smaller.  If `zSig' is not normalized,
                    476: `zExp' must be 0; in that case, the result returned is a subnormal number,
                    477: and it must not require rounding.  In the usual case that `zSig' is
                    478: normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.
                    479: The handling of underflow and overflow follows the IEC/IEEE Standard for
                    480: Binary Floating-Point Arithmetic.
                    481: -------------------------------------------------------------------------------
                    482: */
                    483: static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
                    484: {
                    485:     int8 roundingMode;
                    486:     flag roundNearestEven;
                    487:     int16 roundIncrement, roundBits;
                    488:     flag isTiny;
                    489: 
                    490:     roundingMode = float_rounding_mode();
                    491:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                    492:     roundIncrement = 0x200;
                    493:     if ( ! roundNearestEven ) {
                    494:         if ( roundingMode == float_round_to_zero ) {
                    495:             roundIncrement = 0;
                    496:         }
                    497:         else {
                    498:             roundIncrement = 0x3FF;
                    499:             if ( zSign ) {
                    500:                 if ( roundingMode == float_round_up ) roundIncrement = 0;
                    501:             }
                    502:             else {
                    503:                 if ( roundingMode == float_round_down ) roundIncrement = 0;
                    504:             }
                    505:         }
                    506:     }
                    507:     roundBits = zSig & 0x3FF;
                    508:     if ( 0x7FD <= (bits16) zExp ) {
                    509:         if (    ( 0x7FD < zExp )
                    510:              || (    ( zExp == 0x7FD )
                    511:                   && ( (sbits64) ( zSig + roundIncrement ) < 0 ) )
                    512:            ) {
                    513:             float_raise( float_flag_overflow | float_flag_inexact );
                    514:             return FLOAT64_MANGLE(
                    515:                FLOAT64_DEMANGLE(packFloat64( zSign, 0x7FF, 0 )) -
                    516:                ( roundIncrement == 0 ));
                    517:         }
                    518:         if ( zExp < 0 ) {
                    519:             isTiny =
                    520:                    ( float_detect_tininess == float_tininess_before_rounding )
                    521:                 || ( zExp < -1 )
                    522:                 || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
                    523:             shift64RightJamming( zSig, - zExp, &zSig );
                    524:             zExp = 0;
                    525:             roundBits = zSig & 0x3FF;
                    526:             if ( isTiny && roundBits ) float_raise( float_flag_underflow );
                    527:         }
                    528:     }
                    529:     if ( roundBits ) float_set_inexact();
                    530:     zSig = ( zSig + roundIncrement )>>10;
                    531:     zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
                    532:     if ( zSig == 0 ) zExp = 0;
                    533:     return packFloat64( zSign, zExp, zSig );
                    534: 
                    535: }
                    536: 
                    537: /*
                    538: -------------------------------------------------------------------------------
                    539: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    540: and significand `zSig', and returns the proper double-precision floating-
                    541: point value corresponding to the abstract input.  This routine is just like
                    542: `roundAndPackFloat64' except that `zSig' does not have to be normalized.
                    543: Bit 63 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''
                    544: floating-point exponent.
                    545: -------------------------------------------------------------------------------
                    546: */
                    547: static float64
                    548:  normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
                    549: {
                    550:     int8 shiftCount;
                    551: 
                    552:     shiftCount = countLeadingZeros64( zSig ) - 1;
                    553:     return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount );
                    554: 
                    555: }
                    556: 
                    557: #ifdef FLOATX80
                    558: 
                    559: /*
                    560: -------------------------------------------------------------------------------
                    561: Returns the fraction bits of the extended double-precision floating-point
                    562: value `a'.
                    563: -------------------------------------------------------------------------------
                    564: */
                    565: INLINE bits64 extractFloatx80Frac( floatx80 a )
                    566: {
                    567: 
                    568:     return a.low;
                    569: 
                    570: }
                    571: 
                    572: /*
                    573: -------------------------------------------------------------------------------
                    574: Returns the exponent bits of the extended double-precision floating-point
                    575: value `a'.
                    576: -------------------------------------------------------------------------------
                    577: */
                    578: INLINE int32 extractFloatx80Exp( floatx80 a )
                    579: {
                    580: 
                    581:     return a.high & 0x7FFF;
                    582: 
                    583: }
                    584: 
                    585: /*
                    586: -------------------------------------------------------------------------------
                    587: Returns the sign bit of the extended double-precision floating-point value
                    588: `a'.
                    589: -------------------------------------------------------------------------------
                    590: */
                    591: INLINE flag extractFloatx80Sign( floatx80 a )
                    592: {
                    593: 
                    594:     return a.high>>15;
                    595: 
                    596: }
                    597: 
                    598: /*
                    599: -------------------------------------------------------------------------------
                    600: Normalizes the subnormal extended double-precision floating-point value
                    601: represented by the denormalized significand `aSig'.  The normalized exponent
                    602: and significand are stored at the locations pointed to by `zExpPtr' and
                    603: `zSigPtr', respectively.
                    604: -------------------------------------------------------------------------------
                    605: */
                    606: static void
                    607:  normalizeFloatx80Subnormal( bits64 aSig, int32 *zExpPtr, bits64 *zSigPtr )
                    608: {
                    609:     int8 shiftCount;
                    610: 
                    611:     shiftCount = countLeadingZeros64( aSig );
                    612:     *zSigPtr = aSig<<shiftCount;
                    613:     *zExpPtr = 1 - shiftCount;
                    614: 
                    615: }
                    616: 
                    617: /*
                    618: -------------------------------------------------------------------------------
                    619: Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
                    620: extended double-precision floating-point value, returning the result.
                    621: -------------------------------------------------------------------------------
                    622: */
                    623: INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
                    624: {
                    625:     floatx80 z;
                    626: 
                    627:     z.low = zSig;
                    628:     z.high = ( ( (bits16) zSign )<<15 ) + zExp;
                    629:     return z;
                    630: 
                    631: }
                    632: 
                    633: /*
                    634: -------------------------------------------------------------------------------
                    635: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    636: and extended significand formed by the concatenation of `zSig0' and `zSig1',
                    637: and returns the proper extended double-precision floating-point value
                    638: corresponding to the abstract input.  Ordinarily, the abstract value is
                    639: rounded and packed into the extended double-precision format, with the
                    640: inexact exception raised if the abstract input cannot be represented
                    641: exactly.  However, if the abstract value is too large, the overflow and
                    642: inexact exceptions are raised and an infinity or maximal finite value is
                    643: returned.  If the abstract value is too small, the input value is rounded to
                    644: a subnormal number, and the underflow and inexact exceptions are raised if
                    645: the abstract input cannot be represented exactly as a subnormal extended
                    646: double-precision floating-point number.
                    647:     If `roundingPrecision' is 32 or 64, the result is rounded to the same
                    648: number of bits as single or double precision, respectively.  Otherwise, the
                    649: result is rounded to the full precision of the extended double-precision
                    650: format.
                    651:     The input significand must be normalized or smaller.  If the input
                    652: significand is not normalized, `zExp' must be 0; in that case, the result
                    653: returned is a subnormal number, and it must not require rounding.  The
                    654: handling of underflow and overflow follows the IEC/IEEE Standard for Binary
                    655: Floating-Point Arithmetic.
                    656: -------------------------------------------------------------------------------
                    657: */
                    658: static floatx80
                    659:  roundAndPackFloatx80(
                    660:      int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
                    661:  )
                    662: {
                    663:     int8 roundingMode;
                    664:     flag roundNearestEven, increment, isTiny;
                    665:     int64 roundIncrement, roundMask, roundBits;
                    666: 
                    667:     roundingMode = float_rounding_mode();
                    668:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                    669:     if ( roundingPrecision == 80 ) goto precision80;
                    670:     if ( roundingPrecision == 64 ) {
                    671:         roundIncrement = LIT64( 0x0000000000000400 );
                    672:         roundMask = LIT64( 0x00000000000007FF );
                    673:     }
                    674:     else if ( roundingPrecision == 32 ) {
                    675:         roundIncrement = LIT64( 0x0000008000000000 );
                    676:         roundMask = LIT64( 0x000000FFFFFFFFFF );
                    677:     }
                    678:     else {
                    679:         goto precision80;
                    680:     }
                    681:     zSig0 |= ( zSig1 != 0 );
                    682:     if ( ! roundNearestEven ) {
                    683:         if ( roundingMode == float_round_to_zero ) {
                    684:             roundIncrement = 0;
                    685:         }
                    686:         else {
                    687:             roundIncrement = roundMask;
                    688:             if ( zSign ) {
                    689:                 if ( roundingMode == float_round_up ) roundIncrement = 0;
                    690:             }
                    691:             else {
                    692:                 if ( roundingMode == float_round_down ) roundIncrement = 0;
                    693:             }
                    694:         }
                    695:     }
                    696:     roundBits = zSig0 & roundMask;
                    697:     if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {
                    698:         if (    ( 0x7FFE < zExp )
                    699:              || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )
                    700:            ) {
                    701:             goto overflow;
                    702:         }
                    703:         if ( zExp <= 0 ) {
                    704:             isTiny =
                    705:                    ( float_detect_tininess == float_tininess_before_rounding )
                    706:                 || ( zExp < 0 )
                    707:                 || ( zSig0 <= zSig0 + roundIncrement );
                    708:             shift64RightJamming( zSig0, 1 - zExp, &zSig0 );
                    709:             zExp = 0;
                    710:             roundBits = zSig0 & roundMask;
                    711:             if ( isTiny && roundBits ) float_raise( float_flag_underflow );
                    712:             if ( roundBits ) float_set_inexact();
                    713:             zSig0 += roundIncrement;
                    714:             if ( (sbits64) zSig0 < 0 ) zExp = 1;
                    715:             roundIncrement = roundMask + 1;
                    716:             if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
                    717:                 roundMask |= roundIncrement;
                    718:             }
                    719:             zSig0 &= ~ roundMask;
                    720:             return packFloatx80( zSign, zExp, zSig0 );
                    721:         }
                    722:     }
                    723:     if ( roundBits ) float_set_inexact();
                    724:     zSig0 += roundIncrement;
                    725:     if ( zSig0 < roundIncrement ) {
                    726:         ++zExp;
                    727:         zSig0 = LIT64( 0x8000000000000000 );
                    728:     }
                    729:     roundIncrement = roundMask + 1;
                    730:     if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
                    731:         roundMask |= roundIncrement;
                    732:     }
                    733:     zSig0 &= ~ roundMask;
                    734:     if ( zSig0 == 0 ) zExp = 0;
                    735:     return packFloatx80( zSign, zExp, zSig0 );
                    736:  precision80:
                    737:     increment = ( (sbits64) zSig1 < 0 );
                    738:     if ( ! roundNearestEven ) {
                    739:         if ( roundingMode == float_round_to_zero ) {
                    740:             increment = 0;
                    741:         }
                    742:         else {
                    743:             if ( zSign ) {
                    744:                 increment = ( roundingMode == float_round_down ) && zSig1;
                    745:             }
                    746:             else {
                    747:                 increment = ( roundingMode == float_round_up ) && zSig1;
                    748:             }
                    749:         }
                    750:     }
                    751:     if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {
                    752:         if (    ( 0x7FFE < zExp )
                    753:              || (    ( zExp == 0x7FFE )
                    754:                   && ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) )
                    755:                   && increment
                    756:                 )
                    757:            ) {
                    758:             roundMask = 0;
                    759:  overflow:
                    760:             float_raise( float_flag_overflow | float_flag_inexact );
                    761:             if (    ( roundingMode == float_round_to_zero )
                    762:                  || ( zSign && ( roundingMode == float_round_up ) )
                    763:                  || ( ! zSign && ( roundingMode == float_round_down ) )
                    764:                ) {
                    765:                 return packFloatx80( zSign, 0x7FFE, ~ roundMask );
                    766:             }
                    767:             return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                    768:         }
                    769:         if ( zExp <= 0 ) {
                    770:             isTiny =
                    771:                    ( float_detect_tininess == float_tininess_before_rounding )
                    772:                 || ( zExp < 0 )
                    773:                 || ! increment
                    774:                 || ( zSig0 < LIT64( 0xFFFFFFFFFFFFFFFF ) );
                    775:             shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );
                    776:             zExp = 0;
                    777:             if ( isTiny && zSig1 ) float_raise( float_flag_underflow );
                    778:             if ( zSig1 ) float_set_inexact();
                    779:             if ( roundNearestEven ) {
                    780:                 increment = ( (sbits64) zSig1 < 0 );
                    781:             }
                    782:             else {
                    783:                 if ( zSign ) {
                    784:                     increment = ( roundingMode == float_round_down ) && zSig1;
                    785:                 }
                    786:                 else {
                    787:                     increment = ( roundingMode == float_round_up ) && zSig1;
                    788:                 }
                    789:             }
                    790:             if ( increment ) {
                    791:                 ++zSig0;
                    792:                 zSig0 &=
                    793:                     ~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven );
                    794:                 if ( (sbits64) zSig0 < 0 ) zExp = 1;
                    795:             }
                    796:             return packFloatx80( zSign, zExp, zSig0 );
                    797:         }
                    798:     }
                    799:     if ( zSig1 ) float_set_inexact();
                    800:     if ( increment ) {
                    801:         ++zSig0;
                    802:         if ( zSig0 == 0 ) {
                    803:             ++zExp;
                    804:             zSig0 = LIT64( 0x8000000000000000 );
                    805:         }
                    806:         else {
                    807:             zSig0 &= ~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven );
                    808:         }
                    809:     }
                    810:     else {
                    811:         if ( zSig0 == 0 ) zExp = 0;
                    812:     }
                    813:     return packFloatx80( zSign, zExp, zSig0 );
                    814: 
                    815: }
                    816: 
                    817: /*
                    818: -------------------------------------------------------------------------------
                    819: Takes an abstract floating-point value having sign `zSign', exponent
                    820: `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
                    821: and returns the proper extended double-precision floating-point value
                    822: corresponding to the abstract input.  This routine is just like
                    823: `roundAndPackFloatx80' except that the input significand does not have to be
                    824: normalized.
                    825: -------------------------------------------------------------------------------
                    826: */
                    827: static floatx80
                    828:  normalizeRoundAndPackFloatx80(
                    829:      int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
                    830:  )
                    831: {
                    832:     int8 shiftCount;
                    833: 
                    834:     if ( zSig0 == 0 ) {
                    835:         zSig0 = zSig1;
                    836:         zSig1 = 0;
                    837:         zExp -= 64;
                    838:     }
                    839:     shiftCount = countLeadingZeros64( zSig0 );
                    840:     shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
                    841:     zExp -= shiftCount;
                    842:     return
                    843:         roundAndPackFloatx80( roundingPrecision, zSign, zExp, zSig0, zSig1 );
                    844: 
                    845: }
                    846: 
                    847: #endif
                    848: 
                    849: #ifdef FLOAT128
                    850: 
                    851: /*
                    852: -------------------------------------------------------------------------------
                    853: Returns the least-significant 64 fraction bits of the quadruple-precision
                    854: floating-point value `a'.
                    855: -------------------------------------------------------------------------------
                    856: */
                    857: INLINE bits64 extractFloat128Frac1( float128 a )
                    858: {
                    859: 
                    860:     return a.low;
                    861: 
                    862: }
                    863: 
                    864: /*
                    865: -------------------------------------------------------------------------------
                    866: Returns the most-significant 48 fraction bits of the quadruple-precision
                    867: floating-point value `a'.
                    868: -------------------------------------------------------------------------------
                    869: */
                    870: INLINE bits64 extractFloat128Frac0( float128 a )
                    871: {
                    872: 
                    873:     return a.high & LIT64( 0x0000FFFFFFFFFFFF );
                    874: 
                    875: }
                    876: 
                    877: /*
                    878: -------------------------------------------------------------------------------
                    879: Returns the exponent bits of the quadruple-precision floating-point value
                    880: `a'.
                    881: -------------------------------------------------------------------------------
                    882: */
                    883: INLINE int32 extractFloat128Exp( float128 a )
                    884: {
                    885: 
                    886:     return ( a.high>>48 ) & 0x7FFF;
                    887: 
                    888: }
                    889: 
                    890: /*
                    891: -------------------------------------------------------------------------------
                    892: Returns the sign bit of the quadruple-precision floating-point value `a'.
                    893: -------------------------------------------------------------------------------
                    894: */
                    895: INLINE flag extractFloat128Sign( float128 a )
                    896: {
                    897: 
                    898:     return a.high>>63;
                    899: 
                    900: }
                    901: 
                    902: /*
                    903: -------------------------------------------------------------------------------
                    904: Normalizes the subnormal quadruple-precision floating-point value
                    905: represented by the denormalized significand formed by the concatenation of
                    906: `aSig0' and `aSig1'.  The normalized exponent is stored at the location
                    907: pointed to by `zExpPtr'.  The most significant 49 bits of the normalized
                    908: significand are stored at the location pointed to by `zSig0Ptr', and the
                    909: least significant 64 bits of the normalized significand are stored at the
                    910: location pointed to by `zSig1Ptr'.
                    911: -------------------------------------------------------------------------------
                    912: */
                    913: static void
                    914:  normalizeFloat128Subnormal(
                    915:      bits64 aSig0,
                    916:      bits64 aSig1,
                    917:      int32 *zExpPtr,
                    918:      bits64 *zSig0Ptr,
                    919:      bits64 *zSig1Ptr
                    920:  )
                    921: {
                    922:     int8 shiftCount;
                    923: 
                    924:     if ( aSig0 == 0 ) {
                    925:         shiftCount = countLeadingZeros64( aSig1 ) - 15;
                    926:         if ( shiftCount < 0 ) {
                    927:             *zSig0Ptr = aSig1>>( - shiftCount );
                    928:             *zSig1Ptr = aSig1<<( shiftCount & 63 );
                    929:         }
                    930:         else {
                    931:             *zSig0Ptr = aSig1<<shiftCount;
                    932:             *zSig1Ptr = 0;
                    933:         }
                    934:         *zExpPtr = - shiftCount - 63;
                    935:     }
                    936:     else {
                    937:         shiftCount = countLeadingZeros64( aSig0 ) - 15;
                    938:         shortShift128Left( aSig0, aSig1, shiftCount, zSig0Ptr, zSig1Ptr );
                    939:         *zExpPtr = 1 - shiftCount;
                    940:     }
                    941: 
                    942: }
                    943: 
                    944: /*
                    945: -------------------------------------------------------------------------------
                    946: Packs the sign `zSign', the exponent `zExp', and the significand formed
                    947: by the concatenation of `zSig0' and `zSig1' into a quadruple-precision
                    948: floating-point value, returning the result.  After being shifted into the
                    949: proper positions, the three fields `zSign', `zExp', and `zSig0' are simply
                    950: added together to form the most significant 32 bits of the result.  This
                    951: means that any integer portion of `zSig0' will be added into the exponent.
                    952: Since a properly normalized significand will have an integer portion equal
                    953: to 1, the `zExp' input should be 1 less than the desired result exponent
                    954: whenever `zSig0' and `zSig1' concatenated form a complete, normalized
                    955: significand.
                    956: -------------------------------------------------------------------------------
                    957: */
                    958: INLINE float128
                    959:  packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
                    960: {
                    961:     float128 z;
                    962: 
                    963:     z.low = zSig1;
                    964:     z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0;
                    965:     return z;
                    966: 
                    967: }
                    968: 
                    969: /*
                    970: -------------------------------------------------------------------------------
                    971: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                    972: and extended significand formed by the concatenation of `zSig0', `zSig1',
                    973: and `zSig2', and returns the proper quadruple-precision floating-point value
                    974: corresponding to the abstract input.  Ordinarily, the abstract value is
                    975: simply rounded and packed into the quadruple-precision format, with the
                    976: inexact exception raised if the abstract input cannot be represented
                    977: exactly.  However, if the abstract value is too large, the overflow and
                    978: inexact exceptions are raised and an infinity or maximal finite value is
                    979: returned.  If the abstract value is too small, the input value is rounded to
                    980: a subnormal number, and the underflow and inexact exceptions are raised if
                    981: the abstract input cannot be represented exactly as a subnormal quadruple-
                    982: precision floating-point number.
                    983:     The input significand must be normalized or smaller.  If the input
                    984: significand is not normalized, `zExp' must be 0; in that case, the result
                    985: returned is a subnormal number, and it must not require rounding.  In the
                    986: usual case that the input significand is normalized, `zExp' must be 1 less
                    987: than the ``true'' floating-point exponent.  The handling of underflow and
                    988: overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                    989: -------------------------------------------------------------------------------
                    990: */
                    991: static float128
                    992:  roundAndPackFloat128(
                    993:      flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 )
                    994: {
                    995:     int8 roundingMode;
                    996:     flag roundNearestEven, increment, isTiny;
                    997: 
                    998:     roundingMode = float_rounding_mode();
                    999:     roundNearestEven = ( roundingMode == float_round_nearest_even );
                   1000:     increment = ( (sbits64) zSig2 < 0 );
                   1001:     if ( ! roundNearestEven ) {
                   1002:         if ( roundingMode == float_round_to_zero ) {
                   1003:             increment = 0;
                   1004:         }
                   1005:         else {
                   1006:             if ( zSign ) {
                   1007:                 increment = ( roundingMode == float_round_down ) && zSig2;
                   1008:             }
                   1009:             else {
                   1010:                 increment = ( roundingMode == float_round_up ) && zSig2;
                   1011:             }
                   1012:         }
                   1013:     }
                   1014:     if ( 0x7FFD <= (bits32) zExp ) {
                   1015:         if (    ( 0x7FFD < zExp )
                   1016:              || (    ( zExp == 0x7FFD )
                   1017:                   && eq128(
                   1018:                          LIT64( 0x0001FFFFFFFFFFFF ),
                   1019:                          LIT64( 0xFFFFFFFFFFFFFFFF ),
                   1020:                          zSig0,
                   1021:                          zSig1
                   1022:                      )
                   1023:                   && increment
                   1024:                 )
                   1025:            ) {
                   1026:             float_raise( float_flag_overflow | float_flag_inexact );
                   1027:             if (    ( roundingMode == float_round_to_zero )
                   1028:                  || ( zSign && ( roundingMode == float_round_up ) )
                   1029:                  || ( ! zSign && ( roundingMode == float_round_down ) )
                   1030:                ) {
                   1031:                 return
                   1032:                     packFloat128(
                   1033:                         zSign,
                   1034:                         0x7FFE,
                   1035:                         LIT64( 0x0000FFFFFFFFFFFF ),
                   1036:                         LIT64( 0xFFFFFFFFFFFFFFFF )
                   1037:                     );
                   1038:             }
                   1039:             return packFloat128( zSign, 0x7FFF, 0, 0 );
                   1040:         }
                   1041:         if ( zExp < 0 ) {
                   1042:             isTiny =
                   1043:                    ( float_detect_tininess == float_tininess_before_rounding )
                   1044:                 || ( zExp < -1 )
                   1045:                 || ! increment
                   1046:                 || lt128(
                   1047:                        zSig0,
                   1048:                        zSig1,
                   1049:                        LIT64( 0x0001FFFFFFFFFFFF ),
                   1050:                        LIT64( 0xFFFFFFFFFFFFFFFF )
                   1051:                    );
                   1052:             shift128ExtraRightJamming(
                   1053:                 zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 );
                   1054:             zExp = 0;
                   1055:             if ( isTiny && zSig2 ) float_raise( float_flag_underflow );
                   1056:             if ( roundNearestEven ) {
                   1057:                 increment = ( (sbits64) zSig2 < 0 );
                   1058:             }
                   1059:             else {
                   1060:                 if ( zSign ) {
                   1061:                     increment = ( roundingMode == float_round_down ) && zSig2;
                   1062:                 }
                   1063:                 else {
                   1064:                     increment = ( roundingMode == float_round_up ) && zSig2;
                   1065:                 }
                   1066:             }
                   1067:         }
                   1068:     }
                   1069:     if ( zSig2 ) float_set_inexact();
                   1070:     if ( increment ) {
                   1071:         add128( zSig0, zSig1, 0, 1, &zSig0, &zSig1 );
                   1072:         zSig1 &= ~ ( ( zSig2 + zSig2 == 0 ) & roundNearestEven );
                   1073:     }
                   1074:     else {
                   1075:         if ( ( zSig0 | zSig1 ) == 0 ) zExp = 0;
                   1076:     }
                   1077:     return packFloat128( zSign, zExp, zSig0, zSig1 );
                   1078: 
                   1079: }
                   1080: 
                   1081: /*
                   1082: -------------------------------------------------------------------------------
                   1083: Takes an abstract floating-point value having sign `zSign', exponent `zExp',
                   1084: and significand formed by the concatenation of `zSig0' and `zSig1', and
                   1085: returns the proper quadruple-precision floating-point value corresponding
                   1086: to the abstract input.  This routine is just like `roundAndPackFloat128'
                   1087: except that the input significand has fewer bits and does not have to be
                   1088: normalized.  In all cases, `zExp' must be 1 less than the ``true'' floating-
                   1089: point exponent.
                   1090: -------------------------------------------------------------------------------
                   1091: */
                   1092: static float128
                   1093:  normalizeRoundAndPackFloat128(
                   1094:      flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
                   1095: {
                   1096:     int8 shiftCount;
                   1097:     bits64 zSig2;
                   1098: 
                   1099:     if ( zSig0 == 0 ) {
                   1100:         zSig0 = zSig1;
                   1101:         zSig1 = 0;
                   1102:         zExp -= 64;
                   1103:     }
                   1104:     shiftCount = countLeadingZeros64( zSig0 ) - 15;
                   1105:     if ( 0 <= shiftCount ) {
                   1106:         zSig2 = 0;
                   1107:         shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
                   1108:     }
                   1109:     else {
                   1110:         shift128ExtraRightJamming(
                   1111:             zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 );
                   1112:     }
                   1113:     zExp -= shiftCount;
                   1114:     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
                   1115: 
                   1116: }
                   1117: 
                   1118: #endif
                   1119: 
                   1120: /*
                   1121: -------------------------------------------------------------------------------
                   1122: Returns the result of converting the 32-bit two's complement integer `a'
                   1123: to the single-precision floating-point format.  The conversion is performed
                   1124: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1125: -------------------------------------------------------------------------------
                   1126: */
                   1127: float32 int32_to_float32( int32 a )
                   1128: {
                   1129:     flag zSign;
                   1130: 
                   1131:     if ( a == 0 ) return 0;
                   1132:     if ( a == (sbits32) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
                   1133:     zSign = ( a < 0 );
                   1134:     return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a );
                   1135: 
                   1136: }
                   1137: 
                   1138: /*
                   1139: -------------------------------------------------------------------------------
                   1140: Returns the result of converting the 32-bit two's complement integer `a'
                   1141: to the double-precision floating-point format.  The conversion is performed
                   1142: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1143: -------------------------------------------------------------------------------
                   1144: */
                   1145: float64 int32_to_float64( int32 a )
                   1146: {
                   1147:     flag zSign;
                   1148:     uint32 absA;
                   1149:     int8 shiftCount;
                   1150:     bits64 zSig;
                   1151: 
                   1152:     if ( a == 0 ) return 0;
                   1153:     zSign = ( a < 0 );
                   1154:     absA = zSign ? - a : a;
                   1155:     shiftCount = countLeadingZeros32( absA ) + 21;
                   1156:     zSig = absA;
                   1157:     return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );
                   1158: 
                   1159: }
                   1160: 
                   1161: #ifdef FLOATX80
                   1162: 
                   1163: /*
                   1164: -------------------------------------------------------------------------------
                   1165: Returns the result of converting the 32-bit two's complement integer `a'
                   1166: to the extended double-precision floating-point format.  The conversion
                   1167: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1168: Arithmetic.
                   1169: -------------------------------------------------------------------------------
                   1170: */
                   1171: floatx80 int32_to_floatx80( int32 a )
                   1172: {
                   1173:     flag zSign;
                   1174:     uint32 absA;
                   1175:     int8 shiftCount;
                   1176:     bits64 zSig;
                   1177: 
                   1178:     if ( a == 0 ) return packFloatx80( 0, 0, 0 );
                   1179:     zSign = ( a < 0 );
                   1180:     absA = zSign ? - a : a;
                   1181:     shiftCount = countLeadingZeros32( absA ) + 32;
                   1182:     zSig = absA;
                   1183:     return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
                   1184: 
                   1185: }
                   1186: 
                   1187: #endif
                   1188: 
                   1189: #ifdef FLOAT128
                   1190: 
                   1191: /*
                   1192: -------------------------------------------------------------------------------
                   1193: Returns the result of converting the 32-bit two's complement integer `a' to
                   1194: the quadruple-precision floating-point format.  The conversion is performed
                   1195: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1196: -------------------------------------------------------------------------------
                   1197: */
                   1198: float128 int32_to_float128( int32 a )
                   1199: {
                   1200:     flag zSign;
                   1201:     uint32 absA;
                   1202:     int8 shiftCount;
                   1203:     bits64 zSig0;
                   1204: 
                   1205:     if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
                   1206:     zSign = ( a < 0 );
                   1207:     absA = zSign ? - a : a;
                   1208:     shiftCount = countLeadingZeros32( absA ) + 17;
                   1209:     zSig0 = absA;
                   1210:     return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );
                   1211: 
                   1212: }
                   1213: 
                   1214: #endif
                   1215: 
                   1216: #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */
                   1217: /*
                   1218: -------------------------------------------------------------------------------
                   1219: Returns the result of converting the 64-bit two's complement integer `a'
                   1220: to the single-precision floating-point format.  The conversion is performed
                   1221: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1222: -------------------------------------------------------------------------------
                   1223: */
                   1224: float32 int64_to_float32( int64 a )
                   1225: {
                   1226:     flag zSign;
                   1227:     uint64 absA;
                   1228:     int8 shiftCount;
                   1229: 
                   1230:     if ( a == 0 ) return 0;
                   1231:     zSign = ( a < 0 );
                   1232:     absA = zSign ? - a : a;
                   1233:     shiftCount = countLeadingZeros64( absA ) - 40;
                   1234:     if ( 0 <= shiftCount ) {
                   1235:         return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );
                   1236:     }
                   1237:     else {
                   1238:         shiftCount += 7;
                   1239:         if ( shiftCount < 0 ) {
                   1240:             shift64RightJamming( absA, - shiftCount, &absA );
                   1241:         }
                   1242:         else {
                   1243:             absA <<= shiftCount;
                   1244:         }
                   1245:         return roundAndPackFloat32( zSign, 0x9C - shiftCount, absA );
                   1246:     }
                   1247: 
                   1248: }
                   1249: 
                   1250: /*
                   1251: -------------------------------------------------------------------------------
                   1252: Returns the result of converting the 64-bit two's complement integer `a'
                   1253: to the double-precision floating-point format.  The conversion is performed
                   1254: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1255: -------------------------------------------------------------------------------
                   1256: */
                   1257: float64 int64_to_float64( int64 a )
                   1258: {
                   1259:     flag zSign;
                   1260: 
                   1261:     if ( a == 0 ) return 0;
                   1262:     if ( a == (sbits64) LIT64( 0x8000000000000000 ) ) {
                   1263:         return packFloat64( 1, 0x43E, 0 );
                   1264:     }
                   1265:     zSign = ( a < 0 );
                   1266:     return normalizeRoundAndPackFloat64( zSign, 0x43C, zSign ? - a : a );
                   1267: 
                   1268: }
                   1269: 
                   1270: #ifdef FLOATX80
                   1271: 
                   1272: /*
                   1273: -------------------------------------------------------------------------------
                   1274: Returns the result of converting the 64-bit two's complement integer `a'
                   1275: to the extended double-precision floating-point format.  The conversion
                   1276: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1277: Arithmetic.
                   1278: -------------------------------------------------------------------------------
                   1279: */
                   1280: floatx80 int64_to_floatx80( int64 a )
                   1281: {
                   1282:     flag zSign;
                   1283:     uint64 absA;
                   1284:     int8 shiftCount;
                   1285: 
                   1286:     if ( a == 0 ) return packFloatx80( 0, 0, 0 );
                   1287:     zSign = ( a < 0 );
                   1288:     absA = zSign ? - a : a;
                   1289:     shiftCount = countLeadingZeros64( absA );
                   1290:     return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );
                   1291: 
                   1292: }
                   1293: 
                   1294: #endif
                   1295: 
                   1296: #ifdef FLOAT128
                   1297: 
                   1298: /*
                   1299: -------------------------------------------------------------------------------
                   1300: Returns the result of converting the 64-bit two's complement integer `a' to
                   1301: the quadruple-precision floating-point format.  The conversion is performed
                   1302: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1303: -------------------------------------------------------------------------------
                   1304: */
                   1305: float128 int64_to_float128( int64 a )
                   1306: {
                   1307:     flag zSign;
                   1308:     uint64 absA;
                   1309:     int8 shiftCount;
                   1310:     int32 zExp;
                   1311:     bits64 zSig0, zSig1;
                   1312: 
                   1313:     if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
                   1314:     zSign = ( a < 0 );
                   1315:     absA = zSign ? - a : a;
                   1316:     shiftCount = countLeadingZeros64( absA ) + 49;
                   1317:     zExp = 0x406E - shiftCount;
                   1318:     if ( 64 <= shiftCount ) {
                   1319:         zSig1 = 0;
                   1320:         zSig0 = absA;
                   1321:         shiftCount -= 64;
                   1322:     }
                   1323:     else {
                   1324:         zSig1 = absA;
                   1325:         zSig0 = 0;
                   1326:     }
                   1327:     shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
                   1328:     return packFloat128( zSign, zExp, zSig0, zSig1 );
                   1329: 
                   1330: }
                   1331: 
                   1332: #endif
                   1333: #endif /* !SOFTFLOAT_FOR_GCC */
                   1334: 
                   1335: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   1336: /*
                   1337: -------------------------------------------------------------------------------
                   1338: Returns the result of converting the single-precision floating-point value
                   1339: `a' to the 32-bit two's complement integer format.  The conversion is
                   1340: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1341: Arithmetic---which means in particular that the conversion is rounded
                   1342: according to the current rounding mode.  If `a' is a NaN, the largest
                   1343: positive integer is returned.  Otherwise, if the conversion overflows, the
                   1344: largest integer with the same sign as `a' is returned.
                   1345: -------------------------------------------------------------------------------
                   1346: */
                   1347: int32 float32_to_int32( float32 a )
                   1348: {
                   1349:     flag aSign;
                   1350:     int16 aExp, shiftCount;
                   1351:     bits32 aSig;
                   1352:     bits64 aSig64;
                   1353: 
                   1354:     aSig = extractFloat32Frac( a );
                   1355:     aExp = extractFloat32Exp( a );
                   1356:     aSign = extractFloat32Sign( a );
                   1357:     if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
                   1358:     if ( aExp ) aSig |= 0x00800000;
                   1359:     shiftCount = 0xAF - aExp;
                   1360:     aSig64 = aSig;
                   1361:     aSig64 <<= 32;
                   1362:     if ( 0 < shiftCount ) shift64RightJamming( aSig64, shiftCount, &aSig64 );
                   1363:     return roundAndPackInt32( aSign, aSig64 );
                   1364: 
                   1365: }
                   1366: #endif /* !SOFTFLOAT_FOR_GCC */
                   1367: 
                   1368: /*
                   1369: -------------------------------------------------------------------------------
                   1370: Returns the result of converting the single-precision floating-point value
                   1371: `a' to the 32-bit two's complement integer format.  The conversion is
                   1372: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1373: Arithmetic, except that the conversion is always rounded toward zero.
                   1374: If `a' is a NaN, the largest positive integer is returned.  Otherwise, if
                   1375: the conversion overflows, the largest integer with the same sign as `a' is
                   1376: returned.
                   1377: -------------------------------------------------------------------------------
                   1378: */
                   1379: int32 float32_to_int32_round_to_zero( float32 a )
                   1380: {
                   1381:     flag aSign;
                   1382:     int16 aExp, shiftCount;
                   1383:     bits32 aSig;
                   1384:     int32 z;
                   1385: 
                   1386:     aSig = extractFloat32Frac( a );
                   1387:     aExp = extractFloat32Exp( a );
                   1388:     aSign = extractFloat32Sign( a );
                   1389:     shiftCount = aExp - 0x9E;
                   1390:     if ( 0 <= shiftCount ) {
                   1391:         if ( a != 0xCF000000 ) {
                   1392:             float_raise( float_flag_invalid );
                   1393:             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
                   1394:         }
                   1395:         return (sbits32) 0x80000000;
                   1396:     }
                   1397:     else if ( aExp <= 0x7E ) {
                   1398:         if ( aExp | aSig ) float_set_inexact();
                   1399:         return 0;
                   1400:     }
                   1401:     aSig = ( aSig | 0x00800000 )<<8;
                   1402:     z = aSig>>( - shiftCount );
                   1403:     if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {
                   1404:         float_set_inexact();
                   1405:     }
                   1406:     if ( aSign ) z = - z;
                   1407:     return z;
                   1408: 
                   1409: }
                   1410: 
                   1411: #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */
                   1412: /*
                   1413: -------------------------------------------------------------------------------
                   1414: Returns the result of converting the single-precision floating-point value
                   1415: `a' to the 64-bit two's complement integer format.  The conversion is
                   1416: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1417: Arithmetic---which means in particular that the conversion is rounded
                   1418: according to the current rounding mode.  If `a' is a NaN, the largest
                   1419: positive integer is returned.  Otherwise, if the conversion overflows, the
                   1420: largest integer with the same sign as `a' is returned.
                   1421: -------------------------------------------------------------------------------
                   1422: */
                   1423: int64 float32_to_int64( float32 a )
                   1424: {
                   1425:     flag aSign;
                   1426:     int16 aExp, shiftCount;
                   1427:     bits32 aSig;
                   1428:     bits64 aSig64, aSigExtra;
                   1429: 
                   1430:     aSig = extractFloat32Frac( a );
                   1431:     aExp = extractFloat32Exp( a );
                   1432:     aSign = extractFloat32Sign( a );
                   1433:     shiftCount = 0xBE - aExp;
                   1434:     if ( shiftCount < 0 ) {
                   1435:         float_raise( float_flag_invalid );
                   1436:         if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
                   1437:             return LIT64( 0x7FFFFFFFFFFFFFFF );
                   1438:         }
                   1439:         return (sbits64) LIT64( 0x8000000000000000 );
                   1440:     }
                   1441:     if ( aExp ) aSig |= 0x00800000;
                   1442:     aSig64 = aSig;
                   1443:     aSig64 <<= 40;
                   1444:     shift64ExtraRightJamming( aSig64, 0, shiftCount, &aSig64, &aSigExtra );
                   1445:     return roundAndPackInt64( aSign, aSig64, aSigExtra );
                   1446: 
                   1447: }
                   1448: 
                   1449: /*
                   1450: -------------------------------------------------------------------------------
                   1451: Returns the result of converting the single-precision floating-point value
                   1452: `a' to the 64-bit two's complement integer format.  The conversion is
                   1453: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1454: Arithmetic, except that the conversion is always rounded toward zero.  If
                   1455: `a' is a NaN, the largest positive integer is returned.  Otherwise, if the
                   1456: conversion overflows, the largest integer with the same sign as `a' is
                   1457: returned.
                   1458: -------------------------------------------------------------------------------
                   1459: */
                   1460: int64 float32_to_int64_round_to_zero( float32 a )
                   1461: {
                   1462:     flag aSign;
                   1463:     int16 aExp, shiftCount;
                   1464:     bits32 aSig;
                   1465:     bits64 aSig64;
                   1466:     int64 z;
                   1467: 
                   1468:     aSig = extractFloat32Frac( a );
                   1469:     aExp = extractFloat32Exp( a );
                   1470:     aSign = extractFloat32Sign( a );
                   1471:     shiftCount = aExp - 0xBE;
                   1472:     if ( 0 <= shiftCount ) {
                   1473:         if ( a != 0xDF000000 ) {
                   1474:             float_raise( float_flag_invalid );
                   1475:             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
                   1476:                 return LIT64( 0x7FFFFFFFFFFFFFFF );
                   1477:             }
                   1478:         }
                   1479:         return (sbits64) LIT64( 0x8000000000000000 );
                   1480:     }
                   1481:     else if ( aExp <= 0x7E ) {
                   1482:         if ( aExp | aSig ) float_set_inexact();
                   1483:         return 0;
                   1484:     }
                   1485:     aSig64 = aSig | 0x00800000;
                   1486:     aSig64 <<= 40;
                   1487:     z = aSig64>>( - shiftCount );
                   1488:     if ( (bits64) ( aSig64<<( shiftCount & 63 ) ) ) {
                   1489:         float_set_inexact();
                   1490:     }
                   1491:     if ( aSign ) z = - z;
                   1492:     return z;
                   1493: 
                   1494: }
                   1495: #endif /* !SOFTFLOAT_FOR_GCC */
                   1496: 
                   1497: /*
                   1498: -------------------------------------------------------------------------------
                   1499: Returns the result of converting the single-precision floating-point value
                   1500: `a' to the double-precision floating-point format.  The conversion is
                   1501: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1502: Arithmetic.
                   1503: -------------------------------------------------------------------------------
                   1504: */
                   1505: float64 float32_to_float64( float32 a )
                   1506: {
                   1507:     flag aSign;
                   1508:     int16 aExp;
                   1509:     bits32 aSig;
                   1510: 
                   1511:     aSig = extractFloat32Frac( a );
                   1512:     aExp = extractFloat32Exp( a );
                   1513:     aSign = extractFloat32Sign( a );
                   1514:     if ( aExp == 0xFF ) {
                   1515:         if ( aSig ) return commonNaNToFloat64( float32ToCommonNaN( a ) );
                   1516:         return packFloat64( aSign, 0x7FF, 0 );
                   1517:     }
                   1518:     if ( aExp == 0 ) {
                   1519:         if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
                   1520:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   1521:         --aExp;
                   1522:     }
                   1523:     return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
                   1524: 
                   1525: }
                   1526: 
                   1527: #ifdef FLOATX80
                   1528: 
                   1529: /*
                   1530: -------------------------------------------------------------------------------
                   1531: Returns the result of converting the single-precision floating-point value
                   1532: `a' to the extended double-precision floating-point format.  The conversion
                   1533: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1534: Arithmetic.
                   1535: -------------------------------------------------------------------------------
                   1536: */
                   1537: floatx80 float32_to_floatx80( float32 a )
                   1538: {
                   1539:     flag aSign;
                   1540:     int16 aExp;
                   1541:     bits32 aSig;
                   1542: 
                   1543:     aSig = extractFloat32Frac( a );
                   1544:     aExp = extractFloat32Exp( a );
                   1545:     aSign = extractFloat32Sign( a );
                   1546:     if ( aExp == 0xFF ) {
                   1547:         if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a ) );
                   1548:         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   1549:     }
                   1550:     if ( aExp == 0 ) {
                   1551:         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
                   1552:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   1553:     }
                   1554:     aSig |= 0x00800000;
                   1555:     return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
                   1556: 
                   1557: }
                   1558: 
                   1559: #endif
                   1560: 
                   1561: #ifdef FLOAT128
                   1562: 
                   1563: /*
                   1564: -------------------------------------------------------------------------------
                   1565: Returns the result of converting the single-precision floating-point value
                   1566: `a' to the double-precision floating-point format.  The conversion is
                   1567: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   1568: Arithmetic.
                   1569: -------------------------------------------------------------------------------
                   1570: */
                   1571: float128 float32_to_float128( float32 a )
                   1572: {
                   1573:     flag aSign;
                   1574:     int16 aExp;
                   1575:     bits32 aSig;
                   1576: 
                   1577:     aSig = extractFloat32Frac( a );
                   1578:     aExp = extractFloat32Exp( a );
                   1579:     aSign = extractFloat32Sign( a );
                   1580:     if ( aExp == 0xFF ) {
                   1581:         if ( aSig ) return commonNaNToFloat128( float32ToCommonNaN( a ) );
                   1582:         return packFloat128( aSign, 0x7FFF, 0, 0 );
                   1583:     }
                   1584:     if ( aExp == 0 ) {
                   1585:         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
                   1586:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   1587:         --aExp;
                   1588:     }
                   1589:     return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
                   1590: 
                   1591: }
                   1592: 
                   1593: #endif
                   1594: 
                   1595: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   1596: /*
                   1597: -------------------------------------------------------------------------------
                   1598: Rounds the single-precision floating-point value `a' to an integer, and
                   1599: returns the result as a single-precision floating-point value.  The
                   1600: operation is performed according to the IEC/IEEE Standard for Binary
                   1601: Floating-Point Arithmetic.
                   1602: -------------------------------------------------------------------------------
                   1603: */
                   1604: float32 float32_round_to_int( float32 a )
                   1605: {
                   1606:     flag aSign;
                   1607:     int16 aExp;
                   1608:     bits32 lastBitMask, roundBitsMask;
                   1609:     int8 roundingMode;
                   1610:     float32 z;
                   1611: 
                   1612:     aExp = extractFloat32Exp( a );
                   1613:     if ( 0x96 <= aExp ) {
                   1614:         if ( ( aExp == 0xFF ) && extractFloat32Frac( a ) ) {
                   1615:             return propagateFloat32NaN( a, a );
                   1616:         }
                   1617:         return a;
                   1618:     }
                   1619:     if ( aExp <= 0x7E ) {
                   1620:         if ( (bits32) ( a<<1 ) == 0 ) return a;
                   1621:         float_set_inexact();
                   1622:         aSign = extractFloat32Sign( a );
                   1623:         switch ( float_rounding_mode() ) {
                   1624:          case float_round_nearest_even:
                   1625:             if ( ( aExp == 0x7E ) && extractFloat32Frac( a ) ) {
                   1626:                 return packFloat32( aSign, 0x7F, 0 );
                   1627:             }
                   1628:             break;
                   1629:          case float_round_down:
                   1630:             return aSign ? 0xBF800000 : 0;
                   1631:          case float_round_up:
                   1632:             return aSign ? 0x80000000 : 0x3F800000;
                   1633:         }
                   1634:         return packFloat32( aSign, 0, 0 );
                   1635:     }
                   1636:     lastBitMask = 1;
                   1637:     lastBitMask <<= 0x96 - aExp;
                   1638:     roundBitsMask = lastBitMask - 1;
                   1639:     z = a;
                   1640:     roundingMode = float_rounding_mode();
                   1641:     if ( roundingMode == float_round_nearest_even ) {
                   1642:         z += lastBitMask>>1;
                   1643:         if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask;
                   1644:     }
                   1645:     else if ( roundingMode != float_round_to_zero ) {
                   1646:         if ( extractFloat32Sign( z ) ^ ( roundingMode == float_round_up ) ) {
                   1647:             z += roundBitsMask;
                   1648:         }
                   1649:     }
                   1650:     z &= ~ roundBitsMask;
                   1651:     if ( z != a ) float_set_inexact();
                   1652:     return z;
                   1653: 
                   1654: }
                   1655: #endif /* !SOFTFLOAT_FOR_GCC */
                   1656: 
                   1657: /*
                   1658: -------------------------------------------------------------------------------
                   1659: Returns the result of adding the absolute values of the single-precision
                   1660: floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated
                   1661: before being returned.  `zSign' is ignored if the result is a NaN.
                   1662: The addition is performed according to the IEC/IEEE Standard for Binary
                   1663: Floating-Point Arithmetic.
                   1664: -------------------------------------------------------------------------------
                   1665: */
                   1666: static float32 addFloat32Sigs( float32 a, float32 b, flag zSign )
                   1667: {
                   1668:     int16 aExp, bExp, zExp;
                   1669:     bits32 aSig, bSig, zSig;
                   1670:     int16 expDiff;
                   1671: 
                   1672:     aSig = extractFloat32Frac( a );
                   1673:     aExp = extractFloat32Exp( a );
                   1674:     bSig = extractFloat32Frac( b );
                   1675:     bExp = extractFloat32Exp( b );
                   1676:     expDiff = aExp - bExp;
                   1677:     aSig <<= 6;
                   1678:     bSig <<= 6;
                   1679:     if ( 0 < expDiff ) {
                   1680:         if ( aExp == 0xFF ) {
                   1681:             if ( aSig ) return propagateFloat32NaN( a, b );
                   1682:             return a;
                   1683:         }
                   1684:         if ( bExp == 0 ) {
                   1685:             --expDiff;
                   1686:         }
                   1687:         else {
                   1688:             bSig |= 0x20000000;
                   1689:         }
                   1690:         shift32RightJamming( bSig, expDiff, &bSig );
                   1691:         zExp = aExp;
                   1692:     }
                   1693:     else if ( expDiff < 0 ) {
                   1694:         if ( bExp == 0xFF ) {
                   1695:             if ( bSig ) return propagateFloat32NaN( a, b );
                   1696:             return packFloat32( zSign, 0xFF, 0 );
                   1697:         }
                   1698:         if ( aExp == 0 ) {
                   1699:             ++expDiff;
                   1700:         }
                   1701:         else {
                   1702:             aSig |= 0x20000000;
                   1703:         }
                   1704:         shift32RightJamming( aSig, - expDiff, &aSig );
                   1705:         zExp = bExp;
                   1706:     }
                   1707:     else {
                   1708:         if ( aExp == 0xFF ) {
                   1709:             if ( aSig | bSig ) return propagateFloat32NaN( a, b );
                   1710:             return a;
                   1711:         }
                   1712:         if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
                   1713:         zSig = 0x40000000 + aSig + bSig;
                   1714:         zExp = aExp;
                   1715:         goto roundAndPack;
                   1716:     }
                   1717:     aSig |= 0x20000000;
                   1718:     zSig = ( aSig + bSig )<<1;
                   1719:     --zExp;
                   1720:     if ( (sbits32) zSig < 0 ) {
                   1721:         zSig = aSig + bSig;
                   1722:         ++zExp;
                   1723:     }
                   1724:  roundAndPack:
                   1725:     return roundAndPackFloat32( zSign, zExp, zSig );
                   1726: 
                   1727: }
                   1728: 
                   1729: /*
                   1730: -------------------------------------------------------------------------------
                   1731: Returns the result of subtracting the absolute values of the single-
                   1732: precision floating-point values `a' and `b'.  If `zSign' is 1, the
                   1733: difference is negated before being returned.  `zSign' is ignored if the
                   1734: result is a NaN.  The subtraction is performed according to the IEC/IEEE
                   1735: Standard for Binary Floating-Point Arithmetic.
                   1736: -------------------------------------------------------------------------------
                   1737: */
                   1738: static float32 subFloat32Sigs( float32 a, float32 b, flag zSign )
                   1739: {
                   1740:     int16 aExp, bExp, zExp;
                   1741:     bits32 aSig, bSig, zSig;
                   1742:     int16 expDiff;
                   1743: 
                   1744:     aSig = extractFloat32Frac( a );
                   1745:     aExp = extractFloat32Exp( a );
                   1746:     bSig = extractFloat32Frac( b );
                   1747:     bExp = extractFloat32Exp( b );
                   1748:     expDiff = aExp - bExp;
                   1749:     aSig <<= 7;
                   1750:     bSig <<= 7;
                   1751:     if ( 0 < expDiff ) goto aExpBigger;
                   1752:     if ( expDiff < 0 ) goto bExpBigger;
                   1753:     if ( aExp == 0xFF ) {
                   1754:         if ( aSig | bSig ) return propagateFloat32NaN( a, b );
                   1755:         float_raise( float_flag_invalid );
                   1756:         return float32_default_nan;
                   1757:     }
                   1758:     if ( aExp == 0 ) {
                   1759:         aExp = 1;
                   1760:         bExp = 1;
                   1761:     }
                   1762:     if ( bSig < aSig ) goto aBigger;
                   1763:     if ( aSig < bSig ) goto bBigger;
                   1764:     return packFloat32( float_rounding_mode() == float_round_down, 0, 0 );
                   1765:  bExpBigger:
                   1766:     if ( bExp == 0xFF ) {
                   1767:         if ( bSig ) return propagateFloat32NaN( a, b );
                   1768:         return packFloat32( zSign ^ 1, 0xFF, 0 );
                   1769:     }
                   1770:     if ( aExp == 0 ) {
                   1771:         ++expDiff;
                   1772:     }
                   1773:     else {
                   1774:         aSig |= 0x40000000;
                   1775:     }
                   1776:     shift32RightJamming( aSig, - expDiff, &aSig );
                   1777:     bSig |= 0x40000000;
                   1778:  bBigger:
                   1779:     zSig = bSig - aSig;
                   1780:     zExp = bExp;
                   1781:     zSign ^= 1;
                   1782:     goto normalizeRoundAndPack;
                   1783:  aExpBigger:
                   1784:     if ( aExp == 0xFF ) {
                   1785:         if ( aSig ) return propagateFloat32NaN( a, b );
                   1786:         return a;
                   1787:     }
                   1788:     if ( bExp == 0 ) {
                   1789:         --expDiff;
                   1790:     }
                   1791:     else {
                   1792:         bSig |= 0x40000000;
                   1793:     }
                   1794:     shift32RightJamming( bSig, expDiff, &bSig );
                   1795:     aSig |= 0x40000000;
                   1796:  aBigger:
                   1797:     zSig = aSig - bSig;
                   1798:     zExp = aExp;
                   1799:  normalizeRoundAndPack:
                   1800:     --zExp;
                   1801:     return normalizeRoundAndPackFloat32( zSign, zExp, zSig );
                   1802: 
                   1803: }
                   1804: 
                   1805: /*
                   1806: -------------------------------------------------------------------------------
                   1807: Returns the result of adding the single-precision floating-point values `a'
                   1808: and `b'.  The operation is performed according to the IEC/IEEE Standard for
                   1809: Binary Floating-Point Arithmetic.
                   1810: -------------------------------------------------------------------------------
                   1811: */
                   1812: float32 float32_add( float32 a, float32 b )
                   1813: {
                   1814:     flag aSign, bSign;
                   1815: 
                   1816:     aSign = extractFloat32Sign( a );
                   1817:     bSign = extractFloat32Sign( b );
                   1818:     if ( aSign == bSign ) {
                   1819:         return addFloat32Sigs( a, b, aSign );
                   1820:     }
                   1821:     else {
                   1822:         return subFloat32Sigs( a, b, aSign );
                   1823:     }
                   1824: 
                   1825: }
                   1826: 
                   1827: /*
                   1828: -------------------------------------------------------------------------------
                   1829: Returns the result of subtracting the single-precision floating-point values
                   1830: `a' and `b'.  The operation is performed according to the IEC/IEEE Standard
                   1831: for Binary Floating-Point Arithmetic.
                   1832: -------------------------------------------------------------------------------
                   1833: */
                   1834: float32 float32_sub( float32 a, float32 b )
                   1835: {
                   1836:     flag aSign, bSign;
                   1837: 
                   1838:     aSign = extractFloat32Sign( a );
                   1839:     bSign = extractFloat32Sign( b );
                   1840:     if ( aSign == bSign ) {
                   1841:         return subFloat32Sigs( a, b, aSign );
                   1842:     }
                   1843:     else {
                   1844:         return addFloat32Sigs( a, b, aSign );
                   1845:     }
                   1846: 
                   1847: }
                   1848: 
                   1849: /*
                   1850: -------------------------------------------------------------------------------
                   1851: Returns the result of multiplying the single-precision floating-point values
                   1852: `a' and `b'.  The operation is performed according to the IEC/IEEE Standard
                   1853: for Binary Floating-Point Arithmetic.
                   1854: -------------------------------------------------------------------------------
                   1855: */
                   1856: float32 float32_mul( float32 a, float32 b )
                   1857: {
                   1858:     flag aSign, bSign, zSign;
                   1859:     int16 aExp, bExp, zExp;
                   1860:     bits32 aSig, bSig;
                   1861:     bits64 zSig64;
                   1862:     bits32 zSig;
                   1863: 
                   1864:     aSig = extractFloat32Frac( a );
                   1865:     aExp = extractFloat32Exp( a );
                   1866:     aSign = extractFloat32Sign( a );
                   1867:     bSig = extractFloat32Frac( b );
                   1868:     bExp = extractFloat32Exp( b );
                   1869:     bSign = extractFloat32Sign( b );
                   1870:     zSign = aSign ^ bSign;
                   1871:     if ( aExp == 0xFF ) {
                   1872:         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
                   1873:             return propagateFloat32NaN( a, b );
                   1874:         }
                   1875:         if ( ( bExp | bSig ) == 0 ) {
                   1876:             float_raise( float_flag_invalid );
                   1877:             return float32_default_nan;
                   1878:         }
                   1879:         return packFloat32( zSign, 0xFF, 0 );
                   1880:     }
                   1881:     if ( bExp == 0xFF ) {
                   1882:         if ( bSig ) return propagateFloat32NaN( a, b );
                   1883:         if ( ( aExp | aSig ) == 0 ) {
                   1884:             float_raise( float_flag_invalid );
                   1885:             return float32_default_nan;
                   1886:         }
                   1887:         return packFloat32( zSign, 0xFF, 0 );
                   1888:     }
                   1889:     if ( aExp == 0 ) {
                   1890:         if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
                   1891:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   1892:     }
                   1893:     if ( bExp == 0 ) {
                   1894:         if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
                   1895:         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
                   1896:     }
                   1897:     zExp = aExp + bExp - 0x7F;
                   1898:     aSig = ( aSig | 0x00800000 )<<7;
                   1899:     bSig = ( bSig | 0x00800000 )<<8;
                   1900:     shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );
                   1901:     zSig = zSig64;
                   1902:     if ( 0 <= (sbits32) ( zSig<<1 ) ) {
                   1903:         zSig <<= 1;
                   1904:         --zExp;
                   1905:     }
                   1906:     return roundAndPackFloat32( zSign, zExp, zSig );
                   1907: 
                   1908: }
                   1909: 
                   1910: /*
                   1911: -------------------------------------------------------------------------------
                   1912: Returns the result of dividing the single-precision floating-point value `a'
                   1913: by the corresponding value `b'.  The operation is performed according to the
                   1914: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1915: -------------------------------------------------------------------------------
                   1916: */
                   1917: float32 float32_div( float32 a, float32 b )
                   1918: {
                   1919:     flag aSign, bSign, zSign;
                   1920:     int16 aExp, bExp, zExp;
                   1921:     bits32 aSig, bSig, zSig;
                   1922: 
                   1923:     aSig = extractFloat32Frac( a );
                   1924:     aExp = extractFloat32Exp( a );
                   1925:     aSign = extractFloat32Sign( a );
                   1926:     bSig = extractFloat32Frac( b );
                   1927:     bExp = extractFloat32Exp( b );
                   1928:     bSign = extractFloat32Sign( b );
                   1929:     zSign = aSign ^ bSign;
                   1930:     if ( aExp == 0xFF ) {
                   1931:         if ( aSig ) return propagateFloat32NaN( a, b );
                   1932:         if ( bExp == 0xFF ) {
                   1933:             if ( bSig ) return propagateFloat32NaN( a, b );
                   1934:             float_raise( float_flag_invalid );
                   1935:             return float32_default_nan;
                   1936:         }
                   1937:         return packFloat32( zSign, 0xFF, 0 );
                   1938:     }
                   1939:     if ( bExp == 0xFF ) {
                   1940:         if ( bSig ) return propagateFloat32NaN( a, b );
                   1941:         return packFloat32( zSign, 0, 0 );
                   1942:     }
                   1943:     if ( bExp == 0 ) {
                   1944:         if ( bSig == 0 ) {
                   1945:             if ( ( aExp | aSig ) == 0 ) {
                   1946:                 float_raise( float_flag_invalid );
                   1947:                 return float32_default_nan;
                   1948:             }
                   1949:             float_raise( float_flag_divbyzero );
                   1950:             return packFloat32( zSign, 0xFF, 0 );
                   1951:         }
                   1952:         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
                   1953:     }
                   1954:     if ( aExp == 0 ) {
                   1955:         if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
                   1956:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   1957:     }
                   1958:     zExp = aExp - bExp + 0x7D;
                   1959:     aSig = ( aSig | 0x00800000 )<<7;
                   1960:     bSig = ( bSig | 0x00800000 )<<8;
                   1961:     if ( bSig <= ( aSig + aSig ) ) {
                   1962:         aSig >>= 1;
                   1963:         ++zExp;
                   1964:     }
                   1965:     zSig = ( ( (bits64) aSig )<<32 ) / bSig;
                   1966:     if ( ( zSig & 0x3F ) == 0 ) {
                   1967:         zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );
                   1968:     }
                   1969:     return roundAndPackFloat32( zSign, zExp, zSig );
                   1970: 
                   1971: }
                   1972: 
                   1973: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   1974: /*
                   1975: -------------------------------------------------------------------------------
                   1976: Returns the remainder of the single-precision floating-point value `a'
                   1977: with respect to the corresponding value `b'.  The operation is performed
                   1978: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   1979: -------------------------------------------------------------------------------
                   1980: */
                   1981: float32 float32_rem( float32 a, float32 b )
                   1982: {
                   1983:     flag aSign, bSign, zSign;
                   1984:     int16 aExp, bExp, expDiff;
                   1985:     bits32 aSig, bSig;
                   1986:     bits32 q;
                   1987:     bits64 aSig64, bSig64, q64;
                   1988:     bits32 alternateASig;
                   1989:     sbits32 sigMean;
                   1990: 
                   1991:     aSig = extractFloat32Frac( a );
                   1992:     aExp = extractFloat32Exp( a );
                   1993:     aSign = extractFloat32Sign( a );
                   1994:     bSig = extractFloat32Frac( b );
                   1995:     bExp = extractFloat32Exp( b );
                   1996:     bSign = extractFloat32Sign( b );
                   1997:     if ( aExp == 0xFF ) {
                   1998:         if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {
                   1999:             return propagateFloat32NaN( a, b );
                   2000:         }
                   2001:         float_raise( float_flag_invalid );
                   2002:         return float32_default_nan;
                   2003:     }
                   2004:     if ( bExp == 0xFF ) {
                   2005:         if ( bSig ) return propagateFloat32NaN( a, b );
                   2006:         return a;
                   2007:     }
                   2008:     if ( bExp == 0 ) {
                   2009:         if ( bSig == 0 ) {
                   2010:             float_raise( float_flag_invalid );
                   2011:             return float32_default_nan;
                   2012:         }
                   2013:         normalizeFloat32Subnormal( bSig, &bExp, &bSig );
                   2014:     }
                   2015:     if ( aExp == 0 ) {
                   2016:         if ( aSig == 0 ) return a;
                   2017:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   2018:     }
                   2019:     expDiff = aExp - bExp;
                   2020:     aSig |= 0x00800000;
                   2021:     bSig |= 0x00800000;
                   2022:     if ( expDiff < 32 ) {
                   2023:         aSig <<= 8;
                   2024:         bSig <<= 8;
                   2025:         if ( expDiff < 0 ) {
                   2026:             if ( expDiff < -1 ) return a;
                   2027:             aSig >>= 1;
                   2028:         }
                   2029:         q = ( bSig <= aSig );
                   2030:         if ( q ) aSig -= bSig;
                   2031:         if ( 0 < expDiff ) {
                   2032:             q = ( ( (bits64) aSig )<<32 ) / bSig;
                   2033:             q >>= 32 - expDiff;
                   2034:             bSig >>= 2;
                   2035:             aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
                   2036:         }
                   2037:         else {
                   2038:             aSig >>= 2;
                   2039:             bSig >>= 2;
                   2040:         }
                   2041:     }
                   2042:     else {
                   2043:         if ( bSig <= aSig ) aSig -= bSig;
                   2044:         aSig64 = ( (bits64) aSig )<<40;
                   2045:         bSig64 = ( (bits64) bSig )<<40;
                   2046:         expDiff -= 64;
                   2047:         while ( 0 < expDiff ) {
                   2048:             q64 = estimateDiv128To64( aSig64, 0, bSig64 );
                   2049:             q64 = ( 2 < q64 ) ? q64 - 2 : 0;
                   2050:             aSig64 = - ( ( bSig * q64 )<<38 );
                   2051:             expDiff -= 62;
                   2052:         }
                   2053:         expDiff += 64;
                   2054:         q64 = estimateDiv128To64( aSig64, 0, bSig64 );
                   2055:         q64 = ( 2 < q64 ) ? q64 - 2 : 0;
                   2056:         q = q64>>( 64 - expDiff );
                   2057:         bSig <<= 6;
                   2058:         aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;
                   2059:     }
                   2060:     do {
                   2061:         alternateASig = aSig;
                   2062:         ++q;
                   2063:         aSig -= bSig;
                   2064:     } while ( 0 <= (sbits32) aSig );
                   2065:     sigMean = aSig + alternateASig;
                   2066:     if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {
                   2067:         aSig = alternateASig;
                   2068:     }
                   2069:     zSign = ( (sbits32) aSig < 0 );
                   2070:     if ( zSign ) aSig = - aSig;
                   2071:     return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
                   2072: 
                   2073: }
                   2074: #endif /* !SOFTFLOAT_FOR_GCC */
                   2075: 
                   2076: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   2077: /*
                   2078: -------------------------------------------------------------------------------
                   2079: Returns the square root of the single-precision floating-point value `a'.
                   2080: The operation is performed according to the IEC/IEEE Standard for Binary
                   2081: Floating-Point Arithmetic.
                   2082: -------------------------------------------------------------------------------
                   2083: */
                   2084: float32 float32_sqrt( float32 a )
                   2085: {
                   2086:     flag aSign;
                   2087:     int16 aExp, zExp;
                   2088:     bits32 aSig, zSig;
                   2089:     bits64 rem, term;
                   2090: 
                   2091:     aSig = extractFloat32Frac( a );
                   2092:     aExp = extractFloat32Exp( a );
                   2093:     aSign = extractFloat32Sign( a );
                   2094:     if ( aExp == 0xFF ) {
                   2095:         if ( aSig ) return propagateFloat32NaN( a, 0 );
                   2096:         if ( ! aSign ) return a;
                   2097:         float_raise( float_flag_invalid );
                   2098:         return float32_default_nan;
                   2099:     }
                   2100:     if ( aSign ) {
                   2101:         if ( ( aExp | aSig ) == 0 ) return a;
                   2102:         float_raise( float_flag_invalid );
                   2103:         return float32_default_nan;
                   2104:     }
                   2105:     if ( aExp == 0 ) {
                   2106:         if ( aSig == 0 ) return 0;
                   2107:         normalizeFloat32Subnormal( aSig, &aExp, &aSig );
                   2108:     }
                   2109:     zExp = ( ( aExp - 0x7F )>>1 ) + 0x7E;
                   2110:     aSig = ( aSig | 0x00800000 )<<8;
                   2111:     zSig = estimateSqrt32( aExp, aSig ) + 2;
                   2112:     if ( ( zSig & 0x7F ) <= 5 ) {
                   2113:         if ( zSig < 2 ) {
                   2114:             zSig = 0x7FFFFFFF;
                   2115:             goto roundAndPack;
                   2116:         }
                   2117:         aSig >>= aExp & 1;
                   2118:         term = ( (bits64) zSig ) * zSig;
                   2119:         rem = ( ( (bits64) aSig )<<32 ) - term;
                   2120:         while ( (sbits64) rem < 0 ) {
                   2121:             --zSig;
                   2122:             rem += ( ( (bits64) zSig )<<1 ) | 1;
                   2123:         }
                   2124:         zSig |= ( rem != 0 );
                   2125:     }
                   2126:     shift32RightJamming( zSig, 1, &zSig );
                   2127:  roundAndPack:
                   2128:     return roundAndPackFloat32( 0, zExp, zSig );
                   2129: 
                   2130: }
                   2131: #endif /* !SOFTFLOAT_FOR_GCC */
                   2132: 
                   2133: /*
                   2134: -------------------------------------------------------------------------------
                   2135: Returns 1 if the single-precision floating-point value `a' is equal to
                   2136: the corresponding value `b', and 0 otherwise.  The comparison is performed
                   2137: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2138: -------------------------------------------------------------------------------
                   2139: */
                   2140: flag float32_eq( float32 a, float32 b )
                   2141: {
                   2142: 
                   2143:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2144:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2145:        ) {
                   2146:         if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
                   2147:             float_raise( float_flag_invalid );
                   2148:         }
                   2149:         return 0;
                   2150:     }
                   2151:     return ( a == b ) || ( (bits32) ( ( a | b )<<1 ) == 0 );
                   2152: 
                   2153: }
                   2154: 
                   2155: /*
                   2156: -------------------------------------------------------------------------------
                   2157: Returns 1 if the single-precision floating-point value `a' is less than
                   2158: or equal to the corresponding value `b', and 0 otherwise.  The comparison
                   2159: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2160: Arithmetic.
                   2161: -------------------------------------------------------------------------------
                   2162: */
                   2163: flag float32_le( float32 a, float32 b )
                   2164: {
                   2165:     flag aSign, bSign;
                   2166: 
                   2167:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2168:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2169:        ) {
                   2170:         float_raise( float_flag_invalid );
                   2171:         return 0;
                   2172:     }
                   2173:     aSign = extractFloat32Sign( a );
                   2174:     bSign = extractFloat32Sign( b );
                   2175:     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
                   2176:     return ( a == b ) || ( aSign ^ ( a < b ) );
                   2177: 
                   2178: }
                   2179: 
                   2180: /*
                   2181: -------------------------------------------------------------------------------
                   2182: Returns 1 if the single-precision floating-point value `a' is less than
                   2183: the corresponding value `b', and 0 otherwise.  The comparison is performed
                   2184: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2185: -------------------------------------------------------------------------------
                   2186: */
                   2187: flag float32_lt( float32 a, float32 b )
                   2188: {
                   2189:     flag aSign, bSign;
                   2190: 
                   2191:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2192:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2193:        ) {
                   2194:         float_raise( float_flag_invalid );
                   2195:         return 0;
                   2196:     }
                   2197:     aSign = extractFloat32Sign( a );
                   2198:     bSign = extractFloat32Sign( b );
                   2199:     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
                   2200:     return ( a != b ) && ( aSign ^ ( a < b ) );
                   2201: 
                   2202: }
                   2203: 
                   2204: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   2205: /*
                   2206: -------------------------------------------------------------------------------
                   2207: Returns 1 if the single-precision floating-point value `a' is equal to
                   2208: the corresponding value `b', and 0 otherwise.  The invalid exception is
                   2209: raised if either operand is a NaN.  Otherwise, the comparison is performed
                   2210: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2211: -------------------------------------------------------------------------------
                   2212: */
                   2213: flag float32_eq_signaling( float32 a, float32 b )
                   2214: {
                   2215: 
                   2216:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2217:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2218:        ) {
                   2219:         float_raise( float_flag_invalid );
                   2220:         return 0;
                   2221:     }
                   2222:     return ( a == b ) || ( (bits32) ( ( a | b )<<1 ) == 0 );
                   2223: 
                   2224: }
                   2225: 
                   2226: /*
                   2227: -------------------------------------------------------------------------------
                   2228: Returns 1 if the single-precision floating-point value `a' is less than or
                   2229: equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not
                   2230: cause an exception.  Otherwise, the comparison is performed according to the
                   2231: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2232: -------------------------------------------------------------------------------
                   2233: */
                   2234: flag float32_le_quiet( float32 a, float32 b )
                   2235: {
                   2236:     flag aSign, bSign;
                   2237: 
                   2238:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2239:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2240:        ) {
                   2241:         if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
                   2242:             float_raise( float_flag_invalid );
                   2243:         }
                   2244:         return 0;
                   2245:     }
                   2246:     aSign = extractFloat32Sign( a );
                   2247:     bSign = extractFloat32Sign( b );
                   2248:     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
                   2249:     return ( a == b ) || ( aSign ^ ( a < b ) );
                   2250: 
                   2251: }
                   2252: 
                   2253: /*
                   2254: -------------------------------------------------------------------------------
                   2255: Returns 1 if the single-precision floating-point value `a' is less than
                   2256: the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an
                   2257: exception.  Otherwise, the comparison is performed according to the IEC/IEEE
                   2258: Standard for Binary Floating-Point Arithmetic.
                   2259: -------------------------------------------------------------------------------
                   2260: */
                   2261: flag float32_lt_quiet( float32 a, float32 b )
                   2262: {
                   2263:     flag aSign, bSign;
                   2264: 
                   2265:     if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
                   2266:          || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
                   2267:        ) {
                   2268:         if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
                   2269:             float_raise( float_flag_invalid );
                   2270:         }
                   2271:         return 0;
                   2272:     }
                   2273:     aSign = extractFloat32Sign( a );
                   2274:     bSign = extractFloat32Sign( b );
                   2275:     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
                   2276:     return ( a != b ) && ( aSign ^ ( a < b ) );
                   2277: 
                   2278: }
                   2279: #endif /* !SOFTFLOAT_FOR_GCC */
                   2280: 
                   2281: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   2282: /*
                   2283: -------------------------------------------------------------------------------
                   2284: Returns the result of converting the double-precision floating-point value
                   2285: `a' to the 32-bit two's complement integer format.  The conversion is
                   2286: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2287: Arithmetic---which means in particular that the conversion is rounded
                   2288: according to the current rounding mode.  If `a' is a NaN, the largest
                   2289: positive integer is returned.  Otherwise, if the conversion overflows, the
                   2290: largest integer with the same sign as `a' is returned.
                   2291: -------------------------------------------------------------------------------
                   2292: */
                   2293: int32 float64_to_int32( float64 a )
                   2294: {
                   2295:     flag aSign;
                   2296:     int16 aExp, shiftCount;
                   2297:     bits64 aSig;
                   2298: 
                   2299:     aSig = extractFloat64Frac( a );
                   2300:     aExp = extractFloat64Exp( a );
                   2301:     aSign = extractFloat64Sign( a );
                   2302:     if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
                   2303:     if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
                   2304:     shiftCount = 0x42C - aExp;
                   2305:     if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
                   2306:     return roundAndPackInt32( aSign, aSig );
                   2307: 
                   2308: }
                   2309: #endif /* !SOFTFLOAT_FOR_GCC */
                   2310: 
                   2311: /*
                   2312: -------------------------------------------------------------------------------
                   2313: Returns the result of converting the double-precision floating-point value
                   2314: `a' to the 32-bit two's complement integer format.  The conversion is
                   2315: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2316: Arithmetic, except that the conversion is always rounded toward zero.
                   2317: If `a' is a NaN, the largest positive integer is returned.  Otherwise, if
                   2318: the conversion overflows, the largest integer with the same sign as `a' is
                   2319: returned.
                   2320: -------------------------------------------------------------------------------
                   2321: */
                   2322: int32 float64_to_int32_round_to_zero( float64 a )
                   2323: {
                   2324:     flag aSign;
                   2325:     int16 aExp, shiftCount;
                   2326:     bits64 aSig, savedASig;
                   2327:     int32 z;
                   2328: 
                   2329:     aSig = extractFloat64Frac( a );
                   2330:     aExp = extractFloat64Exp( a );
                   2331:     aSign = extractFloat64Sign( a );
                   2332:     if ( 0x41E < aExp ) {
                   2333:         if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
                   2334:         goto invalid;
                   2335:     }
                   2336:     else if ( aExp < 0x3FF ) {
                   2337:         if ( aExp || aSig ) float_set_inexact();
                   2338:         return 0;
                   2339:     }
                   2340:     aSig |= LIT64( 0x0010000000000000 );
                   2341:     shiftCount = 0x433 - aExp;
                   2342:     savedASig = aSig;
                   2343:     aSig >>= shiftCount;
                   2344:     z = aSig;
                   2345:     if ( aSign ) z = - z;
                   2346:     if ( ( z < 0 ) ^ aSign ) {
                   2347:  invalid:
                   2348:         float_raise( float_flag_invalid );
                   2349:         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
                   2350:     }
                   2351:     if ( ( aSig<<shiftCount ) != savedASig ) {
                   2352:         float_set_inexact();
                   2353:     }
                   2354:     return z;
                   2355: 
                   2356: }
                   2357: 
                   2358: #ifndef SOFTFLOAT_FOR_GCC /* Not needed */
                   2359: /*
                   2360: -------------------------------------------------------------------------------
                   2361: Returns the result of converting the double-precision floating-point value
                   2362: `a' to the 64-bit two's complement integer format.  The conversion is
                   2363: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2364: Arithmetic---which means in particular that the conversion is rounded
                   2365: according to the current rounding mode.  If `a' is a NaN, the largest
                   2366: positive integer is returned.  Otherwise, if the conversion overflows, the
                   2367: largest integer with the same sign as `a' is returned.
                   2368: -------------------------------------------------------------------------------
                   2369: */
                   2370: int64 float64_to_int64( float64 a )
                   2371: {
                   2372:     flag aSign;
                   2373:     int16 aExp, shiftCount;
                   2374:     bits64 aSig, aSigExtra;
                   2375: 
                   2376:     aSig = extractFloat64Frac( a );
                   2377:     aExp = extractFloat64Exp( a );
                   2378:     aSign = extractFloat64Sign( a );
                   2379:     if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
                   2380:     shiftCount = 0x433 - aExp;
                   2381:     if ( shiftCount <= 0 ) {
                   2382:         if ( 0x43E < aExp ) {
                   2383:             float_raise( float_flag_invalid );
                   2384:             if (    ! aSign
                   2385:                  || (    ( aExp == 0x7FF )
                   2386:                       && ( aSig != LIT64( 0x0010000000000000 ) ) )
                   2387:                ) {
                   2388:                 return LIT64( 0x7FFFFFFFFFFFFFFF );
                   2389:             }
                   2390:             return (sbits64) LIT64( 0x8000000000000000 );
                   2391:         }
                   2392:         aSigExtra = 0;
                   2393:         aSig <<= - shiftCount;
                   2394:     }
                   2395:     else {
                   2396:         shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
                   2397:     }
                   2398:     return roundAndPackInt64( aSign, aSig, aSigExtra );
                   2399: 
                   2400: }
                   2401: 
                   2402: /*
                   2403: -------------------------------------------------------------------------------
                   2404: Returns the result of converting the double-precision floating-point value
                   2405: `a' to the 64-bit two's complement integer format.  The conversion is
                   2406: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2407: Arithmetic, except that the conversion is always rounded toward zero.
                   2408: If `a' is a NaN, the largest positive integer is returned.  Otherwise, if
                   2409: the conversion overflows, the largest integer with the same sign as `a' is
                   2410: returned.
                   2411: -------------------------------------------------------------------------------
                   2412: */
                   2413: int64 float64_to_int64_round_to_zero( float64 a )
                   2414: {
                   2415:     flag aSign;
                   2416:     int16 aExp, shiftCount;
                   2417:     bits64 aSig;
                   2418:     int64 z;
                   2419: 
                   2420:     aSig = extractFloat64Frac( a );
                   2421:     aExp = extractFloat64Exp( a );
                   2422:     aSign = extractFloat64Sign( a );
                   2423:     if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
                   2424:     shiftCount = aExp - 0x433;
                   2425:     if ( 0 <= shiftCount ) {
                   2426:         if ( 0x43E <= aExp ) {
                   2427:             if ( a != LIT64( 0xC3E0000000000000 ) ) {
                   2428:                 float_raise( float_flag_invalid );
                   2429:                 if (    ! aSign
                   2430:                      || (    ( aExp == 0x7FF )
                   2431:                           && ( aSig != LIT64( 0x0010000000000000 ) ) )
                   2432:                    ) {
                   2433:                     return LIT64( 0x7FFFFFFFFFFFFFFF );
                   2434:                 }
                   2435:             }
                   2436:             return (sbits64) LIT64( 0x8000000000000000 );
                   2437:         }
                   2438:         z = aSig<<shiftCount;
                   2439:     }
                   2440:     else {
                   2441:         if ( aExp < 0x3FE ) {
                   2442:             if ( aExp | aSig ) float_set_inexact();
                   2443:             return 0;
                   2444:         }
                   2445:         z = aSig>>( - shiftCount );
                   2446:         if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
                   2447:             float_set_inexact();
                   2448:         }
                   2449:     }
                   2450:     if ( aSign ) z = - z;
                   2451:     return z;
                   2452: 
                   2453: }
                   2454: #endif /* !SOFTFLOAT_FOR_GCC */
                   2455: 
                   2456: /*
                   2457: -------------------------------------------------------------------------------
                   2458: Returns the result of converting the double-precision floating-point value
                   2459: `a' to the single-precision floating-point format.  The conversion is
                   2460: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2461: Arithmetic.
                   2462: -------------------------------------------------------------------------------
                   2463: */
                   2464: float32 float64_to_float32( float64 a )
                   2465: {
                   2466:     flag aSign;
                   2467:     int16 aExp;
                   2468:     bits64 aSig;
                   2469:     bits32 zSig;
                   2470: 
                   2471:     aSig = extractFloat64Frac( a );
                   2472:     aExp = extractFloat64Exp( a );
                   2473:     aSign = extractFloat64Sign( a );
                   2474:     if ( aExp == 0x7FF ) {
                   2475:         if ( aSig ) return commonNaNToFloat32( float64ToCommonNaN( a ) );
                   2476:         return packFloat32( aSign, 0xFF, 0 );
                   2477:     }
                   2478:     shift64RightJamming( aSig, 22, &aSig );
                   2479:     zSig = aSig;
                   2480:     if ( aExp || zSig ) {
                   2481:         zSig |= 0x40000000;
                   2482:         aExp -= 0x381;
                   2483:     }
                   2484:     return roundAndPackFloat32( aSign, aExp, zSig );
                   2485: 
                   2486: }
                   2487: 
                   2488: #ifdef FLOATX80
                   2489: 
                   2490: /*
                   2491: -------------------------------------------------------------------------------
                   2492: Returns the result of converting the double-precision floating-point value
                   2493: `a' to the extended double-precision floating-point format.  The conversion
                   2494: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2495: Arithmetic.
                   2496: -------------------------------------------------------------------------------
                   2497: */
                   2498: floatx80 float64_to_floatx80( float64 a )
                   2499: {
                   2500:     flag aSign;
                   2501:     int16 aExp;
                   2502:     bits64 aSig;
                   2503: 
                   2504:     aSig = extractFloat64Frac( a );
                   2505:     aExp = extractFloat64Exp( a );
                   2506:     aSign = extractFloat64Sign( a );
                   2507:     if ( aExp == 0x7FF ) {
                   2508:         if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a ) );
                   2509:         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   2510:     }
                   2511:     if ( aExp == 0 ) {
                   2512:         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
                   2513:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   2514:     }
                   2515:     return
                   2516:         packFloatx80(
                   2517:             aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
                   2518: 
                   2519: }
                   2520: 
                   2521: #endif
                   2522: 
                   2523: #ifdef FLOAT128
                   2524: 
                   2525: /*
                   2526: -------------------------------------------------------------------------------
                   2527: Returns the result of converting the double-precision floating-point value
                   2528: `a' to the quadruple-precision floating-point format.  The conversion is
                   2529: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   2530: Arithmetic.
                   2531: -------------------------------------------------------------------------------
                   2532: */
                   2533: float128 float64_to_float128( float64 a )
                   2534: {
                   2535:     flag aSign;
                   2536:     int16 aExp;
                   2537:     bits64 aSig, zSig0, zSig1;
                   2538: 
                   2539:     aSig = extractFloat64Frac( a );
                   2540:     aExp = extractFloat64Exp( a );
                   2541:     aSign = extractFloat64Sign( a );
                   2542:     if ( aExp == 0x7FF ) {
                   2543:         if ( aSig ) return commonNaNToFloat128( float64ToCommonNaN( a ) );
                   2544:         return packFloat128( aSign, 0x7FFF, 0, 0 );
                   2545:     }
                   2546:     if ( aExp == 0 ) {
                   2547:         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
                   2548:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   2549:         --aExp;
                   2550:     }
                   2551:     shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
                   2552:     return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
                   2553: 
                   2554: }
                   2555: 
                   2556: #endif
                   2557: 
                   2558: #ifndef SOFTFLOAT_FOR_GCC
                   2559: /*
                   2560: -------------------------------------------------------------------------------
                   2561: Rounds the double-precision floating-point value `a' to an integer, and
                   2562: returns the result as a double-precision floating-point value.  The
                   2563: operation is performed according to the IEC/IEEE Standard for Binary
                   2564: Floating-Point Arithmetic.
                   2565: -------------------------------------------------------------------------------
                   2566: */
                   2567: float64 float64_round_to_int( float64 a )
                   2568: {
                   2569:     flag aSign;
                   2570:     int16 aExp;
                   2571:     bits64 lastBitMask, roundBitsMask;
                   2572:     int8 roundingMode;
                   2573:     float64 z;
                   2574: 
                   2575:     aExp = extractFloat64Exp( a );
                   2576:     if ( 0x433 <= aExp ) {
                   2577:         if ( ( aExp == 0x7FF ) && extractFloat64Frac( a ) ) {
                   2578:             return propagateFloat64NaN( a, a );
                   2579:         }
                   2580:         return a;
                   2581:     }
                   2582:     if ( aExp < 0x3FF ) {
                   2583:         if ( (bits64) ( a<<1 ) == 0 ) return a;
                   2584:         float_set_inexact();
                   2585:         aSign = extractFloat64Sign( a );
                   2586:         switch ( float_rounding_mode() ) {
                   2587:          case float_round_nearest_even:
                   2588:             if ( ( aExp == 0x3FE ) && extractFloat64Frac( a ) ) {
                   2589:                 return packFloat64( aSign, 0x3FF, 0 );
                   2590:             }
                   2591:             break;
                   2592:          case float_round_down:
                   2593:             return aSign ? LIT64( 0xBFF0000000000000 ) : 0;
                   2594:          case float_round_up:
                   2595:             return
                   2596:             aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 );
                   2597:         }
                   2598:         return packFloat64( aSign, 0, 0 );
                   2599:     }
                   2600:     lastBitMask = 1;
                   2601:     lastBitMask <<= 0x433 - aExp;
                   2602:     roundBitsMask = lastBitMask - 1;
                   2603:     z = a;
                   2604:     roundingMode = float_rounding_mode();
                   2605:     if ( roundingMode == float_round_nearest_even ) {
                   2606:         z += lastBitMask>>1;
                   2607:         if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask;
                   2608:     }
                   2609:     else if ( roundingMode != float_round_to_zero ) {
                   2610:         if ( extractFloat64Sign( z ) ^ ( roundingMode == float_round_up ) ) {
                   2611:             z += roundBitsMask;
                   2612:         }
                   2613:     }
                   2614:     z &= ~ roundBitsMask;
                   2615:     if ( z != a ) float_set_inexact();
                   2616:     return z;
                   2617: 
                   2618: }
                   2619: #endif
                   2620: 
                   2621: /*
                   2622: -------------------------------------------------------------------------------
                   2623: Returns the result of adding the absolute values of the double-precision
                   2624: floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated
                   2625: before being returned.  `zSign' is ignored if the result is a NaN.
                   2626: The addition is performed according to the IEC/IEEE Standard for Binary
                   2627: Floating-Point Arithmetic.
                   2628: -------------------------------------------------------------------------------
                   2629: */
                   2630: static float64 addFloat64Sigs( float64 a, float64 b, flag zSign )
                   2631: {
                   2632:     int16 aExp, bExp, zExp;
                   2633:     bits64 aSig, bSig, zSig;
                   2634:     int16 expDiff;
                   2635: 
                   2636:     aSig = extractFloat64Frac( a );
                   2637:     aExp = extractFloat64Exp( a );
                   2638:     bSig = extractFloat64Frac( b );
                   2639:     bExp = extractFloat64Exp( b );
                   2640:     expDiff = aExp - bExp;
                   2641:     aSig <<= 9;
                   2642:     bSig <<= 9;
                   2643:     if ( 0 < expDiff ) {
                   2644:         if ( aExp == 0x7FF ) {
                   2645:             if ( aSig ) return propagateFloat64NaN( a, b );
                   2646:             return a;
                   2647:         }
                   2648:         if ( bExp == 0 ) {
                   2649:             --expDiff;
                   2650:         }
                   2651:         else {
                   2652:             bSig |= LIT64( 0x2000000000000000 );
                   2653:         }
                   2654:         shift64RightJamming( bSig, expDiff, &bSig );
                   2655:         zExp = aExp;
                   2656:     }
                   2657:     else if ( expDiff < 0 ) {
                   2658:         if ( bExp == 0x7FF ) {
                   2659:             if ( bSig ) return propagateFloat64NaN( a, b );
                   2660:             return packFloat64( zSign, 0x7FF, 0 );
                   2661:         }
                   2662:         if ( aExp == 0 ) {
                   2663:             ++expDiff;
                   2664:         }
                   2665:         else {
                   2666:             aSig |= LIT64( 0x2000000000000000 );
                   2667:         }
                   2668:         shift64RightJamming( aSig, - expDiff, &aSig );
                   2669:         zExp = bExp;
                   2670:     }
                   2671:     else {
                   2672:         if ( aExp == 0x7FF ) {
                   2673:             if ( aSig | bSig ) return propagateFloat64NaN( a, b );
                   2674:             return a;
                   2675:         }
                   2676:         if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
                   2677:         zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
                   2678:         zExp = aExp;
                   2679:         goto roundAndPack;
                   2680:     }
                   2681:     aSig |= LIT64( 0x2000000000000000 );
                   2682:     zSig = ( aSig + bSig )<<1;
                   2683:     --zExp;
                   2684:     if ( (sbits64) zSig < 0 ) {
                   2685:         zSig = aSig + bSig;
                   2686:         ++zExp;
                   2687:     }
                   2688:  roundAndPack:
                   2689:     return roundAndPackFloat64( zSign, zExp, zSig );
                   2690: 
                   2691: }
                   2692: 
                   2693: /*
                   2694: -------------------------------------------------------------------------------
                   2695: Returns the result of subtracting the absolute values of the double-
                   2696: precision floating-point values `a' and `b'.  If `zSign' is 1, the
                   2697: difference is negated before being returned.  `zSign' is ignored if the
                   2698: result is a NaN.  The subtraction is performed according to the IEC/IEEE
                   2699: Standard for Binary Floating-Point Arithmetic.
                   2700: -------------------------------------------------------------------------------
                   2701: */
                   2702: static float64 subFloat64Sigs( float64 a, float64 b, flag zSign )
                   2703: {
                   2704:     int16 aExp, bExp, zExp;
                   2705:     bits64 aSig, bSig, zSig;
                   2706:     int16 expDiff;
                   2707: 
                   2708:     aSig = extractFloat64Frac( a );
                   2709:     aExp = extractFloat64Exp( a );
                   2710:     bSig = extractFloat64Frac( b );
                   2711:     bExp = extractFloat64Exp( b );
                   2712:     expDiff = aExp - bExp;
                   2713:     aSig <<= 10;
                   2714:     bSig <<= 10;
                   2715:     if ( 0 < expDiff ) goto aExpBigger;
                   2716:     if ( expDiff < 0 ) goto bExpBigger;
                   2717:     if ( aExp == 0x7FF ) {
                   2718:         if ( aSig | bSig ) return propagateFloat64NaN( a, b );
                   2719:         float_raise( float_flag_invalid );
                   2720:         return float64_default_nan;
                   2721:     }
                   2722:     if ( aExp == 0 ) {
                   2723:         aExp = 1;
                   2724:         bExp = 1;
                   2725:     }
                   2726:     if ( bSig < aSig ) goto aBigger;
                   2727:     if ( aSig < bSig ) goto bBigger;
                   2728:     return packFloat64( float_rounding_mode() == float_round_down, 0, 0 );
                   2729:  bExpBigger:
                   2730:     if ( bExp == 0x7FF ) {
                   2731:         if ( bSig ) return propagateFloat64NaN( a, b );
                   2732:         return packFloat64( zSign ^ 1, 0x7FF, 0 );
                   2733:     }
                   2734:     if ( aExp == 0 ) {
                   2735:         ++expDiff;
                   2736:     }
                   2737:     else {
                   2738:         aSig |= LIT64( 0x4000000000000000 );
                   2739:     }
                   2740:     shift64RightJamming( aSig, - expDiff, &aSig );
                   2741:     bSig |= LIT64( 0x4000000000000000 );
                   2742:  bBigger:
                   2743:     zSig = bSig - aSig;
                   2744:     zExp = bExp;
                   2745:     zSign ^= 1;
                   2746:     goto normalizeRoundAndPack;
                   2747:  aExpBigger:
                   2748:     if ( aExp == 0x7FF ) {
                   2749:         if ( aSig ) return propagateFloat64NaN( a, b );
                   2750:         return a;
                   2751:     }
                   2752:     if ( bExp == 0 ) {
                   2753:         --expDiff;
                   2754:     }
                   2755:     else {
                   2756:         bSig |= LIT64( 0x4000000000000000 );
                   2757:     }
                   2758:     shift64RightJamming( bSig, expDiff, &bSig );
                   2759:     aSig |= LIT64( 0x4000000000000000 );
                   2760:  aBigger:
                   2761:     zSig = aSig - bSig;
                   2762:     zExp = aExp;
                   2763:  normalizeRoundAndPack:
                   2764:     --zExp;
                   2765:     return normalizeRoundAndPackFloat64( zSign, zExp, zSig );
                   2766: 
                   2767: }
                   2768: 
                   2769: /*
                   2770: -------------------------------------------------------------------------------
                   2771: Returns the result of adding the double-precision floating-point values `a'
                   2772: and `b'.  The operation is performed according to the IEC/IEEE Standard for
                   2773: Binary Floating-Point Arithmetic.
                   2774: -------------------------------------------------------------------------------
                   2775: */
                   2776: float64 float64_add( float64 a, float64 b )
                   2777: {
                   2778:     flag aSign, bSign;
                   2779: 
                   2780:     aSign = extractFloat64Sign( a );
                   2781:     bSign = extractFloat64Sign( b );
                   2782:     if ( aSign == bSign ) {
                   2783:         return addFloat64Sigs( a, b, aSign );
                   2784:     }
                   2785:     else {
                   2786:         return subFloat64Sigs( a, b, aSign );
                   2787:     }
                   2788: 
                   2789: }
                   2790: 
                   2791: /*
                   2792: -------------------------------------------------------------------------------
                   2793: Returns the result of subtracting the double-precision floating-point values
                   2794: `a' and `b'.  The operation is performed according to the IEC/IEEE Standard
                   2795: for Binary Floating-Point Arithmetic.
                   2796: -------------------------------------------------------------------------------
                   2797: */
                   2798: float64 float64_sub( float64 a, float64 b )
                   2799: {
                   2800:     flag aSign, bSign;
                   2801: 
                   2802:     aSign = extractFloat64Sign( a );
                   2803:     bSign = extractFloat64Sign( b );
                   2804:     if ( aSign == bSign ) {
                   2805:         return subFloat64Sigs( a, b, aSign );
                   2806:     }
                   2807:     else {
                   2808:         return addFloat64Sigs( a, b, aSign );
                   2809:     }
                   2810: 
                   2811: }
                   2812: 
                   2813: /*
                   2814: -------------------------------------------------------------------------------
                   2815: Returns the result of multiplying the double-precision floating-point values
                   2816: `a' and `b'.  The operation is performed according to the IEC/IEEE Standard
                   2817: for Binary Floating-Point Arithmetic.
                   2818: -------------------------------------------------------------------------------
                   2819: */
                   2820: float64 float64_mul( float64 a, float64 b )
                   2821: {
                   2822:     flag aSign, bSign, zSign;
                   2823:     int16 aExp, bExp, zExp;
                   2824:     bits64 aSig, bSig, zSig0, zSig1;
                   2825: 
                   2826:     aSig = extractFloat64Frac( a );
                   2827:     aExp = extractFloat64Exp( a );
                   2828:     aSign = extractFloat64Sign( a );
                   2829:     bSig = extractFloat64Frac( b );
                   2830:     bExp = extractFloat64Exp( b );
                   2831:     bSign = extractFloat64Sign( b );
                   2832:     zSign = aSign ^ bSign;
                   2833:     if ( aExp == 0x7FF ) {
                   2834:         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
                   2835:             return propagateFloat64NaN( a, b );
                   2836:         }
                   2837:         if ( ( bExp | bSig ) == 0 ) {
                   2838:             float_raise( float_flag_invalid );
                   2839:             return float64_default_nan;
                   2840:         }
                   2841:         return packFloat64( zSign, 0x7FF, 0 );
                   2842:     }
                   2843:     if ( bExp == 0x7FF ) {
                   2844:         if ( bSig ) return propagateFloat64NaN( a, b );
                   2845:         if ( ( aExp | aSig ) == 0 ) {
                   2846:             float_raise( float_flag_invalid );
                   2847:             return float64_default_nan;
                   2848:         }
                   2849:         return packFloat64( zSign, 0x7FF, 0 );
                   2850:     }
                   2851:     if ( aExp == 0 ) {
                   2852:         if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
                   2853:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   2854:     }
                   2855:     if ( bExp == 0 ) {
                   2856:         if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
                   2857:         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
                   2858:     }
                   2859:     zExp = aExp + bExp - 0x3FF;
                   2860:     aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
                   2861:     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
                   2862:     mul64To128( aSig, bSig, &zSig0, &zSig1 );
                   2863:     zSig0 |= ( zSig1 != 0 );
                   2864:     if ( 0 <= (sbits64) ( zSig0<<1 ) ) {
                   2865:         zSig0 <<= 1;
                   2866:         --zExp;
                   2867:     }
                   2868:     return roundAndPackFloat64( zSign, zExp, zSig0 );
                   2869: 
                   2870: }
                   2871: 
                   2872: /*
                   2873: -------------------------------------------------------------------------------
                   2874: Returns the result of dividing the double-precision floating-point value `a'
                   2875: by the corresponding value `b'.  The operation is performed according to
                   2876: the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2877: -------------------------------------------------------------------------------
                   2878: */
                   2879: float64 float64_div( float64 a, float64 b )
                   2880: {
                   2881:     flag aSign, bSign, zSign;
                   2882:     int16 aExp, bExp, zExp;
                   2883:     bits64 aSig, bSig, zSig;
                   2884:     bits64 rem0, rem1;
                   2885:     bits64 term0, term1;
                   2886: 
                   2887:     aSig = extractFloat64Frac( a );
                   2888:     aExp = extractFloat64Exp( a );
                   2889:     aSign = extractFloat64Sign( a );
                   2890:     bSig = extractFloat64Frac( b );
                   2891:     bExp = extractFloat64Exp( b );
                   2892:     bSign = extractFloat64Sign( b );
                   2893:     zSign = aSign ^ bSign;
                   2894:     if ( aExp == 0x7FF ) {
                   2895:         if ( aSig ) return propagateFloat64NaN( a, b );
                   2896:         if ( bExp == 0x7FF ) {
                   2897:             if ( bSig ) return propagateFloat64NaN( a, b );
                   2898:             float_raise( float_flag_invalid );
                   2899:             return float64_default_nan;
                   2900:         }
                   2901:         return packFloat64( zSign, 0x7FF, 0 );
                   2902:     }
                   2903:     if ( bExp == 0x7FF ) {
                   2904:         if ( bSig ) return propagateFloat64NaN( a, b );
                   2905:         return packFloat64( zSign, 0, 0 );
                   2906:     }
                   2907:     if ( bExp == 0 ) {
                   2908:         if ( bSig == 0 ) {
                   2909:             if ( ( aExp | aSig ) == 0 ) {
                   2910:                 float_raise( float_flag_invalid );
                   2911:                 return float64_default_nan;
                   2912:             }
                   2913:             float_raise( float_flag_divbyzero );
                   2914:             return packFloat64( zSign, 0x7FF, 0 );
                   2915:         }
                   2916:         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
                   2917:     }
                   2918:     if ( aExp == 0 ) {
                   2919:         if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
                   2920:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   2921:     }
                   2922:     zExp = aExp - bExp + 0x3FD;
                   2923:     aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;
                   2924:     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
                   2925:     if ( bSig <= ( aSig + aSig ) ) {
                   2926:         aSig >>= 1;
                   2927:         ++zExp;
                   2928:     }
                   2929:     zSig = estimateDiv128To64( aSig, 0, bSig );
                   2930:     if ( ( zSig & 0x1FF ) <= 2 ) {
                   2931:         mul64To128( bSig, zSig, &term0, &term1 );
                   2932:         sub128( aSig, 0, term0, term1, &rem0, &rem1 );
                   2933:         while ( (sbits64) rem0 < 0 ) {
                   2934:             --zSig;
                   2935:             add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
                   2936:         }
                   2937:         zSig |= ( rem1 != 0 );
                   2938:     }
                   2939:     return roundAndPackFloat64( zSign, zExp, zSig );
                   2940: 
                   2941: }
                   2942: 
                   2943: #ifndef SOFTFLOAT_FOR_GCC
                   2944: /*
                   2945: -------------------------------------------------------------------------------
                   2946: Returns the remainder of the double-precision floating-point value `a'
                   2947: with respect to the corresponding value `b'.  The operation is performed
                   2948: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   2949: -------------------------------------------------------------------------------
                   2950: */
                   2951: float64 float64_rem( float64 a, float64 b )
                   2952: {
                   2953:     flag aSign, bSign, zSign;
                   2954:     int16 aExp, bExp, expDiff;
                   2955:     bits64 aSig, bSig;
                   2956:     bits64 q, alternateASig;
                   2957:     sbits64 sigMean;
                   2958: 
                   2959:     aSig = extractFloat64Frac( a );
                   2960:     aExp = extractFloat64Exp( a );
                   2961:     aSign = extractFloat64Sign( a );
                   2962:     bSig = extractFloat64Frac( b );
                   2963:     bExp = extractFloat64Exp( b );
                   2964:     bSign = extractFloat64Sign( b );
                   2965:     if ( aExp == 0x7FF ) {
                   2966:         if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {
                   2967:             return propagateFloat64NaN( a, b );
                   2968:         }
                   2969:         float_raise( float_flag_invalid );
                   2970:         return float64_default_nan;
                   2971:     }
                   2972:     if ( bExp == 0x7FF ) {
                   2973:         if ( bSig ) return propagateFloat64NaN( a, b );
                   2974:         return a;
                   2975:     }
                   2976:     if ( bExp == 0 ) {
                   2977:         if ( bSig == 0 ) {
                   2978:             float_raise( float_flag_invalid );
                   2979:             return float64_default_nan;
                   2980:         }
                   2981:         normalizeFloat64Subnormal( bSig, &bExp, &bSig );
                   2982:     }
                   2983:     if ( aExp == 0 ) {
                   2984:         if ( aSig == 0 ) return a;
                   2985:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   2986:     }
                   2987:     expDiff = aExp - bExp;
                   2988:     aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;
                   2989:     bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;
                   2990:     if ( expDiff < 0 ) {
                   2991:         if ( expDiff < -1 ) return a;
                   2992:         aSig >>= 1;
                   2993:     }
                   2994:     q = ( bSig <= aSig );
                   2995:     if ( q ) aSig -= bSig;
                   2996:     expDiff -= 64;
                   2997:     while ( 0 < expDiff ) {
                   2998:         q = estimateDiv128To64( aSig, 0, bSig );
                   2999:         q = ( 2 < q ) ? q - 2 : 0;
                   3000:         aSig = - ( ( bSig>>2 ) * q );
                   3001:         expDiff -= 62;
                   3002:     }
                   3003:     expDiff += 64;
                   3004:     if ( 0 < expDiff ) {
                   3005:         q = estimateDiv128To64( aSig, 0, bSig );
                   3006:         q = ( 2 < q ) ? q - 2 : 0;
                   3007:         q >>= 64 - expDiff;
                   3008:         bSig >>= 2;
                   3009:         aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;
                   3010:     }
                   3011:     else {
                   3012:         aSig >>= 2;
                   3013:         bSig >>= 2;
                   3014:     }
                   3015:     do {
                   3016:         alternateASig = aSig;
                   3017:         ++q;
                   3018:         aSig -= bSig;
                   3019:     } while ( 0 <= (sbits64) aSig );
                   3020:     sigMean = aSig + alternateASig;
                   3021:     if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {
                   3022:         aSig = alternateASig;
                   3023:     }
                   3024:     zSign = ( (sbits64) aSig < 0 );
                   3025:     if ( zSign ) aSig = - aSig;
                   3026:     return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
                   3027: 
                   3028: }
                   3029: 
                   3030: /*
                   3031: -------------------------------------------------------------------------------
                   3032: Returns the square root of the double-precision floating-point value `a'.
                   3033: The operation is performed according to the IEC/IEEE Standard for Binary
                   3034: Floating-Point Arithmetic.
                   3035: -------------------------------------------------------------------------------
                   3036: */
                   3037: float64 float64_sqrt( float64 a )
                   3038: {
                   3039:     flag aSign;
                   3040:     int16 aExp, zExp;
                   3041:     bits64 aSig, zSig, doubleZSig;
                   3042:     bits64 rem0, rem1, term0, term1;
                   3043: 
                   3044:     aSig = extractFloat64Frac( a );
                   3045:     aExp = extractFloat64Exp( a );
                   3046:     aSign = extractFloat64Sign( a );
                   3047:     if ( aExp == 0x7FF ) {
                   3048:         if ( aSig ) return propagateFloat64NaN( a, a );
                   3049:         if ( ! aSign ) return a;
                   3050:         float_raise( float_flag_invalid );
                   3051:         return float64_default_nan;
                   3052:     }
                   3053:     if ( aSign ) {
                   3054:         if ( ( aExp | aSig ) == 0 ) return a;
                   3055:         float_raise( float_flag_invalid );
                   3056:         return float64_default_nan;
                   3057:     }
                   3058:     if ( aExp == 0 ) {
                   3059:         if ( aSig == 0 ) return 0;
                   3060:         normalizeFloat64Subnormal( aSig, &aExp, &aSig );
                   3061:     }
                   3062:     zExp = ( ( aExp - 0x3FF )>>1 ) + 0x3FE;
                   3063:     aSig |= LIT64( 0x0010000000000000 );
                   3064:     zSig = estimateSqrt32( aExp, aSig>>21 );
                   3065:     aSig <<= 9 - ( aExp & 1 );
                   3066:     zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );
                   3067:     if ( ( zSig & 0x1FF ) <= 5 ) {
                   3068:         doubleZSig = zSig<<1;
                   3069:         mul64To128( zSig, zSig, &term0, &term1 );
                   3070:         sub128( aSig, 0, term0, term1, &rem0, &rem1 );
                   3071:         while ( (sbits64) rem0 < 0 ) {
                   3072:             --zSig;
                   3073:             doubleZSig -= 2;
                   3074:             add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 );
                   3075:         }
                   3076:         zSig |= ( ( rem0 | rem1 ) != 0 );
                   3077:     }
                   3078:     return roundAndPackFloat64( 0, zExp, zSig );
                   3079: 
                   3080: }
                   3081: #endif
                   3082: 
                   3083: /*
                   3084: -------------------------------------------------------------------------------
                   3085: Returns 1 if the double-precision floating-point value `a' is equal to the
                   3086: corresponding value `b', and 0 otherwise.  The comparison is performed
                   3087: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3088: -------------------------------------------------------------------------------
                   3089: */
                   3090: flag float64_eq( float64 a, float64 b )
                   3091: {
                   3092: 
                   3093:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3094:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3095:        ) {
                   3096:         if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
                   3097:             float_raise( float_flag_invalid );
                   3098:         }
                   3099:         return 0;
                   3100:     }
                   3101:     return ( a == b ) ||
                   3102:        ( (bits64) ( ( FLOAT64_DEMANGLE(a) | FLOAT64_DEMANGLE(b) )<<1 ) == 0 );
                   3103: 
                   3104: }
                   3105: 
                   3106: /*
                   3107: -------------------------------------------------------------------------------
                   3108: Returns 1 if the double-precision floating-point value `a' is less than or
                   3109: equal to the corresponding value `b', and 0 otherwise.  The comparison is
                   3110: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   3111: Arithmetic.
                   3112: -------------------------------------------------------------------------------
                   3113: */
                   3114: flag float64_le( float64 a, float64 b )
                   3115: {
                   3116:     flag aSign, bSign;
                   3117: 
                   3118:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3119:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3120:        ) {
                   3121:         float_raise( float_flag_invalid );
                   3122:         return 0;
                   3123:     }
                   3124:     aSign = extractFloat64Sign( a );
                   3125:     bSign = extractFloat64Sign( b );
                   3126:     if ( aSign != bSign )
                   3127:        return aSign ||
                   3128:            ( (bits64) ( ( FLOAT64_DEMANGLE(a) | FLOAT64_DEMANGLE(b) )<<1 ) ==
                   3129:              0 );
                   3130:     return ( a == b ) ||
                   3131:        ( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
                   3132: 
                   3133: }
                   3134: 
                   3135: /*
                   3136: -------------------------------------------------------------------------------
                   3137: Returns 1 if the double-precision floating-point value `a' is less than
                   3138: the corresponding value `b', and 0 otherwise.  The comparison is performed
                   3139: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3140: -------------------------------------------------------------------------------
                   3141: */
                   3142: flag float64_lt( float64 a, float64 b )
                   3143: {
                   3144:     flag aSign, bSign;
                   3145: 
                   3146:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3147:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3148:        ) {
                   3149:         float_raise( float_flag_invalid );
                   3150:         return 0;
                   3151:     }
                   3152:     aSign = extractFloat64Sign( a );
                   3153:     bSign = extractFloat64Sign( b );
                   3154:     if ( aSign != bSign )
                   3155:        return aSign &&
                   3156:            ( (bits64) ( ( FLOAT64_DEMANGLE(a) | FLOAT64_DEMANGLE(b) )<<1 ) !=
                   3157:              0 );
                   3158:     return ( a != b ) &&
                   3159:        ( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
                   3160: 
                   3161: }
                   3162: 
                   3163: #ifndef SOFTFLOAT_FOR_GCC
                   3164: /*
                   3165: -------------------------------------------------------------------------------
                   3166: Returns 1 if the double-precision floating-point value `a' is equal to the
                   3167: corresponding value `b', and 0 otherwise.  The invalid exception is raised
                   3168: if either operand is a NaN.  Otherwise, the comparison is performed
                   3169: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3170: -------------------------------------------------------------------------------
                   3171: */
                   3172: flag float64_eq_signaling( float64 a, float64 b )
                   3173: {
                   3174: 
                   3175:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3176:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3177:        ) {
                   3178:         float_raise( float_flag_invalid );
                   3179:         return 0;
                   3180:     }
                   3181:     return ( a == b ) || ( (bits64) ( ( a | b )<<1 ) == 0 );
                   3182: 
                   3183: }
                   3184: 
                   3185: /*
                   3186: -------------------------------------------------------------------------------
                   3187: Returns 1 if the double-precision floating-point value `a' is less than or
                   3188: equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not
                   3189: cause an exception.  Otherwise, the comparison is performed according to the
                   3190: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3191: -------------------------------------------------------------------------------
                   3192: */
                   3193: flag float64_le_quiet( float64 a, float64 b )
                   3194: {
                   3195:     flag aSign, bSign;
                   3196: 
                   3197:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3198:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3199:        ) {
                   3200:         if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
                   3201:             float_raise( float_flag_invalid );
                   3202:         }
                   3203:         return 0;
                   3204:     }
                   3205:     aSign = extractFloat64Sign( a );
                   3206:     bSign = extractFloat64Sign( b );
                   3207:     if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );
                   3208:     return ( a == b ) || ( aSign ^ ( a < b ) );
                   3209: 
                   3210: }
                   3211: 
                   3212: /*
                   3213: -------------------------------------------------------------------------------
                   3214: Returns 1 if the double-precision floating-point value `a' is less than
                   3215: the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an
                   3216: exception.  Otherwise, the comparison is performed according to the IEC/IEEE
                   3217: Standard for Binary Floating-Point Arithmetic.
                   3218: -------------------------------------------------------------------------------
                   3219: */
                   3220: flag float64_lt_quiet( float64 a, float64 b )
                   3221: {
                   3222:     flag aSign, bSign;
                   3223: 
                   3224:     if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
                   3225:          || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
                   3226:        ) {
                   3227:         if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
                   3228:             float_raise( float_flag_invalid );
                   3229:         }
                   3230:         return 0;
                   3231:     }
                   3232:     aSign = extractFloat64Sign( a );
                   3233:     bSign = extractFloat64Sign( b );
                   3234:     if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );
                   3235:     return ( a != b ) && ( aSign ^ ( a < b ) );
                   3236: 
                   3237: }
                   3238: #endif
                   3239: 
                   3240: #ifdef FLOATX80
                   3241: 
                   3242: /*
                   3243: -------------------------------------------------------------------------------
                   3244: Returns the result of converting the extended double-precision floating-
                   3245: point value `a' to the 32-bit two's complement integer format.  The
                   3246: conversion is performed according to the IEC/IEEE Standard for Binary
                   3247: Floating-Point Arithmetic---which means in particular that the conversion
                   3248: is rounded according to the current rounding mode.  If `a' is a NaN, the
                   3249: largest positive integer is returned.  Otherwise, if the conversion
                   3250: overflows, the largest integer with the same sign as `a' is returned.
                   3251: -------------------------------------------------------------------------------
                   3252: */
                   3253: int32 floatx80_to_int32( floatx80 a )
                   3254: {
                   3255:     flag aSign;
                   3256:     int32 aExp, shiftCount;
                   3257:     bits64 aSig;
                   3258: 
                   3259:     aSig = extractFloatx80Frac( a );
                   3260:     aExp = extractFloatx80Exp( a );
                   3261:     aSign = extractFloatx80Sign( a );
                   3262:     if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
                   3263:     shiftCount = 0x4037 - aExp;
                   3264:     if ( shiftCount <= 0 ) shiftCount = 1;
                   3265:     shift64RightJamming( aSig, shiftCount, &aSig );
                   3266:     return roundAndPackInt32( aSign, aSig );
                   3267: 
                   3268: }
                   3269: 
                   3270: /*
                   3271: -------------------------------------------------------------------------------
                   3272: Returns the result of converting the extended double-precision floating-
                   3273: point value `a' to the 32-bit two's complement integer format.  The
                   3274: conversion is performed according to the IEC/IEEE Standard for Binary
                   3275: Floating-Point Arithmetic, except that the conversion is always rounded
                   3276: toward zero.  If `a' is a NaN, the largest positive integer is returned.
                   3277: Otherwise, if the conversion overflows, the largest integer with the same
                   3278: sign as `a' is returned.
                   3279: -------------------------------------------------------------------------------
                   3280: */
                   3281: int32 floatx80_to_int32_round_to_zero( floatx80 a )
                   3282: {
                   3283:     flag aSign;
                   3284:     int32 aExp, shiftCount;
                   3285:     bits64 aSig, savedASig;
                   3286:     int32 z;
                   3287: 
                   3288:     aSig = extractFloatx80Frac( a );
                   3289:     aExp = extractFloatx80Exp( a );
                   3290:     aSign = extractFloatx80Sign( a );
                   3291:     if ( 0x401E < aExp ) {
                   3292:         if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
                   3293:         goto invalid;
                   3294:     }
                   3295:     else if ( aExp < 0x3FFF ) {
                   3296:         if ( aExp || aSig ) float_set_inexact();
                   3297:         return 0;
                   3298:     }
                   3299:     shiftCount = 0x403E - aExp;
                   3300:     savedASig = aSig;
                   3301:     aSig >>= shiftCount;
                   3302:     z = aSig;
                   3303:     if ( aSign ) z = - z;
                   3304:     if ( ( z < 0 ) ^ aSign ) {
                   3305:  invalid:
                   3306:         float_raise( float_flag_invalid );
                   3307:         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
                   3308:     }
                   3309:     if ( ( aSig<<shiftCount ) != savedASig ) {
                   3310:         float_set_inexact();
                   3311:     }
                   3312:     return z;
                   3313: 
                   3314: }
                   3315: 
                   3316: /*
                   3317: -------------------------------------------------------------------------------
                   3318: Returns the result of converting the extended double-precision floating-
                   3319: point value `a' to the 64-bit two's complement integer format.  The
                   3320: conversion is performed according to the IEC/IEEE Standard for Binary
                   3321: Floating-Point Arithmetic---which means in particular that the conversion
                   3322: is rounded according to the current rounding mode.  If `a' is a NaN,
                   3323: the largest positive integer is returned.  Otherwise, if the conversion
                   3324: overflows, the largest integer with the same sign as `a' is returned.
                   3325: -------------------------------------------------------------------------------
                   3326: */
                   3327: int64 floatx80_to_int64( floatx80 a )
                   3328: {
                   3329:     flag aSign;
                   3330:     int32 aExp, shiftCount;
                   3331:     bits64 aSig, aSigExtra;
                   3332: 
                   3333:     aSig = extractFloatx80Frac( a );
                   3334:     aExp = extractFloatx80Exp( a );
                   3335:     aSign = extractFloatx80Sign( a );
                   3336:     shiftCount = 0x403E - aExp;
                   3337:     if ( shiftCount <= 0 ) {
                   3338:         if ( shiftCount ) {
                   3339:             float_raise( float_flag_invalid );
                   3340:             if (    ! aSign
                   3341:                  || (    ( aExp == 0x7FFF )
                   3342:                       && ( aSig != LIT64( 0x8000000000000000 ) ) )
                   3343:                ) {
                   3344:                 return LIT64( 0x7FFFFFFFFFFFFFFF );
                   3345:             }
                   3346:             return (sbits64) LIT64( 0x8000000000000000 );
                   3347:         }
                   3348:         aSigExtra = 0;
                   3349:     }
                   3350:     else {
                   3351:         shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
                   3352:     }
                   3353:     return roundAndPackInt64( aSign, aSig, aSigExtra );
                   3354: 
                   3355: }
                   3356: 
                   3357: /*
                   3358: -------------------------------------------------------------------------------
                   3359: Returns the result of converting the extended double-precision floating-
                   3360: point value `a' to the 64-bit two's complement integer format.  The
                   3361: conversion is performed according to the IEC/IEEE Standard for Binary
                   3362: Floating-Point Arithmetic, except that the conversion is always rounded
                   3363: toward zero.  If `a' is a NaN, the largest positive integer is returned.
                   3364: Otherwise, if the conversion overflows, the largest integer with the same
                   3365: sign as `a' is returned.
                   3366: -------------------------------------------------------------------------------
                   3367: */
                   3368: int64 floatx80_to_int64_round_to_zero( floatx80 a )
                   3369: {
                   3370:     flag aSign;
                   3371:     int32 aExp, shiftCount;
                   3372:     bits64 aSig;
                   3373:     int64 z;
                   3374: 
                   3375:     aSig = extractFloatx80Frac( a );
                   3376:     aExp = extractFloatx80Exp( a );
                   3377:     aSign = extractFloatx80Sign( a );
                   3378:     shiftCount = aExp - 0x403E;
                   3379:     if ( 0 <= shiftCount ) {
                   3380:         aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
                   3381:         if ( ( a.high != 0xC03E ) || aSig ) {
                   3382:             float_raise( float_flag_invalid );
                   3383:             if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
                   3384:                 return LIT64( 0x7FFFFFFFFFFFFFFF );
                   3385:             }
                   3386:         }
                   3387:         return (sbits64) LIT64( 0x8000000000000000 );
                   3388:     }
                   3389:     else if ( aExp < 0x3FFF ) {
                   3390:         if ( aExp | aSig ) float_set_inexact();
                   3391:         return 0;
                   3392:     }
                   3393:     z = aSig>>( - shiftCount );
                   3394:     if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {
                   3395:         float_set_inexact();
                   3396:     }
                   3397:     if ( aSign ) z = - z;
                   3398:     return z;
                   3399: 
                   3400: }
                   3401: 
                   3402: /*
                   3403: -------------------------------------------------------------------------------
                   3404: Returns the result of converting the extended double-precision floating-
                   3405: point value `a' to the single-precision floating-point format.  The
                   3406: conversion is performed according to the IEC/IEEE Standard for Binary
                   3407: Floating-Point Arithmetic.
                   3408: -------------------------------------------------------------------------------
                   3409: */
                   3410: float32 floatx80_to_float32( floatx80 a )
                   3411: {
                   3412:     flag aSign;
                   3413:     int32 aExp;
                   3414:     bits64 aSig;
                   3415: 
                   3416:     aSig = extractFloatx80Frac( a );
                   3417:     aExp = extractFloatx80Exp( a );
                   3418:     aSign = extractFloatx80Sign( a );
                   3419:     if ( aExp == 0x7FFF ) {
                   3420:         if ( (bits64) ( aSig<<1 ) ) {
                   3421:             return commonNaNToFloat32( floatx80ToCommonNaN( a ) );
                   3422:         }
                   3423:         return packFloat32( aSign, 0xFF, 0 );
                   3424:     }
                   3425:     shift64RightJamming( aSig, 33, &aSig );
                   3426:     if ( aExp || aSig ) aExp -= 0x3F81;
                   3427:     return roundAndPackFloat32( aSign, aExp, aSig );
                   3428: 
                   3429: }
                   3430: 
                   3431: /*
                   3432: -------------------------------------------------------------------------------
                   3433: Returns the result of converting the extended double-precision floating-
                   3434: point value `a' to the double-precision floating-point format.  The
                   3435: conversion is performed according to the IEC/IEEE Standard for Binary
                   3436: Floating-Point Arithmetic.
                   3437: -------------------------------------------------------------------------------
                   3438: */
                   3439: float64 floatx80_to_float64( floatx80 a )
                   3440: {
                   3441:     flag aSign;
                   3442:     int32 aExp;
                   3443:     bits64 aSig, zSig;
                   3444: 
                   3445:     aSig = extractFloatx80Frac( a );
                   3446:     aExp = extractFloatx80Exp( a );
                   3447:     aSign = extractFloatx80Sign( a );
                   3448:     if ( aExp == 0x7FFF ) {
                   3449:         if ( (bits64) ( aSig<<1 ) ) {
                   3450:             return commonNaNToFloat64( floatx80ToCommonNaN( a ) );
                   3451:         }
                   3452:         return packFloat64( aSign, 0x7FF, 0 );
                   3453:     }
                   3454:     shift64RightJamming( aSig, 1, &zSig );
                   3455:     if ( aExp || aSig ) aExp -= 0x3C01;
                   3456:     return roundAndPackFloat64( aSign, aExp, zSig );
                   3457: 
                   3458: }
                   3459: 
                   3460: #ifdef FLOAT128
                   3461: 
                   3462: /*
                   3463: -------------------------------------------------------------------------------
                   3464: Returns the result of converting the extended double-precision floating-
                   3465: point value `a' to the quadruple-precision floating-point format.  The
                   3466: conversion is performed according to the IEC/IEEE Standard for Binary
                   3467: Floating-Point Arithmetic.
                   3468: -------------------------------------------------------------------------------
                   3469: */
                   3470: float128 floatx80_to_float128( floatx80 a )
                   3471: {
                   3472:     flag aSign;
                   3473:     int16 aExp;
                   3474:     bits64 aSig, zSig0, zSig1;
                   3475: 
                   3476:     aSig = extractFloatx80Frac( a );
                   3477:     aExp = extractFloatx80Exp( a );
                   3478:     aSign = extractFloatx80Sign( a );
                   3479:     if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {
                   3480:         return commonNaNToFloat128( floatx80ToCommonNaN( a ) );
                   3481:     }
                   3482:     shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
                   3483:     return packFloat128( aSign, aExp, zSig0, zSig1 );
                   3484: 
                   3485: }
                   3486: 
                   3487: #endif
                   3488: 
                   3489: /*
                   3490: -------------------------------------------------------------------------------
                   3491: Rounds the extended double-precision floating-point value `a' to an integer,
                   3492: and returns the result as an extended quadruple-precision floating-point
                   3493: value.  The operation is performed according to the IEC/IEEE Standard for
                   3494: Binary Floating-Point Arithmetic.
                   3495: -------------------------------------------------------------------------------
                   3496: */
                   3497: floatx80 floatx80_round_to_int( floatx80 a )
                   3498: {
                   3499:     flag aSign;
                   3500:     int32 aExp;
                   3501:     bits64 lastBitMask, roundBitsMask;
                   3502:     int8 roundingMode;
                   3503:     floatx80 z;
                   3504: 
                   3505:     aExp = extractFloatx80Exp( a );
                   3506:     if ( 0x403E <= aExp ) {
                   3507:         if ( ( aExp == 0x7FFF ) && (bits64) ( extractFloatx80Frac( a )<<1 ) ) {
                   3508:             return propagateFloatx80NaN( a, a );
                   3509:         }
                   3510:         return a;
                   3511:     }
                   3512:     if ( aExp < 0x3FFF ) {
                   3513:         if (    ( aExp == 0 )
                   3514:              && ( (bits64) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {
                   3515:             return a;
                   3516:         }
                   3517:         float_set_inexact();
                   3518:         aSign = extractFloatx80Sign( a );
                   3519:         switch ( float_rounding_mode() ) {
                   3520:          case float_round_nearest_even:
                   3521:             if ( ( aExp == 0x3FFE ) && (bits64) ( extractFloatx80Frac( a )<<1 )
                   3522:                ) {
                   3523:                 return
                   3524:                     packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
                   3525:             }
                   3526:             break;
                   3527:          case float_round_down:
                   3528:             return
                   3529:                   aSign ?
                   3530:                       packFloatx80( 1, 0x3FFF, LIT64( 0x8000000000000000 ) )
                   3531:                 : packFloatx80( 0, 0, 0 );
                   3532:          case float_round_up:
                   3533:             return
                   3534:                   aSign ? packFloatx80( 1, 0, 0 )
                   3535:                 : packFloatx80( 0, 0x3FFF, LIT64( 0x8000000000000000 ) );
                   3536:         }
                   3537:         return packFloatx80( aSign, 0, 0 );
                   3538:     }
                   3539:     lastBitMask = 1;
                   3540:     lastBitMask <<= 0x403E - aExp;
                   3541:     roundBitsMask = lastBitMask - 1;
                   3542:     z = a;
                   3543:     roundingMode = float_rounding_mode();
                   3544:     if ( roundingMode == float_round_nearest_even ) {
                   3545:         z.low += lastBitMask>>1;
                   3546:         if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask;
                   3547:     }
                   3548:     else if ( roundingMode != float_round_to_zero ) {
                   3549:         if ( extractFloatx80Sign( z ) ^ ( roundingMode == float_round_up ) ) {
                   3550:             z.low += roundBitsMask;
                   3551:         }
                   3552:     }
                   3553:     z.low &= ~ roundBitsMask;
                   3554:     if ( z.low == 0 ) {
                   3555:         ++z.high;
                   3556:         z.low = LIT64( 0x8000000000000000 );
                   3557:     }
                   3558:     if ( z.low != a.low ) float_set_inexact();
                   3559:     return z;
                   3560: 
                   3561: }
                   3562: 
                   3563: /*
                   3564: -------------------------------------------------------------------------------
                   3565: Returns the result of adding the absolute values of the extended double-
                   3566: precision floating-point values `a' and `b'.  If `zSign' is 1, the sum is
                   3567: negated before being returned.  `zSign' is ignored if the result is a NaN.
                   3568: The addition is performed according to the IEC/IEEE Standard for Binary
                   3569: Floating-Point Arithmetic.
                   3570: -------------------------------------------------------------------------------
                   3571: */
                   3572: static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
                   3573: {
                   3574:     int32 aExp, bExp, zExp;
                   3575:     bits64 aSig, bSig, zSig0, zSig1;
                   3576:     int32 expDiff;
                   3577: 
                   3578:     aSig = extractFloatx80Frac( a );
                   3579:     aExp = extractFloatx80Exp( a );
                   3580:     bSig = extractFloatx80Frac( b );
                   3581:     bExp = extractFloatx80Exp( b );
                   3582:     expDiff = aExp - bExp;
                   3583:     if ( 0 < expDiff ) {
                   3584:         if ( aExp == 0x7FFF ) {
                   3585:             if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3586:             return a;
                   3587:         }
                   3588:         if ( bExp == 0 ) --expDiff;
                   3589:         shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
                   3590:         zExp = aExp;
                   3591:     }
                   3592:     else if ( expDiff < 0 ) {
                   3593:         if ( bExp == 0x7FFF ) {
                   3594:             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3595:             return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3596:         }
                   3597:         if ( aExp == 0 ) ++expDiff;
                   3598:         shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
                   3599:         zExp = bExp;
                   3600:     }
                   3601:     else {
                   3602:         if ( aExp == 0x7FFF ) {
                   3603:             if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
                   3604:                 return propagateFloatx80NaN( a, b );
                   3605:             }
                   3606:             return a;
                   3607:         }
                   3608:         zSig1 = 0;
                   3609:         zSig0 = aSig + bSig;
                   3610:         if ( aExp == 0 ) {
                   3611:             normalizeFloatx80Subnormal( zSig0, &zExp, &zSig0 );
                   3612:             goto roundAndPack;
                   3613:         }
                   3614:         zExp = aExp;
                   3615:         goto shiftRight1;
                   3616:     }
                   3617:     zSig0 = aSig + bSig;
                   3618:     if ( (sbits64) zSig0 < 0 ) goto roundAndPack;
                   3619:  shiftRight1:
                   3620:     shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 );
                   3621:     zSig0 |= LIT64( 0x8000000000000000 );
                   3622:     ++zExp;
                   3623:  roundAndPack:
                   3624:     return
                   3625:         roundAndPackFloatx80(
                   3626:             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
                   3627: 
                   3628: }
                   3629: 
                   3630: /*
                   3631: -------------------------------------------------------------------------------
                   3632: Returns the result of subtracting the absolute values of the extended
                   3633: double-precision floating-point values `a' and `b'.  If `zSign' is 1, the
                   3634: difference is negated before being returned.  `zSign' is ignored if the
                   3635: result is a NaN.  The subtraction is performed according to the IEC/IEEE
                   3636: Standard for Binary Floating-Point Arithmetic.
                   3637: -------------------------------------------------------------------------------
                   3638: */
                   3639: static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
                   3640: {
                   3641:     int32 aExp, bExp, zExp;
                   3642:     bits64 aSig, bSig, zSig0, zSig1;
                   3643:     int32 expDiff;
                   3644:     floatx80 z;
                   3645: 
                   3646:     aSig = extractFloatx80Frac( a );
                   3647:     aExp = extractFloatx80Exp( a );
                   3648:     bSig = extractFloatx80Frac( b );
                   3649:     bExp = extractFloatx80Exp( b );
                   3650:     expDiff = aExp - bExp;
                   3651:     if ( 0 < expDiff ) goto aExpBigger;
                   3652:     if ( expDiff < 0 ) goto bExpBigger;
                   3653:     if ( aExp == 0x7FFF ) {
                   3654:         if ( (bits64) ( ( aSig | bSig )<<1 ) ) {
                   3655:             return propagateFloatx80NaN( a, b );
                   3656:         }
                   3657:         float_raise( float_flag_invalid );
                   3658:         z.low = floatx80_default_nan_low;
                   3659:         z.high = floatx80_default_nan_high;
                   3660:         return z;
                   3661:     }
                   3662:     if ( aExp == 0 ) {
                   3663:         aExp = 1;
                   3664:         bExp = 1;
                   3665:     }
                   3666:     zSig1 = 0;
                   3667:     if ( bSig < aSig ) goto aBigger;
                   3668:     if ( aSig < bSig ) goto bBigger;
                   3669:     return packFloatx80( float_rounding_mode() == float_round_down, 0, 0 );
                   3670:  bExpBigger:
                   3671:     if ( bExp == 0x7FFF ) {
                   3672:         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3673:         return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3674:     }
                   3675:     if ( aExp == 0 ) ++expDiff;
                   3676:     shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
                   3677:  bBigger:
                   3678:     sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
                   3679:     zExp = bExp;
                   3680:     zSign ^= 1;
                   3681:     goto normalizeRoundAndPack;
                   3682:  aExpBigger:
                   3683:     if ( aExp == 0x7FFF ) {
                   3684:         if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3685:         return a;
                   3686:     }
                   3687:     if ( bExp == 0 ) --expDiff;
                   3688:     shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
                   3689:  aBigger:
                   3690:     sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
                   3691:     zExp = aExp;
                   3692:  normalizeRoundAndPack:
                   3693:     return
                   3694:         normalizeRoundAndPackFloatx80(
                   3695:             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
                   3696: 
                   3697: }
                   3698: 
                   3699: /*
                   3700: -------------------------------------------------------------------------------
                   3701: Returns the result of adding the extended double-precision floating-point
                   3702: values `a' and `b'.  The operation is performed according to the IEC/IEEE
                   3703: Standard for Binary Floating-Point Arithmetic.
                   3704: -------------------------------------------------------------------------------
                   3705: */
                   3706: floatx80 floatx80_add( floatx80 a, floatx80 b )
                   3707: {
                   3708:     flag aSign, bSign;
                   3709: 
                   3710:     aSign = extractFloatx80Sign( a );
                   3711:     bSign = extractFloatx80Sign( b );
                   3712:     if ( aSign == bSign ) {
                   3713:         return addFloatx80Sigs( a, b, aSign );
                   3714:     }
                   3715:     else {
                   3716:         return subFloatx80Sigs( a, b, aSign );
                   3717:     }
                   3718: 
                   3719: }
                   3720: 
                   3721: /*
                   3722: -------------------------------------------------------------------------------
                   3723: Returns the result of subtracting the extended double-precision floating-
                   3724: point values `a' and `b'.  The operation is performed according to the
                   3725: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3726: -------------------------------------------------------------------------------
                   3727: */
                   3728: floatx80 floatx80_sub( floatx80 a, floatx80 b )
                   3729: {
                   3730:     flag aSign, bSign;
                   3731: 
                   3732:     aSign = extractFloatx80Sign( a );
                   3733:     bSign = extractFloatx80Sign( b );
                   3734:     if ( aSign == bSign ) {
                   3735:         return subFloatx80Sigs( a, b, aSign );
                   3736:     }
                   3737:     else {
                   3738:         return addFloatx80Sigs( a, b, aSign );
                   3739:     }
                   3740: 
                   3741: }
                   3742: 
                   3743: /*
                   3744: -------------------------------------------------------------------------------
                   3745: Returns the result of multiplying the extended double-precision floating-
                   3746: point values `a' and `b'.  The operation is performed according to the
                   3747: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3748: -------------------------------------------------------------------------------
                   3749: */
                   3750: floatx80 floatx80_mul( floatx80 a, floatx80 b )
                   3751: {
                   3752:     flag aSign, bSign, zSign;
                   3753:     int32 aExp, bExp, zExp;
                   3754:     bits64 aSig, bSig, zSig0, zSig1;
                   3755:     floatx80 z;
                   3756: 
                   3757:     aSig = extractFloatx80Frac( a );
                   3758:     aExp = extractFloatx80Exp( a );
                   3759:     aSign = extractFloatx80Sign( a );
                   3760:     bSig = extractFloatx80Frac( b );
                   3761:     bExp = extractFloatx80Exp( b );
                   3762:     bSign = extractFloatx80Sign( b );
                   3763:     zSign = aSign ^ bSign;
                   3764:     if ( aExp == 0x7FFF ) {
                   3765:         if (    (bits64) ( aSig<<1 )
                   3766:              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
                   3767:             return propagateFloatx80NaN( a, b );
                   3768:         }
                   3769:         if ( ( bExp | bSig ) == 0 ) goto invalid;
                   3770:         return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3771:     }
                   3772:     if ( bExp == 0x7FFF ) {
                   3773:         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3774:         if ( ( aExp | aSig ) == 0 ) {
                   3775:  invalid:
                   3776:             float_raise( float_flag_invalid );
                   3777:             z.low = floatx80_default_nan_low;
                   3778:             z.high = floatx80_default_nan_high;
                   3779:             return z;
                   3780:         }
                   3781:         return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3782:     }
                   3783:     if ( aExp == 0 ) {
                   3784:         if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
                   3785:         normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
                   3786:     }
                   3787:     if ( bExp == 0 ) {
                   3788:         if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
                   3789:         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
                   3790:     }
                   3791:     zExp = aExp + bExp - 0x3FFE;
                   3792:     mul64To128( aSig, bSig, &zSig0, &zSig1 );
                   3793:     if ( 0 < (sbits64) zSig0 ) {
                   3794:         shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
                   3795:         --zExp;
                   3796:     }
                   3797:     return
                   3798:         roundAndPackFloatx80(
                   3799:             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
                   3800: 
                   3801: }
                   3802: 
                   3803: /*
                   3804: -------------------------------------------------------------------------------
                   3805: Returns the result of dividing the extended double-precision floating-point
                   3806: value `a' by the corresponding value `b'.  The operation is performed
                   3807: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3808: -------------------------------------------------------------------------------
                   3809: */
                   3810: floatx80 floatx80_div( floatx80 a, floatx80 b )
                   3811: {
                   3812:     flag aSign, bSign, zSign;
                   3813:     int32 aExp, bExp, zExp;
                   3814:     bits64 aSig, bSig, zSig0, zSig1;
                   3815:     bits64 rem0, rem1, rem2, term0, term1, term2;
                   3816:     floatx80 z;
                   3817: 
                   3818:     aSig = extractFloatx80Frac( a );
                   3819:     aExp = extractFloatx80Exp( a );
                   3820:     aSign = extractFloatx80Sign( a );
                   3821:     bSig = extractFloatx80Frac( b );
                   3822:     bExp = extractFloatx80Exp( b );
                   3823:     bSign = extractFloatx80Sign( b );
                   3824:     zSign = aSign ^ bSign;
                   3825:     if ( aExp == 0x7FFF ) {
                   3826:         if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3827:         if ( bExp == 0x7FFF ) {
                   3828:             if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3829:             goto invalid;
                   3830:         }
                   3831:         return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3832:     }
                   3833:     if ( bExp == 0x7FFF ) {
                   3834:         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3835:         return packFloatx80( zSign, 0, 0 );
                   3836:     }
                   3837:     if ( bExp == 0 ) {
                   3838:         if ( bSig == 0 ) {
                   3839:             if ( ( aExp | aSig ) == 0 ) {
                   3840:  invalid:
                   3841:                 float_raise( float_flag_invalid );
                   3842:                 z.low = floatx80_default_nan_low;
                   3843:                 z.high = floatx80_default_nan_high;
                   3844:                 return z;
                   3845:             }
                   3846:             float_raise( float_flag_divbyzero );
                   3847:             return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   3848:         }
                   3849:         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
                   3850:     }
                   3851:     if ( aExp == 0 ) {
                   3852:         if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
                   3853:         normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
                   3854:     }
                   3855:     zExp = aExp - bExp + 0x3FFE;
                   3856:     rem1 = 0;
                   3857:     if ( bSig <= aSig ) {
                   3858:         shift128Right( aSig, 0, 1, &aSig, &rem1 );
                   3859:         ++zExp;
                   3860:     }
                   3861:     zSig0 = estimateDiv128To64( aSig, rem1, bSig );
                   3862:     mul64To128( bSig, zSig0, &term0, &term1 );
                   3863:     sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
                   3864:     while ( (sbits64) rem0 < 0 ) {
                   3865:         --zSig0;
                   3866:         add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
                   3867:     }
                   3868:     zSig1 = estimateDiv128To64( rem1, 0, bSig );
                   3869:     if ( (bits64) ( zSig1<<1 ) <= 8 ) {
                   3870:         mul64To128( bSig, zSig1, &term1, &term2 );
                   3871:         sub128( rem1, 0, term1, term2, &rem1, &rem2 );
                   3872:         while ( (sbits64) rem1 < 0 ) {
                   3873:             --zSig1;
                   3874:             add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
                   3875:         }
                   3876:         zSig1 |= ( ( rem1 | rem2 ) != 0 );
                   3877:     }
                   3878:     return
                   3879:         roundAndPackFloatx80(
                   3880:             floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
                   3881: 
                   3882: }
                   3883: 
                   3884: /*
                   3885: -------------------------------------------------------------------------------
                   3886: Returns the remainder of the extended double-precision floating-point value
                   3887: `a' with respect to the corresponding value `b'.  The operation is performed
                   3888: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   3889: -------------------------------------------------------------------------------
                   3890: */
                   3891: floatx80 floatx80_rem( floatx80 a, floatx80 b )
                   3892: {
                   3893:     flag aSign, bSign, zSign;
                   3894:     int32 aExp, bExp, expDiff;
                   3895:     bits64 aSig0, aSig1, bSig;
                   3896:     bits64 q, term0, term1, alternateASig0, alternateASig1;
                   3897:     floatx80 z;
                   3898: 
                   3899:     aSig0 = extractFloatx80Frac( a );
                   3900:     aExp = extractFloatx80Exp( a );
                   3901:     aSign = extractFloatx80Sign( a );
                   3902:     bSig = extractFloatx80Frac( b );
                   3903:     bExp = extractFloatx80Exp( b );
                   3904:     bSign = extractFloatx80Sign( b );
                   3905:     if ( aExp == 0x7FFF ) {
                   3906:         if (    (bits64) ( aSig0<<1 )
                   3907:              || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {
                   3908:             return propagateFloatx80NaN( a, b );
                   3909:         }
                   3910:         goto invalid;
                   3911:     }
                   3912:     if ( bExp == 0x7FFF ) {
                   3913:         if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b );
                   3914:         return a;
                   3915:     }
                   3916:     if ( bExp == 0 ) {
                   3917:         if ( bSig == 0 ) {
                   3918:  invalid:
                   3919:             float_raise( float_flag_invalid );
                   3920:             z.low = floatx80_default_nan_low;
                   3921:             z.high = floatx80_default_nan_high;
                   3922:             return z;
                   3923:         }
                   3924:         normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
                   3925:     }
                   3926:     if ( aExp == 0 ) {
                   3927:         if ( (bits64) ( aSig0<<1 ) == 0 ) return a;
                   3928:         normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
                   3929:     }
                   3930:     bSig |= LIT64( 0x8000000000000000 );
                   3931:     zSign = aSign;
                   3932:     expDiff = aExp - bExp;
                   3933:     aSig1 = 0;
                   3934:     if ( expDiff < 0 ) {
                   3935:         if ( expDiff < -1 ) return a;
                   3936:         shift128Right( aSig0, 0, 1, &aSig0, &aSig1 );
                   3937:         expDiff = 0;
                   3938:     }
                   3939:     q = ( bSig <= aSig0 );
                   3940:     if ( q ) aSig0 -= bSig;
                   3941:     expDiff -= 64;
                   3942:     while ( 0 < expDiff ) {
                   3943:         q = estimateDiv128To64( aSig0, aSig1, bSig );
                   3944:         q = ( 2 < q ) ? q - 2 : 0;
                   3945:         mul64To128( bSig, q, &term0, &term1 );
                   3946:         sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
                   3947:         shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );
                   3948:         expDiff -= 62;
                   3949:     }
                   3950:     expDiff += 64;
                   3951:     if ( 0 < expDiff ) {
                   3952:         q = estimateDiv128To64( aSig0, aSig1, bSig );
                   3953:         q = ( 2 < q ) ? q - 2 : 0;
                   3954:         q >>= 64 - expDiff;
                   3955:         mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );
                   3956:         sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
                   3957:         shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
                   3958:         while ( le128( term0, term1, aSig0, aSig1 ) ) {
                   3959:             ++q;
                   3960:             sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
                   3961:         }
                   3962:     }
                   3963:     else {
                   3964:         term1 = 0;
                   3965:         term0 = bSig;
                   3966:     }
                   3967:     sub128( term0, term1, aSig0, aSig1, &alternateASig0, &alternateASig1 );
                   3968:     if (    lt128( alternateASig0, alternateASig1, aSig0, aSig1 )
                   3969:          || (    eq128( alternateASig0, alternateASig1, aSig0, aSig1 )
                   3970:               && ( q & 1 ) )
                   3971:        ) {
                   3972:         aSig0 = alternateASig0;
                   3973:         aSig1 = alternateASig1;
                   3974:         zSign = ! zSign;
                   3975:     }
                   3976:     return
                   3977:         normalizeRoundAndPackFloatx80(
                   3978:             80, zSign, bExp + expDiff, aSig0, aSig1 );
                   3979: 
                   3980: }
                   3981: 
                   3982: /*
                   3983: -------------------------------------------------------------------------------
                   3984: Returns the square root of the extended double-precision floating-point
                   3985: value `a'.  The operation is performed according to the IEC/IEEE Standard
                   3986: for Binary Floating-Point Arithmetic.
                   3987: -------------------------------------------------------------------------------
                   3988: */
                   3989: floatx80 floatx80_sqrt( floatx80 a )
                   3990: {
                   3991:     flag aSign;
                   3992:     int32 aExp, zExp;
                   3993:     bits64 aSig0, aSig1, zSig0, zSig1, doubleZSig0;
                   3994:     bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;
                   3995:     floatx80 z;
                   3996: 
                   3997:     aSig0 = extractFloatx80Frac( a );
                   3998:     aExp = extractFloatx80Exp( a );
                   3999:     aSign = extractFloatx80Sign( a );
                   4000:     if ( aExp == 0x7FFF ) {
                   4001:         if ( (bits64) ( aSig0<<1 ) ) return propagateFloatx80NaN( a, a );
                   4002:         if ( ! aSign ) return a;
                   4003:         goto invalid;
                   4004:     }
                   4005:     if ( aSign ) {
                   4006:         if ( ( aExp | aSig0 ) == 0 ) return a;
                   4007:  invalid:
                   4008:         float_raise( float_flag_invalid );
                   4009:         z.low = floatx80_default_nan_low;
                   4010:         z.high = floatx80_default_nan_high;
                   4011:         return z;
                   4012:     }
                   4013:     if ( aExp == 0 ) {
                   4014:         if ( aSig0 == 0 ) return packFloatx80( 0, 0, 0 );
                   4015:         normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
                   4016:     }
                   4017:     zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFF;
                   4018:     zSig0 = estimateSqrt32( aExp, aSig0>>32 );
                   4019:     shift128Right( aSig0, 0, 2 + ( aExp & 1 ), &aSig0, &aSig1 );
                   4020:     zSig0 = estimateDiv128To64( aSig0, aSig1, zSig0<<32 ) + ( zSig0<<30 );
                   4021:     doubleZSig0 = zSig0<<1;
                   4022:     mul64To128( zSig0, zSig0, &term0, &term1 );
                   4023:     sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );
                   4024:     while ( (sbits64) rem0 < 0 ) {
                   4025:         --zSig0;
                   4026:         doubleZSig0 -= 2;
                   4027:         add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );
                   4028:     }
                   4029:     zSig1 = estimateDiv128To64( rem1, 0, doubleZSig0 );
                   4030:     if ( ( zSig1 & LIT64( 0x3FFFFFFFFFFFFFFF ) ) <= 5 ) {
                   4031:         if ( zSig1 == 0 ) zSig1 = 1;
                   4032:         mul64To128( doubleZSig0, zSig1, &term1, &term2 );
                   4033:         sub128( rem1, 0, term1, term2, &rem1, &rem2 );
                   4034:         mul64To128( zSig1, zSig1, &term2, &term3 );
                   4035:         sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );
                   4036:         while ( (sbits64) rem1 < 0 ) {
                   4037:             --zSig1;
                   4038:             shortShift128Left( 0, zSig1, 1, &term2, &term3 );
                   4039:             term3 |= 1;
                   4040:             term2 |= doubleZSig0;
                   4041:             add192( rem1, rem2, rem3, 0, term2, term3, &rem1, &rem2, &rem3 );
                   4042:         }
                   4043:         zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
                   4044:     }
                   4045:     shortShift128Left( 0, zSig1, 1, &zSig0, &zSig1 );
                   4046:     zSig0 |= doubleZSig0;
                   4047:     return
                   4048:         roundAndPackFloatx80(
                   4049:             floatx80_rounding_precision, 0, zExp, zSig0, zSig1 );
                   4050: 
                   4051: }
                   4052: 
                   4053: /*
                   4054: -------------------------------------------------------------------------------
                   4055: Returns 1 if the extended double-precision floating-point value `a' is
                   4056: equal to the corresponding value `b', and 0 otherwise.  The comparison is
                   4057: performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4058: Arithmetic.
                   4059: -------------------------------------------------------------------------------
                   4060: */
                   4061: flag floatx80_eq( floatx80 a, floatx80 b )
                   4062: {
                   4063: 
                   4064:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4065:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4066:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4067:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4068:        ) {
                   4069:         if (    floatx80_is_signaling_nan( a )
                   4070:              || floatx80_is_signaling_nan( b ) ) {
                   4071:             float_raise( float_flag_invalid );
                   4072:         }
                   4073:         return 0;
                   4074:     }
                   4075:     return
                   4076:            ( a.low == b.low )
                   4077:         && (    ( a.high == b.high )
                   4078:              || (    ( a.low == 0 )
                   4079:                   && ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) )
                   4080:            );
                   4081: 
                   4082: }
                   4083: 
                   4084: /*
                   4085: -------------------------------------------------------------------------------
                   4086: Returns 1 if the extended double-precision floating-point value `a' is
                   4087: less than or equal to the corresponding value `b', and 0 otherwise.  The
                   4088: comparison is performed according to the IEC/IEEE Standard for Binary
                   4089: Floating-Point Arithmetic.
                   4090: -------------------------------------------------------------------------------
                   4091: */
                   4092: flag floatx80_le( floatx80 a, floatx80 b )
                   4093: {
                   4094:     flag aSign, bSign;
                   4095: 
                   4096:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4097:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4098:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4099:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4100:        ) {
                   4101:         float_raise( float_flag_invalid );
                   4102:         return 0;
                   4103:     }
                   4104:     aSign = extractFloatx80Sign( a );
                   4105:     bSign = extractFloatx80Sign( b );
                   4106:     if ( aSign != bSign ) {
                   4107:         return
                   4108:                aSign
                   4109:             || (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   4110:                  == 0 );
                   4111:     }
                   4112:     return
                   4113:           aSign ? le128( b.high, b.low, a.high, a.low )
                   4114:         : le128( a.high, a.low, b.high, b.low );
                   4115: 
                   4116: }
                   4117: 
                   4118: /*
                   4119: -------------------------------------------------------------------------------
                   4120: Returns 1 if the extended double-precision floating-point value `a' is
                   4121: less than the corresponding value `b', and 0 otherwise.  The comparison
                   4122: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4123: Arithmetic.
                   4124: -------------------------------------------------------------------------------
                   4125: */
                   4126: flag floatx80_lt( floatx80 a, floatx80 b )
                   4127: {
                   4128:     flag aSign, bSign;
                   4129: 
                   4130:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4131:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4132:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4133:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4134:        ) {
                   4135:         float_raise( float_flag_invalid );
                   4136:         return 0;
                   4137:     }
                   4138:     aSign = extractFloatx80Sign( a );
                   4139:     bSign = extractFloatx80Sign( b );
                   4140:     if ( aSign != bSign ) {
                   4141:         return
                   4142:                aSign
                   4143:             && (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   4144:                  != 0 );
                   4145:     }
                   4146:     return
                   4147:           aSign ? lt128( b.high, b.low, a.high, a.low )
                   4148:         : lt128( a.high, a.low, b.high, b.low );
                   4149: 
                   4150: }
                   4151: 
                   4152: /*
                   4153: -------------------------------------------------------------------------------
                   4154: Returns 1 if the extended double-precision floating-point value `a' is equal
                   4155: to the corresponding value `b', and 0 otherwise.  The invalid exception is
                   4156: raised if either operand is a NaN.  Otherwise, the comparison is performed
                   4157: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   4158: -------------------------------------------------------------------------------
                   4159: */
                   4160: flag floatx80_eq_signaling( floatx80 a, floatx80 b )
                   4161: {
                   4162: 
                   4163:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4164:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4165:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4166:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4167:        ) {
                   4168:         float_raise( float_flag_invalid );
                   4169:         return 0;
                   4170:     }
                   4171:     return
                   4172:            ( a.low == b.low )
                   4173:         && (    ( a.high == b.high )
                   4174:              || (    ( a.low == 0 )
                   4175:                   && ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) )
                   4176:            );
                   4177: 
                   4178: }
                   4179: 
                   4180: /*
                   4181: -------------------------------------------------------------------------------
                   4182: Returns 1 if the extended double-precision floating-point value `a' is less
                   4183: than or equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs
                   4184: do not cause an exception.  Otherwise, the comparison is performed according
                   4185: to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   4186: -------------------------------------------------------------------------------
                   4187: */
                   4188: flag floatx80_le_quiet( floatx80 a, floatx80 b )
                   4189: {
                   4190:     flag aSign, bSign;
                   4191: 
                   4192:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4193:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4194:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4195:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4196:        ) {
                   4197:         if (    floatx80_is_signaling_nan( a )
                   4198:              || floatx80_is_signaling_nan( b ) ) {
                   4199:             float_raise( float_flag_invalid );
                   4200:         }
                   4201:         return 0;
                   4202:     }
                   4203:     aSign = extractFloatx80Sign( a );
                   4204:     bSign = extractFloatx80Sign( b );
                   4205:     if ( aSign != bSign ) {
                   4206:         return
                   4207:                aSign
                   4208:             || (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   4209:                  == 0 );
                   4210:     }
                   4211:     return
                   4212:           aSign ? le128( b.high, b.low, a.high, a.low )
                   4213:         : le128( a.high, a.low, b.high, b.low );
                   4214: 
                   4215: }
                   4216: 
                   4217: /*
                   4218: -------------------------------------------------------------------------------
                   4219: Returns 1 if the extended double-precision floating-point value `a' is less
                   4220: than the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause
                   4221: an exception.  Otherwise, the comparison is performed according to the
                   4222: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   4223: -------------------------------------------------------------------------------
                   4224: */
                   4225: flag floatx80_lt_quiet( floatx80 a, floatx80 b )
                   4226: {
                   4227:     flag aSign, bSign;
                   4228: 
                   4229:     if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
                   4230:               && (bits64) ( extractFloatx80Frac( a )<<1 ) )
                   4231:          || (    ( extractFloatx80Exp( b ) == 0x7FFF )
                   4232:               && (bits64) ( extractFloatx80Frac( b )<<1 ) )
                   4233:        ) {
                   4234:         if (    floatx80_is_signaling_nan( a )
                   4235:              || floatx80_is_signaling_nan( b ) ) {
                   4236:             float_raise( float_flag_invalid );
                   4237:         }
                   4238:         return 0;
                   4239:     }
                   4240:     aSign = extractFloatx80Sign( a );
                   4241:     bSign = extractFloatx80Sign( b );
                   4242:     if ( aSign != bSign ) {
                   4243:         return
                   4244:                aSign
                   4245:             && (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   4246:                  != 0 );
                   4247:     }
                   4248:     return
                   4249:           aSign ? lt128( b.high, b.low, a.high, a.low )
                   4250:         : lt128( a.high, a.low, b.high, b.low );
                   4251: 
                   4252: }
                   4253: 
                   4254: #endif
                   4255: 
                   4256: #ifdef FLOAT128
                   4257: 
                   4258: /*
                   4259: -------------------------------------------------------------------------------
                   4260: Returns the result of converting the quadruple-precision floating-point
                   4261: value `a' to the 32-bit two's complement integer format.  The conversion
                   4262: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4263: Arithmetic---which means in particular that the conversion is rounded
                   4264: according to the current rounding mode.  If `a' is a NaN, the largest
                   4265: positive integer is returned.  Otherwise, if the conversion overflows, the
                   4266: largest integer with the same sign as `a' is returned.
                   4267: -------------------------------------------------------------------------------
                   4268: */
                   4269: int32 float128_to_int32( float128 a )
                   4270: {
                   4271:     flag aSign;
                   4272:     int32 aExp, shiftCount;
                   4273:     bits64 aSig0, aSig1;
                   4274: 
                   4275:     aSig1 = extractFloat128Frac1( a );
                   4276:     aSig0 = extractFloat128Frac0( a );
                   4277:     aExp = extractFloat128Exp( a );
                   4278:     aSign = extractFloat128Sign( a );
                   4279:     if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
                   4280:     if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );
                   4281:     aSig0 |= ( aSig1 != 0 );
                   4282:     shiftCount = 0x4028 - aExp;
                   4283:     if ( 0 < shiftCount ) shift64RightJamming( aSig0, shiftCount, &aSig0 );
                   4284:     return roundAndPackInt32( aSign, aSig0 );
                   4285: 
                   4286: }
                   4287: 
                   4288: /*
                   4289: -------------------------------------------------------------------------------
                   4290: Returns the result of converting the quadruple-precision floating-point
                   4291: value `a' to the 32-bit two's complement integer format.  The conversion
                   4292: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4293: Arithmetic, except that the conversion is always rounded toward zero.  If
                   4294: `a' is a NaN, the largest positive integer is returned.  Otherwise, if the
                   4295: conversion overflows, the largest integer with the same sign as `a' is
                   4296: returned.
                   4297: -------------------------------------------------------------------------------
                   4298: */
                   4299: int32 float128_to_int32_round_to_zero( float128 a )
                   4300: {
                   4301:     flag aSign;
                   4302:     int32 aExp, shiftCount;
                   4303:     bits64 aSig0, aSig1, savedASig;
                   4304:     int32 z;
                   4305: 
                   4306:     aSig1 = extractFloat128Frac1( a );
                   4307:     aSig0 = extractFloat128Frac0( a );
                   4308:     aExp = extractFloat128Exp( a );
                   4309:     aSign = extractFloat128Sign( a );
                   4310:     aSig0 |= ( aSig1 != 0 );
                   4311:     if ( 0x401E < aExp ) {
                   4312:         if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
                   4313:         goto invalid;
                   4314:     }
                   4315:     else if ( aExp < 0x3FFF ) {
                   4316:         if ( aExp || aSig0 ) float_set_inexact();
                   4317:         return 0;
                   4318:     }
                   4319:     aSig0 |= LIT64( 0x0001000000000000 );
                   4320:     shiftCount = 0x402F - aExp;
                   4321:     savedASig = aSig0;
                   4322:     aSig0 >>= shiftCount;
                   4323:     z = aSig0;
                   4324:     if ( aSign ) z = - z;
                   4325:     if ( ( z < 0 ) ^ aSign ) {
                   4326:  invalid:
                   4327:         float_raise( float_flag_invalid );
                   4328:         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
                   4329:     }
                   4330:     if ( ( aSig0<<shiftCount ) != savedASig ) {
                   4331:         float_set_inexact();
                   4332:     }
                   4333:     return z;
                   4334: 
                   4335: }
                   4336: 
                   4337: /*
                   4338: -------------------------------------------------------------------------------
                   4339: Returns the result of converting the quadruple-precision floating-point
                   4340: value `a' to the 64-bit two's complement integer format.  The conversion
                   4341: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4342: Arithmetic---which means in particular that the conversion is rounded
                   4343: according to the current rounding mode.  If `a' is a NaN, the largest
                   4344: positive integer is returned.  Otherwise, if the conversion overflows, the
                   4345: largest integer with the same sign as `a' is returned.
                   4346: -------------------------------------------------------------------------------
                   4347: */
                   4348: int64 float128_to_int64( float128 a )
                   4349: {
                   4350:     flag aSign;
                   4351:     int32 aExp, shiftCount;
                   4352:     bits64 aSig0, aSig1;
                   4353: 
                   4354:     aSig1 = extractFloat128Frac1( a );
                   4355:     aSig0 = extractFloat128Frac0( a );
                   4356:     aExp = extractFloat128Exp( a );
                   4357:     aSign = extractFloat128Sign( a );
                   4358:     if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );
                   4359:     shiftCount = 0x402F - aExp;
                   4360:     if ( shiftCount <= 0 ) {
                   4361:         if ( 0x403E < aExp ) {
                   4362:             float_raise( float_flag_invalid );
                   4363:             if (    ! aSign
                   4364:                  || (    ( aExp == 0x7FFF )
                   4365:                       && ( aSig1 || ( aSig0 != LIT64( 0x0001000000000000 ) ) )
                   4366:                     )
                   4367:                ) {
                   4368:                 return LIT64( 0x7FFFFFFFFFFFFFFF );
                   4369:             }
                   4370:             return (sbits64) LIT64( 0x8000000000000000 );
                   4371:         }
                   4372:         shortShift128Left( aSig0, aSig1, - shiftCount, &aSig0, &aSig1 );
                   4373:     }
                   4374:     else {
                   4375:         shift64ExtraRightJamming( aSig0, aSig1, shiftCount, &aSig0, &aSig1 );
                   4376:     }
                   4377:     return roundAndPackInt64( aSign, aSig0, aSig1 );
                   4378: 
                   4379: }
                   4380: 
                   4381: /*
                   4382: -------------------------------------------------------------------------------
                   4383: Returns the result of converting the quadruple-precision floating-point
                   4384: value `a' to the 64-bit two's complement integer format.  The conversion
                   4385: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4386: Arithmetic, except that the conversion is always rounded toward zero.
                   4387: If `a' is a NaN, the largest positive integer is returned.  Otherwise, if
                   4388: the conversion overflows, the largest integer with the same sign as `a' is
                   4389: returned.
                   4390: -------------------------------------------------------------------------------
                   4391: */
                   4392: int64 float128_to_int64_round_to_zero( float128 a )
                   4393: {
                   4394:     flag aSign;
                   4395:     int32 aExp, shiftCount;
                   4396:     bits64 aSig0, aSig1;
                   4397:     int64 z;
                   4398: 
                   4399:     aSig1 = extractFloat128Frac1( a );
                   4400:     aSig0 = extractFloat128Frac0( a );
                   4401:     aExp = extractFloat128Exp( a );
                   4402:     aSign = extractFloat128Sign( a );
                   4403:     if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );
                   4404:     shiftCount = aExp - 0x402F;
                   4405:     if ( 0 < shiftCount ) {
                   4406:         if ( 0x403E <= aExp ) {
                   4407:             aSig0 &= LIT64( 0x0000FFFFFFFFFFFF );
                   4408:             if (    ( a.high == LIT64( 0xC03E000000000000 ) )
                   4409:                  && ( aSig1 < LIT64( 0x0002000000000000 ) ) ) {
                   4410:                 if ( aSig1 ) float_set_inexact();
                   4411:             }
                   4412:             else {
                   4413:                 float_raise( float_flag_invalid );
                   4414:                 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
                   4415:                     return LIT64( 0x7FFFFFFFFFFFFFFF );
                   4416:                 }
                   4417:             }
                   4418:             return (sbits64) LIT64( 0x8000000000000000 );
                   4419:         }
                   4420:         z = ( aSig0<<shiftCount ) | ( aSig1>>( ( - shiftCount ) & 63 ) );
                   4421:         if ( (bits64) ( aSig1<<shiftCount ) ) {
                   4422:             float_set_inexact();
                   4423:         }
                   4424:     }
                   4425:     else {
                   4426:         if ( aExp < 0x3FFF ) {
                   4427:             if ( aExp | aSig0 | aSig1 ) {
                   4428:                 float_set_inexact();
                   4429:             }
                   4430:             return 0;
                   4431:         }
                   4432:         z = aSig0>>( - shiftCount );
                   4433:         if (    aSig1
                   4434:              || ( shiftCount && (bits64) ( aSig0<<( shiftCount & 63 ) ) ) ) {
                   4435:             float_set_inexact();
                   4436:         }
                   4437:     }
                   4438:     if ( aSign ) z = - z;
                   4439:     return z;
                   4440: 
                   4441: }
                   4442: 
                   4443: /*
                   4444: -------------------------------------------------------------------------------
                   4445: Returns the result of converting the quadruple-precision floating-point
                   4446: value `a' to the single-precision floating-point format.  The conversion
                   4447: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4448: Arithmetic.
                   4449: -------------------------------------------------------------------------------
                   4450: */
                   4451: float32 float128_to_float32( float128 a )
                   4452: {
                   4453:     flag aSign;
                   4454:     int32 aExp;
                   4455:     bits64 aSig0, aSig1;
                   4456:     bits32 zSig;
                   4457: 
                   4458:     aSig1 = extractFloat128Frac1( a );
                   4459:     aSig0 = extractFloat128Frac0( a );
                   4460:     aExp = extractFloat128Exp( a );
                   4461:     aSign = extractFloat128Sign( a );
                   4462:     if ( aExp == 0x7FFF ) {
                   4463:         if ( aSig0 | aSig1 ) {
                   4464:             return commonNaNToFloat32( float128ToCommonNaN( a ) );
                   4465:         }
                   4466:         return packFloat32( aSign, 0xFF, 0 );
                   4467:     }
                   4468:     aSig0 |= ( aSig1 != 0 );
                   4469:     shift64RightJamming( aSig0, 18, &aSig0 );
                   4470:     zSig = aSig0;
                   4471:     if ( aExp || zSig ) {
                   4472:         zSig |= 0x40000000;
                   4473:         aExp -= 0x3F81;
                   4474:     }
                   4475:     return roundAndPackFloat32( aSign, aExp, zSig );
                   4476: 
                   4477: }
                   4478: 
                   4479: /*
                   4480: -------------------------------------------------------------------------------
                   4481: Returns the result of converting the quadruple-precision floating-point
                   4482: value `a' to the double-precision floating-point format.  The conversion
                   4483: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   4484: Arithmetic.
                   4485: -------------------------------------------------------------------------------
                   4486: */
                   4487: float64 float128_to_float64( float128 a )
                   4488: {
                   4489:     flag aSign;
                   4490:     int32 aExp;
                   4491:     bits64 aSig0, aSig1;
                   4492: 
                   4493:     aSig1 = extractFloat128Frac1( a );
                   4494:     aSig0 = extractFloat128Frac0( a );
                   4495:     aExp = extractFloat128Exp( a );
                   4496:     aSign = extractFloat128Sign( a );
                   4497:     if ( aExp == 0x7FFF ) {
                   4498:         if ( aSig0 | aSig1 ) {
                   4499:             return commonNaNToFloat64( float128ToCommonNaN( a ) );
                   4500:         }
                   4501:         return packFloat64( aSign, 0x7FF, 0 );
                   4502:     }
                   4503:     shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 );
                   4504:     aSig0 |= ( aSig1 != 0 );
                   4505:     if ( aExp || aSig0 ) {
                   4506:         aSig0 |= LIT64( 0x4000000000000000 );
                   4507:         aExp -= 0x3C01;
                   4508:     }
                   4509:     return roundAndPackFloat64( aSign, aExp, aSig0 );
                   4510: 
                   4511: }
                   4512: 
                   4513: #ifdef FLOATX80
                   4514: 
                   4515: /*
                   4516: -------------------------------------------------------------------------------
                   4517: Returns the result of converting the quadruple-precision floating-point
                   4518: value `a' to the extended double-precision floating-point format.  The
                   4519: conversion is performed according to the IEC/IEEE Standard for Binary
                   4520: Floating-Point Arithmetic.
                   4521: -------------------------------------------------------------------------------
                   4522: */
                   4523: floatx80 float128_to_floatx80( float128 a )
                   4524: {
                   4525:     flag aSign;
                   4526:     int32 aExp;
                   4527:     bits64 aSig0, aSig1;
                   4528: 
                   4529:     aSig1 = extractFloat128Frac1( a );
                   4530:     aSig0 = extractFloat128Frac0( a );
                   4531:     aExp = extractFloat128Exp( a );
                   4532:     aSign = extractFloat128Sign( a );
                   4533:     if ( aExp == 0x7FFF ) {
                   4534:         if ( aSig0 | aSig1 ) {
                   4535:             return commonNaNToFloatx80( float128ToCommonNaN( a ) );
                   4536:         }
                   4537:         return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
                   4538:     }
                   4539:     if ( aExp == 0 ) {
                   4540:         if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
                   4541:         normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
                   4542:     }
                   4543:     else {
                   4544:         aSig0 |= LIT64( 0x0001000000000000 );
                   4545:     }
                   4546:     shortShift128Left( aSig0, aSig1, 15, &aSig0, &aSig1 );
                   4547:     return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 );
                   4548: 
                   4549: }
                   4550: 
                   4551: #endif
                   4552: 
                   4553: /*
                   4554: -------------------------------------------------------------------------------
                   4555: Rounds the quadruple-precision floating-point value `a' to an integer, and
                   4556: returns the result as a quadruple-precision floating-point value.  The
                   4557: operation is performed according to the IEC/IEEE Standard for Binary
                   4558: Floating-Point Arithmetic.
                   4559: -------------------------------------------------------------------------------
                   4560: */
                   4561: float128 float128_round_to_int( float128 a )
                   4562: {
                   4563:     flag aSign;
                   4564:     int32 aExp;
                   4565:     bits64 lastBitMask, roundBitsMask;
                   4566:     int8 roundingMode;
                   4567:     float128 z;
                   4568: 
                   4569:     aExp = extractFloat128Exp( a );
                   4570:     if ( 0x402F <= aExp ) {
                   4571:         if ( 0x406F <= aExp ) {
                   4572:             if (    ( aExp == 0x7FFF )
                   4573:                  && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) )
                   4574:                ) {
                   4575:                 return propagateFloat128NaN( a, a );
                   4576:             }
                   4577:             return a;
                   4578:         }
                   4579:         lastBitMask = 1;
                   4580:         lastBitMask = ( lastBitMask<<( 0x406E - aExp ) )<<1;
                   4581:         roundBitsMask = lastBitMask - 1;
                   4582:         z = a;
                   4583:         roundingMode = float_rounding_mode();
                   4584:         if ( roundingMode == float_round_nearest_even ) {
                   4585:             if ( lastBitMask ) {
                   4586:                 add128( z.high, z.low, 0, lastBitMask>>1, &z.high, &z.low );
                   4587:                 if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask;
                   4588:             }
                   4589:             else {
                   4590:                 if ( (sbits64) z.low < 0 ) {
                   4591:                     ++z.high;
                   4592:                     if ( (bits64) ( z.low<<1 ) == 0 ) z.high &= ~1;
                   4593:                 }
                   4594:             }
                   4595:         }
                   4596:         else if ( roundingMode != float_round_to_zero ) {
                   4597:             if (   extractFloat128Sign( z )
                   4598:                  ^ ( roundingMode == float_round_up ) ) {
                   4599:                 add128( z.high, z.low, 0, roundBitsMask, &z.high, &z.low );
                   4600:             }
                   4601:         }
                   4602:         z.low &= ~ roundBitsMask;
                   4603:     }
                   4604:     else {
                   4605:         if ( aExp < 0x3FFF ) {
                   4606:             if ( ( ( (bits64) ( a.high<<1 ) ) | a.low ) == 0 ) return a;
                   4607:             float_set_inexact();
                   4608:             aSign = extractFloat128Sign( a );
                   4609:             switch ( float_rounding_mode() ) {
                   4610:              case float_round_nearest_even:
                   4611:                 if (    ( aExp == 0x3FFE )
                   4612:                      && (   extractFloat128Frac0( a )
                   4613:                           | extractFloat128Frac1( a ) )
                   4614:                    ) {
                   4615:                     return packFloat128( aSign, 0x3FFF, 0, 0 );
                   4616:                 }
                   4617:                 break;
                   4618:              case float_round_down:
                   4619:                 return
                   4620:                       aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
                   4621:                     : packFloat128( 0, 0, 0, 0 );
                   4622:              case float_round_up:
                   4623:                 return
                   4624:                       aSign ? packFloat128( 1, 0, 0, 0 )
                   4625:                     : packFloat128( 0, 0x3FFF, 0, 0 );
                   4626:             }
                   4627:             return packFloat128( aSign, 0, 0, 0 );
                   4628:         }
                   4629:         lastBitMask = 1;
                   4630:         lastBitMask <<= 0x402F - aExp;
                   4631:         roundBitsMask = lastBitMask - 1;
                   4632:         z.low = 0;
                   4633:         z.high = a.high;
                   4634:         roundingMode = float_rounding_mode();
                   4635:         if ( roundingMode == float_round_nearest_even ) {
                   4636:             z.high += lastBitMask>>1;
                   4637:             if ( ( ( z.high & roundBitsMask ) | a.low ) == 0 ) {
                   4638:                 z.high &= ~ lastBitMask;
                   4639:             }
                   4640:         }
                   4641:         else if ( roundingMode != float_round_to_zero ) {
                   4642:             if (   extractFloat128Sign( z )
                   4643:                  ^ ( roundingMode == float_round_up ) ) {
                   4644:                 z.high |= ( a.low != 0 );
                   4645:                 z.high += roundBitsMask;
                   4646:             }
                   4647:         }
                   4648:         z.high &= ~ roundBitsMask;
                   4649:     }
                   4650:     if ( ( z.low != a.low ) || ( z.high != a.high ) ) {
                   4651:         float_set_inexact();
                   4652:     }
                   4653:     return z;
                   4654: 
                   4655: }
                   4656: 
                   4657: /*
                   4658: -------------------------------------------------------------------------------
                   4659: Returns the result of adding the absolute values of the quadruple-precision
                   4660: floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated
                   4661: before being returned.  `zSign' is ignored if the result is a NaN.
                   4662: The addition is performed according to the IEC/IEEE Standard for Binary
                   4663: Floating-Point Arithmetic.
                   4664: -------------------------------------------------------------------------------
                   4665: */
                   4666: static float128 addFloat128Sigs( float128 a, float128 b, flag zSign )
                   4667: {
                   4668:     int32 aExp, bExp, zExp;
                   4669:     bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
                   4670:     int32 expDiff;
                   4671: 
                   4672:     aSig1 = extractFloat128Frac1( a );
                   4673:     aSig0 = extractFloat128Frac0( a );
                   4674:     aExp = extractFloat128Exp( a );
                   4675:     bSig1 = extractFloat128Frac1( b );
                   4676:     bSig0 = extractFloat128Frac0( b );
                   4677:     bExp = extractFloat128Exp( b );
                   4678:     expDiff = aExp - bExp;
                   4679:     if ( 0 < expDiff ) {
                   4680:         if ( aExp == 0x7FFF ) {
                   4681:             if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b );
                   4682:             return a;
                   4683:         }
                   4684:         if ( bExp == 0 ) {
                   4685:             --expDiff;
                   4686:         }
                   4687:         else {
                   4688:             bSig0 |= LIT64( 0x0001000000000000 );
                   4689:         }
                   4690:         shift128ExtraRightJamming(
                   4691:             bSig0, bSig1, 0, expDiff, &bSig0, &bSig1, &zSig2 );
                   4692:         zExp = aExp;
                   4693:     }
                   4694:     else if ( expDiff < 0 ) {
                   4695:         if ( bExp == 0x7FFF ) {
                   4696:             if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   4697:             return packFloat128( zSign, 0x7FFF, 0, 0 );
                   4698:         }
                   4699:         if ( aExp == 0 ) {
                   4700:             ++expDiff;
                   4701:         }
                   4702:         else {
                   4703:             aSig0 |= LIT64( 0x0001000000000000 );
                   4704:         }
                   4705:         shift128ExtraRightJamming(
                   4706:             aSig0, aSig1, 0, - expDiff, &aSig0, &aSig1, &zSig2 );
                   4707:         zExp = bExp;
                   4708:     }
                   4709:     else {
                   4710:         if ( aExp == 0x7FFF ) {
                   4711:             if ( aSig0 | aSig1 | bSig0 | bSig1 ) {
                   4712:                 return propagateFloat128NaN( a, b );
                   4713:             }
                   4714:             return a;
                   4715:         }
                   4716:         add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );
                   4717:         if ( aExp == 0 ) return packFloat128( zSign, 0, zSig0, zSig1 );
                   4718:         zSig2 = 0;
                   4719:         zSig0 |= LIT64( 0x0002000000000000 );
                   4720:         zExp = aExp;
                   4721:         goto shiftRight1;
                   4722:     }
                   4723:     aSig0 |= LIT64( 0x0001000000000000 );
                   4724:     add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );
                   4725:     --zExp;
                   4726:     if ( zSig0 < LIT64( 0x0002000000000000 ) ) goto roundAndPack;
                   4727:     ++zExp;
                   4728:  shiftRight1:
                   4729:     shift128ExtraRightJamming(
                   4730:         zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );
                   4731:  roundAndPack:
                   4732:     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
                   4733: 
                   4734: }
                   4735: 
                   4736: /*
                   4737: -------------------------------------------------------------------------------
                   4738: Returns the result of subtracting the absolute values of the quadruple-
                   4739: precision floating-point values `a' and `b'.  If `zSign' is 1, the
                   4740: difference is negated before being returned.  `zSign' is ignored if the
                   4741: result is a NaN.  The subtraction is performed according to the IEC/IEEE
                   4742: Standard for Binary Floating-Point Arithmetic.
                   4743: -------------------------------------------------------------------------------
                   4744: */
                   4745: static float128 subFloat128Sigs( float128 a, float128 b, flag zSign )
                   4746: {
                   4747:     int32 aExp, bExp, zExp;
                   4748:     bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;
                   4749:     int32 expDiff;
                   4750:     float128 z;
                   4751: 
                   4752:     aSig1 = extractFloat128Frac1( a );
                   4753:     aSig0 = extractFloat128Frac0( a );
                   4754:     aExp = extractFloat128Exp( a );
                   4755:     bSig1 = extractFloat128Frac1( b );
                   4756:     bSig0 = extractFloat128Frac0( b );
                   4757:     bExp = extractFloat128Exp( b );
                   4758:     expDiff = aExp - bExp;
                   4759:     shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 );
                   4760:     shortShift128Left( bSig0, bSig1, 14, &bSig0, &bSig1 );
                   4761:     if ( 0 < expDiff ) goto aExpBigger;
                   4762:     if ( expDiff < 0 ) goto bExpBigger;
                   4763:     if ( aExp == 0x7FFF ) {
                   4764:         if ( aSig0 | aSig1 | bSig0 | bSig1 ) {
                   4765:             return propagateFloat128NaN( a, b );
                   4766:         }
                   4767:         float_raise( float_flag_invalid );
                   4768:         z.low = float128_default_nan_low;
                   4769:         z.high = float128_default_nan_high;
                   4770:         return z;
                   4771:     }
                   4772:     if ( aExp == 0 ) {
                   4773:         aExp = 1;
                   4774:         bExp = 1;
                   4775:     }
                   4776:     if ( bSig0 < aSig0 ) goto aBigger;
                   4777:     if ( aSig0 < bSig0 ) goto bBigger;
                   4778:     if ( bSig1 < aSig1 ) goto aBigger;
                   4779:     if ( aSig1 < bSig1 ) goto bBigger;
                   4780:     return packFloat128( float_rounding_mode() == float_round_down, 0, 0, 0 );
                   4781:  bExpBigger:
                   4782:     if ( bExp == 0x7FFF ) {
                   4783:         if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   4784:         return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 );
                   4785:     }
                   4786:     if ( aExp == 0 ) {
                   4787:         ++expDiff;
                   4788:     }
                   4789:     else {
                   4790:         aSig0 |= LIT64( 0x4000000000000000 );
                   4791:     }
                   4792:     shift128RightJamming( aSig0, aSig1, - expDiff, &aSig0, &aSig1 );
                   4793:     bSig0 |= LIT64( 0x4000000000000000 );
                   4794:  bBigger:
                   4795:     sub128( bSig0, bSig1, aSig0, aSig1, &zSig0, &zSig1 );
                   4796:     zExp = bExp;
                   4797:     zSign ^= 1;
                   4798:     goto normalizeRoundAndPack;
                   4799:  aExpBigger:
                   4800:     if ( aExp == 0x7FFF ) {
                   4801:         if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b );
                   4802:         return a;
                   4803:     }
                   4804:     if ( bExp == 0 ) {
                   4805:         --expDiff;
                   4806:     }
                   4807:     else {
                   4808:         bSig0 |= LIT64( 0x4000000000000000 );
                   4809:     }
                   4810:     shift128RightJamming( bSig0, bSig1, expDiff, &bSig0, &bSig1 );
                   4811:     aSig0 |= LIT64( 0x4000000000000000 );
                   4812:  aBigger:
                   4813:     sub128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );
                   4814:     zExp = aExp;
                   4815:  normalizeRoundAndPack:
                   4816:     --zExp;
                   4817:     return normalizeRoundAndPackFloat128( zSign, zExp - 14, zSig0, zSig1 );
                   4818: 
                   4819: }
                   4820: 
                   4821: /*
                   4822: -------------------------------------------------------------------------------
                   4823: Returns the result of adding the quadruple-precision floating-point values
                   4824: `a' and `b'.  The operation is performed according to the IEC/IEEE Standard
                   4825: for Binary Floating-Point Arithmetic.
                   4826: -------------------------------------------------------------------------------
                   4827: */
                   4828: float128 float128_add( float128 a, float128 b )
                   4829: {
                   4830:     flag aSign, bSign;
                   4831: 
                   4832:     aSign = extractFloat128Sign( a );
                   4833:     bSign = extractFloat128Sign( b );
                   4834:     if ( aSign == bSign ) {
                   4835:         return addFloat128Sigs( a, b, aSign );
                   4836:     }
                   4837:     else {
                   4838:         return subFloat128Sigs( a, b, aSign );
                   4839:     }
                   4840: 
                   4841: }
                   4842: 
                   4843: /*
                   4844: -------------------------------------------------------------------------------
                   4845: Returns the result of subtracting the quadruple-precision floating-point
                   4846: values `a' and `b'.  The operation is performed according to the IEC/IEEE
                   4847: Standard for Binary Floating-Point Arithmetic.
                   4848: -------------------------------------------------------------------------------
                   4849: */
                   4850: float128 float128_sub( float128 a, float128 b )
                   4851: {
                   4852:     flag aSign, bSign;
                   4853: 
                   4854:     aSign = extractFloat128Sign( a );
                   4855:     bSign = extractFloat128Sign( b );
                   4856:     if ( aSign == bSign ) {
                   4857:         return subFloat128Sigs( a, b, aSign );
                   4858:     }
                   4859:     else {
                   4860:         return addFloat128Sigs( a, b, aSign );
                   4861:     }
                   4862: 
                   4863: }
                   4864: 
                   4865: /*
                   4866: -------------------------------------------------------------------------------
                   4867: Returns the result of multiplying the quadruple-precision floating-point
                   4868: values `a' and `b'.  The operation is performed according to the IEC/IEEE
                   4869: Standard for Binary Floating-Point Arithmetic.
                   4870: -------------------------------------------------------------------------------
                   4871: */
                   4872: float128 float128_mul( float128 a, float128 b )
                   4873: {
                   4874:     flag aSign, bSign, zSign;
                   4875:     int32 aExp, bExp, zExp;
                   4876:     bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3;
                   4877:     float128 z;
                   4878: 
                   4879:     aSig1 = extractFloat128Frac1( a );
                   4880:     aSig0 = extractFloat128Frac0( a );
                   4881:     aExp = extractFloat128Exp( a );
                   4882:     aSign = extractFloat128Sign( a );
                   4883:     bSig1 = extractFloat128Frac1( b );
                   4884:     bSig0 = extractFloat128Frac0( b );
                   4885:     bExp = extractFloat128Exp( b );
                   4886:     bSign = extractFloat128Sign( b );
                   4887:     zSign = aSign ^ bSign;
                   4888:     if ( aExp == 0x7FFF ) {
                   4889:         if (    ( aSig0 | aSig1 )
                   4890:              || ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {
                   4891:             return propagateFloat128NaN( a, b );
                   4892:         }
                   4893:         if ( ( bExp | bSig0 | bSig1 ) == 0 ) goto invalid;
                   4894:         return packFloat128( zSign, 0x7FFF, 0, 0 );
                   4895:     }
                   4896:     if ( bExp == 0x7FFF ) {
                   4897:         if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   4898:         if ( ( aExp | aSig0 | aSig1 ) == 0 ) {
                   4899:  invalid:
                   4900:             float_raise( float_flag_invalid );
                   4901:             z.low = float128_default_nan_low;
                   4902:             z.high = float128_default_nan_high;
                   4903:             return z;
                   4904:         }
                   4905:         return packFloat128( zSign, 0x7FFF, 0, 0 );
                   4906:     }
                   4907:     if ( aExp == 0 ) {
                   4908:         if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
                   4909:         normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
                   4910:     }
                   4911:     if ( bExp == 0 ) {
                   4912:         if ( ( bSig0 | bSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
                   4913:         normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );
                   4914:     }
                   4915:     zExp = aExp + bExp - 0x4000;
                   4916:     aSig0 |= LIT64( 0x0001000000000000 );
                   4917:     shortShift128Left( bSig0, bSig1, 16, &bSig0, &bSig1 );
                   4918:     mul128To256( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1, &zSig2, &zSig3 );
                   4919:     add128( zSig0, zSig1, aSig0, aSig1, &zSig0, &zSig1 );
                   4920:     zSig2 |= ( zSig3 != 0 );
                   4921:     if ( LIT64( 0x0002000000000000 ) <= zSig0 ) {
                   4922:         shift128ExtraRightJamming(
                   4923:             zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );
                   4924:         ++zExp;
                   4925:     }
                   4926:     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
                   4927: 
                   4928: }
                   4929: 
                   4930: /*
                   4931: -------------------------------------------------------------------------------
                   4932: Returns the result of dividing the quadruple-precision floating-point value
                   4933: `a' by the corresponding value `b'.  The operation is performed according to
                   4934: the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   4935: -------------------------------------------------------------------------------
                   4936: */
                   4937: float128 float128_div( float128 a, float128 b )
                   4938: {
                   4939:     flag aSign, bSign, zSign;
                   4940:     int32 aExp, bExp, zExp;
                   4941:     bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;
                   4942:     bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;
                   4943:     float128 z;
                   4944: 
                   4945:     aSig1 = extractFloat128Frac1( a );
                   4946:     aSig0 = extractFloat128Frac0( a );
                   4947:     aExp = extractFloat128Exp( a );
                   4948:     aSign = extractFloat128Sign( a );
                   4949:     bSig1 = extractFloat128Frac1( b );
                   4950:     bSig0 = extractFloat128Frac0( b );
                   4951:     bExp = extractFloat128Exp( b );
                   4952:     bSign = extractFloat128Sign( b );
                   4953:     zSign = aSign ^ bSign;
                   4954:     if ( aExp == 0x7FFF ) {
                   4955:         if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, b );
                   4956:         if ( bExp == 0x7FFF ) {
                   4957:             if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   4958:             goto invalid;
                   4959:         }
                   4960:         return packFloat128( zSign, 0x7FFF, 0, 0 );
                   4961:     }
                   4962:     if ( bExp == 0x7FFF ) {
                   4963:         if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   4964:         return packFloat128( zSign, 0, 0, 0 );
                   4965:     }
                   4966:     if ( bExp == 0 ) {
                   4967:         if ( ( bSig0 | bSig1 ) == 0 ) {
                   4968:             if ( ( aExp | aSig0 | aSig1 ) == 0 ) {
                   4969:  invalid:
                   4970:                 float_raise( float_flag_invalid );
                   4971:                 z.low = float128_default_nan_low;
                   4972:                 z.high = float128_default_nan_high;
                   4973:                 return z;
                   4974:             }
                   4975:             float_raise( float_flag_divbyzero );
                   4976:             return packFloat128( zSign, 0x7FFF, 0, 0 );
                   4977:         }
                   4978:         normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );
                   4979:     }
                   4980:     if ( aExp == 0 ) {
                   4981:         if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
                   4982:         normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
                   4983:     }
                   4984:     zExp = aExp - bExp + 0x3FFD;
                   4985:     shortShift128Left(
                   4986:         aSig0 | LIT64( 0x0001000000000000 ), aSig1, 15, &aSig0, &aSig1 );
                   4987:     shortShift128Left(
                   4988:         bSig0 | LIT64( 0x0001000000000000 ), bSig1, 15, &bSig0, &bSig1 );
                   4989:     if ( le128( bSig0, bSig1, aSig0, aSig1 ) ) {
                   4990:         shift128Right( aSig0, aSig1, 1, &aSig0, &aSig1 );
                   4991:         ++zExp;
                   4992:     }
                   4993:     zSig0 = estimateDiv128To64( aSig0, aSig1, bSig0 );
                   4994:     mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 );
                   4995:     sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 );
                   4996:     while ( (sbits64) rem0 < 0 ) {
                   4997:         --zSig0;
                   4998:         add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 );
                   4999:     }
                   5000:     zSig1 = estimateDiv128To64( rem1, rem2, bSig0 );
                   5001:     if ( ( zSig1 & 0x3FFF ) <= 4 ) {
                   5002:         mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 );
                   5003:         sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 );
                   5004:         while ( (sbits64) rem1 < 0 ) {
                   5005:             --zSig1;
                   5006:             add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &rem3 );
                   5007:         }
                   5008:         zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
                   5009:     }
                   5010:     shift128ExtraRightJamming( zSig0, zSig1, 0, 15, &zSig0, &zSig1, &zSig2 );
                   5011:     return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
                   5012: 
                   5013: }
                   5014: 
                   5015: /*
                   5016: -------------------------------------------------------------------------------
                   5017: Returns the remainder of the quadruple-precision floating-point value `a'
                   5018: with respect to the corresponding value `b'.  The operation is performed
                   5019: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   5020: -------------------------------------------------------------------------------
                   5021: */
                   5022: float128 float128_rem( float128 a, float128 b )
                   5023: {
                   5024:     flag aSign, bSign, zSign;
                   5025:     int32 aExp, bExp, expDiff;
                   5026:     bits64 aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;
                   5027:     bits64 allZero, alternateASig0, alternateASig1, sigMean1;
                   5028:     sbits64 sigMean0;
                   5029:     float128 z;
                   5030: 
                   5031:     aSig1 = extractFloat128Frac1( a );
                   5032:     aSig0 = extractFloat128Frac0( a );
                   5033:     aExp = extractFloat128Exp( a );
                   5034:     aSign = extractFloat128Sign( a );
                   5035:     bSig1 = extractFloat128Frac1( b );
                   5036:     bSig0 = extractFloat128Frac0( b );
                   5037:     bExp = extractFloat128Exp( b );
                   5038:     bSign = extractFloat128Sign( b );
                   5039:     if ( aExp == 0x7FFF ) {
                   5040:         if (    ( aSig0 | aSig1 )
                   5041:              || ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {
                   5042:             return propagateFloat128NaN( a, b );
                   5043:         }
                   5044:         goto invalid;
                   5045:     }
                   5046:     if ( bExp == 0x7FFF ) {
                   5047:         if ( bSig0 | bSig1 ) return propagateFloat128NaN( a, b );
                   5048:         return a;
                   5049:     }
                   5050:     if ( bExp == 0 ) {
                   5051:         if ( ( bSig0 | bSig1 ) == 0 ) {
                   5052:  invalid:
                   5053:             float_raise( float_flag_invalid );
                   5054:             z.low = float128_default_nan_low;
                   5055:             z.high = float128_default_nan_high;
                   5056:             return z;
                   5057:         }
                   5058:         normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );
                   5059:     }
                   5060:     if ( aExp == 0 ) {
                   5061:         if ( ( aSig0 | aSig1 ) == 0 ) return a;
                   5062:         normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
                   5063:     }
                   5064:     expDiff = aExp - bExp;
                   5065:     if ( expDiff < -1 ) return a;
                   5066:     shortShift128Left(
                   5067:         aSig0 | LIT64( 0x0001000000000000 ),
                   5068:         aSig1,
                   5069:         15 - ( expDiff < 0 ),
                   5070:         &aSig0,
                   5071:         &aSig1
                   5072:     );
                   5073:     shortShift128Left(
                   5074:         bSig0 | LIT64( 0x0001000000000000 ), bSig1, 15, &bSig0, &bSig1 );
                   5075:     q = le128( bSig0, bSig1, aSig0, aSig1 );
                   5076:     if ( q ) sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 );
                   5077:     expDiff -= 64;
                   5078:     while ( 0 < expDiff ) {
                   5079:         q = estimateDiv128To64( aSig0, aSig1, bSig0 );
                   5080:         q = ( 4 < q ) ? q - 4 : 0;
                   5081:         mul128By64To192( bSig0, bSig1, q, &term0, &term1, &term2 );
                   5082:         shortShift192Left( term0, term1, term2, 61, &term1, &term2, &allZero );
                   5083:         shortShift128Left( aSig0, aSig1, 61, &aSig0, &allZero );
                   5084:         sub128( aSig0, 0, term1, term2, &aSig0, &aSig1 );
                   5085:         expDiff -= 61;
                   5086:     }
                   5087:     if ( -64 < expDiff ) {
                   5088:         q = estimateDiv128To64( aSig0, aSig1, bSig0 );
                   5089:         q = ( 4 < q ) ? q - 4 : 0;
                   5090:         q >>= - expDiff;
                   5091:         shift128Right( bSig0, bSig1, 12, &bSig0, &bSig1 );
                   5092:         expDiff += 52;
                   5093:         if ( expDiff < 0 ) {
                   5094:             shift128Right( aSig0, aSig1, - expDiff, &aSig0, &aSig1 );
                   5095:         }
                   5096:         else {
                   5097:             shortShift128Left( aSig0, aSig1, expDiff, &aSig0, &aSig1 );
                   5098:         }
                   5099:         mul128By64To192( bSig0, bSig1, q, &term0, &term1, &term2 );
                   5100:         sub128( aSig0, aSig1, term1, term2, &aSig0, &aSig1 );
                   5101:     }
                   5102:     else {
                   5103:         shift128Right( aSig0, aSig1, 12, &aSig0, &aSig1 );
                   5104:         shift128Right( bSig0, bSig1, 12, &bSig0, &bSig1 );
                   5105:     }
                   5106:     do {
                   5107:         alternateASig0 = aSig0;
                   5108:         alternateASig1 = aSig1;
                   5109:         ++q;
                   5110:         sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 );
                   5111:     } while ( 0 <= (sbits64) aSig0 );
                   5112:     add128(
                   5113:         aSig0, aSig1, alternateASig0, alternateASig1, &sigMean0, &sigMean1 );
                   5114:     if (    ( sigMean0 < 0 )
                   5115:          || ( ( ( sigMean0 | sigMean1 ) == 0 ) && ( q & 1 ) ) ) {
                   5116:         aSig0 = alternateASig0;
                   5117:         aSig1 = alternateASig1;
                   5118:     }
                   5119:     zSign = ( (sbits64) aSig0 < 0 );
                   5120:     if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );
                   5121:     return
                   5122:         normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
                   5123: 
                   5124: }
                   5125: 
                   5126: /*
                   5127: -------------------------------------------------------------------------------
                   5128: Returns the square root of the quadruple-precision floating-point value `a'.
                   5129: The operation is performed according to the IEC/IEEE Standard for Binary
                   5130: Floating-Point Arithmetic.
                   5131: -------------------------------------------------------------------------------
                   5132: */
                   5133: float128 float128_sqrt( float128 a )
                   5134: {
                   5135:     flag aSign;
                   5136:     int32 aExp, zExp;
                   5137:     bits64 aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;
                   5138:     bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;
                   5139:     float128 z;
                   5140: 
                   5141:     aSig1 = extractFloat128Frac1( a );
                   5142:     aSig0 = extractFloat128Frac0( a );
                   5143:     aExp = extractFloat128Exp( a );
                   5144:     aSign = extractFloat128Sign( a );
                   5145:     if ( aExp == 0x7FFF ) {
                   5146:         if ( aSig0 | aSig1 ) return propagateFloat128NaN( a, a );
                   5147:         if ( ! aSign ) return a;
                   5148:         goto invalid;
                   5149:     }
                   5150:     if ( aSign ) {
                   5151:         if ( ( aExp | aSig0 | aSig1 ) == 0 ) return a;
                   5152:  invalid:
                   5153:         float_raise( float_flag_invalid );
                   5154:         z.low = float128_default_nan_low;
                   5155:         z.high = float128_default_nan_high;
                   5156:         return z;
                   5157:     }
                   5158:     if ( aExp == 0 ) {
                   5159:         if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( 0, 0, 0, 0 );
                   5160:         normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
                   5161:     }
                   5162:     zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFE;
                   5163:     aSig0 |= LIT64( 0x0001000000000000 );
                   5164:     zSig0 = estimateSqrt32( aExp, aSig0>>17 );
                   5165:     shortShift128Left( aSig0, aSig1, 13 - ( aExp & 1 ), &aSig0, &aSig1 );
                   5166:     zSig0 = estimateDiv128To64( aSig0, aSig1, zSig0<<32 ) + ( zSig0<<30 );
                   5167:     doubleZSig0 = zSig0<<1;
                   5168:     mul64To128( zSig0, zSig0, &term0, &term1 );
                   5169:     sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );
                   5170:     while ( (sbits64) rem0 < 0 ) {
                   5171:         --zSig0;
                   5172:         doubleZSig0 -= 2;
                   5173:         add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );
                   5174:     }
                   5175:     zSig1 = estimateDiv128To64( rem1, 0, doubleZSig0 );
                   5176:     if ( ( zSig1 & 0x1FFF ) <= 5 ) {
                   5177:         if ( zSig1 == 0 ) zSig1 = 1;
                   5178:         mul64To128( doubleZSig0, zSig1, &term1, &term2 );
                   5179:         sub128( rem1, 0, term1, term2, &rem1, &rem2 );
                   5180:         mul64To128( zSig1, zSig1, &term2, &term3 );
                   5181:         sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );
                   5182:         while ( (sbits64) rem1 < 0 ) {
                   5183:             --zSig1;
                   5184:             shortShift128Left( 0, zSig1, 1, &term2, &term3 );
                   5185:             term3 |= 1;
                   5186:             term2 |= doubleZSig0;
                   5187:             add192( rem1, rem2, rem3, 0, term2, term3, &rem1, &rem2, &rem3 );
                   5188:         }
                   5189:         zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
                   5190:     }
                   5191:     shift128ExtraRightJamming( zSig0, zSig1, 0, 14, &zSig0, &zSig1, &zSig2 );
                   5192:     return roundAndPackFloat128( 0, zExp, zSig0, zSig1, zSig2 );
                   5193: 
                   5194: }
                   5195: 
                   5196: /*
                   5197: -------------------------------------------------------------------------------
                   5198: Returns 1 if the quadruple-precision floating-point value `a' is equal to
                   5199: the corresponding value `b', and 0 otherwise.  The comparison is performed
                   5200: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   5201: -------------------------------------------------------------------------------
                   5202: */
                   5203: flag float128_eq( float128 a, float128 b )
                   5204: {
                   5205: 
                   5206:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5207:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5208:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5209:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5210:        ) {
                   5211:         if (    float128_is_signaling_nan( a )
                   5212:              || float128_is_signaling_nan( b ) ) {
                   5213:             float_raise( float_flag_invalid );
                   5214:         }
                   5215:         return 0;
                   5216:     }
                   5217:     return
                   5218:            ( a.low == b.low )
                   5219:         && (    ( a.high == b.high )
                   5220:              || (    ( a.low == 0 )
                   5221:                   && ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) )
                   5222:            );
                   5223: 
                   5224: }
                   5225: 
                   5226: /*
                   5227: -------------------------------------------------------------------------------
                   5228: Returns 1 if the quadruple-precision floating-point value `a' is less than
                   5229: or equal to the corresponding value `b', and 0 otherwise.  The comparison
                   5230: is performed according to the IEC/IEEE Standard for Binary Floating-Point
                   5231: Arithmetic.
                   5232: -------------------------------------------------------------------------------
                   5233: */
                   5234: flag float128_le( float128 a, float128 b )
                   5235: {
                   5236:     flag aSign, bSign;
                   5237: 
                   5238:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5239:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5240:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5241:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5242:        ) {
                   5243:         float_raise( float_flag_invalid );
                   5244:         return 0;
                   5245:     }
                   5246:     aSign = extractFloat128Sign( a );
                   5247:     bSign = extractFloat128Sign( b );
                   5248:     if ( aSign != bSign ) {
                   5249:         return
                   5250:                aSign
                   5251:             || (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   5252:                  == 0 );
                   5253:     }
                   5254:     return
                   5255:           aSign ? le128( b.high, b.low, a.high, a.low )
                   5256:         : le128( a.high, a.low, b.high, b.low );
                   5257: 
                   5258: }
                   5259: 
                   5260: /*
                   5261: -------------------------------------------------------------------------------
                   5262: Returns 1 if the quadruple-precision floating-point value `a' is less than
                   5263: the corresponding value `b', and 0 otherwise.  The comparison is performed
                   5264: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   5265: -------------------------------------------------------------------------------
                   5266: */
                   5267: flag float128_lt( float128 a, float128 b )
                   5268: {
                   5269:     flag aSign, bSign;
                   5270: 
                   5271:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5272:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5273:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5274:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5275:        ) {
                   5276:         float_raise( float_flag_invalid );
                   5277:         return 0;
                   5278:     }
                   5279:     aSign = extractFloat128Sign( a );
                   5280:     bSign = extractFloat128Sign( b );
                   5281:     if ( aSign != bSign ) {
                   5282:         return
                   5283:                aSign
                   5284:             && (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   5285:                  != 0 );
                   5286:     }
                   5287:     return
                   5288:           aSign ? lt128( b.high, b.low, a.high, a.low )
                   5289:         : lt128( a.high, a.low, b.high, b.low );
                   5290: 
                   5291: }
                   5292: 
                   5293: /*
                   5294: -------------------------------------------------------------------------------
                   5295: Returns 1 if the quadruple-precision floating-point value `a' is equal to
                   5296: the corresponding value `b', and 0 otherwise.  The invalid exception is
                   5297: raised if either operand is a NaN.  Otherwise, the comparison is performed
                   5298: according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   5299: -------------------------------------------------------------------------------
                   5300: */
                   5301: flag float128_eq_signaling( float128 a, float128 b )
                   5302: {
                   5303: 
                   5304:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5305:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5306:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5307:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5308:        ) {
                   5309:         float_raise( float_flag_invalid );
                   5310:         return 0;
                   5311:     }
                   5312:     return
                   5313:            ( a.low == b.low )
                   5314:         && (    ( a.high == b.high )
                   5315:              || (    ( a.low == 0 )
                   5316:                   && ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) )
                   5317:            );
                   5318: 
                   5319: }
                   5320: 
                   5321: /*
                   5322: -------------------------------------------------------------------------------
                   5323: Returns 1 if the quadruple-precision floating-point value `a' is less than
                   5324: or equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not
                   5325: cause an exception.  Otherwise, the comparison is performed according to the
                   5326: IEC/IEEE Standard for Binary Floating-Point Arithmetic.
                   5327: -------------------------------------------------------------------------------
                   5328: */
                   5329: flag float128_le_quiet( float128 a, float128 b )
                   5330: {
                   5331:     flag aSign, bSign;
                   5332: 
                   5333:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5334:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5335:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5336:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5337:        ) {
                   5338:         if (    float128_is_signaling_nan( a )
                   5339:              || float128_is_signaling_nan( b ) ) {
                   5340:             float_raise( float_flag_invalid );
                   5341:         }
                   5342:         return 0;
                   5343:     }
                   5344:     aSign = extractFloat128Sign( a );
                   5345:     bSign = extractFloat128Sign( b );
                   5346:     if ( aSign != bSign ) {
                   5347:         return
                   5348:                aSign
                   5349:             || (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   5350:                  == 0 );
                   5351:     }
                   5352:     return
                   5353:           aSign ? le128( b.high, b.low, a.high, a.low )
                   5354:         : le128( a.high, a.low, b.high, b.low );
                   5355: 
                   5356: }
                   5357: 
                   5358: /*
                   5359: -------------------------------------------------------------------------------
                   5360: Returns 1 if the quadruple-precision floating-point value `a' is less than
                   5361: the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an
                   5362: exception.  Otherwise, the comparison is performed according to the IEC/IEEE
                   5363: Standard for Binary Floating-Point Arithmetic.
                   5364: -------------------------------------------------------------------------------
                   5365: */
                   5366: flag float128_lt_quiet( float128 a, float128 b )
                   5367: {
                   5368:     flag aSign, bSign;
                   5369: 
                   5370:     if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
                   5371:               && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
                   5372:          || (    ( extractFloat128Exp( b ) == 0x7FFF )
                   5373:               && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
                   5374:        ) {
                   5375:         if (    float128_is_signaling_nan( a )
                   5376:              || float128_is_signaling_nan( b ) ) {
                   5377:             float_raise( float_flag_invalid );
                   5378:         }
                   5379:         return 0;
                   5380:     }
                   5381:     aSign = extractFloat128Sign( a );
                   5382:     bSign = extractFloat128Sign( b );
                   5383:     if ( aSign != bSign ) {
                   5384:         return
                   5385:                aSign
                   5386:             && (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                   5387:                  != 0 );
                   5388:     }
                   5389:     return
                   5390:           aSign ? lt128( b.high, b.low, a.high, a.low )
                   5391:         : lt128( a.high, a.low, b.high, b.low );
                   5392: 
                   5393: }
                   5394: 
                   5395: #endif
                   5396: 
                   5397: 
                   5398: #if defined(SOFTFLOAT_FOR_GCC) && defined(SOFTFLOAT_NEED_FIXUNS)
                   5399: 
                   5400: /*
                   5401:  * These two routines are not part of the original softfloat distribution.
                   5402:  *
                   5403:  * They are based on the corresponding conversions to integer but return
                   5404:  * unsigned numbers instead since these functions are required by GCC.
                   5405:  *
                   5406:  * Added by Mark Brinicombe <mark@netbsd.org>  27/09/97
                   5407:  *
                   5408:  * float64 version overhauled for SoftFloat 2a [bjh21 2000-07-15]
                   5409:  */
                   5410: 
                   5411: /*
                   5412: -------------------------------------------------------------------------------
                   5413: Returns the result of converting the double-precision floating-point value
                   5414: `a' to the 32-bit unsigned integer format.  The conversion is
                   5415: performed according to the IEC/IEEE Standard for Binary Floating-point
                   5416: Arithmetic, except that the conversion is always rounded toward zero.  If
                   5417: `a' is a NaN, the largest positive integer is returned.  If the conversion
                   5418: overflows, the largest integer positive is returned.
                   5419: -------------------------------------------------------------------------------
                   5420: */
                   5421: uint32 float64_to_uint32_round_to_zero( float64 a )
                   5422: {
                   5423:     flag aSign;
                   5424:     int16 aExp, shiftCount;
                   5425:     bits64 aSig, savedASig;
                   5426:     uint32 z;
                   5427: 
                   5428:     aSig = extractFloat64Frac( a );
                   5429:     aExp = extractFloat64Exp( a );
                   5430:     aSign = extractFloat64Sign( a );
                   5431: 
                   5432:     if (aSign) {
                   5433:         float_raise( float_flag_invalid );
                   5434:        return(0);
                   5435:     }
                   5436: 
                   5437:     if ( 0x41E < aExp ) {
                   5438:         float_raise( float_flag_invalid );
                   5439:         return 0xffffffff;
                   5440:     }
                   5441:     else if ( aExp < 0x3FF ) {
                   5442:         if ( aExp || aSig ) float_set_inexact();
                   5443:         return 0;
                   5444:     }
                   5445:     aSig |= LIT64( 0x0010000000000000 );
                   5446:     shiftCount = 0x433 - aExp;
                   5447:     savedASig = aSig;
                   5448:     aSig >>= shiftCount;
                   5449:     z = aSig;
                   5450:     if ( ( aSig<<shiftCount ) != savedASig ) {
                   5451:         float_set_inexact();
                   5452:     }
                   5453:     return z;
                   5454: 
                   5455: }
                   5456: 
                   5457: /*
                   5458: -------------------------------------------------------------------------------
                   5459: Returns the result of converting the single-precision floating-point value
                   5460: `a' to the 32-bit unsigned integer format.  The conversion is
                   5461: performed according to the IEC/IEEE Standard for Binary Floating-point
                   5462: Arithmetic, except that the conversion is always rounded toward zero.  If
                   5463: `a' is a NaN, the largest positive integer is returned.  If the conversion
                   5464: overflows, the largest positive integer is returned.
                   5465: -------------------------------------------------------------------------------
                   5466: */
                   5467: uint32 float32_to_uint32_round_to_zero( float32 a )
                   5468: {
                   5469:     flag aSign;
                   5470:     int16 aExp, shiftCount;
                   5471:     bits32 aSig;
                   5472:     uint32 z;
                   5473: 
                   5474:     aSig = extractFloat32Frac( a );
                   5475:     aExp = extractFloat32Exp( a );
                   5476:     aSign = extractFloat32Sign( a );
                   5477:     shiftCount = aExp - 0x9E;
                   5478: 
                   5479:     if (aSign) {
                   5480:         float_raise( float_flag_invalid );
                   5481:        return(0);
                   5482:     }
                   5483:     if ( 0 < shiftCount ) {
                   5484:         float_raise( float_flag_invalid );
                   5485:         return 0xFFFFFFFF;
                   5486:     }
                   5487:     else if ( aExp <= 0x7E ) {
                   5488:         if ( aExp | aSig ) float_set_inexact();
                   5489:         return 0;
                   5490:     }
                   5491:     aSig = ( aSig | 0x800000 )<<8;
                   5492:     z = aSig>>( - shiftCount );
                   5493:     if ( aSig<<( shiftCount & 31 ) ) {
                   5494:         float_set_inexact();
                   5495:     }
                   5496:     return z;
                   5497: 
                   5498: }
                   5499: 
                   5500: #endif
1.2     ! thorpej  5501: 
        !          5502: #endif /* _STANDALONE */

CVSweb <webmaster@jp.NetBSD.org>