numa: add -numa node,memdev= option
[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 #ifndef HOST_UTILS_H
26 #define HOST_UTILS_H 1
27
28 #include "qemu/compiler.h" /* QEMU_GNUC_PREREQ */
29 #include <limits.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 static inline int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor)
49 {
50 if (divisor == 0) {
51 return 1;
52 } else {
53 __uint128_t dividend = ((__uint128_t)*phigh << 64) | *plow;
54 __uint128_t result = dividend / divisor;
55 *plow = result;
56 *phigh = dividend % divisor;
57 return result > UINT64_MAX;
58 }
59 }
60
61 static inline int divs128(int64_t *plow, int64_t *phigh, int64_t divisor)
62 {
63 if (divisor == 0) {
64 return 1;
65 } else {
66 __int128_t dividend = ((__int128_t)*phigh << 64) | *plow;
67 __int128_t result = dividend / divisor;
68 *plow = result;
69 *phigh = dividend % divisor;
70 return result != *plow;
71 }
72 }
73 #else
74 void muls64(uint64_t *phigh, uint64_t *plow, int64_t a, int64_t b);
75 void mulu64(uint64_t *phigh, uint64_t *plow, uint64_t a, uint64_t b);
76 int divu128(uint64_t *plow, uint64_t *phigh, uint64_t divisor);
77 int divs128(int64_t *plow, int64_t *phigh, int64_t divisor);
78 #endif
79
80 /**
81 * clz32 - count leading zeros in a 32-bit value.
82 * @val: The value to search
83 *
84 * Returns 32 if the value is zero. Note that the GCC builtin is
85 * undefined if the value is zero.
86 */
87 static inline int clz32(uint32_t val)
88 {
89 #if QEMU_GNUC_PREREQ(3, 4)
90 return val ? __builtin_clz(val) : 32;
91 #else
92 /* Binary search for the leading one bit. */
93 int cnt = 0;
94
95 if (!(val & 0xFFFF0000U)) {
96 cnt += 16;
97 val <<= 16;
98 }
99 if (!(val & 0xFF000000U)) {
100 cnt += 8;
101 val <<= 8;
102 }
103 if (!(val & 0xF0000000U)) {
104 cnt += 4;
105 val <<= 4;
106 }
107 if (!(val & 0xC0000000U)) {
108 cnt += 2;
109 val <<= 2;
110 }
111 if (!(val & 0x80000000U)) {
112 cnt++;
113 val <<= 1;
114 }
115 if (!(val & 0x80000000U)) {
116 cnt++;
117 }
118 return cnt;
119 #endif
120 }
121
122 /**
123 * clo32 - count leading ones in a 32-bit value.
124 * @val: The value to search
125 *
126 * Returns 32 if the value is -1.
127 */
128 static inline int clo32(uint32_t val)
129 {
130 return clz32(~val);
131 }
132
133 /**
134 * clz64 - count leading zeros in a 64-bit value.
135 * @val: The value to search
136 *
137 * Returns 64 if the value is zero. Note that the GCC builtin is
138 * undefined if the value is zero.
139 */
140 static inline int clz64(uint64_t val)
141 {
142 #if QEMU_GNUC_PREREQ(3, 4)
143 return val ? __builtin_clzll(val) : 64;
144 #else
145 int cnt = 0;
146
147 if (!(val >> 32)) {
148 cnt += 32;
149 } else {
150 val >>= 32;
151 }
152
153 return cnt + clz32(val);
154 #endif
155 }
156
157 /**
158 * clo64 - count leading ones in a 64-bit value.
159 * @val: The value to search
160 *
161 * Returns 64 if the value is -1.
162 */
163 static inline int clo64(uint64_t val)
164 {
165 return clz64(~val);
166 }
167
168 /**
169 * ctz32 - count trailing zeros in a 32-bit value.
170 * @val: The value to search
171 *
172 * Returns 32 if the value is zero. Note that the GCC builtin is
173 * undefined if the value is zero.
174 */
175 static inline int ctz32(uint32_t val)
176 {
177 #if QEMU_GNUC_PREREQ(3, 4)
178 return val ? __builtin_ctz(val) : 32;
179 #else
180 /* Binary search for the trailing one bit. */
181 int cnt;
182
183 cnt = 0;
184 if (!(val & 0x0000FFFFUL)) {
185 cnt += 16;
186 val >>= 16;
187 }
188 if (!(val & 0x000000FFUL)) {
189 cnt += 8;
190 val >>= 8;
191 }
192 if (!(val & 0x0000000FUL)) {
193 cnt += 4;
194 val >>= 4;
195 }
196 if (!(val & 0x00000003UL)) {
197 cnt += 2;
198 val >>= 2;
199 }
200 if (!(val & 0x00000001UL)) {
201 cnt++;
202 val >>= 1;
203 }
204 if (!(val & 0x00000001UL)) {
205 cnt++;
206 }
207
208 return cnt;
209 #endif
210 }
211
212 /**
213 * cto32 - count trailing ones in a 32-bit value.
214 * @val: The value to search
215 *
216 * Returns 32 if the value is -1.
217 */
218 static inline int cto32(uint32_t val)
219 {
220 return ctz32(~val);
221 }
222
223 /**
224 * ctz64 - count trailing zeros in a 64-bit value.
225 * @val: The value to search
226 *
227 * Returns 64 if the value is zero. Note that the GCC builtin is
228 * undefined if the value is zero.
229 */
230 static inline int ctz64(uint64_t val)
231 {
232 #if QEMU_GNUC_PREREQ(3, 4)
233 return val ? __builtin_ctzll(val) : 64;
234 #else
235 int cnt;
236
237 cnt = 0;
238 if (!((uint32_t)val)) {
239 cnt += 32;
240 val >>= 32;
241 }
242
243 return cnt + ctz32(val);
244 #endif
245 }
246
247 /**
248 * cto64 - count trailing ones in a 64-bit value.
249 * @val: The value to search
250 *
251 * Returns 64 if the value is -1.
252 */
253 static inline int cto64(uint64_t val)
254 {
255 return ctz64(~val);
256 }
257
258 /**
259 * clrsb32 - count leading redundant sign bits in a 32-bit value.
260 * @val: The value to search
261 *
262 * Returns the number of bits following the sign bit that are equal to it.
263 * No special cases; output range is [0-31].
264 */
265 static inline int clrsb32(uint32_t val)
266 {
267 #if QEMU_GNUC_PREREQ(4, 7)
268 return __builtin_clrsb(val);
269 #else
270 return clz32(val ^ ((int32_t)val >> 1)) - 1;
271 #endif
272 }
273
274 /**
275 * clrsb64 - count leading redundant sign bits in a 64-bit value.
276 * @val: The value to search
277 *
278 * Returns the number of bits following the sign bit that are equal to it.
279 * No special cases; output range is [0-63].
280 */
281 static inline int clrsb64(uint64_t val)
282 {
283 #if QEMU_GNUC_PREREQ(4, 7)
284 return __builtin_clrsbll(val);
285 #else
286 return clz64(val ^ ((int64_t)val >> 1)) - 1;
287 #endif
288 }
289
290 /**
291 * ctpop8 - count the population of one bits in an 8-bit value.
292 * @val: The value to search
293 */
294 static inline int ctpop8(uint8_t val)
295 {
296 #if QEMU_GNUC_PREREQ(3, 4)
297 return __builtin_popcount(val);
298 #else
299 val = (val & 0x55) + ((val >> 1) & 0x55);
300 val = (val & 0x33) + ((val >> 2) & 0x33);
301 val = (val & 0x0f) + ((val >> 4) & 0x0f);
302
303 return val;
304 #endif
305 }
306
307 /**
308 * ctpop16 - count the population of one bits in a 16-bit value.
309 * @val: The value to search
310 */
311 static inline int ctpop16(uint16_t val)
312 {
313 #if QEMU_GNUC_PREREQ(3, 4)
314 return __builtin_popcount(val);
315 #else
316 val = (val & 0x5555) + ((val >> 1) & 0x5555);
317 val = (val & 0x3333) + ((val >> 2) & 0x3333);
318 val = (val & 0x0f0f) + ((val >> 4) & 0x0f0f);
319 val = (val & 0x00ff) + ((val >> 8) & 0x00ff);
320
321 return val;
322 #endif
323 }
324
325 /**
326 * ctpop32 - count the population of one bits in a 32-bit value.
327 * @val: The value to search
328 */
329 static inline int ctpop32(uint32_t val)
330 {
331 #if QEMU_GNUC_PREREQ(3, 4)
332 return __builtin_popcount(val);
333 #else
334 val = (val & 0x55555555) + ((val >> 1) & 0x55555555);
335 val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
336 val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f);
337 val = (val & 0x00ff00ff) + ((val >> 8) & 0x00ff00ff);
338 val = (val & 0x0000ffff) + ((val >> 16) & 0x0000ffff);
339
340 return val;
341 #endif
342 }
343
344 /**
345 * ctpop64 - count the population of one bits in a 64-bit value.
346 * @val: The value to search
347 */
348 static inline int ctpop64(uint64_t val)
349 {
350 #if QEMU_GNUC_PREREQ(3, 4)
351 return __builtin_popcountll(val);
352 #else
353 val = (val & 0x5555555555555555ULL) + ((val >> 1) & 0x5555555555555555ULL);
354 val = (val & 0x3333333333333333ULL) + ((val >> 2) & 0x3333333333333333ULL);
355 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 0x0f0f0f0f0f0f0f0fULL);
356 val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 0x00ff00ff00ff00ffULL);
357 val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 0x0000ffff0000ffffULL);
358 val = (val & 0x00000000ffffffffULL) + ((val >> 32) & 0x00000000ffffffffULL);
359
360 return val;
361 #endif
362 }
363
364 /* Host type specific sizes of these routines. */
365
366 #if ULONG_MAX == UINT32_MAX
367 # define clzl clz32
368 # define ctzl ctz32
369 # define clol clo32
370 # define ctol cto32
371 # define ctpopl ctpop32
372 #elif ULONG_MAX == UINT64_MAX
373 # define clzl clz64
374 # define ctzl ctz64
375 # define clol clo64
376 # define ctol cto64
377 # define ctpopl ctpop64
378 #else
379 # error Unknown sizeof long
380 #endif
381
382 #endif