1/* $FreeBSD$ */ 2 3/* 4=============================================================================== 5 6This C source fragment is part of the SoftFloat IEC/IEEE Floating-point 7Arithmetic Package, Release 2a. 8 9Written by John R. Hauser. This work was made possible in part by the 10International Computer Science Institute, located at Suite 600, 1947 Center 11Street, Berkeley, California 94704. Funding was partially provided by the 12National Science Foundation under grant MIP-9311980. The original version 13of this code was written as part of a project to build a fixed-point vector 14processor in collaboration with the University of California at Berkeley, 15overseen by Profs. Nelson Morgan and John Wawrzynek. More information 16is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 17arithmetic/SoftFloat.html'. 18 19THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 20has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 21TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 22PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 23AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 24 25Derivative works are acceptable, even for commercial purposes, so long as 26(1) they include prominent notice that the work is derivative, and (2) they 27include prominent notice akin to these four paragraphs for those parts of 28this code that are retained. 29 30=============================================================================== 31*/ 32 33/* 34------------------------------------------------------------------------------- 35Shifts `a' right by the number of bits given in `count'. If any nonzero 36bits are shifted off, they are ``jammed'' into the least significant bit of 37the result by setting the least significant bit to 1. The value of `count' 38can be arbitrarily large; in particular, if `count' is greater than 32, the 39result will be either 0 or 1, depending on whether `a' is zero or nonzero. 40The result is stored in the location pointed to by `zPtr'. 41------------------------------------------------------------------------------- 42*/ 43INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr ) 44{ 45 bits32 z; 46 47 if ( count == 0 ) { 48 z = a; 49 } 50 else if ( count < 32 ) { 51 z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 ); 52 } 53 else { 54 z = ( a != 0 ); 55 } 56 *zPtr = z; 57 58} 59 60/* 61------------------------------------------------------------------------------- 62Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the 63number of bits given in `count'. Any bits shifted off are lost. The value 64of `count' can be arbitrarily large; in particular, if `count' is greater 65than 64, the result will be 0. The result is broken into two 32-bit pieces 66which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'. 67------------------------------------------------------------------------------- 68*/ 69INLINE void 70 shift64Right( 71 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr ) 72{ 73 bits32 z0, z1; 74 int8 negCount = ( - count ) & 31; 75 76 if ( count == 0 ) { 77 z1 = a1; 78 z0 = a0; 79 } 80 else if ( count < 32 ) { 81 z1 = ( a0<<negCount ) | ( a1>>count ); 82 z0 = a0>>count; 83 } 84 else { 85 z1 = ( count < 64 ) ? ( a0>>( count & 31 ) ) : 0; 86 z0 = 0; 87 } 88 *z1Ptr = z1; 89 *z0Ptr = z0; 90 91} 92 93/* 94------------------------------------------------------------------------------- 95Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the 96number of bits given in `count'. If any nonzero bits are shifted off, they 97are ``jammed'' into the least significant bit of the result by setting the 98least significant bit to 1. The value of `count' can be arbitrarily large; 99in particular, if `count' is greater than 64, the result will be either 0 100or 1, depending on whether the concatenation of `a0' and `a1' is zero or 101nonzero. The result is broken into two 32-bit pieces which are stored at 102the locations pointed to by `z0Ptr' and `z1Ptr'. 103------------------------------------------------------------------------------- 104*/ 105INLINE void 106 shift64RightJamming( 107 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr ) 108{ 109 bits32 z0, z1; 110 int8 negCount = ( - count ) & 31; 111 112 if ( count == 0 ) { 113 z1 = a1; 114 z0 = a0; 115 } 116 else if ( count < 32 ) { 117 z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 ); 118 z0 = a0>>count; 119 } 120 else { 121 if ( count == 32 ) { 122 z1 = a0 | ( a1 != 0 ); 123 } 124 else if ( count < 64 ) { 125 z1 = ( a0>>( count & 31 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 ); 126 } 127 else { 128 z1 = ( ( a0 | a1 ) != 0 ); 129 } 130 z0 = 0; 131 } 132 *z1Ptr = z1; 133 *z0Ptr = z0; 134 135} 136 137/* 138------------------------------------------------------------------------------- 139Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' right 140by 32 _plus_ the number of bits given in `count'. The shifted result is 141at most 64 nonzero bits; these are broken into two 32-bit pieces which are 142stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted 143off form a third 32-bit result as follows: The _last_ bit shifted off is 144the most-significant bit of the extra result, and the other 31 bits of the 145extra result are all zero if and only if _all_but_the_last_ bits shifted off 146were all zero. This extra result is stored in the location pointed to by 147`z2Ptr'. The value of `count' can be arbitrarily large. 148 (This routine makes more sense if `a0', `a1', and `a2' are considered 149to form a fixed-point value with binary point between `a1' and `a2'. This 150fixed-point value is shifted right by the number of bits given in `count', 151and the integer part of the result is returned at the locations pointed to 152by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly 153corrupted as described above, and is returned at the location pointed to by 154`z2Ptr'.) 155------------------------------------------------------------------------------- 156*/ 157INLINE void 158 shift64ExtraRightJamming( 159 bits32 a0, 160 bits32 a1, 161 bits32 a2, 162 int16 count, 163 bits32 *z0Ptr, 164 bits32 *z1Ptr, 165 bits32 *z2Ptr 166 ) 167{ 168 bits32 z0, z1, z2; 169 int8 negCount = ( - count ) & 31; 170 171 if ( count == 0 ) { 172 z2 = a2; 173 z1 = a1; 174 z0 = a0; 175 } 176 else { 177 if ( count < 32 ) { 178 z2 = a1<<negCount; 179 z1 = ( a0<<negCount ) | ( a1>>count ); 180 z0 = a0>>count; 181 } 182 else { 183 if ( count == 32 ) { 184 z2 = a1; 185 z1 = a0; 186 } 187 else { 188 a2 |= a1; 189 if ( count < 64 ) { 190 z2 = a0<<negCount; 191 z1 = a0>>( count & 31 ); 192 } 193 else { 194 z2 = ( count == 64 ) ? a0 : ( a0 != 0 ); 195 z1 = 0; 196 } 197 } 198 z0 = 0; 199 } 200 z2 |= ( a2 != 0 ); 201 } 202 *z2Ptr = z2; 203 *z1Ptr = z1; 204 *z0Ptr = z0; 205 206} 207 208/* 209------------------------------------------------------------------------------- 210Shifts the 64-bit value formed by concatenating `a0' and `a1' left by the 211number of bits given in `count'. Any bits shifted off are lost. The value 212of `count' must be less than 32. The result is broken into two 32-bit 213pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'. 214------------------------------------------------------------------------------- 215*/ 216INLINE void 217 shortShift64Left( 218 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr ) 219{ 220 221 *z1Ptr = a1<<count; 222 *z0Ptr = 223 ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 31 ) ); 224 225} 226 227/* 228------------------------------------------------------------------------------- 229Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' left 230by the number of bits given in `count'. Any bits shifted off are lost. 231The value of `count' must be less than 32. The result is broken into three 23232-bit pieces which are stored at the locations pointed to by `z0Ptr', 233`z1Ptr', and `z2Ptr'. 234------------------------------------------------------------------------------- 235*/ 236INLINE void 237 shortShift96Left( 238 bits32 a0, 239 bits32 a1, 240 bits32 a2, 241 int16 count, 242 bits32 *z0Ptr, 243 bits32 *z1Ptr, 244 bits32 *z2Ptr 245 ) 246{ 247 bits32 z0, z1, z2; 248 int8 negCount; 249 250 z2 = a2<<count; 251 z1 = a1<<count; 252 z0 = a0<<count; 253 if ( 0 < count ) { 254 negCount = ( ( - count ) & 31 ); 255 z1 |= a2>>negCount; 256 z0 |= a1>>negCount; 257 } 258 *z2Ptr = z2; 259 *z1Ptr = z1; 260 *z0Ptr = z0; 261 262} 263 264/* 265------------------------------------------------------------------------------- 266Adds the 64-bit value formed by concatenating `a0' and `a1' to the 64-bit 267value formed by concatenating `b0' and `b1'. Addition is modulo 2^64, so 268any carry out is lost. The result is broken into two 32-bit pieces which 269are stored at the locations pointed to by `z0Ptr' and `z1Ptr'. 270------------------------------------------------------------------------------- 271*/ 272INLINE void 273 add64( 274 bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr ) 275{ 276 bits32 z1; 277 278 z1 = a1 + b1; 279 *z1Ptr = z1; 280 *z0Ptr = a0 + b0 + ( z1 < a1 ); 281 282} 283 284/* 285------------------------------------------------------------------------------- 286Adds the 96-bit value formed by concatenating `a0', `a1', and `a2' to the 28796-bit value formed by concatenating `b0', `b1', and `b2'. Addition is 288modulo 2^96, so any carry out is lost. The result is broken into three 28932-bit pieces which are stored at the locations pointed to by `z0Ptr', 290`z1Ptr', and `z2Ptr'. 291------------------------------------------------------------------------------- 292*/ 293INLINE void 294 add96( 295 bits32 a0, 296 bits32 a1, 297 bits32 a2, 298 bits32 b0, 299 bits32 b1, 300 bits32 b2, 301 bits32 *z0Ptr, 302 bits32 *z1Ptr, 303 bits32 *z2Ptr 304 ) 305{ 306 bits32 z0, z1, z2; 307 int8 carry0, carry1; 308 309 z2 = a2 + b2; 310 carry1 = ( z2 < a2 ); 311 z1 = a1 + b1; 312 carry0 = ( z1 < a1 ); 313 z0 = a0 + b0; 314 z1 += carry1; 315 z0 += ( z1 < (bits32)carry1 ); 316 z0 += carry0; 317 *z2Ptr = z2; 318 *z1Ptr = z1; 319 *z0Ptr = z0; 320 321} 322 323/* 324------------------------------------------------------------------------------- 325Subtracts the 64-bit value formed by concatenating `b0' and `b1' from the 32664-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo 3272^64, so any borrow out (carry out) is lost. The result is broken into two 32832-bit pieces which are stored at the locations pointed to by `z0Ptr' and 329`z1Ptr'. 330------------------------------------------------------------------------------- 331*/ 332INLINE void 333 sub64( 334 bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr ) 335{ 336 337 *z1Ptr = a1 - b1; 338 *z0Ptr = a0 - b0 - ( a1 < b1 ); 339 340} 341 342/* 343------------------------------------------------------------------------------- 344Subtracts the 96-bit value formed by concatenating `b0', `b1', and `b2' from 345the 96-bit value formed by concatenating `a0', `a1', and `a2'. Subtraction 346is modulo 2^96, so any borrow out (carry out) is lost. The result is broken 347into three 32-bit pieces which are stored at the locations pointed to by 348`z0Ptr', `z1Ptr', and `z2Ptr'. 349------------------------------------------------------------------------------- 350*/ 351INLINE void 352 sub96( 353 bits32 a0, 354 bits32 a1, 355 bits32 a2, 356 bits32 b0, 357 bits32 b1, 358 bits32 b2, 359 bits32 *z0Ptr, 360 bits32 *z1Ptr, 361 bits32 *z2Ptr 362 ) 363{ 364 bits32 z0, z1, z2; 365 int8 borrow0, borrow1; 366 367 z2 = a2 - b2; 368 borrow1 = ( a2 < b2 ); 369 z1 = a1 - b1; 370 borrow0 = ( a1 < b1 ); 371 z0 = a0 - b0; 372 z0 -= ( z1 < (bits32)borrow1 ); 373 z1 -= borrow1; 374 z0 -= borrow0; 375 *z2Ptr = z2; 376 *z1Ptr = z1; 377 *z0Ptr = z0; 378 379} 380 381/* 382------------------------------------------------------------------------------- 383Multiplies `a' by `b' to obtain a 64-bit product. The product is broken 384into two 32-bit pieces which are stored at the locations pointed to by 385`z0Ptr' and `z1Ptr'. 386------------------------------------------------------------------------------- 387*/ 388INLINE void mul32To64( bits32 a, bits32 b, bits32 *z0Ptr, bits32 *z1Ptr ) 389{ 390 bits16 aHigh, aLow, bHigh, bLow; 391 bits32 z0, zMiddleA, zMiddleB, z1; 392 393 aLow = a; 394 aHigh = a>>16; 395 bLow = b; 396 bHigh = b>>16; 397 z1 = ( (bits32) aLow ) * bLow; 398 zMiddleA = ( (bits32) aLow ) * bHigh; 399 zMiddleB = ( (bits32) aHigh ) * bLow; 400 z0 = ( (bits32) aHigh ) * bHigh; 401 zMiddleA += zMiddleB; 402 z0 += ( ( (bits32) ( zMiddleA < zMiddleB ) )<<16 ) + ( zMiddleA>>16 ); 403 zMiddleA <<= 16; 404 z1 += zMiddleA; 405 z0 += ( z1 < zMiddleA ); 406 *z1Ptr = z1; 407 *z0Ptr = z0; 408 409} 410 411/* 412------------------------------------------------------------------------------- 413Multiplies the 64-bit value formed by concatenating `a0' and `a1' by `b' 414to obtain a 96-bit product. The product is broken into three 32-bit pieces 415which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and 416`z2Ptr'. 417------------------------------------------------------------------------------- 418*/ 419INLINE void 420 mul64By32To96( 421 bits32 a0, 422 bits32 a1, 423 bits32 b, 424 bits32 *z0Ptr, 425 bits32 *z1Ptr, 426 bits32 *z2Ptr 427 ) 428{ 429 bits32 z0, z1, z2, more1; 430 431 mul32To64( a1, b, &z1, &z2 ); 432 mul32To64( a0, b, &z0, &more1 ); 433 add64( z0, more1, 0, z1, &z0, &z1 ); 434 *z2Ptr = z2; 435 *z1Ptr = z1; 436 *z0Ptr = z0; 437 438} 439 440/* 441------------------------------------------------------------------------------- 442Multiplies the 64-bit value formed by concatenating `a0' and `a1' to the 44364-bit value formed by concatenating `b0' and `b1' to obtain a 128-bit 444product. The product is broken into four 32-bit pieces which are stored at 445the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'. 446------------------------------------------------------------------------------- 447*/ 448INLINE void 449 mul64To128( 450 bits32 a0, 451 bits32 a1, 452 bits32 b0, 453 bits32 b1, 454 bits32 *z0Ptr, 455 bits32 *z1Ptr, 456 bits32 *z2Ptr, 457 bits32 *z3Ptr 458 ) 459{ 460 bits32 z0, z1, z2, z3; 461 bits32 more1, more2; 462 463 mul32To64( a1, b1, &z2, &z3 ); 464 mul32To64( a1, b0, &z1, &more2 ); 465 add64( z1, more2, 0, z2, &z1, &z2 ); 466 mul32To64( a0, b0, &z0, &more1 ); 467 add64( z0, more1, 0, z1, &z0, &z1 ); 468 mul32To64( a0, b1, &more1, &more2 ); 469 add64( more1, more2, 0, z2, &more1, &z2 ); 470 add64( z0, z1, 0, more1, &z0, &z1 ); 471 *z3Ptr = z3; 472 *z2Ptr = z2; 473 *z1Ptr = z1; 474 *z0Ptr = z0; 475 476} 477 478/* 479------------------------------------------------------------------------------- 480Returns an approximation to the 32-bit integer quotient obtained by dividing 481`b' into the 64-bit value formed by concatenating `a0' and `a1'. The 482divisor `b' must be at least 2^31. If q is the exact quotient truncated 483toward zero, the approximation returned lies between q and q + 2 inclusive. 484If the exact quotient q is larger than 32 bits, the maximum positive 32-bit 485unsigned integer is returned. 486------------------------------------------------------------------------------- 487*/ 488static bits32 estimateDiv64To32( bits32 a0, bits32 a1, bits32 b ) 489{ 490 bits32 b0, b1; 491 bits32 rem0, rem1, term0, term1; 492 bits32 z; 493 494 if ( b <= a0 ) return 0xFFFFFFFF; 495 b0 = b>>16; 496 z = ( b0<<16 <= a0 ) ? 0xFFFF0000 : ( a0 / b0 )<<16; 497 mul32To64( b, z, &term0, &term1 ); 498 sub64( a0, a1, term0, term1, &rem0, &rem1 ); 499 while ( ( (sbits32) rem0 ) < 0 ) { 500 z -= 0x10000; 501 b1 = b<<16; 502 add64( rem0, rem1, b0, b1, &rem0, &rem1 ); 503 } 504 rem0 = ( rem0<<16 ) | ( rem1>>16 ); 505 z |= ( b0<<16 <= rem0 ) ? 0xFFFF : rem0 / b0; 506 return z; 507 508} 509 510#ifndef SOFTFLOAT_FOR_GCC 511/* 512------------------------------------------------------------------------------- 513Returns an approximation to the square root of the 32-bit significand given 514by `a'. Considered as an integer, `a' must be at least 2^31. If bit 0 of 515`aExp' (the least significant bit) is 1, the integer returned approximates 5162^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp' 517is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either 518case, the approximation returned lies strictly within +/-2 of the exact 519value. 520------------------------------------------------------------------------------- 521*/ 522static bits32 estimateSqrt32( int16 aExp, bits32 a ) 523{ 524 static const bits16 sqrtOddAdjustments[] = { 525 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, 526 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 527 }; 528 static const bits16 sqrtEvenAdjustments[] = { 529 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, 530 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 531 }; 532 int8 index; 533 bits32 z; 534 535 index = ( a>>27 ) & 15; 536 if ( aExp & 1 ) { 537 z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ]; 538 z = ( ( a / z )<<14 ) + ( z<<15 ); 539 a >>= 1; 540 } 541 else { 542 z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ]; 543 z = a / z + z; 544 z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 ); 545 if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 ); 546 } 547 return ( ( estimateDiv64To32( a, 0, z ) )>>1 ) + ( z>>1 ); 548 549} 550#endif 551 552/* 553------------------------------------------------------------------------------- 554Returns the number of leading 0 bits before the most-significant 1 bit of 555`a'. If `a' is zero, 32 is returned. 556------------------------------------------------------------------------------- 557*/ 558static int8 countLeadingZeros32( bits32 a ) 559{ 560 static const int8 countLeadingZerosHigh[] = { 561 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 562 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 565 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 566 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 567 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 568 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 570 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 571 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 572 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 573 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 575 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 576 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 577 }; 578 int8 shiftCount; 579 580 shiftCount = 0; 581 if ( a < 0x10000 ) { 582 shiftCount += 16; 583 a <<= 16; 584 } 585 if ( a < 0x1000000 ) { 586 shiftCount += 8; 587 a <<= 8; 588 } 589 shiftCount += countLeadingZerosHigh[ a>>24 ]; 590 return shiftCount; 591 592} 593 594/* 595------------------------------------------------------------------------------- 596Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is 597equal to the 64-bit value formed by concatenating `b0' and `b1'. Otherwise, 598returns 0. 599------------------------------------------------------------------------------- 600*/ 601INLINE flag eq64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 ) 602{ 603 604 return ( a0 == b0 ) && ( a1 == b1 ); 605 606} 607 608/* 609------------------------------------------------------------------------------- 610Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less 611than or equal to the 64-bit value formed by concatenating `b0' and `b1'. 612Otherwise, returns 0. 613------------------------------------------------------------------------------- 614*/ 615INLINE flag le64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 ) 616{ 617 618 return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) ); 619 620} 621 622/* 623------------------------------------------------------------------------------- 624Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less 625than the 64-bit value formed by concatenating `b0' and `b1'. Otherwise, 626returns 0. 627------------------------------------------------------------------------------- 628*/ 629INLINE flag lt64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 ) 630{ 631 632 return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) ); 633 634} 635 636/* 637------------------------------------------------------------------------------- 638Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is not 639equal to the 64-bit value formed by concatenating `b0' and `b1'. Otherwise, 640returns 0. 641------------------------------------------------------------------------------- 642*/ 643INLINE flag ne64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 ) 644{ 645 646 return ( a0 != b0 ) || ( a1 != b1 ); 647 648} 649 650