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