Home | History | Annotate | Download | only in fpu
      1 /*
      2  * QEMU float support
      3  *
      4  * Derived from SoftFloat.
      5  */
      6 
      7 /*============================================================================
      8 
      9 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
     10 Arithmetic Package, Release 2b.
     11 
     12 Written by John R. Hauser.  This work was made possible in part by the
     13 International Computer Science Institute, located at Suite 600, 1947 Center
     14 Street, Berkeley, California 94704.  Funding was partially provided by the
     15 National Science Foundation under grant MIP-9311980.  The original version
     16 of this code was written as part of a project to build a fixed-point vector
     17 processor in collaboration with the University of California at Berkeley,
     18 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
     19 is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
     20 arithmetic/SoftFloat.html'.
     21 
     22 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
     23 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
     24 RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
     25 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
     26 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
     27 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
     28 INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
     29 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
     30 
     31 Derivative works are acceptable, even for commercial purposes, so long as
     32 (1) the source code for the derivative work includes prominent notice that
     33 the work is derivative, and (2) the source code includes prominent notice with
     34 these four paragraphs for those parts of this code that are retained.
     35 
     36 =============================================================================*/
     37 
     38 /*----------------------------------------------------------------------------
     39 | Raises the exceptions specified by `flags'.  Floating-point traps can be
     40 | defined here if desired.  It is currently not possible for such a trap
     41 | to substitute a result value.  If traps are not implemented, this routine
     42 | should be simply `float_exception_flags |= flags;'.
     43 *----------------------------------------------------------------------------*/
     44 
     45 void float_raise( int8 flags STATUS_PARAM )
     46 {
     47     STATUS(float_exception_flags) |= flags;
     48 }
     49 
     50 /*----------------------------------------------------------------------------
     51 | Internal canonical NaN format.
     52 *----------------------------------------------------------------------------*/
     53 typedef struct {
     54     flag sign;
     55     uint64_t high, low;
     56 } commonNaNT;
     57 
     58 /*----------------------------------------------------------------------------
     59 | Returns 1 if the half-precision floating-point value `a' is a quiet
     60 | NaN; otherwise returns 0.
     61 *----------------------------------------------------------------------------*/
     62 
     63 int float16_is_quiet_nan(float16 a_)
     64 {
     65     uint16_t a = float16_val(a_);
     66 #if SNAN_BIT_IS_ONE
     67     return (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
     68 #else
     69     return ((a & ~0x8000) >= 0x7c80);
     70 #endif
     71 }
     72 
     73 /*----------------------------------------------------------------------------
     74 | Returns 1 if the half-precision floating-point value `a' is a signaling
     75 | NaN; otherwise returns 0.
     76 *----------------------------------------------------------------------------*/
     77 
     78 int float16_is_signaling_nan(float16 a_)
     79 {
     80     uint16_t a = float16_val(a_);
     81 #if SNAN_BIT_IS_ONE
     82     return ((a & ~0x8000) >= 0x7c80);
     83 #else
     84     return (((a >> 9) & 0x3F) == 0x3E) && (a & 0x1FF);
     85 #endif
     86 }
     87 
     88 /*----------------------------------------------------------------------------
     89 | Returns a quiet NaN if the half-precision floating point value `a' is a
     90 | signaling NaN; otherwise returns `a'.
     91 *----------------------------------------------------------------------------*/
     92 float16 float16_maybe_silence_nan(float16 a_)
     93 {
     94     if (float16_is_signaling_nan(a_)) {
     95 #if SNAN_BIT_IS_ONE
     96 #  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
     97         return float16_default_nan;
     98 #  else
     99 #    error Rules for silencing a signaling NaN are target-specific
    100 #  endif
    101 #else
    102         uint16_t a = float16_val(a_);
    103         a |= (1 << 9);
    104         return make_float16(a);
    105 #endif
    106     }
    107     return a_;
    108 }
    109 
    110 /*----------------------------------------------------------------------------
    111 | Returns the result of converting the half-precision floating-point NaN
    112 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
    113 | exception is raised.
    114 *----------------------------------------------------------------------------*/
    115 
    116 static commonNaNT float16ToCommonNaN( float16 a STATUS_PARAM )
    117 {
    118     commonNaNT z;
    119 
    120     if ( float16_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
    121     z.sign = float16_val(a) >> 15;
    122     z.low = 0;
    123     z.high = ((uint64_t) float16_val(a))<<54;
    124     return z;
    125 }
    126 
    127 /*----------------------------------------------------------------------------
    128 | Returns the result of converting the canonical NaN `a' to the half-
    129 | precision floating-point format.
    130 *----------------------------------------------------------------------------*/
    131 
    132 static float16 commonNaNToFloat16(commonNaNT a STATUS_PARAM)
    133 {
    134     uint16_t mantissa = a.high>>54;
    135 
    136     if (STATUS(default_nan_mode)) {
    137         return float16_default_nan;
    138     }
    139 
    140     if (mantissa) {
    141         return make_float16(((((uint16_t) a.sign) << 15)
    142                              | (0x1F << 10) | mantissa));
    143     } else {
    144         return float16_default_nan;
    145     }
    146 }
    147 
    148 /*----------------------------------------------------------------------------
    149 | Returns 1 if the single-precision floating-point value `a' is a quiet
    150 | NaN; otherwise returns 0.
    151 *----------------------------------------------------------------------------*/
    152 
    153 int float32_is_quiet_nan( float32 a_ )
    154 {
    155     uint32_t a = float32_val(a_);
    156 #if SNAN_BIT_IS_ONE
    157     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
    158 #else
    159     return ( 0xFF800000 <= (uint32_t) ( a<<1 ) );
    160 #endif
    161 }
    162 
    163 /*----------------------------------------------------------------------------
    164 | Returns 1 if the single-precision floating-point value `a' is a signaling
    165 | NaN; otherwise returns 0.
    166 *----------------------------------------------------------------------------*/
    167 
    168 int float32_is_signaling_nan( float32 a_ )
    169 {
    170     uint32_t a = float32_val(a_);
    171 #if SNAN_BIT_IS_ONE
    172     return ( 0xFF800000 <= (uint32_t) ( a<<1 ) );
    173 #else
    174     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
    175 #endif
    176 }
    177 
    178 /*----------------------------------------------------------------------------
    179 | Returns a quiet NaN if the single-precision floating point value `a' is a
    180 | signaling NaN; otherwise returns `a'.
    181 *----------------------------------------------------------------------------*/
    182 
    183 float32 float32_maybe_silence_nan( float32 a_ )
    184 {
    185     if (float32_is_signaling_nan(a_)) {
    186 #if SNAN_BIT_IS_ONE
    187 #  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
    188         return float32_default_nan;
    189 #  else
    190 #    error Rules for silencing a signaling NaN are target-specific
    191 #  endif
    192 #else
    193         uint32_t a = float32_val(a_);
    194         a |= (1 << 22);
    195         return make_float32(a);
    196 #endif
    197     }
    198     return a_;
    199 }
    200 
    201 /*----------------------------------------------------------------------------
    202 | Returns the result of converting the single-precision floating-point NaN
    203 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
    204 | exception is raised.
    205 *----------------------------------------------------------------------------*/
    206 
    207 static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
    208 {
    209     commonNaNT z;
    210 
    211     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
    212     z.sign = float32_val(a)>>31;
    213     z.low = 0;
    214     z.high = ( (uint64_t) float32_val(a) )<<41;
    215     return z;
    216 }
    217 
    218 /*----------------------------------------------------------------------------
    219 | Returns the result of converting the canonical NaN `a' to the single-
    220 | precision floating-point format.
    221 *----------------------------------------------------------------------------*/
    222 
    223 static float32 commonNaNToFloat32( commonNaNT a STATUS_PARAM)
    224 {
    225     uint32_t mantissa = a.high>>41;
    226 
    227     if ( STATUS(default_nan_mode) ) {
    228         return float32_default_nan;
    229     }
    230 
    231     if ( mantissa )
    232         return make_float32(
    233             ( ( (uint32_t) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
    234     else
    235         return float32_default_nan;
    236 }
    237 
    238 /*----------------------------------------------------------------------------
    239 | Select which NaN to propagate for a two-input operation.
    240 | IEEE754 doesn't specify all the details of this, so the
    241 | algorithm is target-specific.
    242 | The routine is passed various bits of information about the
    243 | two NaNs and should return 0 to select NaN a and 1 for NaN b.
    244 | Note that signalling NaNs are always squashed to quiet NaNs
    245 | by the caller, by calling floatXX_maybe_silence_nan() before
    246 | returning them.
    247 |
    248 | aIsLargerSignificand is only valid if both a and b are NaNs
    249 | of some kind, and is true if a has the larger significand,
    250 | or if both a and b have the same significand but a is
    251 | positive but b is negative. It is only needed for the x87
    252 | tie-break rule.
    253 *----------------------------------------------------------------------------*/
    254 
    255 #if defined(TARGET_ARM)
    256 static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
    257                     flag aIsLargerSignificand)
    258 {
    259     /* ARM mandated NaN propagation rules: take the first of:
    260      *  1. A if it is signaling
    261      *  2. B if it is signaling
    262      *  3. A (quiet)
    263      *  4. B (quiet)
    264      * A signaling NaN is always quietened before returning it.
    265      */
    266     if (aIsSNaN) {
    267         return 0;
    268     } else if (bIsSNaN) {
    269         return 1;
    270     } else if (aIsQNaN) {
    271         return 0;
    272     } else {
    273         return 1;
    274     }
    275 }
    276 #elif defined(TARGET_MIPS)
    277 static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
    278                     flag aIsLargerSignificand)
    279 {
    280     /* According to MIPS specifications, if one of the two operands is
    281      * a sNaN, a new qNaN has to be generated. This is done in
    282      * floatXX_maybe_silence_nan(). For qNaN inputs the specifications
    283      * says: "When possible, this QNaN result is one of the operand QNaN
    284      * values." In practice it seems that most implementations choose
    285      * the first operand if both operands are qNaN. In short this gives
    286      * the following rules:
    287      *  1. A if it is signaling
    288      *  2. B if it is signaling
    289      *  3. A (quiet)
    290      *  4. B (quiet)
    291      * A signaling NaN is always silenced before returning it.
    292      */
    293     if (aIsSNaN) {
    294         return 0;
    295     } else if (bIsSNaN) {
    296         return 1;
    297     } else if (aIsQNaN) {
    298         return 0;
    299     } else {
    300         return 1;
    301     }
    302 }
    303 #elif defined(TARGET_PPC)
    304 static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
    305                    flag aIsLargerSignificand)
    306 {
    307     /* PowerPC propagation rules:
    308      *  1. A if it sNaN or qNaN
    309      *  2. B if it sNaN or qNaN
    310      * A signaling NaN is always silenced before returning it.
    311      */
    312     if (aIsSNaN || aIsQNaN) {
    313         return 0;
    314     } else {
    315         return 1;
    316     }
    317 }
    318 #else
    319 static int pickNaN(flag aIsQNaN, flag aIsSNaN, flag bIsQNaN, flag bIsSNaN,
    320                     flag aIsLargerSignificand)
    321 {
    322     /* This implements x87 NaN propagation rules:
    323      * SNaN + QNaN => return the QNaN
    324      * two SNaNs => return the one with the larger significand, silenced
    325      * two QNaNs => return the one with the larger significand
    326      * SNaN and a non-NaN => return the SNaN, silenced
    327      * QNaN and a non-NaN => return the QNaN
    328      *
    329      * If we get down to comparing significands and they are the same,
    330      * return the NaN with the positive sign bit (if any).
    331      */
    332     if (aIsSNaN) {
    333         if (bIsSNaN) {
    334             return aIsLargerSignificand ? 0 : 1;
    335         }
    336         return bIsQNaN ? 1 : 0;
    337     }
    338     else if (aIsQNaN) {
    339         if (bIsSNaN || !bIsQNaN)
    340             return 0;
    341         else {
    342             return aIsLargerSignificand ? 0 : 1;
    343         }
    344     } else {
    345         return 1;
    346     }
    347 }
    348 #endif
    349 
    350 /*----------------------------------------------------------------------------
    351 | Takes two single-precision floating-point values `a' and `b', one of which
    352 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
    353 | signaling NaN, the invalid exception is raised.
    354 *----------------------------------------------------------------------------*/
    355 
    356 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
    357 {
    358     flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    359     flag aIsLargerSignificand;
    360     uint32_t av, bv;
    361 
    362     aIsQuietNaN = float32_is_quiet_nan( a );
    363     aIsSignalingNaN = float32_is_signaling_nan( a );
    364     bIsQuietNaN = float32_is_quiet_nan( b );
    365     bIsSignalingNaN = float32_is_signaling_nan( b );
    366     av = float32_val(a);
    367     bv = float32_val(b);
    368 
    369     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
    370 
    371     if ( STATUS(default_nan_mode) )
    372         return float32_default_nan;
    373 
    374     if ((uint32_t)(av<<1) < (uint32_t)(bv<<1)) {
    375         aIsLargerSignificand = 0;
    376     } else if ((uint32_t)(bv<<1) < (uint32_t)(av<<1)) {
    377         aIsLargerSignificand = 1;
    378     } else {
    379         aIsLargerSignificand = (av < bv) ? 1 : 0;
    380     }
    381 
    382     if (pickNaN(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
    383                 aIsLargerSignificand)) {
    384         return float32_maybe_silence_nan(b);
    385     } else {
    386         return float32_maybe_silence_nan(a);
    387     }
    388 }
    389 
    390 /*----------------------------------------------------------------------------
    391 | Returns 1 if the double-precision floating-point value `a' is a quiet
    392 | NaN; otherwise returns 0.
    393 *----------------------------------------------------------------------------*/
    394 
    395 int float64_is_quiet_nan( float64 a_ )
    396 {
    397     uint64_t a = float64_val(a_);
    398 #if SNAN_BIT_IS_ONE
    399     return
    400            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
    401         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
    402 #else
    403     return ( LIT64( 0xFFF0000000000000 ) <= (uint64_t) ( a<<1 ) );
    404 #endif
    405 }
    406 
    407 /*----------------------------------------------------------------------------
    408 | Returns 1 if the double-precision floating-point value `a' is a signaling
    409 | NaN; otherwise returns 0.
    410 *----------------------------------------------------------------------------*/
    411 
    412 int float64_is_signaling_nan( float64 a_ )
    413 {
    414     uint64_t a = float64_val(a_);
    415 #if SNAN_BIT_IS_ONE
    416     return ( LIT64( 0xFFF0000000000000 ) <= (uint64_t) ( a<<1 ) );
    417 #else
    418     return
    419            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
    420         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
    421 #endif
    422 }
    423 
    424 /*----------------------------------------------------------------------------
    425 | Returns a quiet NaN if the double-precision floating point value `a' is a
    426 | signaling NaN; otherwise returns `a'.
    427 *----------------------------------------------------------------------------*/
    428 
    429 float64 float64_maybe_silence_nan( float64 a_ )
    430 {
    431     if (float64_is_signaling_nan(a_)) {
    432 #if SNAN_BIT_IS_ONE
    433 #  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
    434         return float64_default_nan;
    435 #  else
    436 #    error Rules for silencing a signaling NaN are target-specific
    437 #  endif
    438 #else
    439         uint64_t a = float64_val(a_);
    440         a |= LIT64( 0x0008000000000000 );
    441         return make_float64(a);
    442 #endif
    443     }
    444     return a_;
    445 }
    446 
    447 /*----------------------------------------------------------------------------
    448 | Returns the result of converting the double-precision floating-point NaN
    449 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
    450 | exception is raised.
    451 *----------------------------------------------------------------------------*/
    452 
    453 static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
    454 {
    455     commonNaNT z;
    456 
    457     if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
    458     z.sign = float64_val(a)>>63;
    459     z.low = 0;
    460     z.high = float64_val(a)<<12;
    461     return z;
    462 }
    463 
    464 /*----------------------------------------------------------------------------
    465 | Returns the result of converting the canonical NaN `a' to the double-
    466 | precision floating-point format.
    467 *----------------------------------------------------------------------------*/
    468 
    469 static float64 commonNaNToFloat64( commonNaNT a STATUS_PARAM)
    470 {
    471     uint64_t mantissa = a.high>>12;
    472 
    473     if ( STATUS(default_nan_mode) ) {
    474         return float64_default_nan;
    475     }
    476 
    477     if ( mantissa )
    478         return make_float64(
    479               ( ( (uint64_t) a.sign )<<63 )
    480             | LIT64( 0x7FF0000000000000 )
    481             | ( a.high>>12 ));
    482     else
    483         return float64_default_nan;
    484 }
    485 
    486 /*----------------------------------------------------------------------------
    487 | Takes two double-precision floating-point values `a' and `b', one of which
    488 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
    489 | signaling NaN, the invalid exception is raised.
    490 *----------------------------------------------------------------------------*/
    491 
    492 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
    493 {
    494     flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    495     flag aIsLargerSignificand;
    496     uint64_t av, bv;
    497 
    498     aIsQuietNaN = float64_is_quiet_nan( a );
    499     aIsSignalingNaN = float64_is_signaling_nan( a );
    500     bIsQuietNaN = float64_is_quiet_nan( b );
    501     bIsSignalingNaN = float64_is_signaling_nan( b );
    502     av = float64_val(a);
    503     bv = float64_val(b);
    504 
    505     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
    506 
    507     if ( STATUS(default_nan_mode) )
    508         return float64_default_nan;
    509 
    510     if ((uint64_t)(av<<1) < (uint64_t)(bv<<1)) {
    511         aIsLargerSignificand = 0;
    512     } else if ((uint64_t)(bv<<1) < (uint64_t)(av<<1)) {
    513         aIsLargerSignificand = 1;
    514     } else {
    515         aIsLargerSignificand = (av < bv) ? 1 : 0;
    516     }
    517 
    518     if (pickNaN(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
    519                 aIsLargerSignificand)) {
    520         return float64_maybe_silence_nan(b);
    521     } else {
    522         return float64_maybe_silence_nan(a);
    523     }
    524 }
    525 
    526 #ifdef FLOATX80
    527 
    528 /*----------------------------------------------------------------------------
    529 | Returns 1 if the extended double-precision floating-point value `a' is a
    530 | quiet NaN; otherwise returns 0. This slightly differs from the same
    531 | function for other types as floatx80 has an explicit bit.
    532 *----------------------------------------------------------------------------*/
    533 
    534 int floatx80_is_quiet_nan( floatx80 a )
    535 {
    536 #if SNAN_BIT_IS_ONE
    537     uint64_t aLow;
    538 
    539     aLow = a.low & ~ LIT64( 0x4000000000000000 );
    540     return
    541            ( ( a.high & 0x7FFF ) == 0x7FFF )
    542         && (uint64_t) ( aLow<<1 )
    543         && ( a.low == aLow );
    544 #else
    545     return ( ( a.high & 0x7FFF ) == 0x7FFF )
    546         && (LIT64( 0x8000000000000000 ) <= ((uint64_t) ( a.low<<1 )));
    547 #endif
    548 }
    549 
    550 /*----------------------------------------------------------------------------
    551 | Returns 1 if the extended double-precision floating-point value `a' is a
    552 | signaling NaN; otherwise returns 0. This slightly differs from the same
    553 | function for other types as floatx80 has an explicit bit.
    554 *----------------------------------------------------------------------------*/
    555 
    556 int floatx80_is_signaling_nan( floatx80 a )
    557 {
    558 #if SNAN_BIT_IS_ONE
    559     return ( ( a.high & 0x7FFF ) == 0x7FFF )
    560         && (LIT64( 0x8000000000000000 ) <= ((uint64_t) ( a.low<<1 )));
    561 #else
    562     uint64_t aLow;
    563 
    564     aLow = a.low & ~ LIT64( 0x4000000000000000 );
    565     return
    566            ( ( a.high & 0x7FFF ) == 0x7FFF )
    567         && (uint64_t) ( aLow<<1 )
    568         && ( a.low == aLow );
    569 #endif
    570 }
    571 
    572 /*----------------------------------------------------------------------------
    573 | Returns a quiet NaN if the extended double-precision floating point value
    574 | `a' is a signaling NaN; otherwise returns `a'.
    575 *----------------------------------------------------------------------------*/
    576 
    577 floatx80 floatx80_maybe_silence_nan( floatx80 a )
    578 {
    579     if (floatx80_is_signaling_nan(a)) {
    580 #if SNAN_BIT_IS_ONE
    581 #  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
    582         a.low = floatx80_default_nan_low;
    583         a.high = floatx80_default_nan_high;
    584 #  else
    585 #    error Rules for silencing a signaling NaN are target-specific
    586 #  endif
    587 #else
    588         a.low |= LIT64( 0xC000000000000000 );
    589         return a;
    590 #endif
    591     }
    592     return a;
    593 }
    594 
    595 /*----------------------------------------------------------------------------
    596 | Returns the result of converting the extended double-precision floating-
    597 | point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the
    598 | invalid exception is raised.
    599 *----------------------------------------------------------------------------*/
    600 
    601 static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
    602 {
    603     commonNaNT z;
    604 
    605     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
    606     if ( a.low >> 63 ) {
    607         z.sign = a.high >> 15;
    608         z.low = 0;
    609         z.high = a.low << 1;
    610     } else {
    611         z.sign = floatx80_default_nan_high >> 15;
    612         z.low = 0;
    613         z.high = floatx80_default_nan_low << 1;
    614     }
    615     return z;
    616 }
    617 
    618 /*----------------------------------------------------------------------------
    619 | Returns the result of converting the canonical NaN `a' to the extended
    620 | double-precision floating-point format.
    621 *----------------------------------------------------------------------------*/
    622 
    623 static floatx80 commonNaNToFloatx80( commonNaNT a STATUS_PARAM)
    624 {
    625     floatx80 z;
    626 
    627     if ( STATUS(default_nan_mode) ) {
    628         z.low = floatx80_default_nan_low;
    629         z.high = floatx80_default_nan_high;
    630         return z;
    631     }
    632 
    633     if (a.high >> 1) {
    634         z.low = LIT64( 0x8000000000000000 ) | a.high >> 1;
    635         z.high = ( ( (uint16_t) a.sign )<<15 ) | 0x7FFF;
    636     } else {
    637         z.low = floatx80_default_nan_low;
    638         z.high = floatx80_default_nan_high;
    639     }
    640 
    641     return z;
    642 }
    643 
    644 /*----------------------------------------------------------------------------
    645 | Takes two extended double-precision floating-point values `a' and `b', one
    646 | of which is a NaN, and returns the appropriate NaN result.  If either `a' or
    647 | `b' is a signaling NaN, the invalid exception is raised.
    648 *----------------------------------------------------------------------------*/
    649 
    650 static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
    651 {
    652     flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    653     flag aIsLargerSignificand;
    654 
    655     aIsQuietNaN = floatx80_is_quiet_nan( a );
    656     aIsSignalingNaN = floatx80_is_signaling_nan( a );
    657     bIsQuietNaN = floatx80_is_quiet_nan( b );
    658     bIsSignalingNaN = floatx80_is_signaling_nan( b );
    659 
    660     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
    661 
    662     if ( STATUS(default_nan_mode) ) {
    663         a.low = floatx80_default_nan_low;
    664         a.high = floatx80_default_nan_high;
    665         return a;
    666     }
    667 
    668     if (a.low < b.low) {
    669         aIsLargerSignificand = 0;
    670     } else if (b.low < a.low) {
    671         aIsLargerSignificand = 1;
    672     } else {
    673         aIsLargerSignificand = (a.high < b.high) ? 1 : 0;
    674     }
    675 
    676     if (pickNaN(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
    677                 aIsLargerSignificand)) {
    678         return floatx80_maybe_silence_nan(b);
    679     } else {
    680         return floatx80_maybe_silence_nan(a);
    681     }
    682 }
    683 
    684 #endif
    685 
    686 #ifdef FLOAT128
    687 
    688 /*----------------------------------------------------------------------------
    689 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
    690 | NaN; otherwise returns 0.
    691 *----------------------------------------------------------------------------*/
    692 
    693 int float128_is_quiet_nan( float128 a )
    694 {
    695 #if SNAN_BIT_IS_ONE
    696     return
    697            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
    698         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
    699 #else
    700     return
    701            ( LIT64( 0xFFFE000000000000 ) <= (uint64_t) ( a.high<<1 ) )
    702         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
    703 #endif
    704 }
    705 
    706 /*----------------------------------------------------------------------------
    707 | Returns 1 if the quadruple-precision floating-point value `a' is a
    708 | signaling NaN; otherwise returns 0.
    709 *----------------------------------------------------------------------------*/
    710 
    711 int float128_is_signaling_nan( float128 a )
    712 {
    713 #if SNAN_BIT_IS_ONE
    714     return
    715            ( LIT64( 0xFFFE000000000000 ) <= (uint64_t) ( a.high<<1 ) )
    716         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
    717 #else
    718     return
    719            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
    720         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
    721 #endif
    722 }
    723 
    724 /*----------------------------------------------------------------------------
    725 | Returns a quiet NaN if the quadruple-precision floating point value `a' is
    726 | a signaling NaN; otherwise returns `a'.
    727 *----------------------------------------------------------------------------*/
    728 
    729 float128 float128_maybe_silence_nan( float128 a )
    730 {
    731     if (float128_is_signaling_nan(a)) {
    732 #if SNAN_BIT_IS_ONE
    733 #  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
    734         a.low = float128_default_nan_low;
    735         a.high = float128_default_nan_high;
    736 #  else
    737 #    error Rules for silencing a signaling NaN are target-specific
    738 #  endif
    739 #else
    740         a.high |= LIT64( 0x0000800000000000 );
    741         return a;
    742 #endif
    743     }
    744     return a;
    745 }
    746 
    747 /*----------------------------------------------------------------------------
    748 | Returns the result of converting the quadruple-precision floating-point NaN
    749 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
    750 | exception is raised.
    751 *----------------------------------------------------------------------------*/
    752 
    753 static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
    754 {
    755     commonNaNT z;
    756 
    757     if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
    758     z.sign = a.high>>63;
    759     shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
    760     return z;
    761 }
    762 
    763 /*----------------------------------------------------------------------------
    764 | Returns the result of converting the canonical NaN `a' to the quadruple-
    765 | precision floating-point format.
    766 *----------------------------------------------------------------------------*/
    767 
    768 static float128 commonNaNToFloat128( commonNaNT a STATUS_PARAM)
    769 {
    770     float128 z;
    771 
    772     if ( STATUS(default_nan_mode) ) {
    773         z.low = float128_default_nan_low;
    774         z.high = float128_default_nan_high;
    775         return z;
    776     }
    777 
    778     shift128Right( a.high, a.low, 16, &z.high, &z.low );
    779     z.high |= ( ( (uint64_t) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
    780     return z;
    781 }
    782 
    783 /*----------------------------------------------------------------------------
    784 | Takes two quadruple-precision floating-point values `a' and `b', one of
    785 | which is a NaN, and returns the appropriate NaN result.  If either `a' or
    786 | `b' is a signaling NaN, the invalid exception is raised.
    787 *----------------------------------------------------------------------------*/
    788 
    789 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
    790 {
    791     flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    792     flag aIsLargerSignificand;
    793 
    794     aIsQuietNaN = float128_is_quiet_nan( a );
    795     aIsSignalingNaN = float128_is_signaling_nan( a );
    796     bIsQuietNaN = float128_is_quiet_nan( b );
    797     bIsSignalingNaN = float128_is_signaling_nan( b );
    798 
    799     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
    800 
    801     if ( STATUS(default_nan_mode) ) {
    802         a.low = float128_default_nan_low;
    803         a.high = float128_default_nan_high;
    804         return a;
    805     }
    806 
    807     if (lt128(a.high<<1, a.low, b.high<<1, b.low)) {
    808         aIsLargerSignificand = 0;
    809     } else if (lt128(b.high<<1, b.low, a.high<<1, a.low)) {
    810         aIsLargerSignificand = 1;
    811     } else {
    812         aIsLargerSignificand = (a.high < b.high) ? 1 : 0;
    813     }
    814 
    815     if (pickNaN(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
    816                 aIsLargerSignificand)) {
    817         return float128_maybe_silence_nan(b);
    818     } else {
    819         return float128_maybe_silence_nan(a);
    820     }
    821 }
    822 
    823 #endif
    824