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