| blob | 59e6e76fe00d655e7a3115025368f9945687ab92 |
2 /*
3 ===============================================================================
5 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
6 Arithmetic Package, Release 2a.
8 Written by John R. Hauser. This work was made possible in part by the
9 International Computer Science Institute, located at Suite 600, 1947 Center
10 Street, Berkeley, California 94704. Funding was partially provided by the
11 National Science Foundation under grant MIP-9311980. The original version
12 of this code was written as part of a project to build a fixed-point vector
13 processor in collaboration with the University of California at Berkeley,
14 overseen by Profs. Nelson Morgan and John Wawrzynek. More information
15 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
16 arithmetic/SoftFloat.html'.
18 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
19 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
20 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
21 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
22 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
24 Derivative works are acceptable, even for commercial purposes, so long as
25 (1) they include prominent notice that the work is derivative, and (2) they
26 include prominent notice akin to these four paragraphs for those parts of
27 this code that are retained.
29 ===============================================================================
30 */
32 /*
33 -------------------------------------------------------------------------------
34 Shifts `a' right by the number of bits given in `count'. If any nonzero
35 bits are shifted off, they are ``jammed'' into the least significant bit of
36 the result by setting the least significant bit to 1. The value of `count'
37 can be arbitrarily large; in particular, if `count' is greater than 32, the
38 result will be either 0 or 1, depending on whether `a' is zero or nonzero.
39 The result is stored in the location pointed to by `zPtr'.
40 -------------------------------------------------------------------------------
41 */
42 INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
43 {
44 bits32 z;
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;
57 }
59 /*
60 -------------------------------------------------------------------------------
61 Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
62 number of bits given in `count'. Any bits shifted off are lost. The value
63 of `count' can be arbitrarily large; in particular, if `count' is greater
64 than 64, the result will be 0. The result is broken into two 32-bit pieces
65 which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
66 -------------------------------------------------------------------------------
67 */
68 INLINE void
69 shift64Right(
70 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
71 {
72 bits32 z0, z1;
73 int8 negCount = ( - count ) & 31;
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;
90 }
92 /*
93 -------------------------------------------------------------------------------
94 Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
95 number of bits given in `count'. If any nonzero bits are shifted off, they
96 are ``jammed'' into the least significant bit of the result by setting the
97 least significant bit to 1. The value of `count' can be arbitrarily large;
98 in particular, if `count' is greater than 64, the result will be either 0
99 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
100 nonzero. The result is broken into two 32-bit pieces which are stored at
101 the locations pointed to by `z0Ptr' and `z1Ptr'.
102 -------------------------------------------------------------------------------
103 */
104 INLINE void
105 shift64RightJamming(
106 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
107 {
108 bits32 z0, z1;
109 int8 negCount = ( - count ) & 31;
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;
134 }
136 /*
137 -------------------------------------------------------------------------------
138 Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' right
139 by 32 _plus_ the number of bits given in `count'. The shifted result is
140 at most 64 nonzero bits; these are broken into two 32-bit pieces which are
141 stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
142 off form a third 32-bit result as follows: The _last_ bit shifted off is
143 the most-significant bit of the extra result, and the other 31 bits of the
144 extra result are all zero if and only if _all_but_the_last_ bits shifted off
145 were 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
148 to form a fixed-point value with binary point between `a1' and `a2'. This
149 fixed-point value is shifted right by the number of bits given in `count',
150 and the integer part of the result is returned at the locations pointed to
151 by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly
152 corrupted as described above, and is returned at the location pointed to by
153 `z2Ptr'.)
154 -------------------------------------------------------------------------------
155 */
156 INLINE 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;
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;
205 }
207 /*
208 -------------------------------------------------------------------------------
209 Shifts the 64-bit value formed by concatenating `a0' and `a1' left by the
210 number of bits given in `count'. Any bits shifted off are lost. The value
211 of `count' must be less than 32. The result is broken into two 32-bit
212 pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
213 -------------------------------------------------------------------------------
214 */
215 INLINE void
216 shortShift64Left(
217 bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
218 {
220 *z1Ptr = a1<<count;
221 *z0Ptr =
222 ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 31 ) );
224 }
226 /*
227 -------------------------------------------------------------------------------
228 Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' left
229 by the number of bits given in `count'. Any bits shifted off are lost.
230 The value of `count' must be less than 32. The result is broken into three
231 32-bit pieces which are stored at the locations pointed to by `z0Ptr',
232 `z1Ptr', and `z2Ptr'.
233 -------------------------------------------------------------------------------
234 */
235 INLINE 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;
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;
261 }
263 /*
264 -------------------------------------------------------------------------------
265 Adds the 64-bit value formed by concatenating `a0' and `a1' to the 64-bit
266 value formed by concatenating `b0' and `b1'. Addition is modulo 2^64, so
267 any carry out is lost. The result is broken into two 32-bit pieces which
268 are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
269 -------------------------------------------------------------------------------
270 */
271 INLINE void
272 add64(
273 bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
274 {
275 bits32 z1;
277 z1 = a1 + b1;
278 *z1Ptr = z1;
279 *z0Ptr = a0 + b0 + ( z1 < a1 );
281 }
283 /*
284 -------------------------------------------------------------------------------
285 Adds the 96-bit value formed by concatenating `a0', `a1', and `a2' to the
286 96-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
287 modulo 2^96, so any carry out is lost. The result is broken into three
288 32-bit pieces which are stored at the locations pointed to by `z0Ptr',
289 `z1Ptr', and `z2Ptr'.
290 -------------------------------------------------------------------------------
291 */
292 INLINE 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;
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;
320 }
322 /*
323 -------------------------------------------------------------------------------
324 Subtracts the 64-bit value formed by concatenating `b0' and `b1' from the
325 64-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
326 2^64, so any borrow out (carry out) is lost. The result is broken into two
327 32-bit pieces which are stored at the locations pointed to by `z0Ptr' and
328 `z1Ptr'.
329 -------------------------------------------------------------------------------
330 */
331 INLINE void
332 sub64(
333 bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
334 {
336 *z1Ptr = a1 - b1;
337 *z0Ptr = a0 - b0 - ( a1 < b1 );
339 }
341 /*
342 -------------------------------------------------------------------------------
343 Subtracts the 96-bit value formed by concatenating `b0', `b1', and `b2' from
344 the 96-bit value formed by concatenating `a0', `a1', and `a2'. Subtraction
345 is modulo 2^96, so any borrow out (carry out) is lost. The result is broken
346 into three 32-bit pieces which are stored at the locations pointed to by
347 `z0Ptr', `z1Ptr', and `z2Ptr'.
348 -------------------------------------------------------------------------------
349 */
350 INLINE 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;
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;
378 }
380 /*
381 -------------------------------------------------------------------------------
382 Multiplies `a' by `b' to obtain a 64-bit product. The product is broken
383 into two 32-bit pieces which are stored at the locations pointed to by
384 `z0Ptr' and `z1Ptr'.
385 -------------------------------------------------------------------------------
386 */
387 INLINE void mul32To64( bits32 a, bits32 b, bits32 *z0Ptr, bits32 *z1Ptr )
388 {
389 bits16 aHigh, aLow, bHigh, bLow;
390 bits32 z0, zMiddleA, zMiddleB, z1;
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;
408 }
410 /*
411 -------------------------------------------------------------------------------
412 Multiplies the 64-bit value formed by concatenating `a0' and `a1' by `b'
413 to obtain a 96-bit product. The product is broken into three 32-bit pieces
414 which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
415 `z2Ptr'.
416 -------------------------------------------------------------------------------
417 */
418 INLINE 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;
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;
437 }
439 /*
440 -------------------------------------------------------------------------------
441 Multiplies the 64-bit value formed by concatenating `a0' and `a1' to the
442 64-bit value formed by concatenating `b0' and `b1' to obtain a 128-bit
443 product. The product is broken into four 32-bit pieces which are stored at
444 the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
445 -------------------------------------------------------------------------------
446 */
447 INLINE 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;
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;
475 }
477 /*
478 -------------------------------------------------------------------------------
479 Returns 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
481 divisor `b' must be at least 2^31. If q is the exact quotient truncated
482 toward zero, the approximation returned lies between q and q + 2 inclusive.
483 If the exact quotient q is larger than 32 bits, the maximum positive 32-bit
484 unsigned integer is returned.
485 -------------------------------------------------------------------------------
486 */
487 static bits32 estimateDiv64To32( bits32 a0, bits32 a1, bits32 b )
488 {
489 bits32 b0, b1;
490 bits32 rem0, rem1, term0, term1;
491 bits32 z;
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;
507 }
509 #ifndef SOFTFLOAT_FOR_GCC
510 /*
511 -------------------------------------------------------------------------------
512 Returns an approximation to the square root of the 32-bit significand given
513 by `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
515 2^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp'
516 is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either
517 case, the approximation returned lies strictly within +/-2 of the exact
518 value.
519 -------------------------------------------------------------------------------
520 */
521 static 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;
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 );
548 }
549 #endif
551 /*
552 -------------------------------------------------------------------------------
553 Returns the number of leading 0 bits before the most-significant 1 bit of
554 `a'. If `a' is zero, 32 is returned.
555 -------------------------------------------------------------------------------
556 */
557 static 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;
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;
591 }
593 /*
594 -------------------------------------------------------------------------------
595 Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is
596 equal to the 64-bit value formed by concatenating `b0' and `b1'. Otherwise,
597 returns 0.
598 -------------------------------------------------------------------------------
599 */
600 INLINE flag eq64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
601 {
603 return ( a0 == b0 ) && ( a1 == b1 );
605 }
607 /*
608 -------------------------------------------------------------------------------
609 Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
610 than or equal to the 64-bit value formed by concatenating `b0' and `b1'.
611 Otherwise, returns 0.
612 -------------------------------------------------------------------------------
613 */
614 INLINE flag le64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
615 {
617 return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
619 }
621 /*
622 -------------------------------------------------------------------------------
623 Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
624 than the 64-bit value formed by concatenating `b0' and `b1'. Otherwise,
625 returns 0.
626 -------------------------------------------------------------------------------
627 */
628 INLINE flag lt64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
629 {
631 return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
633 }
635 /*
636 -------------------------------------------------------------------------------
637 Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is not
638 equal to the 64-bit value formed by concatenating `b0' and `b1'. Otherwise,
639 returns 0.
640 -------------------------------------------------------------------------------
641 */
642 INLINE flag ne64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
643 {
645 return ( a0 != b0 ) || ( a1 != b1 );
647 }