]> git.proxmox.com Git - mirror_qemu.git/blob - include/qemu/host-utils.h
Include qemu-common.h exactly where needed
[mirror_qemu.git] / include / qemu / host-utils.h
1 /*
2 * Utility compute operations used by translated code.
3 *
4 * Copyright (c) 2007 Thiemo Seufer
5 * Copyright (c) 2007 Jocelyn Mayer
6 *
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:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
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
23 * THE SOFTWARE.
24 */
25
26 #ifndef HOST_UTILS_H
27 #define HOST_UTILS_H
28
29 #include "qemu/bswap.h"
30
31 #ifdef CONFIG_INT128
32 static inline void mulu64(uint64_t *plow, uint64_t *phigh,
33 uint64_t a, uint64_t b)
34 {
35 __uint128_t r = (__uint128_t)a * b;
36 *plow = r;
37 *phigh = r >> 64;
38 }
39
40 static inline void muls64(uint64_t *plow, uint64_t *phigh,
41 int64_t a, int64_t b)
42 {
43 __int128_t r = (__int128_t)a * b;
44 *plow = r;
45 *phigh = r >> 64;
46 }
47
48 /* compute with 96 bit intermediate result: (a*b)/c */
49 static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
50 {
51 return (__int128_t)a * b / c;
52 }
53
54 static inline int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor)
55 {
56 if (divisor == 0) {
57 return 1;
58 } else {
59 __uint128_t dividend = ((__uint128_t)*phigh << 64) | *plow;
60 __uint128_t result = dividend / divisor;
61 *plow = result;
62 *phigh = dividend % divisor;
63 return result > UINT64_MAX;
64 }
65 }
66
67 static inline int divs128(int64_t *plow, int64_t *phigh, int64_t divisor)
68 {
69 if (divisor == 0) {
70 return 1;
71 } else {
72 __int128_t dividend = ((__int128_t)*phigh << 64) | *plow;
73 __int128_t result = dividend / divisor;
74 *plow = result;
75 *phigh = dividend % divisor;
76 return result != *plow;
77 }
78 }
79 #else
80 void muls64(uint64_t *phigh, uint64_t *plow, int64_t a, int64_t b);
81 void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b);
82 int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor);
83 int divs128(int64_t *plow, int64_t *phigh, int64_t divisor);
84
85 static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
86 {
87 union {
88 uint64_t ll;
89 struct {
90 #ifdef HOST_WORDS_BIGENDIAN
91 uint32_t high, low;
92 #else
93 uint32_t low, high;
94 #endif
95 } l;
96 } u, res;
97 uint64_t rl, rh;
98
99 u.ll = a;
100 rl = (uint64_t)u.l.low * (uint64_t)b;
101 rh = (uint64_t)u.l.high * (uint64_t)b;
102 rh += (rl >> 32);
103 res.l.high = rh / c;
104 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
105 return res.ll;
106 }
107 #endif
108
109 /**
110 * clz32 - count leading zeros in a 32-bit value.
111 * @val: The value to search
112 *
113 * Returns 32 if the value is zero. Note that the GCC builtin is
114 * undefined if the value is zero.
115 */
116 static inline int clz32(uint32_t val)
117 {
118 return val ? __builtin_clz(val) : 32;
119 }
120
121 /**
122 * clo32 - count leading ones in a 32-bit value.
123 * @val: The value to search
124 *
125 * Returns 32 if the value is -1.
126 */
127 static inline int clo32(uint32_t val)
128 {
129 return clz32(~val);
130 }
131
132 /**
133 * clz64 - count leading zeros in a 64-bit value.
134 * @val: The value to search
135 *
136 * Returns 64 if the value is zero. Note that the GCC builtin is
137 * undefined if the value is zero.
138 */
139 static inline int clz64(uint64_t val)
140 {
141 return val ? __builtin_clzll(val) : 64;
142 }
143
144 /**
145 * clo64 - count leading ones in a 64-bit value.
146 * @val: The value to search
147 *
148 * Returns 64 if the value is -1.
149 */
150 static inline int clo64(uint64_t val)
151 {
152 return clz64(~val);
153 }
154
155 /**
156 * ctz32 - count trailing zeros in a 32-bit value.
157 * @val: The value to search
158 *
159 * Returns 32 if the value is zero. Note that the GCC builtin is
160 * undefined if the value is zero.
161 */
162 static inline int ctz32(uint32_t val)
163 {
164 return val ? __builtin_ctz(val) : 32;
165 }
166
167 /**
168 * cto32 - count trailing ones in a 32-bit value.
169 * @val: The value to search
170 *
171 * Returns 32 if the value is -1.
172 */
173 static inline int cto32(uint32_t val)
174 {
175 return ctz32(~val);
176 }
177
178 /**
179 * ctz64 - count trailing zeros in a 64-bit value.
180 * @val: The value to search
181 *
182 * Returns 64 if the value is zero. Note that the GCC builtin is
183 * undefined if the value is zero.
184 */
185 static inline int ctz64(uint64_t val)
186 {
187 return val ? __builtin_ctzll(val) : 64;
188 }
189
190 /**
191 * cto64 - count trailing ones in a 64-bit value.
192 * @val: The value to search
193 *
194 * Returns 64 if the value is -1.
195 */
196 static inline int cto64(uint64_t val)
197 {
198 return ctz64(~val);
199 }
200
201 /**
202 * clrsb32 - count leading redundant sign bits in a 32-bit value.
203 * @val: The value to search
204 *
205 * Returns the number of bits following the sign bit that are equal to it.
206 * No special cases; output range is [0-31].
207 */
208 static inline int clrsb32(uint32_t val)
209 {
210 #if __has_builtin(__builtin_clrsb) || !defined(__clang__)
211 return __builtin_clrsb(val);
212 #else
213 return clz32(val ^ ((int32_t)val >> 1)) - 1;
214 #endif
215 }
216
217 /**
218 * clrsb64 - count leading redundant sign bits in a 64-bit value.
219 * @val: The value to search
220 *
221 * Returns the number of bits following the sign bit that are equal to it.
222 * No special cases; output range is [0-63].
223 */
224 static inline int clrsb64(uint64_t val)
225 {
226 #if __has_builtin(__builtin_clrsbll) || !defined(__clang__)
227 return __builtin_clrsbll(val);
228 #else
229 return clz64(val ^ ((int64_t)val >> 1)) - 1;
230 #endif
231 }
232
233 /**
234 * ctpop8 - count the population of one bits in an 8-bit value.
235 * @val: The value to search
236 */
237 static inline int ctpop8(uint8_t val)
238 {
239 return __builtin_popcount(val);
240 }
241
242 /**
243 * ctpop16 - count the population of one bits in a 16-bit value.
244 * @val: The value to search
245 */
246 static inline int ctpop16(uint16_t val)
247 {
248 return __builtin_popcount(val);
249 }
250
251 /**
252 * ctpop32 - count the population of one bits in a 32-bit value.
253 * @val: The value to search
254 */
255 static inline int ctpop32(uint32_t val)
256 {
257 return __builtin_popcount(val);
258 }
259
260 /**
261 * ctpop64 - count the population of one bits in a 64-bit value.
262 * @val: The value to search
263 */
264 static inline int ctpop64(uint64_t val)
265 {
266 return __builtin_popcountll(val);
267 }
268
269 /**
270 * revbit8 - reverse the bits in an 8-bit value.
271 * @x: The value to modify.
272 */
273 static inline uint8_t revbit8(uint8_t x)
274 {
275 /* Assign the correct nibble position. */
276 x = ((x & 0xf0) >> 4)
277 | ((x & 0x0f) << 4);
278 /* Assign the correct bit position. */
279 x = ((x & 0x88) >> 3)
280 | ((x & 0x44) >> 1)
281 | ((x & 0x22) << 1)
282 | ((x & 0x11) << 3);
283 return x;
284 }
285
286 /**
287 * revbit16 - reverse the bits in a 16-bit value.
288 * @x: The value to modify.
289 */
290 static inline uint16_t revbit16(uint16_t x)
291 {
292 /* Assign the correct byte position. */
293 x = bswap16(x);
294 /* Assign the correct nibble position. */
295 x = ((x & 0xf0f0) >> 4)
296 | ((x & 0x0f0f) << 4);
297 /* Assign the correct bit position. */
298 x = ((x & 0x8888) >> 3)
299 | ((x & 0x4444) >> 1)
300 | ((x & 0x2222) << 1)
301 | ((x & 0x1111) << 3);
302 return x;
303 }
304
305 /**
306 * revbit32 - reverse the bits in a 32-bit value.
307 * @x: The value to modify.
308 */
309 static inline uint32_t revbit32(uint32_t x)
310 {
311 /* Assign the correct byte position. */
312 x = bswap32(x);
313 /* Assign the correct nibble position. */
314 x = ((x & 0xf0f0f0f0u) >> 4)
315 | ((x & 0x0f0f0f0fu) << 4);
316 /* Assign the correct bit position. */
317 x = ((x & 0x88888888u) >> 3)
318 | ((x & 0x44444444u) >> 1)
319 | ((x & 0x22222222u) << 1)
320 | ((x & 0x11111111u) << 3);
321 return x;
322 }
323
324 /**
325 * revbit64 - reverse the bits in a 64-bit value.
326 * @x: The value to modify.
327 */
328 static inline uint64_t revbit64(uint64_t x)
329 {
330 /* Assign the correct byte position. */
331 x = bswap64(x);
332 /* Assign the correct nibble position. */
333 x = ((x & 0xf0f0f0f0f0f0f0f0ull) >> 4)
334 | ((x & 0x0f0f0f0f0f0f0f0full) << 4);
335 /* Assign the correct bit position. */
336 x = ((x & 0x8888888888888888ull) >> 3)
337 | ((x & 0x4444444444444444ull) >> 1)
338 | ((x & 0x2222222222222222ull) << 1)
339 | ((x & 0x1111111111111111ull) << 3);
340 return x;
341 }
342
343 /* Host type specific sizes of these routines. */
344
345 #if ULONG_MAX == UINT32_MAX
346 # define clzl clz32
347 # define ctzl ctz32
348 # define clol clo32
349 # define ctol cto32
350 # define ctpopl ctpop32
351 # define revbitl revbit32
352 #elif ULONG_MAX == UINT64_MAX
353 # define clzl clz64
354 # define ctzl ctz64
355 # define clol clo64
356 # define ctol cto64
357 # define ctpopl ctpop64
358 # define revbitl revbit64
359 #else
360 # error Unknown sizeof long
361 #endif
362
363 static inline bool is_power_of_2(uint64_t value)
364 {
365 if (!value) {
366 return false;
367 }
368
369 return !(value & (value - 1));
370 }
371
372 /**
373 * Return @value rounded down to the nearest power of two or zero.
374 */
375 static inline uint64_t pow2floor(uint64_t value)
376 {
377 if (!value) {
378 /* Avoid undefined shift by 64 */
379 return 0;
380 }
381 return 0x8000000000000000ull >> clz64(value);
382 }
383
384 /*
385 * Return @value rounded up to the nearest power of two modulo 2^64.
386 * This is *zero* for @value > 2^63, so be careful.
387 */
388 static inline uint64_t pow2ceil(uint64_t value)
389 {
390 int n = clz64(value - 1);
391
392 if (!n) {
393 /*
394 * @value - 1 has no leading zeroes, thus @value - 1 >= 2^63
395 * Therefore, either @value == 0 or @value > 2^63.
396 * If it's 0, return 1, else return 0.
397 */
398 return !value;
399 }
400 return 0x8000000000000000ull >> (n - 1);
401 }
402
403 static inline uint32_t pow2roundup32(uint32_t x)
404 {
405 x |= (x >> 1);
406 x |= (x >> 2);
407 x |= (x >> 4);
408 x |= (x >> 8);
409 x |= (x >> 16);
410 return x + 1;
411 }
412
413 /**
414 * urshift - 128-bit Unsigned Right Shift.
415 * @plow: in/out - lower 64-bit integer.
416 * @phigh: in/out - higher 64-bit integer.
417 * @shift: in - bytes to shift, between 0 and 127.
418 *
419 * Result is zero-extended and stored in plow/phigh, which are
420 * input/output variables. Shift values outside the range will
421 * be mod to 128. In other words, the caller is responsible to
422 * verify/assert both the shift range and plow/phigh pointers.
423 */
424 void urshift(uint64_t *plow, uint64_t *phigh, int32_t shift);
425
426 /**
427 * ulshift - 128-bit Unsigned Left Shift.
428 * @plow: in/out - lower 64-bit integer.
429 * @phigh: in/out - higher 64-bit integer.
430 * @shift: in - bytes to shift, between 0 and 127.
431 * @overflow: out - true if any 1-bit is shifted out.
432 *
433 * Result is zero-extended and stored in plow/phigh, which are
434 * input/output variables. Shift values outside the range will
435 * be mod to 128. In other words, the caller is responsible to
436 * verify/assert both the shift range and plow/phigh pointers.
437 */
438 void ulshift(uint64_t *plow, uint64_t *phigh, int32_t shift, bool *overflow);
439
440 #endif