fpu/softfloat-macros.h

   1 /*
   2  * QEMU float support macros
   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 notice) 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 | This macro tests for minimum version of the GNU C compiler.
  40 *----------------------------------------------------------------------------*/
  41 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
  42 # define SOFTFLOAT_GNUC_PREREQ(maj, min) \
  43          ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
  44 #else
  45 # define SOFTFLOAT_GNUC_PREREQ(maj, min) 0
  46 #endif
  47
  48
  49 /*----------------------------------------------------------------------------
  50 | Shifts `a' right by the number of bits given in `count'.  If any nonzero
  51 | bits are shifted off, they are ``jammed'' into the least significant bit of
  52 | the result by setting the least significant bit to 1.  The value of `count'
  53 | can be arbitrarily large; in particular, if `count' is greater than 32, the
  54 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.
  55 | The result is stored in the location pointed to by `zPtr'.
  56 *----------------------------------------------------------------------------*/
  57
  58 INLINE void shift32RightJamming( uint32_t a, int16 count, uint32_t *zPtr )
  59 {
  60     uint32_t z;
  61
  62     if ( count == 0 ) {
  63         z = a;
  64     }
  65     else if ( count < 32 ) {
  66         z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
  67     }
  68     else {
  69         z = ( a != 0 );
  70     }
  71     *zPtr = z;
  72
  73 }
  74
  75 /*----------------------------------------------------------------------------
  76 | Shifts `a' right by the number of bits given in `count'.  If any nonzero
  77 | bits are shifted off, they are ``jammed'' into the least significant bit of
  78 | the result by setting the least significant bit to 1.  The value of `count'
  79 | can be arbitrarily large; in particular, if `count' is greater than 64, the
  80 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.
  81 | The result is stored in the location pointed to by `zPtr'.
  82 *----------------------------------------------------------------------------*/
  83
  84 INLINE void shift64RightJamming( uint64_t a, int16 count, uint64_t *zPtr )
  85 {
  86     uint64_t z;
  87
  88     if ( count == 0 ) {
  89         z = a;
  90     }
  91     else if ( count < 64 ) {
  92         z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
  93     }
  94     else {
  95         z = ( a != 0 );
  96     }
  97     *zPtr = z;
  98
  99 }
 100
 101 /*----------------------------------------------------------------------------
 102 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
 103 | _plus_ the number of bits given in `count'.  The shifted result is at most
 104 | 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'.  The
 105 | bits shifted off form a second 64-bit result as follows:  The _last_ bit
 106 | shifted off is the most-significant bit of the extra result, and the other
 107 | 63 bits of the extra result are all zero if and only if _all_but_the_last_
 108 | bits shifted off were all zero.  This extra result is stored in the location
 109 | pointed to by `z1Ptr'.  The value of `count' can be arbitrarily large.
 110 |     (This routine makes more sense if `a0' and `a1' are considered to form
 111 | a fixed-point value with binary point between `a0' and `a1'.  This fixed-
 112 | point value is shifted right by the number of bits given in `count', and
 113 | the integer part of the result is returned at the location pointed to by
 114 | `z0Ptr'.  The fractional part of the result may be slightly corrupted as
 115 | described above, and is returned at the location pointed to by `z1Ptr'.)
 116 *----------------------------------------------------------------------------*/
 117
 118 INLINE void
 119  shift64ExtraRightJamming(
 120      uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
 121 {
 122     uint64_t z0, z1;
 123     int8 negCount = ( - count ) & 63;
 124
 125     if ( count == 0 ) {
 126         z1 = a1;
 127         z0 = a0;
 128     }
 129     else if ( count < 64 ) {
 130         z1 = ( a0<<negCount ) | ( a1 != 0 );
 131         z0 = a0>>count;
 132     }
 133     else {
 134         if ( count == 64 ) {
 135             z1 = a0 | ( a1 != 0 );
 136         }
 137         else {
 138             z1 = ( ( a0 | a1 ) != 0 );
 139         }
 140         z0 = 0;
 141     }
 142     *z1Ptr = z1;
 143     *z0Ptr = z0;
 144
 145 }
 146
 147 /*----------------------------------------------------------------------------
 148 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
 149 | number of bits given in `count'.  Any bits shifted off are lost.  The value
 150 | of `count' can be arbitrarily large; in particular, if `count' is greater
 151 | than 128, the result will be 0.  The result is broken into two 64-bit pieces
 152 | which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
 153 *----------------------------------------------------------------------------*/
 154
 155 INLINE void
 156  shift128Right(
 157      uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
 158 {
 159     uint64_t z0, z1;
 160     int8 negCount = ( - count ) & 63;
 161
 162     if ( count == 0 ) {
 163         z1 = a1;
 164         z0 = a0;
 165     }
 166     else if ( count < 64 ) {
 167         z1 = ( a0<<negCount ) | ( a1>>count );
 168         z0 = a0>>count;
 169     }
 170     else {
 171         z1 = ( count < 64 ) ? ( a0>>( count & 63 ) ) : 0;
 172         z0 = 0;
 173     }
 174     *z1Ptr = z1;
 175     *z0Ptr = z0;
 176
 177 }
 178
 179 /*----------------------------------------------------------------------------
 180 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
 181 | number of bits given in `count'.  If any nonzero bits are shifted off, they
 182 | are ``jammed'' into the least significant bit of the result by setting the
 183 | least significant bit to 1.  The value of `count' can be arbitrarily large;
 184 | in particular, if `count' is greater than 128, the result will be either
 185 | 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
 186 | nonzero.  The result is broken into two 64-bit pieces which are stored at
 187 | the locations pointed to by `z0Ptr' and `z1Ptr'.
 188 *----------------------------------------------------------------------------*/
 189
 190 INLINE void
 191  shift128RightJamming(
 192      uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
 193 {
 194     uint64_t z0, z1;
 195     int8 negCount = ( - count ) & 63;
 196
 197     if ( count == 0 ) {
 198         z1 = a1;
 199         z0 = a0;
 200     }
 201     else if ( count < 64 ) {
 202         z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
 203         z0 = a0>>count;
 204     }
 205     else {
 206         if ( count == 64 ) {
 207             z1 = a0 | ( a1 != 0 );
 208         }
 209         else if ( count < 128 ) {
 210             z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
 211         }
 212         else {
 213             z1 = ( ( a0 | a1 ) != 0 );
 214         }
 215         z0 = 0;
 216     }
 217     *z1Ptr = z1;
 218     *z0Ptr = z0;
 219
 220 }
 221
 222 /*----------------------------------------------------------------------------
 223 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
 224 | by 64 _plus_ the number of bits given in `count'.  The shifted result is
 225 | at most 128 nonzero bits; these are broken into two 64-bit pieces which are
 226 | stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted
 227 | off form a third 64-bit result as follows:  The _last_ bit shifted off is
 228 | the most-significant bit of the extra result, and the other 63 bits of the
 229 | extra result are all zero if and only if _all_but_the_last_ bits shifted off
 230 | were all zero.  This extra result is stored in the location pointed to by
 231 | `z2Ptr'.  The value of `count' can be arbitrarily large.
 232 |     (This routine makes more sense if `a0', `a1', and `a2' are considered
 233 | to form a fixed-point value with binary point between `a1' and `a2'.  This
 234 | fixed-point value is shifted right by the number of bits given in `count',
 235 | and the integer part of the result is returned at the locations pointed to
 236 | by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly
 237 | corrupted as described above, and is returned at the location pointed to by
 238 | `z2Ptr'.)
 239 *----------------------------------------------------------------------------*/
 240
 241 INLINE void
 242  shift128ExtraRightJamming(
 243      uint64_t a0,
 244      uint64_t a1,
 245      uint64_t a2,
 246      int16 count,
 247      uint64_t *z0Ptr,
 248      uint64_t *z1Ptr,
 249      uint64_t *z2Ptr
 250  )
 251 {
 252     uint64_t z0, z1, z2;
 253     int8 negCount = ( - count ) & 63;
 254
 255     if ( count == 0 ) {
 256         z2 = a2;
 257         z1 = a1;
 258         z0 = a0;
 259     }
 260     else {
 261         if ( count < 64 ) {
 262             z2 = a1<<negCount;
 263             z1 = ( a0<<negCount ) | ( a1>>count );
 264             z0 = a0>>count;
 265         }
 266         else {
 267             if ( count == 64 ) {
 268                 z2 = a1;
 269                 z1 = a0;
 270             }
 271             else {
 272                 a2 |= a1;
 273                 if ( count < 128 ) {
 274                     z2 = a0<<negCount;
 275                     z1 = a0>>( count & 63 );
 276                 }
 277                 else {
 278                     z2 = ( count == 128 ) ? a0 : ( a0 != 0 );
 279                     z1 = 0;
 280                 }
 281             }
 282             z0 = 0;
 283         }
 284         z2 |= ( a2 != 0 );
 285     }
 286     *z2Ptr = z2;
 287     *z1Ptr = z1;
 288     *z0Ptr = z0;
 289
 290 }
 291
 292 /*----------------------------------------------------------------------------
 293 | Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
 294 | number of bits given in `count'.  Any bits shifted off are lost.  The value
 295 | of `count' must be less than 64.  The result is broken into two 64-bit
 296 | pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
 297 *----------------------------------------------------------------------------*/
 298
 299 INLINE void
 300  shortShift128Left(
 301      uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
 302 {
 303
 304     *z1Ptr = a1<<count;
 305     *z0Ptr =
 306         ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );
 307
 308 }
 309
 310 /*----------------------------------------------------------------------------
 311 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
 312 | by the number of bits given in `count'.  Any bits shifted off are lost.
 313 | The value of `count' must be less than 64.  The result is broken into three
 314 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
 315 | `z1Ptr', and `z2Ptr'.
 316 *----------------------------------------------------------------------------*/
 317
 318 INLINE void
 319  shortShift192Left(
 320      uint64_t a0,
 321      uint64_t a1,
 322      uint64_t a2,
 323      int16 count,
 324      uint64_t *z0Ptr,
 325      uint64_t *z1Ptr,
 326      uint64_t *z2Ptr
 327  )
 328 {
 329     uint64_t z0, z1, z2;
 330     int8 negCount;
 331
 332     z2 = a2<<count;
 333     z1 = a1<<count;
 334     z0 = a0<<count;
 335     if ( 0 < count ) {
 336         negCount = ( ( - count ) & 63 );
 337         z1 |= a2>>negCount;
 338         z0 |= a1>>negCount;
 339     }
 340     *z2Ptr = z2;
 341     *z1Ptr = z1;
 342     *z0Ptr = z0;
 343
 344 }
 345
 346 /*----------------------------------------------------------------------------
 347 | Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
 348 | value formed by concatenating `b0' and `b1'.  Addition is modulo 2^128, so
 349 | any carry out is lost.  The result is broken into two 64-bit pieces which
 350 | are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
 351 *----------------------------------------------------------------------------*/
 352
 353 INLINE void
 354  add128(
 355      uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
 356 {
 357     uint64_t z1;
 358
 359     z1 = a1 + b1;
 360     *z1Ptr = z1;
 361     *z0Ptr = a0 + b0 + ( z1 < a1 );
 362
 363 }
 364
 365 /*----------------------------------------------------------------------------
 366 | Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
 367 | 192-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is
 368 | modulo 2^192, so any carry out is lost.  The result is broken into three
 369 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
 370 | `z1Ptr', and `z2Ptr'.
 371 *----------------------------------------------------------------------------*/
 372
 373 INLINE void
 374  add192(
 375      uint64_t a0,
 376      uint64_t a1,
 377      uint64_t a2,
 378      uint64_t b0,
 379      uint64_t b1,
 380      uint64_t b2,
 381      uint64_t *z0Ptr,
 382      uint64_t *z1Ptr,
 383      uint64_t *z2Ptr
 384  )
 385 {
 386     uint64_t z0, z1, z2;
 387     int8 carry0, carry1;
 388
 389     z2 = a2 + b2;
 390     carry1 = ( z2 < a2 );
 391     z1 = a1 + b1;
 392     carry0 = ( z1 < a1 );
 393     z0 = a0 + b0;
 394     z1 += carry1;
 395     z0 += ( z1 < carry1 );
 396     z0 += carry0;
 397     *z2Ptr = z2;
 398     *z1Ptr = z1;
 399     *z0Ptr = z0;
 400
 401 }
 402
 403 /*----------------------------------------------------------------------------
 404 | Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
 405 | 128-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo
 406 | 2^128, so any borrow out (carry out) is lost.  The result is broken into two
 407 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
 408 | `z1Ptr'.
 409 *----------------------------------------------------------------------------*/
 410
 411 INLINE void
 412  sub128(
 413      uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
 414 {
 415
 416     *z1Ptr = a1 - b1;
 417     *z0Ptr = a0 - b0 - ( a1 < b1 );
 418
 419 }
 420
 421 /*----------------------------------------------------------------------------
 422 | Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
 423 | from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
 424 | Subtraction is modulo 2^192, so any borrow out (carry out) is lost.  The
 425 | result is broken into three 64-bit pieces which are stored at the locations
 426 | pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
 427 *----------------------------------------------------------------------------*/
 428
 429 INLINE void
 430  sub192(
 431      uint64_t a0,
 432      uint64_t a1,
 433      uint64_t a2,
 434      uint64_t b0,
 435      uint64_t b1,
 436      uint64_t b2,
 437      uint64_t *z0Ptr,
 438      uint64_t *z1Ptr,
 439      uint64_t *z2Ptr
 440  )
 441 {
 442     uint64_t z0, z1, z2;
 443     int8 borrow0, borrow1;
 444
 445     z2 = a2 - b2;
 446     borrow1 = ( a2 < b2 );
 447     z1 = a1 - b1;
 448     borrow0 = ( a1 < b1 );
 449     z0 = a0 - b0;
 450     z0 -= ( z1 < borrow1 );
 451     z1 -= borrow1;
 452     z0 -= borrow0;
 453     *z2Ptr = z2;
 454     *z1Ptr = z1;
 455     *z0Ptr = z0;
 456
 457 }
 458
 459 /*----------------------------------------------------------------------------
 460 | Multiplies `a' by `b' to obtain a 128-bit product.  The product is broken
 461 | into two 64-bit pieces which are stored at the locations pointed to by
 462 | `z0Ptr' and `z1Ptr'.
 463 *----------------------------------------------------------------------------*/
 464
 465 INLINE void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
 466 {
 467     uint32_t aHigh, aLow, bHigh, bLow;
 468     uint64_t z0, zMiddleA, zMiddleB, z1;
 469
 470     aLow = a;
 471     aHigh = a>>32;
 472     bLow = b;
 473     bHigh = b>>32;
 474     z1 = ( (uint64_t) aLow ) * bLow;
 475     zMiddleA = ( (uint64_t) aLow ) * bHigh;
 476     zMiddleB = ( (uint64_t) aHigh ) * bLow;
 477     z0 = ( (uint64_t) aHigh ) * bHigh;
 478     zMiddleA += zMiddleB;
 479     z0 += ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
 480     zMiddleA <<= 32;
 481     z1 += zMiddleA;
 482     z0 += ( z1 < zMiddleA );
 483     *z1Ptr = z1;
 484     *z0Ptr = z0;
 485
 486 }
 487
 488 /*----------------------------------------------------------------------------
 489 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' by
 490 | `b' to obtain a 192-bit product.  The product is broken into three 64-bit
 491 | pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
 492 | `z2Ptr'.
 493 *----------------------------------------------------------------------------*/
 494
 495 INLINE void
 496  mul128By64To192(
 497      uint64_t a0,
 498      uint64_t a1,
 499      uint64_t b,
 500      uint64_t *z0Ptr,
 501      uint64_t *z1Ptr,
 502      uint64_t *z2Ptr
 503  )
 504 {
 505     uint64_t z0, z1, z2, more1;
 506
 507     mul64To128( a1, b, &z1, &z2 );
 508     mul64To128( a0, b, &z0, &more1 );
 509     add128( z0, more1, 0, z1, &z0, &z1 );
 510     *z2Ptr = z2;
 511     *z1Ptr = z1;
 512     *z0Ptr = z0;
 513
 514 }
 515
 516 /*----------------------------------------------------------------------------
 517 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
 518 | 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
 519 | product.  The product is broken into four 64-bit pieces which are stored at
 520 | the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
 521 *----------------------------------------------------------------------------*/
 522
 523 INLINE void
 524  mul128To256(
 525      uint64_t a0,
 526      uint64_t a1,
 527      uint64_t b0,
 528      uint64_t b1,
 529      uint64_t *z0Ptr,
 530      uint64_t *z1Ptr,
 531      uint64_t *z2Ptr,
 532      uint64_t *z3Ptr
 533  )
 534 {
 535     uint64_t z0, z1, z2, z3;
 536     uint64_t more1, more2;
 537
 538     mul64To128( a1, b1, &z2, &z3 );
 539     mul64To128( a1, b0, &z1, &more2 );
 540     add128( z1, more2, 0, z2, &z1, &z2 );
 541     mul64To128( a0, b0, &z0, &more1 );
 542     add128( z0, more1, 0, z1, &z0, &z1 );
 543     mul64To128( a0, b1, &more1, &more2 );
 544     add128( more1, more2, 0, z2, &more1, &z2 );
 545     add128( z0, z1, 0, more1, &z0, &z1 );
 546     *z3Ptr = z3;
 547     *z2Ptr = z2;
 548     *z1Ptr = z1;
 549     *z0Ptr = z0;
 550
 551 }
 552
 553 /*----------------------------------------------------------------------------
 554 | Returns an approximation to the 64-bit integer quotient obtained by dividing
 555 | `b' into the 128-bit value formed by concatenating `a0' and `a1'.  The
 556 | divisor `b' must be at least 2^63.  If q is the exact quotient truncated
 557 | toward zero, the approximation returned lies between q and q + 2 inclusive.
 558 | If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
 559 | unsigned integer is returned.
 560 *----------------------------------------------------------------------------*/
 561
 562 static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
 563 {
 564     uint64_t b0, b1;
 565     uint64_t rem0, rem1, term0, term1;
 566     uint64_t z;
 567
 568     if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
 569     b0 = b>>32;
 570     z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
 571     mul64To128( b, z, &term0, &term1 );
 572     sub128( a0, a1, term0, term1, &rem0, &rem1 );
 573     while ( ( (int64_t) rem0 ) < 0 ) {
 574         z -= LIT64( 0x100000000 );
 575         b1 = b<<32;
 576         add128( rem0, rem1, b0, b1, &rem0, &rem1 );
 577     }
 578     rem0 = ( rem0<<32 ) | ( rem1>>32 );
 579     z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;
 580     return z;
 581
 582 }
 583
 584 /*----------------------------------------------------------------------------
 585 | Returns an approximation to the square root of the 32-bit significand given
 586 | by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of
 587 | `aExp' (the least significant bit) is 1, the integer returned approximates
 588 | 2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'
 589 | is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either
 590 | case, the approximation returned lies strictly within +/-2 of the exact
 591 | value.
 592 *----------------------------------------------------------------------------*/
 593
 594 static uint32_t estimateSqrt32( int16 aExp, uint32_t a )
 595 {
 596     static const uint16_t sqrtOddAdjustments[] = {
 597         0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
 598         0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
 599     };
 600     static const uint16_t sqrtEvenAdjustments[] = {
 601         0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
 602         0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
 603     };
 604     int8 index;
 605     uint32_t z;
 606
 607     index = ( a>>27 ) & 15;
 608     if ( aExp & 1 ) {
 609         z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ (int)index ];
 610         z = ( ( a / z )<<14 ) + ( z<<15 );
 611         a >>= 1;
 612     }
 613     else {
 614         z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ];
 615         z = a / z + z;
 616         z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
 617         if ( z <= a ) return (uint32_t) ( ( (int32_t) a )>>1 );
 618     }
 619     return ( (uint32_t) ( ( ( (uint64_t) a )<<31 ) / z ) ) + ( z>>1 );
 620
 621 }
 622
 623 /*----------------------------------------------------------------------------
 624 | Returns the number of leading 0 bits before the most-significant 1 bit of
 625 | `a'.  If `a' is zero, 32 is returned.
 626 *----------------------------------------------------------------------------*/
 627
 628 static int8 countLeadingZeros32( uint32_t a )
 629 {
 630 #if SOFTFLOAT_GNUC_PREREQ(3, 4)
 631     if (a) {
 632         return __builtin_clz(a);
 633     } else {
 634         return 32;
 635     }
 636 #else
 637     static const int8 countLeadingZerosHigh[] = {
 638         8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
 639         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 640         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 641         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 642         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 643         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 644         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 645         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 646         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 647         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 648         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 649         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 650         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 651         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 652         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 653         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 654     };
 655     int8 shiftCount;
 656
 657     shiftCount = 0;
 658     if ( a < 0x10000 ) {
 659         shiftCount += 16;
 660         a <<= 16;
 661     }
 662     if ( a < 0x1000000 ) {
 663         shiftCount += 8;
 664         a <<= 8;
 665     }
 666     shiftCount += countLeadingZerosHigh[ a>>24 ];
 667     return shiftCount;
 668 #endif
 669 }
 670
 671 /*----------------------------------------------------------------------------
 672 | Returns the number of leading 0 bits before the most-significant 1 bit of
 673 | `a'.  If `a' is zero, 64 is returned.
 674 *----------------------------------------------------------------------------*/
 675
 676 static int8 countLeadingZeros64( uint64_t a )
 677 {
 678 #if SOFTFLOAT_GNUC_PREREQ(3, 4)
 679     if (a) {
 680         return __builtin_clzll(a);
 681     } else {
 682         return 64;
 683     }
 684 #else
 685     int8 shiftCount;
 686
 687     shiftCount = 0;
 688     if ( a < ( (uint64_t) 1 )<<32 ) {
 689         shiftCount += 32;
 690     }
 691     else {
 692         a >>= 32;
 693     }
 694     shiftCount += countLeadingZeros32( a );
 695     return shiftCount;
 696 #endif
 697 }
 698
 699 /*----------------------------------------------------------------------------
 700 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
 701 | is equal to the 128-bit value formed by concatenating `b0' and `b1'.
 702 | Otherwise, returns 0.
 703 *----------------------------------------------------------------------------*/
 704
 705 INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 706 {
 707
 708     return ( a0 == b0 ) && ( a1 == b1 );
 709
 710 }
 711
 712 /*----------------------------------------------------------------------------
 713 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
 714 | than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
 715 | Otherwise, returns 0.
 716 *----------------------------------------------------------------------------*/
 717
 718 INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 719 {
 720
 721     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
 722
 723 }
 724
 725 /*----------------------------------------------------------------------------
 726 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
 727 | than the 128-bit value formed by concatenating `b0' and `b1'.  Otherwise,
 728 | returns 0.
 729 *----------------------------------------------------------------------------*/
 730
 731 INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 732 {
 733
 734     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
 735
 736 }
 737
 738 /*----------------------------------------------------------------------------
 739 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
 740 | not equal to the 128-bit value formed by concatenating `b0' and `b1'.
 741 | Otherwise, returns 0.
 742 *----------------------------------------------------------------------------*/
 743
 744 INLINE flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
 745 {
 746
 747     return ( a0 != b0 ) || ( a1 != b1 );
 748
 749 }