2 * QEMU float support macros
4 * The code in this source file is derived from release 2a of the SoftFloat
5 * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
6 * some later contributions) are provided under that license, as detailed below.
7 * It has subsequently been modified by contributors to the QEMU Project,
8 * so some portions are provided under:
9 * the SoftFloat-2a license
13 * Any future contributions to this file after December 1st 2014 will be
14 * taken to be licensed under the Softfloat-2a license unless specifically
15 * indicated otherwise.
19 ===============================================================================
20 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
21 Arithmetic Package, Release 2a.
23 Written by John R. Hauser. This work was made possible in part by the
24 International Computer Science Institute, located at Suite 600, 1947 Center
25 Street, Berkeley, California 94704. Funding was partially provided by the
26 National Science Foundation under grant MIP-9311980. The original version
27 of this code was written as part of a project to build a fixed-point vector
28 processor in collaboration with the University of California at Berkeley,
29 overseen by Profs. Nelson Morgan and John Wawrzynek. More information
30 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
31 arithmetic/SoftFloat.html'.
33 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
34 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
36 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
39 Derivative works are acceptable, even for commercial purposes, so long as
40 (1) they include prominent notice that the work is derivative, and (2) they
41 include prominent notice akin to these four paragraphs for those parts of
42 this code that are retained.
44 ===============================================================================
48 * Copyright (c) 2006, Fabrice Bellard
49 * All rights reserved.
51 * Redistribution and use in source and binary forms, with or without
52 * modification, are permitted provided that the following conditions are met:
54 * 1. Redistributions of source code must retain the above copyright notice,
55 * this list of conditions and the following disclaimer.
57 * 2. Redistributions in binary form must reproduce the above copyright notice,
58 * this list of conditions and the following disclaimer in the documentation
59 * and/or other materials provided with the distribution.
61 * 3. Neither the name of the copyright holder nor the names of its contributors
62 * may be used to endorse or promote products derived from this software without
63 * specific prior written permission.
65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
66 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
69 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
70 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
71 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
72 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
73 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
74 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
75 * THE POSSIBILITY OF SUCH DAMAGE.
78 /* Portions of this work are licensed under the terms of the GNU GPL,
79 * version 2 or later. See the COPYING file in the top-level directory.
82 /*----------------------------------------------------------------------------
83 | This macro tests for minimum version of the GNU C compiler.
84 *----------------------------------------------------------------------------*/
85 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
86 # define SOFTFLOAT_GNUC_PREREQ(maj, min) \
87 ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
89 # define SOFTFLOAT_GNUC_PREREQ(maj, min) 0
93 /*----------------------------------------------------------------------------
94 | Shifts `a' right by the number of bits given in `count'. If any nonzero
95 | bits are shifted off, they are ``jammed'' into the least significant bit of
96 | the result by setting the least significant bit to 1. The value of `count'
97 | can be arbitrarily large; in particular, if `count' is greater than 32, the
98 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.
99 | The result is stored in the location pointed to by `zPtr'.
100 *----------------------------------------------------------------------------*/
102 static inline void shift32RightJamming(uint32_t a
, int count
, uint32_t *zPtr
)
109 else if ( count
< 32 ) {
110 z
= ( a
>>count
) | ( ( a
<<( ( - count
) & 31 ) ) != 0 );
119 /*----------------------------------------------------------------------------
120 | Shifts `a' right by the number of bits given in `count'. If any nonzero
121 | bits are shifted off, they are ``jammed'' into the least significant bit of
122 | the result by setting the least significant bit to 1. The value of `count'
123 | can be arbitrarily large; in particular, if `count' is greater than 64, the
124 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.
125 | The result is stored in the location pointed to by `zPtr'.
126 *----------------------------------------------------------------------------*/
128 static inline void shift64RightJamming(uint64_t a
, int count
, uint64_t *zPtr
)
135 else if ( count
< 64 ) {
136 z
= ( a
>>count
) | ( ( a
<<( ( - count
) & 63 ) ) != 0 );
145 /*----------------------------------------------------------------------------
146 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
147 | _plus_ the number of bits given in `count'. The shifted result is at most
148 | 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'. The
149 | bits shifted off form a second 64-bit result as follows: The _last_ bit
150 | shifted off is the most-significant bit of the extra result, and the other
151 | 63 bits of the extra result are all zero if and only if _all_but_the_last_
152 | bits shifted off were all zero. This extra result is stored in the location
153 | pointed to by `z1Ptr'. The value of `count' can be arbitrarily large.
154 | (This routine makes more sense if `a0' and `a1' are considered to form a
155 | fixed-point value with binary point between `a0' and `a1'. This fixed-point
156 | value is shifted right by the number of bits given in `count', and the
157 | integer part of the result is returned at the location pointed to by
158 | `z0Ptr'. The fractional part of the result may be slightly corrupted as
159 | described above, and is returned at the location pointed to by `z1Ptr'.)
160 *----------------------------------------------------------------------------*/
163 shift64ExtraRightJamming(
164 uint64_t a0
, uint64_t a1
, int count
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
167 int8_t negCount
= ( - count
) & 63;
173 else if ( count
< 64 ) {
174 z1
= ( a0
<<negCount
) | ( a1
!= 0 );
179 z1
= a0
| ( a1
!= 0 );
182 z1
= ( ( a0
| a1
) != 0 );
191 /*----------------------------------------------------------------------------
192 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
193 | number of bits given in `count'. Any bits shifted off are lost. The value
194 | of `count' can be arbitrarily large; in particular, if `count' is greater
195 | than 128, the result will be 0. The result is broken into two 64-bit pieces
196 | which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
197 *----------------------------------------------------------------------------*/
201 uint64_t a0
, uint64_t a1
, int count
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
204 int8_t negCount
= ( - count
) & 63;
210 else if ( count
< 64 ) {
211 z1
= ( a0
<<negCount
) | ( a1
>>count
);
215 z1
= (count
< 128) ? (a0
>> (count
& 63)) : 0;
223 /*----------------------------------------------------------------------------
224 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
225 | number of bits given in `count'. If any nonzero bits are shifted off, they
226 | are ``jammed'' into the least significant bit of the result by setting the
227 | least significant bit to 1. The value of `count' can be arbitrarily large;
228 | in particular, if `count' is greater than 128, the result will be either
229 | 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or
230 | nonzero. The result is broken into two 64-bit pieces which are stored at
231 | the locations pointed to by `z0Ptr' and `z1Ptr'.
232 *----------------------------------------------------------------------------*/
235 shift128RightJamming(
236 uint64_t a0
, uint64_t a1
, int count
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
239 int8_t negCount
= ( - count
) & 63;
245 else if ( count
< 64 ) {
246 z1
= ( a0
<<negCount
) | ( a1
>>count
) | ( ( a1
<<negCount
) != 0 );
251 z1
= a0
| ( a1
!= 0 );
253 else if ( count
< 128 ) {
254 z1
= ( a0
>>( count
& 63 ) ) | ( ( ( a0
<<negCount
) | a1
) != 0 );
257 z1
= ( ( a0
| a1
) != 0 );
266 /*----------------------------------------------------------------------------
267 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
268 | by 64 _plus_ the number of bits given in `count'. The shifted result is
269 | at most 128 nonzero bits; these are broken into two 64-bit pieces which are
270 | stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
271 | off form a third 64-bit result as follows: The _last_ bit shifted off is
272 | the most-significant bit of the extra result, and the other 63 bits of the
273 | extra result are all zero if and only if _all_but_the_last_ bits shifted off
274 | were all zero. This extra result is stored in the location pointed to by
275 | `z2Ptr'. The value of `count' can be arbitrarily large.
276 | (This routine makes more sense if `a0', `a1', and `a2' are considered
277 | to form a fixed-point value with binary point between `a1' and `a2'. This
278 | fixed-point value is shifted right by the number of bits given in `count',
279 | and the integer part of the result is returned at the locations pointed to
280 | by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly
281 | corrupted as described above, and is returned at the location pointed to by
283 *----------------------------------------------------------------------------*/
286 shift128ExtraRightJamming(
297 int8_t negCount
= ( - count
) & 63;
307 z1
= ( a0
<<negCount
) | ( a1
>>count
);
319 z1
= a0
>>( count
& 63 );
322 z2
= ( count
== 128 ) ? a0
: ( a0
!= 0 );
336 /*----------------------------------------------------------------------------
337 | Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
338 | number of bits given in `count'. Any bits shifted off are lost. The value
339 | of `count' must be less than 64. The result is broken into two 64-bit
340 | pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
341 *----------------------------------------------------------------------------*/
345 uint64_t a0
, uint64_t a1
, int count
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
350 ( count
== 0 ) ? a0
: ( a0
<<count
) | ( a1
>>( ( - count
) & 63 ) );
354 /*----------------------------------------------------------------------------
355 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
356 | by the number of bits given in `count'. Any bits shifted off are lost.
357 | The value of `count' must be less than 64. The result is broken into three
358 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
359 | `z1Ptr', and `z2Ptr'.
360 *----------------------------------------------------------------------------*/
380 negCount
= ( ( - count
) & 63 );
390 /*----------------------------------------------------------------------------
391 | Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
392 | value formed by concatenating `b0' and `b1'. Addition is modulo 2^128, so
393 | any carry out is lost. The result is broken into two 64-bit pieces which
394 | are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
395 *----------------------------------------------------------------------------*/
399 uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
405 *z0Ptr
= a0
+ b0
+ ( z1
< a1
);
409 /*----------------------------------------------------------------------------
410 | Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
411 | 192-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
412 | modulo 2^192, so any carry out is lost. The result is broken into three
413 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
414 | `z1Ptr', and `z2Ptr'.
415 *----------------------------------------------------------------------------*/
431 int8_t carry0
, carry1
;
434 carry1
= ( z2
< a2
);
436 carry0
= ( z1
< a1
);
439 z0
+= ( z1
< carry1
);
447 /*----------------------------------------------------------------------------
448 | Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
449 | 128-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
450 | 2^128, so any borrow out (carry out) is lost. The result is broken into two
451 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
453 *----------------------------------------------------------------------------*/
457 uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
461 *z0Ptr
= a0
- b0
- ( a1
< b1
);
465 /*----------------------------------------------------------------------------
466 | Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
467 | from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
468 | Subtraction is modulo 2^192, so any borrow out (carry out) is lost. The
469 | result is broken into three 64-bit pieces which are stored at the locations
470 | pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.
471 *----------------------------------------------------------------------------*/
487 int8_t borrow0
, borrow1
;
490 borrow1
= ( a2
< b2
);
492 borrow0
= ( a1
< b1
);
494 z0
-= ( z1
< borrow1
);
503 /*----------------------------------------------------------------------------
504 | Multiplies `a' by `b' to obtain a 128-bit product. The product is broken
505 | into two 64-bit pieces which are stored at the locations pointed to by
506 | `z0Ptr' and `z1Ptr'.
507 *----------------------------------------------------------------------------*/
509 static inline void mul64To128( uint64_t a
, uint64_t b
, uint64_t *z0Ptr
, uint64_t *z1Ptr
)
511 uint32_t aHigh
, aLow
, bHigh
, bLow
;
512 uint64_t z0
, zMiddleA
, zMiddleB
, z1
;
518 z1
= ( (uint64_t) aLow
) * bLow
;
519 zMiddleA
= ( (uint64_t) aLow
) * bHigh
;
520 zMiddleB
= ( (uint64_t) aHigh
) * bLow
;
521 z0
= ( (uint64_t) aHigh
) * bHigh
;
522 zMiddleA
+= zMiddleB
;
523 z0
+= ( ( (uint64_t) ( zMiddleA
< zMiddleB
) )<<32 ) + ( zMiddleA
>>32 );
526 z0
+= ( z1
< zMiddleA
);
532 /*----------------------------------------------------------------------------
533 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' by
534 | `b' to obtain a 192-bit product. The product is broken into three 64-bit
535 | pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
537 *----------------------------------------------------------------------------*/
549 uint64_t z0
, z1
, z2
, more1
;
551 mul64To128( a1
, b
, &z1
, &z2
);
552 mul64To128( a0
, b
, &z0
, &more1
);
553 add128( z0
, more1
, 0, z1
, &z0
, &z1
);
560 /*----------------------------------------------------------------------------
561 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
562 | 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
563 | product. The product is broken into four 64-bit pieces which are stored at
564 | the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
565 *----------------------------------------------------------------------------*/
579 uint64_t z0
, z1
, z2
, z3
;
580 uint64_t more1
, more2
;
582 mul64To128( a1
, b1
, &z2
, &z3
);
583 mul64To128( a1
, b0
, &z1
, &more2
);
584 add128( z1
, more2
, 0, z2
, &z1
, &z2
);
585 mul64To128( a0
, b0
, &z0
, &more1
);
586 add128( z0
, more1
, 0, z1
, &z0
, &z1
);
587 mul64To128( a0
, b1
, &more1
, &more2
);
588 add128( more1
, more2
, 0, z2
, &more1
, &z2
);
589 add128( z0
, z1
, 0, more1
, &z0
, &z1
);
597 /*----------------------------------------------------------------------------
598 | Returns an approximation to the 64-bit integer quotient obtained by dividing
599 | `b' into the 128-bit value formed by concatenating `a0' and `a1'. The
600 | divisor `b' must be at least 2^63. If q is the exact quotient truncated
601 | toward zero, the approximation returned lies between q and q + 2 inclusive.
602 | If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
603 | unsigned integer is returned.
604 *----------------------------------------------------------------------------*/
606 static inline uint64_t estimateDiv128To64(uint64_t a0
, uint64_t a1
, uint64_t b
)
609 uint64_t rem0
, rem1
, term0
, term1
;
612 if ( b
<= a0
) return LIT64( 0xFFFFFFFFFFFFFFFF );
614 z
= ( b0
<<32 <= a0
) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0
/ b0
)<<32;
615 mul64To128( b
, z
, &term0
, &term1
);
616 sub128( a0
, a1
, term0
, term1
, &rem0
, &rem1
);
617 while ( ( (int64_t) rem0
) < 0 ) {
618 z
-= LIT64( 0x100000000 );
620 add128( rem0
, rem1
, b0
, b1
, &rem0
, &rem1
);
622 rem0
= ( rem0
<<32 ) | ( rem1
>>32 );
623 z
|= ( b0
<<32 <= rem0
) ? 0xFFFFFFFF : rem0
/ b0
;
628 /* From the GNU Multi Precision Library - longlong.h __udiv_qrnnd
629 * (https://gmplib.org/repo/gmp/file/tip/longlong.h)
631 * Licensed under the GPLv2/LGPLv3
633 static inline uint64_t div128To64(uint64_t n0
, uint64_t n1
, uint64_t d
)
635 uint64_t d0
, d1
, q0
, q1
, r1
, r0
, m
;
643 r1
= (r1
<< 32) | (n0
>> 32);
659 r0
= (r0
<< 32) | (uint32_t)n0
;
672 /* Return remainder in LSB */
673 return (q1
<< 32) | q0
| (r0
!= 0);
676 /*----------------------------------------------------------------------------
677 | Returns an approximation to the square root of the 32-bit significand given
678 | by `a'. Considered as an integer, `a' must be at least 2^31. If bit 0 of
679 | `aExp' (the least significant bit) is 1, the integer returned approximates
680 | 2^31*sqrt(`a'/2^31), where `a' is considered an integer. If bit 0 of `aExp'
681 | is 0, the integer returned approximates 2^31*sqrt(`a'/2^30). In either
682 | case, the approximation returned lies strictly within +/-2 of the exact
684 *----------------------------------------------------------------------------*/
686 static inline uint32_t estimateSqrt32(int aExp
, uint32_t a
)
688 static const uint16_t sqrtOddAdjustments
[] = {
689 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
690 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
692 static const uint16_t sqrtEvenAdjustments
[] = {
693 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
694 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
699 index
= ( a
>>27 ) & 15;
701 z
= 0x4000 + ( a
>>17 ) - sqrtOddAdjustments
[ (int)index
];
702 z
= ( ( a
/ z
)<<14 ) + ( z
<<15 );
706 z
= 0x8000 + ( a
>>17 ) - sqrtEvenAdjustments
[ (int)index
];
708 z
= ( 0x20000 <= z
) ? 0xFFFF8000 : ( z
<<15 );
709 if ( z
<= a
) return (uint32_t) ( ( (int32_t) a
)>>1 );
711 return ( (uint32_t) ( ( ( (uint64_t) a
)<<31 ) / z
) ) + ( z
>>1 );
715 /*----------------------------------------------------------------------------
716 | Returns the number of leading 0 bits before the most-significant 1 bit of
717 | `a'. If `a' is zero, 32 is returned.
718 *----------------------------------------------------------------------------*/
720 static inline int8_t countLeadingZeros32(uint32_t a
)
722 #if SOFTFLOAT_GNUC_PREREQ(3, 4)
724 return __builtin_clz(a
);
729 static const int8_t countLeadingZerosHigh
[] = {
730 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
731 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
732 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
733 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
734 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
735 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
736 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
737 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
739 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
741 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
742 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
743 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
745 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
754 if ( a
< 0x1000000 ) {
758 shiftCount
+= countLeadingZerosHigh
[ a
>>24 ];
763 /*----------------------------------------------------------------------------
764 | Returns the number of leading 0 bits before the most-significant 1 bit of
765 | `a'. If `a' is zero, 64 is returned.
766 *----------------------------------------------------------------------------*/
768 static inline int8_t countLeadingZeros64(uint64_t a
)
770 #if SOFTFLOAT_GNUC_PREREQ(3, 4)
772 return __builtin_clzll(a
);
780 if ( a
< ( (uint64_t) 1 )<<32 ) {
786 shiftCount
+= countLeadingZeros32( a
);
791 /*----------------------------------------------------------------------------
792 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
793 | is equal to the 128-bit value formed by concatenating `b0' and `b1'.
794 | Otherwise, returns 0.
795 *----------------------------------------------------------------------------*/
797 static inline flag
eq128( uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
)
800 return ( a0
== b0
) && ( a1
== b1
);
804 /*----------------------------------------------------------------------------
805 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
806 | than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
807 | Otherwise, returns 0.
808 *----------------------------------------------------------------------------*/
810 static inline flag
le128( uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
)
813 return ( a0
< b0
) || ( ( a0
== b0
) && ( a1
<= b1
) );
817 /*----------------------------------------------------------------------------
818 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
819 | than the 128-bit value formed by concatenating `b0' and `b1'. Otherwise,
821 *----------------------------------------------------------------------------*/
823 static inline flag
lt128( uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
)
826 return ( a0
< b0
) || ( ( a0
== b0
) && ( a1
< b1
) );
830 /*----------------------------------------------------------------------------
831 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
832 | not equal to the 128-bit value formed by concatenating `b0' and `b1'.
833 | Otherwise, returns 0.
834 *----------------------------------------------------------------------------*/
836 static inline flag
ne128( uint64_t a0
, uint64_t a1
, uint64_t b0
, uint64_t b1
)
839 return ( a0
!= b0
) || ( a1
!= b1
);