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