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 */
29 #include "qemu/bswap.h"
34 static inline void mulu64(uint64_t *plow
, uint64_t *phigh
,
35 uint64_t a
, uint64_t b
)
37 __uint128_t r
= (__uint128_t
)a
* b
;
42 static inline void muls64(uint64_t *plow
, uint64_t *phigh
,
45 __int128_t r
= (__int128_t
)a
* b
;
50 /* compute with 96 bit intermediate result: (a*b)/c */
51 static inline uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
53 return (__int128_t
)a
* b
/ c
;
56 static inline int divu128(uint64_t *plow
, uint64_t *phigh
, uint64_t divisor
)
61 __uint128_t dividend
= ((__uint128_t
)*phigh
<< 64) | *plow
;
62 __uint128_t result
= dividend
/ divisor
;
64 *phigh
= dividend
% divisor
;
65 return result
> UINT64_MAX
;
69 static inline int divs128(int64_t *plow
, int64_t *phigh
, int64_t divisor
)
74 __int128_t dividend
= ((__int128_t
)*phigh
<< 64) | *plow
;
75 __int128_t result
= dividend
/ divisor
;
77 *phigh
= dividend
% divisor
;
78 return result
!= *plow
;
82 void muls64(uint64_t *phigh
, uint64_t *plow
, int64_t a
, int64_t b
);
83 void mulu64(uint64_t *phigh
, uint64_t *plow
, uint64_t a
, uint64_t b
);
84 int divu128(uint64_t *plow
, uint64_t *phigh
, uint64_t divisor
);
85 int divs128(int64_t *plow
, int64_t *phigh
, int64_t divisor
);
87 static inline uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
92 #ifdef HOST_WORDS_BIGENDIAN
102 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
103 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
106 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
112 * clz32 - count leading zeros in a 32-bit value.
113 * @val: The value to search
115 * Returns 32 if the value is zero. Note that the GCC builtin is
116 * undefined if the value is zero.
118 static inline int clz32(uint32_t val
)
120 #if QEMU_GNUC_PREREQ(3, 4)
121 return val
? __builtin_clz(val
) : 32;
123 /* Binary search for the leading one bit. */
126 if (!(val
& 0xFFFF0000U
)) {
130 if (!(val
& 0xFF000000U
)) {
134 if (!(val
& 0xF0000000U
)) {
138 if (!(val
& 0xC0000000U
)) {
142 if (!(val
& 0x80000000U
)) {
146 if (!(val
& 0x80000000U
)) {
154 * clo32 - count leading ones in a 32-bit value.
155 * @val: The value to search
157 * Returns 32 if the value is -1.
159 static inline int clo32(uint32_t val
)
165 * clz64 - count leading zeros in a 64-bit value.
166 * @val: The value to search
168 * Returns 64 if the value is zero. Note that the GCC builtin is
169 * undefined if the value is zero.
171 static inline int clz64(uint64_t val
)
173 #if QEMU_GNUC_PREREQ(3, 4)
174 return val
? __builtin_clzll(val
) : 64;
184 return cnt
+ clz32(val
);
189 * clo64 - count leading ones in a 64-bit value.
190 * @val: The value to search
192 * Returns 64 if the value is -1.
194 static inline int clo64(uint64_t val
)
200 * ctz32 - count trailing zeros in a 32-bit value.
201 * @val: The value to search
203 * Returns 32 if the value is zero. Note that the GCC builtin is
204 * undefined if the value is zero.
206 static inline int ctz32(uint32_t val
)
208 #if QEMU_GNUC_PREREQ(3, 4)
209 return val
? __builtin_ctz(val
) : 32;
211 /* Binary search for the trailing one bit. */
215 if (!(val
& 0x0000FFFFUL
)) {
219 if (!(val
& 0x000000FFUL
)) {
223 if (!(val
& 0x0000000FUL
)) {
227 if (!(val
& 0x00000003UL
)) {
231 if (!(val
& 0x00000001UL
)) {
235 if (!(val
& 0x00000001UL
)) {
244 * cto32 - count trailing ones in a 32-bit value.
245 * @val: The value to search
247 * Returns 32 if the value is -1.
249 static inline int cto32(uint32_t val
)
255 * ctz64 - count trailing zeros in a 64-bit value.
256 * @val: The value to search
258 * Returns 64 if the value is zero. Note that the GCC builtin is
259 * undefined if the value is zero.
261 static inline int ctz64(uint64_t val
)
263 #if QEMU_GNUC_PREREQ(3, 4)
264 return val
? __builtin_ctzll(val
) : 64;
269 if (!((uint32_t)val
)) {
274 return cnt
+ ctz32(val
);
279 * cto64 - count trailing ones in a 64-bit value.
280 * @val: The value to search
282 * Returns 64 if the value is -1.
284 static inline int cto64(uint64_t val
)
290 * clrsb32 - count leading redundant sign bits in a 32-bit value.
291 * @val: The value to search
293 * Returns the number of bits following the sign bit that are equal to it.
294 * No special cases; output range is [0-31].
296 static inline int clrsb32(uint32_t val
)
298 #if QEMU_GNUC_PREREQ(4, 7)
299 return __builtin_clrsb(val
);
301 return clz32(val
^ ((int32_t)val
>> 1)) - 1;
306 * clrsb64 - count leading redundant sign bits in a 64-bit value.
307 * @val: The value to search
309 * Returns the number of bits following the sign bit that are equal to it.
310 * No special cases; output range is [0-63].
312 static inline int clrsb64(uint64_t val
)
314 #if QEMU_GNUC_PREREQ(4, 7)
315 return __builtin_clrsbll(val
);
317 return clz64(val
^ ((int64_t)val
>> 1)) - 1;
322 * ctpop8 - count the population of one bits in an 8-bit value.
323 * @val: The value to search
325 static inline int ctpop8(uint8_t val
)
327 #if QEMU_GNUC_PREREQ(3, 4)
328 return __builtin_popcount(val
);
330 val
= (val
& 0x55) + ((val
>> 1) & 0x55);
331 val
= (val
& 0x33) + ((val
>> 2) & 0x33);
332 val
= (val
& 0x0f) + ((val
>> 4) & 0x0f);
339 * ctpop16 - count the population of one bits in a 16-bit value.
340 * @val: The value to search
342 static inline int ctpop16(uint16_t val
)
344 #if QEMU_GNUC_PREREQ(3, 4)
345 return __builtin_popcount(val
);
347 val
= (val
& 0x5555) + ((val
>> 1) & 0x5555);
348 val
= (val
& 0x3333) + ((val
>> 2) & 0x3333);
349 val
= (val
& 0x0f0f) + ((val
>> 4) & 0x0f0f);
350 val
= (val
& 0x00ff) + ((val
>> 8) & 0x00ff);
357 * ctpop32 - count the population of one bits in a 32-bit value.
358 * @val: The value to search
360 static inline int ctpop32(uint32_t val
)
362 #if QEMU_GNUC_PREREQ(3, 4)
363 return __builtin_popcount(val
);
365 val
= (val
& 0x55555555) + ((val
>> 1) & 0x55555555);
366 val
= (val
& 0x33333333) + ((val
>> 2) & 0x33333333);
367 val
= (val
& 0x0f0f0f0f) + ((val
>> 4) & 0x0f0f0f0f);
368 val
= (val
& 0x00ff00ff) + ((val
>> 8) & 0x00ff00ff);
369 val
= (val
& 0x0000ffff) + ((val
>> 16) & 0x0000ffff);
376 * ctpop64 - count the population of one bits in a 64-bit value.
377 * @val: The value to search
379 static inline int ctpop64(uint64_t val
)
381 #if QEMU_GNUC_PREREQ(3, 4)
382 return __builtin_popcountll(val
);
384 val
= (val
& 0x5555555555555555ULL
) + ((val
>> 1) & 0x5555555555555555ULL
);
385 val
= (val
& 0x3333333333333333ULL
) + ((val
>> 2) & 0x3333333333333333ULL
);
386 val
= (val
& 0x0f0f0f0f0f0f0f0fULL
) + ((val
>> 4) & 0x0f0f0f0f0f0f0f0fULL
);
387 val
= (val
& 0x00ff00ff00ff00ffULL
) + ((val
>> 8) & 0x00ff00ff00ff00ffULL
);
388 val
= (val
& 0x0000ffff0000ffffULL
) + ((val
>> 16) & 0x0000ffff0000ffffULL
);
389 val
= (val
& 0x00000000ffffffffULL
) + ((val
>> 32) & 0x00000000ffffffffULL
);
396 * revbit8 - reverse the bits in an 8-bit value.
397 * @x: The value to modify.
399 static inline uint8_t revbit8(uint8_t x
)
401 /* Assign the correct nibble position. */
402 x
= ((x
& 0xf0) >> 4)
404 /* Assign the correct bit position. */
405 x
= ((x
& 0x88) >> 3)
413 * revbit16 - reverse the bits in a 16-bit value.
414 * @x: The value to modify.
416 static inline uint16_t revbit16(uint16_t x
)
418 /* Assign the correct byte position. */
420 /* Assign the correct nibble position. */
421 x
= ((x
& 0xf0f0) >> 4)
422 | ((x
& 0x0f0f) << 4);
423 /* Assign the correct bit position. */
424 x
= ((x
& 0x8888) >> 3)
425 | ((x
& 0x4444) >> 1)
426 | ((x
& 0x2222) << 1)
427 | ((x
& 0x1111) << 3);
432 * revbit32 - reverse the bits in a 32-bit value.
433 * @x: The value to modify.
435 static inline uint32_t revbit32(uint32_t x
)
437 /* Assign the correct byte position. */
439 /* Assign the correct nibble position. */
440 x
= ((x
& 0xf0f0f0f0u
) >> 4)
441 | ((x
& 0x0f0f0f0fu
) << 4);
442 /* Assign the correct bit position. */
443 x
= ((x
& 0x88888888u
) >> 3)
444 | ((x
& 0x44444444u
) >> 1)
445 | ((x
& 0x22222222u
) << 1)
446 | ((x
& 0x11111111u
) << 3);
451 * revbit64 - reverse the bits in a 64-bit value.
452 * @x: The value to modify.
454 static inline uint64_t revbit64(uint64_t x
)
456 /* Assign the correct byte position. */
458 /* Assign the correct nibble position. */
459 x
= ((x
& 0xf0f0f0f0f0f0f0f0ull
) >> 4)
460 | ((x
& 0x0f0f0f0f0f0f0f0full
) << 4);
461 /* Assign the correct bit position. */
462 x
= ((x
& 0x8888888888888888ull
) >> 3)
463 | ((x
& 0x4444444444444444ull
) >> 1)
464 | ((x
& 0x2222222222222222ull
) << 1)
465 | ((x
& 0x1111111111111111ull
) << 3);
469 /* Host type specific sizes of these routines. */
471 #if ULONG_MAX == UINT32_MAX
476 # define ctpopl ctpop32
477 # define revbitl revbit32
478 #elif ULONG_MAX == UINT64_MAX
483 # define ctpopl ctpop64
484 # define revbitl revbit64
486 # error Unknown sizeof long
489 static inline bool is_power_of_2(uint64_t value
)
495 return !(value
& (value
- 1));
498 /* round down to the nearest power of 2*/
499 static inline int64_t pow2floor(int64_t value
)
501 if (!is_power_of_2(value
)) {
502 value
= 0x8000000000000000ULL
>> clz64(value
);
507 /* round up to the nearest power of 2 (0 if overflow) */
508 static inline uint64_t pow2ceil(uint64_t value
)
510 uint8_t nlz
= clz64(value
);
512 if (is_power_of_2(value
)) {
518 return 1ULL << (64 - nlz
);