fpu/softfloat-specialize.h

   1
   2 /*============================================================================
   3
   4 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
   5 Arithmetic Package, Release 2b.
   6
   7 Written by John R. Hauser.  This work was made possible in part by the
   8 International Computer Science Institute, located at Suite 600, 1947 Center
   9 Street, Berkeley, California 94704.  Funding was partially provided by the
  10 National Science Foundation under grant MIP-9311980.  The original version
  11 of this code was written as part of a project to build a fixed-point vector
  12 processor in collaboration with the University of California at Berkeley,
  13 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
  14 is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
  15 arithmetic/SoftFloat.html'.
  16
  17 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
  18 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
  19 RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
  20 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
  21 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
  22 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
  23 INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
  24 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
  25
  26 Derivative works are acceptable, even for commercial purposes, so long as
  27 (1) the source code for the derivative work includes prominent notice that
  28 the work is derivative, and (2) the source code includes prominent notice with
  29 these four paragraphs for those parts of this code that are retained.
  30
  31 =============================================================================*/
  32
  33 #if defined(TARGET_MIPS) || defined(TARGET_HPPA)
  34 #define SNAN_BIT_IS_ONE         1
  35 #else
  36 #define SNAN_BIT_IS_ONE         0
  37 #endif
  38
  39 /*----------------------------------------------------------------------------
  40 | Raises the exceptions specified by `flags'.  Floating-point traps can be
  41 | defined here if desired.  It is currently not possible for such a trap
  42 | to substitute a result value.  If traps are not implemented, this routine
  43 | should be simply `float_exception_flags |= flags;'.
  44 *----------------------------------------------------------------------------*/
  45
  46 void float_raise( int8 flags STATUS_PARAM )
  47 {
  48     STATUS(float_exception_flags) |= flags;
  49 }
  50
  51 /*----------------------------------------------------------------------------
  52 | Internal canonical NaN format.
  53 *----------------------------------------------------------------------------*/
  54 typedef struct {
  55     flag sign;
  56     bits64 high, low;
  57 } commonNaNT;
  58
  59 /*----------------------------------------------------------------------------
  60 | The pattern for a default generated single-precision NaN.
  61 *----------------------------------------------------------------------------*/
  62 #if defined(TARGET_SPARC)
  63 #define float32_default_nan make_float32(0x7FFFFFFF)
  64 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
  65 #define float32_default_nan make_float32(0x7FC00000)
  66 #elif defined(TARGET_HPPA)
  67 #define float32_default_nan make_float32(0x7FA00000)
  68 #elif SNAN_BIT_IS_ONE
  69 #define float32_default_nan make_float32(0x7FBFFFFF)
  70 #else
  71 #define float32_default_nan make_float32(0xFFC00000)
  72 #endif
  73
  74 /*----------------------------------------------------------------------------
  75 | Returns 1 if the single-precision floating-point value `a' is a quiet
  76 | NaN; otherwise returns 0.
  77 *----------------------------------------------------------------------------*/
  78
  79 int float32_is_nan( float32 a_ )
  80 {
  81     uint32_t a = float32_val(a_);
  82 #if SNAN_BIT_IS_ONE
  83     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
  84 #else
  85     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
  86 #endif
  87 }
  88
  89 /*----------------------------------------------------------------------------
  90 | Returns 1 if the single-precision floating-point value `a' is a signaling
  91 | NaN; otherwise returns 0.
  92 *----------------------------------------------------------------------------*/
  93
  94 int float32_is_signaling_nan( float32 a_ )
  95 {
  96     uint32_t a = float32_val(a_);
  97 #if SNAN_BIT_IS_ONE
  98     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
  99 #else
 100     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
 101 #endif
 102 }
 103
 104 /*----------------------------------------------------------------------------
 105 | Returns the result of converting the single-precision floating-point NaN
 106 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
 107 | exception is raised.
 108 *----------------------------------------------------------------------------*/
 109
 110 static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
 111 {
 112     commonNaNT z;
 113
 114     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
 115     z.sign = float32_val(a)>>31;
 116     z.low = 0;
 117     z.high = ( (bits64) float32_val(a) )<<41;
 118     return z;
 119 }
 120
 121 /*----------------------------------------------------------------------------
 122 | Returns the result of converting the canonical NaN `a' to the single-
 123 | precision floating-point format.
 124 *----------------------------------------------------------------------------*/
 125
 126 static float32 commonNaNToFloat32( commonNaNT a )
 127 {
 128     bits32 mantissa = a.high>>41;
 129     if ( mantissa )
 130         return make_float32(
 131             ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
 132     else
 133         return float32_default_nan;
 134 }
 135
 136 /*----------------------------------------------------------------------------
 137 | Takes two single-precision floating-point values `a' and `b', one of which
 138 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
 139 | signaling NaN, the invalid exception is raised.
 140 *----------------------------------------------------------------------------*/
 141
 142 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
 143 {
 144     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 145     bits32 av, bv, res;
 146
 147     if ( STATUS(default_nan_mode) )
 148         return float32_default_nan;
 149
 150     aIsNaN = float32_is_nan( a );
 151     aIsSignalingNaN = float32_is_signaling_nan( a );
 152     bIsNaN = float32_is_nan( b );
 153     bIsSignalingNaN = float32_is_signaling_nan( b );
 154     av = float32_val(a);
 155     bv = float32_val(b);
 156 #if SNAN_BIT_IS_ONE
 157     av &= ~0x00400000;
 158     bv &= ~0x00400000;
 159 #else
 160     av |= 0x00400000;
 161     bv |= 0x00400000;
 162 #endif
 163     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 164     if ( aIsSignalingNaN ) {
 165         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 166         res = bIsNaN ? bv : av;
 167     }
 168     else if ( aIsNaN ) {
 169         if ( bIsSignalingNaN || ! bIsNaN )
 170             res = av;
 171         else {
 172  returnLargerSignificand:
 173             if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) )
 174                 res = bv;
 175             else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) )
 176                 res = av;
 177             else
 178                 res = ( av < bv ) ? av : bv;
 179         }
 180     }
 181     else {
 182         res = bv;
 183     }
 184     return make_float32(res);
 185 }
 186
 187 /*----------------------------------------------------------------------------
 188 | The pattern for a default generated double-precision NaN.
 189 *----------------------------------------------------------------------------*/
 190 #if defined(TARGET_SPARC)
 191 #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
 192 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
 193 #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
 194 #elif defined(TARGET_HPPA)
 195 #define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 ))
 196 #elif SNAN_BIT_IS_ONE
 197 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
 198 #else
 199 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
 200 #endif
 201
 202 /*----------------------------------------------------------------------------
 203 | Returns 1 if the double-precision floating-point value `a' is a quiet
 204 | NaN; otherwise returns 0.
 205 *----------------------------------------------------------------------------*/
 206
 207 int float64_is_nan( float64 a_ )
 208 {
 209     bits64 a = float64_val(a_);
 210 #if SNAN_BIT_IS_ONE
 211     return
 212            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 213         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 214 #else
 215     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
 216 #endif
 217 }
 218
 219 /*----------------------------------------------------------------------------
 220 | Returns 1 if the double-precision floating-point value `a' is a signaling
 221 | NaN; otherwise returns 0.
 222 *----------------------------------------------------------------------------*/
 223
 224 int float64_is_signaling_nan( float64 a_ )
 225 {
 226     bits64 a = float64_val(a_);
 227 #if SNAN_BIT_IS_ONE
 228     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
 229 #else
 230     return
 231            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 232         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 233 #endif
 234 }
 235
 236 /*----------------------------------------------------------------------------
 237 | Returns the result of converting the double-precision floating-point NaN
 238 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
 239 | exception is raised.
 240 *----------------------------------------------------------------------------*/
 241
 242 static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
 243 {
 244     commonNaNT z;
 245
 246     if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
 247     z.sign = float64_val(a)>>63;
 248     z.low = 0;
 249     z.high = float64_val(a)<<12;
 250     return z;
 251 }
 252
 253 /*----------------------------------------------------------------------------
 254 | Returns the result of converting the canonical NaN `a' to the double-
 255 | precision floating-point format.
 256 *----------------------------------------------------------------------------*/
 257
 258 static float64 commonNaNToFloat64( commonNaNT a )
 259 {
 260     bits64 mantissa = a.high>>12;
 261
 262     if ( mantissa )
 263         return make_float64(
 264               ( ( (bits64) a.sign )<<63 )
 265             | LIT64( 0x7FF0000000000000 )
 266             | ( a.high>>12 ));
 267     else
 268         return float64_default_nan;
 269 }
 270
 271 /*----------------------------------------------------------------------------
 272 | Takes two double-precision floating-point values `a' and `b', one of which
 273 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
 274 | signaling NaN, the invalid exception is raised.
 275 *----------------------------------------------------------------------------*/
 276
 277 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
 278 {
 279     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 280     bits64 av, bv, res;
 281
 282     if ( STATUS(default_nan_mode) )
 283         return float64_default_nan;
 284
 285     aIsNaN = float64_is_nan( a );
 286     aIsSignalingNaN = float64_is_signaling_nan( a );
 287     bIsNaN = float64_is_nan( b );
 288     bIsSignalingNaN = float64_is_signaling_nan( b );
 289     av = float64_val(a);
 290     bv = float64_val(b);
 291 #if SNAN_BIT_IS_ONE
 292     av &= ~LIT64( 0x0008000000000000 );
 293     bv &= ~LIT64( 0x0008000000000000 );
 294 #else
 295     av |= LIT64( 0x0008000000000000 );
 296     bv |= LIT64( 0x0008000000000000 );
 297 #endif
 298     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 299     if ( aIsSignalingNaN ) {
 300         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 301         res = bIsNaN ? bv : av;
 302     }
 303     else if ( aIsNaN ) {
 304         if ( bIsSignalingNaN || ! bIsNaN )
 305             res = av;
 306         else {
 307  returnLargerSignificand:
 308             if ( (bits64) ( av<<1 ) < (bits64) ( bv<<1 ) )
 309                 res = bv;
 310             else if ( (bits64) ( bv<<1 ) < (bits64) ( av<<1 ) )
 311                 res = av;
 312             else
 313                 res = ( av < bv ) ? av : bv;
 314         }
 315     }
 316     else {
 317         res = bv;
 318     }
 319     return make_float64(res);
 320 }
 321
 322 #ifdef FLOATX80
 323
 324 /*----------------------------------------------------------------------------
 325 | The pattern for a default generated extended double-precision NaN.  The
 326 | `high' and `low' values hold the most- and least-significant bits,
 327 | respectively.
 328 *----------------------------------------------------------------------------*/
 329 #if SNAN_BIT_IS_ONE
 330 #define floatx80_default_nan_high 0x7FFF
 331 #define floatx80_default_nan_low  LIT64( 0xBFFFFFFFFFFFFFFF )
 332 #else
 333 #define floatx80_default_nan_high 0xFFFF
 334 #define floatx80_default_nan_low  LIT64( 0xC000000000000000 )
 335 #endif
 336
 337 /*----------------------------------------------------------------------------
 338 | Returns 1 if the extended double-precision floating-point value `a' is a
 339 | quiet NaN; otherwise returns 0.
 340 *----------------------------------------------------------------------------*/
 341
 342 int floatx80_is_nan( floatx80 a )
 343 {
 344 #if SNAN_BIT_IS_ONE
 345     bits64 aLow;
 346
 347     aLow = a.low & ~ LIT64( 0x4000000000000000 );
 348     return
 349            ( ( a.high & 0x7FFF ) == 0x7FFF )
 350         && (bits64) ( aLow<<1 )
 351         && ( a.low == aLow );
 352 #else
 353     return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
 354 #endif
 355 }
 356
 357 /*----------------------------------------------------------------------------
 358 | Returns 1 if the extended double-precision floating-point value `a' is a
 359 | signaling NaN; otherwise returns 0.
 360 *----------------------------------------------------------------------------*/
 361
 362 int floatx80_is_signaling_nan( floatx80 a )
 363 {
 364 #if SNAN_BIT_IS_ONE
 365     return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
 366 #else
 367     bits64 aLow;
 368
 369     aLow = a.low & ~ LIT64( 0x4000000000000000 );
 370     return
 371            ( ( a.high & 0x7FFF ) == 0x7FFF )
 372         && (bits64) ( aLow<<1 )
 373         && ( a.low == aLow );
 374 #endif
 375 }
 376
 377 /*----------------------------------------------------------------------------
 378 | Returns the result of converting the extended double-precision floating-
 379 | point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the
 380 | invalid exception is raised.
 381 *----------------------------------------------------------------------------*/
 382
 383 static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
 384 {
 385     commonNaNT z;
 386
 387     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
 388     z.sign = a.high>>15;
 389     z.low = 0;
 390     z.high = a.low;
 391     return z;
 392 }
 393
 394 /*----------------------------------------------------------------------------
 395 | Returns the result of converting the canonical NaN `a' to the extended
 396 | double-precision floating-point format.
 397 *----------------------------------------------------------------------------*/
 398
 399 static floatx80 commonNaNToFloatx80( commonNaNT a )
 400 {
 401     floatx80 z;
 402
 403     if (a.high)
 404         z.low = a.high;
 405     else
 406         z.low = floatx80_default_nan_low;
 407     z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
 408     return z;
 409 }
 410
 411 /*----------------------------------------------------------------------------
 412 | Takes two extended double-precision floating-point values `a' and `b', one
 413 | of which is a NaN, and returns the appropriate NaN result.  If either `a' or
 414 | `b' is a signaling NaN, the invalid exception is raised.
 415 *----------------------------------------------------------------------------*/
 416
 417 static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
 418 {
 419     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 420
 421     if ( STATUS(default_nan_mode) ) {
 422         a.low = floatx80_default_nan_low;
 423         a.high = floatx80_default_nan_high;
 424         return a;
 425     }
 426
 427     aIsNaN = floatx80_is_nan( a );
 428     aIsSignalingNaN = floatx80_is_signaling_nan( a );
 429     bIsNaN = floatx80_is_nan( b );
 430     bIsSignalingNaN = floatx80_is_signaling_nan( b );
 431 #if SNAN_BIT_IS_ONE
 432     a.low &= ~LIT64( 0xC000000000000000 );
 433     b.low &= ~LIT64( 0xC000000000000000 );
 434 #else
 435     a.low |= LIT64( 0xC000000000000000 );
 436     b.low |= LIT64( 0xC000000000000000 );
 437 #endif
 438     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 439     if ( aIsSignalingNaN ) {
 440         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 441         return bIsNaN ? b : a;
 442     }
 443     else if ( aIsNaN ) {
 444         if ( bIsSignalingNaN || ! bIsNaN ) return a;
 445  returnLargerSignificand:
 446         if ( a.low < b.low ) return b;
 447         if ( b.low < a.low ) return a;
 448         return ( a.high < b.high ) ? a : b;
 449     }
 450     else {
 451         return b;
 452     }
 453 }
 454
 455 #endif
 456
 457 #ifdef FLOAT128
 458
 459 /*----------------------------------------------------------------------------
 460 | The pattern for a default generated quadruple-precision NaN.  The `high' and
 461 | `low' values hold the most- and least-significant bits, respectively.
 462 *----------------------------------------------------------------------------*/
 463 #if SNAN_BIT_IS_ONE
 464 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
 465 #define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
 466 #else
 467 #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
 468 #define float128_default_nan_low  LIT64( 0x0000000000000000 )
 469 #endif
 470
 471 /*----------------------------------------------------------------------------
 472 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
 473 | NaN; otherwise returns 0.
 474 *----------------------------------------------------------------------------*/
 475
 476 int float128_is_nan( float128 a )
 477 {
 478 #if SNAN_BIT_IS_ONE
 479     return
 480            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
 481         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
 482 #else
 483     return
 484            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
 485         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
 486 #endif
 487 }
 488
 489 /*----------------------------------------------------------------------------
 490 | Returns 1 if the quadruple-precision floating-point value `a' is a
 491 | signaling NaN; otherwise returns 0.
 492 *----------------------------------------------------------------------------*/
 493
 494 int float128_is_signaling_nan( float128 a )
 495 {
 496 #if SNAN_BIT_IS_ONE
 497     return
 498            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
 499         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
 500 #else
 501     return
 502            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
 503         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
 504 #endif
 505 }
 506
 507 /*----------------------------------------------------------------------------
 508 | Returns the result of converting the quadruple-precision floating-point NaN
 509 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
 510 | exception is raised.
 511 *----------------------------------------------------------------------------*/
 512
 513 static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
 514 {
 515     commonNaNT z;
 516
 517     if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
 518     z.sign = a.high>>63;
 519     shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
 520     return z;
 521 }
 522
 523 /*----------------------------------------------------------------------------
 524 | Returns the result of converting the canonical NaN `a' to the quadruple-
 525 | precision floating-point format.
 526 *----------------------------------------------------------------------------*/
 527
 528 static float128 commonNaNToFloat128( commonNaNT a )
 529 {
 530     float128 z;
 531
 532     shift128Right( a.high, a.low, 16, &z.high, &z.low );
 533     z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
 534     return z;
 535 }
 536
 537 /*----------------------------------------------------------------------------
 538 | Takes two quadruple-precision floating-point values `a' and `b', one of
 539 | which is a NaN, and returns the appropriate NaN result.  If either `a' or
 540 | `b' is a signaling NaN, the invalid exception is raised.
 541 *----------------------------------------------------------------------------*/
 542
 543 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
 544 {
 545     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 546
 547     if ( STATUS(default_nan_mode) ) {
 548         a.low = float128_default_nan_low;
 549         a.high = float128_default_nan_high;
 550         return a;
 551     }
 552
 553     aIsNaN = float128_is_nan( a );
 554     aIsSignalingNaN = float128_is_signaling_nan( a );
 555     bIsNaN = float128_is_nan( b );
 556     bIsSignalingNaN = float128_is_signaling_nan( b );
 557 #if SNAN_BIT_IS_ONE
 558     a.high &= ~LIT64( 0x0000800000000000 );
 559     b.high &= ~LIT64( 0x0000800000000000 );
 560 #else
 561     a.high |= LIT64( 0x0000800000000000 );
 562     b.high |= LIT64( 0x0000800000000000 );
 563 #endif
 564     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 565     if ( aIsSignalingNaN ) {
 566         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 567         return bIsNaN ? b : a;
 568     }
 569     else if ( aIsNaN ) {
 570         if ( bIsSignalingNaN || ! bIsNaN ) return a;
 571  returnLargerSignificand:
 572         if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
 573         if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
 574         return ( a.high < b.high ) ? a : b;
 575     }
 576     else {
 577         return b;
 578     }
 579 }
 580
 581 #endif