2 * Utility compute operations used by translated code.
4 * Copyright (c) 2007 Thiemo Seufer
5 * Copyright (c) 2007 Jocelyn Mayer
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #define HOST_UTILS_H 1
28 #include "qemu/compiler.h" /* QEMU_GNUC_PREREQ */
32 static inline void mulu64(uint64_t *plow
, uint64_t *phigh
,
33 uint64_t a
, uint64_t b
)
35 __uint128_t r
= (__uint128_t
)a
* b
;
40 static inline void muls64(uint64_t *plow
, uint64_t *phigh
,
43 __int128_t r
= (__int128_t
)a
* b
;
48 void muls64(uint64_t *phigh
, uint64_t *plow
, int64_t a
, int64_t b
);
49 void mulu64(uint64_t *phigh
, uint64_t *plow
, uint64_t a
, uint64_t b
);
53 * clz32 - count leading zeros in a 32-bit value.
54 * @val: The value to search
56 * Returns 32 if the value is zero. Note that the GCC builtin is
57 * undefined if the value is zero.
59 static inline int clz32(uint32_t val
)
61 #if QEMU_GNUC_PREREQ(3, 4)
62 return val
? __builtin_clz(val
) : 32;
64 /* Binary search for the leading one bit. */
67 if (!(val
& 0xFFFF0000U
)) {
71 if (!(val
& 0xFF000000U
)) {
75 if (!(val
& 0xF0000000U
)) {
79 if (!(val
& 0xC0000000U
)) {
83 if (!(val
& 0x80000000U
)) {
87 if (!(val
& 0x80000000U
)) {
95 * clo32 - count leading ones in a 32-bit value.
96 * @val: The value to search
98 * Returns 32 if the value is -1.
100 static inline int clo32(uint32_t val
)
106 * clz64 - count leading zeros in a 64-bit value.
107 * @val: The value to search
109 * Returns 64 if the value is zero. Note that the GCC builtin is
110 * undefined if the value is zero.
112 static inline int clz64(uint64_t val
)
114 #if QEMU_GNUC_PREREQ(3, 4)
115 return val
? __builtin_clzll(val
) : 64;
125 return cnt
+ clz32(val
);
130 * clo64 - count leading ones in a 64-bit value.
131 * @val: The value to search
133 * Returns 64 if the value is -1.
135 static inline int clo64(uint64_t val
)
141 * ctz32 - count trailing zeros in a 32-bit value.
142 * @val: The value to search
144 * Returns 32 if the value is zero. Note that the GCC builtin is
145 * undefined if the value is zero.
147 static inline int ctz32(uint32_t val
)
149 #if QEMU_GNUC_PREREQ(3, 4)
150 return val
? __builtin_ctz(val
) : 32;
152 /* Binary search for the trailing one bit. */
156 if (!(val
& 0x0000FFFFUL
)) {
160 if (!(val
& 0x000000FFUL
)) {
164 if (!(val
& 0x0000000FUL
)) {
168 if (!(val
& 0x00000003UL
)) {
172 if (!(val
& 0x00000001UL
)) {
176 if (!(val
& 0x00000001UL
)) {
185 * cto32 - count trailing ones in a 32-bit value.
186 * @val: The value to search
188 * Returns 32 if the value is -1.
190 static inline int cto32(uint32_t val
)
196 * ctz64 - count trailing zeros in a 64-bit value.
197 * @val: The value to search
199 * Returns 64 if the value is zero. Note that the GCC builtin is
200 * undefined if the value is zero.
202 static inline int ctz64(uint64_t val
)
204 #if QEMU_GNUC_PREREQ(3, 4)
205 return val
? __builtin_ctzll(val
) : 64;
210 if (!((uint32_t)val
)) {
215 return cnt
+ ctz32(val
);
220 * ctz64 - count trailing ones in a 64-bit value.
221 * @val: The value to search
223 * Returns 64 if the value is -1.
225 static inline int cto64(uint64_t val
)
231 * clrsb32 - count leading redundant sign bits in a 32-bit value.
232 * @val: The value to search
234 * Returns the number of bits following the sign bit that are equal to it.
235 * No special cases; output range is [0-31].
237 static inline int clrsb32(uint32_t val
)
239 #if QEMU_GNUC_PREREQ(4, 7)
240 return __builtin_clrsb(val
);
242 return clz32(val
^ ((int32_t)val
>> 1)) - 1;
247 * clrsb64 - count leading redundant sign bits in a 64-bit value.
248 * @val: The value to search
250 * Returns the number of bits following the sign bit that are equal to it.
251 * No special cases; output range is [0-63].
253 static inline int clrsb64(uint64_t val
)
255 #if QEMU_GNUC_PREREQ(4, 7)
256 return __builtin_clrsbll(val
);
258 return clz64(val
^ ((int64_t)val
>> 1)) - 1;
263 * ctpop8 - count the population of one bits in an 8-bit value.
264 * @val: The value to search
266 static inline int ctpop8(uint8_t val
)
268 #if QEMU_GNUC_PREREQ(3, 4)
269 return __builtin_popcount(val
);
271 val
= (val
& 0x55) + ((val
>> 1) & 0x55);
272 val
= (val
& 0x33) + ((val
>> 2) & 0x33);
273 val
= (val
& 0x0f) + ((val
>> 4) & 0x0f);
280 * ctpop16 - count the population of one bits in a 16-bit value.
281 * @val: The value to search
283 static inline int ctpop16(uint16_t val
)
285 #if QEMU_GNUC_PREREQ(3, 4)
286 return __builtin_popcount(val
);
288 val
= (val
& 0x5555) + ((val
>> 1) & 0x5555);
289 val
= (val
& 0x3333) + ((val
>> 2) & 0x3333);
290 val
= (val
& 0x0f0f) + ((val
>> 4) & 0x0f0f);
291 val
= (val
& 0x00ff) + ((val
>> 8) & 0x00ff);
298 * ctpop32 - count the population of one bits in a 32-bit value.
299 * @val: The value to search
301 static inline int ctpop32(uint32_t val
)
303 #if QEMU_GNUC_PREREQ(3, 4)
304 return __builtin_popcount(val
);
306 val
= (val
& 0x55555555) + ((val
>> 1) & 0x55555555);
307 val
= (val
& 0x33333333) + ((val
>> 2) & 0x33333333);
308 val
= (val
& 0x0f0f0f0f) + ((val
>> 4) & 0x0f0f0f0f);
309 val
= (val
& 0x00ff00ff) + ((val
>> 8) & 0x00ff00ff);
310 val
= (val
& 0x0000ffff) + ((val
>> 16) & 0x0000ffff);
317 * ctpop64 - count the population of one bits in a 64-bit value.
318 * @val: The value to search
320 static inline int ctpop64(uint64_t val
)
322 #if QEMU_GNUC_PREREQ(3, 4)
323 return __builtin_popcountll(val
);
325 val
= (val
& 0x5555555555555555ULL
) + ((val
>> 1) & 0x5555555555555555ULL
);
326 val
= (val
& 0x3333333333333333ULL
) + ((val
>> 2) & 0x3333333333333333ULL
);
327 val
= (val
& 0x0f0f0f0f0f0f0f0fULL
) + ((val
>> 4) & 0x0f0f0f0f0f0f0f0fULL
);
328 val
= (val
& 0x00ff00ff00ff00ffULL
) + ((val
>> 8) & 0x00ff00ff00ff00ffULL
);
329 val
= (val
& 0x0000ffff0000ffffULL
) + ((val
>> 16) & 0x0000ffff0000ffffULL
);
330 val
= (val
& 0x00000000ffffffffULL
) + ((val
>> 32) & 0x00000000ffffffffULL
);
336 /* Host type specific sizes of these routines. */
338 #if ULONG_MAX == UINT32_MAX
343 # define ctpopl ctpop32
344 #elif ULONG_MAX == UINT64_MAX
349 # define ctpopl ctpop64
351 # error Unknown sizeof long