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