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 | Underflow tininess-detection mode, statically initialized to default value.
  41 | (The declaration in `softfloat.h' must match the `int8' type here.)
  42 *----------------------------------------------------------------------------*/
  43 int8 float_detect_tininess = float_tininess_after_rounding;
  44
  45 /*----------------------------------------------------------------------------
  46 | Raises the exceptions specified by `flags'.  Floating-point traps can be
  47 | defined here if desired.  It is currently not possible for such a trap
  48 | to substitute a result value.  If traps are not implemented, this routine
  49 | should be simply `float_exception_flags |= flags;'.
  50 *----------------------------------------------------------------------------*/
  51
  52 void float_raise( int8 flags STATUS_PARAM )
  53 {
  54     STATUS(float_exception_flags) |= flags;
  55 }
  56
  57 /*----------------------------------------------------------------------------
  58 | Internal canonical NaN format.
  59 *----------------------------------------------------------------------------*/
  60 typedef struct {
  61     flag sign;
  62     bits64 high, low;
  63 } commonNaNT;
  64
  65 /*----------------------------------------------------------------------------
  66 | The pattern for a default generated single-precision NaN.
  67 *----------------------------------------------------------------------------*/
  68 #if defined(TARGET_SPARC)
  69 #define float32_default_nan make_float32(0x7FFFFFFF)
  70 #elif defined(TARGET_POWERPC)
  71 #define float32_default_nan make_float32(0x7FC00000)
  72 #elif defined(TARGET_HPPA)
  73 #define float32_default_nan make_float32(0x7FA00000)
  74 #elif SNAN_BIT_IS_ONE
  75 #define float32_default_nan make_float32(0x7FBFFFFF)
  76 #else
  77 #define float32_default_nan make_float32(0xFFC00000)
  78 #endif
  79
  80 /*----------------------------------------------------------------------------
  81 | Returns 1 if the single-precision floating-point value `a' is a quiet
  82 | NaN; otherwise returns 0.
  83 *----------------------------------------------------------------------------*/
  84
  85 int float32_is_nan( float32 a_ )
  86 {
  87     uint32_t a = float32_val(a_);
  88 #if SNAN_BIT_IS_ONE
  89     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
  90 #else
  91     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
  92 #endif
  93 }
  94
  95 /*----------------------------------------------------------------------------
  96 | Returns 1 if the single-precision floating-point value `a' is a signaling
  97 | NaN; otherwise returns 0.
  98 *----------------------------------------------------------------------------*/
  99
 100 int float32_is_signaling_nan( float32 a_ )
 101 {
 102     uint32_t a = float32_val(a_);
 103 #if SNAN_BIT_IS_ONE
 104     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
 105 #else
 106     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
 107 #endif
 108 }
 109
 110 /*----------------------------------------------------------------------------
 111 | Returns the result of converting the single-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 float32ToCommonNaN( float32 a STATUS_PARAM )
 117 {
 118     commonNaNT z;
 119
 120     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
 121     z.sign = float32_val(a)>>31;
 122     z.low = 0;
 123     z.high = ( (bits64) float32_val(a) )<<41;
 124     return z;
 125 }
 126
 127 /*----------------------------------------------------------------------------
 128 | Returns the result of converting the canonical NaN `a' to the single-
 129 | precision floating-point format.
 130 *----------------------------------------------------------------------------*/
 131
 132 static float32 commonNaNToFloat32( commonNaNT a )
 133 {
 134     bits32 mantissa = a.high>>41;
 135     if ( mantissa )
 136         return make_float32(
 137             ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
 138     else
 139         return float32_default_nan;
 140 }
 141
 142 /*----------------------------------------------------------------------------
 143 | Takes two single-precision floating-point values `a' and `b', one of which
 144 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
 145 | signaling NaN, the invalid exception is raised.
 146 *----------------------------------------------------------------------------*/
 147
 148 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
 149 {
 150     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 151     bits32 av, bv, res;
 152
 153     aIsNaN = float32_is_nan( a );
 154     aIsSignalingNaN = float32_is_signaling_nan( a );
 155     bIsNaN = float32_is_nan( b );
 156     bIsSignalingNaN = float32_is_signaling_nan( b );
 157     av = float32_val(a);
 158     bv = float32_val(b);
 159 #if SNAN_BIT_IS_ONE
 160     av &= ~0x00400000;
 161     bv &= ~0x00400000;
 162 #else
 163     av |= 0x00400000;
 164     bv |= 0x00400000;
 165 #endif
 166     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 167     if ( aIsSignalingNaN ) {
 168         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 169         res = bIsNaN ? bv : av;
 170     }
 171     else if ( aIsNaN ) {
 172         if ( bIsSignalingNaN | ! bIsNaN )
 173             res = av;
 174         else {
 175  returnLargerSignificand:
 176             if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) )
 177                 res = bv;
 178             else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) )
 179                 res = av;
 180             else
 181                 res = ( av < bv ) ? av : bv;
 182         }
 183     }
 184     else {
 185         res = bv;
 186     }
 187     return make_float32(res);
 188 }
 189
 190 /*----------------------------------------------------------------------------
 191 | The pattern for a default generated double-precision NaN.
 192 *----------------------------------------------------------------------------*/
 193 #if defined(TARGET_SPARC)
 194 #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
 195 #elif defined(TARGET_POWERPC)
 196 #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
 197 #elif defined(TARGET_HPPA)
 198 #define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 ))
 199 #elif SNAN_BIT_IS_ONE
 200 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
 201 #else
 202 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
 203 #endif
 204
 205 /*----------------------------------------------------------------------------
 206 | Returns 1 if the double-precision floating-point value `a' is a quiet
 207 | NaN; otherwise returns 0.
 208 *----------------------------------------------------------------------------*/
 209
 210 int float64_is_nan( float64 a_ )
 211 {
 212     bits64 a = float64_val(a_);
 213 #if SNAN_BIT_IS_ONE
 214     return
 215            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 216         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 217 #else
 218     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
 219 #endif
 220 }
 221
 222 /*----------------------------------------------------------------------------
 223 | Returns 1 if the double-precision floating-point value `a' is a signaling
 224 | NaN; otherwise returns 0.
 225 *----------------------------------------------------------------------------*/
 226
 227 int float64_is_signaling_nan( float64 a_ )
 228 {
 229     bits64 a = float64_val(a_);
 230 #if SNAN_BIT_IS_ONE
 231     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
 232 #else
 233     return
 234            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 235         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 236 #endif
 237 }
 238
 239 /*----------------------------------------------------------------------------
 240 | Returns the result of converting the double-precision floating-point NaN
 241 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
 242 | exception is raised.
 243 *----------------------------------------------------------------------------*/
 244
 245 static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
 246 {
 247     commonNaNT z;
 248
 249     if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
 250     z.sign = float64_val(a)>>63;
 251     z.low = 0;
 252     z.high = float64_val(a)<<12;
 253     return z;
 254 }
 255
 256 /*----------------------------------------------------------------------------
 257 | Returns the result of converting the canonical NaN `a' to the double-
 258 | precision floating-point format.
 259 *----------------------------------------------------------------------------*/
 260
 261 static float64 commonNaNToFloat64( commonNaNT a )
 262 {
 263     bits64 mantissa = a.high>>12;
 264
 265     if ( mantissa )
 266         return make_float64(
 267               ( ( (bits64) a.sign )<<63 )
 268             | LIT64( 0x7FF0000000000000 )
 269             | ( a.high>>12 ));
 270     else
 271         return float64_default_nan;
 272 }
 273
 274 /*----------------------------------------------------------------------------
 275 | Takes two double-precision floating-point values `a' and `b', one of which
 276 | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
 277 | signaling NaN, the invalid exception is raised.
 278 *----------------------------------------------------------------------------*/
 279
 280 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
 281 {
 282     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 283     bits64 av, bv, res;
 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     aIsNaN = floatx80_is_nan( a );
 422     aIsSignalingNaN = floatx80_is_signaling_nan( a );
 423     bIsNaN = floatx80_is_nan( b );
 424     bIsSignalingNaN = floatx80_is_signaling_nan( b );
 425 #if SNAN_BIT_IS_ONE
 426     a.low &= ~LIT64( 0xC000000000000000 );
 427     b.low &= ~LIT64( 0xC000000000000000 );
 428 #else
 429     a.low |= LIT64( 0xC000000000000000 );
 430     b.low |= LIT64( 0xC000000000000000 );
 431 #endif
 432     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 433     if ( aIsSignalingNaN ) {
 434         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 435         return bIsNaN ? b : a;
 436     }
 437     else if ( aIsNaN ) {
 438         if ( bIsSignalingNaN | ! bIsNaN ) return a;
 439  returnLargerSignificand:
 440         if ( a.low < b.low ) return b;
 441         if ( b.low < a.low ) return a;
 442         return ( a.high < b.high ) ? a : b;
 443     }
 444     else {
 445         return b;
 446     }
 447 }
 448
 449 #endif
 450
 451 #ifdef FLOAT128
 452
 453 /*----------------------------------------------------------------------------
 454 | The pattern for a default generated quadruple-precision NaN.  The `high' and
 455 | `low' values hold the most- and least-significant bits, respectively.
 456 *----------------------------------------------------------------------------*/
 457 #if SNAN_BIT_IS_ONE
 458 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
 459 #define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
 460 #else
 461 #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
 462 #define float128_default_nan_low  LIT64( 0x0000000000000000 )
 463 #endif
 464
 465 /*----------------------------------------------------------------------------
 466 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
 467 | NaN; otherwise returns 0.
 468 *----------------------------------------------------------------------------*/
 469
 470 int float128_is_nan( float128 a )
 471 {
 472 #if SNAN_BIT_IS_ONE
 473     return
 474            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
 475         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
 476 #else
 477     return
 478            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
 479         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
 480 #endif
 481 }
 482
 483 /*----------------------------------------------------------------------------
 484 | Returns 1 if the quadruple-precision floating-point value `a' is a
 485 | signaling NaN; otherwise returns 0.
 486 *----------------------------------------------------------------------------*/
 487
 488 int float128_is_signaling_nan( float128 a )
 489 {
 490 #if SNAN_BIT_IS_ONE
 491     return
 492            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
 493         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
 494 #else
 495     return
 496            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
 497         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
 498 #endif
 499 }
 500
 501 /*----------------------------------------------------------------------------
 502 | Returns the result of converting the quadruple-precision floating-point NaN
 503 | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
 504 | exception is raised.
 505 *----------------------------------------------------------------------------*/
 506
 507 static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
 508 {
 509     commonNaNT z;
 510
 511     if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
 512     z.sign = a.high>>63;
 513     shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
 514     return z;
 515 }
 516
 517 /*----------------------------------------------------------------------------
 518 | Returns the result of converting the canonical NaN `a' to the quadruple-
 519 | precision floating-point format.
 520 *----------------------------------------------------------------------------*/
 521
 522 static float128 commonNaNToFloat128( commonNaNT a )
 523 {
 524     float128 z;
 525
 526     shift128Right( a.high, a.low, 16, &z.high, &z.low );
 527     z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
 528     return z;
 529 }
 530
 531 /*----------------------------------------------------------------------------
 532 | Takes two quadruple-precision floating-point values `a' and `b', one of
 533 | which is a NaN, and returns the appropriate NaN result.  If either `a' or
 534 | `b' is a signaling NaN, the invalid exception is raised.
 535 *----------------------------------------------------------------------------*/
 536
 537 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
 538 {
 539     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 540
 541     aIsNaN = float128_is_nan( a );
 542     aIsSignalingNaN = float128_is_signaling_nan( a );
 543     bIsNaN = float128_is_nan( b );
 544     bIsSignalingNaN = float128_is_signaling_nan( b );
 545 #if SNAN_BIT_IS_ONE
 546     a.high &= ~LIT64( 0x0000800000000000 );
 547     b.high &= ~LIT64( 0x0000800000000000 );
 548 #else
 549     a.high |= LIT64( 0x0000800000000000 );
 550     b.high |= LIT64( 0x0000800000000000 );
 551 #endif
 552     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
 553     if ( aIsSignalingNaN ) {
 554         if ( bIsSignalingNaN ) goto returnLargerSignificand;
 555         return bIsNaN ? b : a;
 556     }
 557     else if ( aIsNaN ) {
 558         if ( bIsSignalingNaN | ! bIsNaN ) return a;
 559  returnLargerSignificand:
 560         if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
 561         if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
 562         return ( a.high < b.high ) ? a : b;
 563     }
 564     else {
 565         return b;
 566     }
 567 }
 568
 569 #endif