]>
Commit | Line | Data |
---|---|---|
064af421 | 1 | /* |
2fec66db | 2 | * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. |
064af421 | 3 | * |
a14bc59f BP |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
064af421 | 7 | * |
a14bc59f BP |
8 | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
064af421 BP |
15 | */ |
16 | ||
17 | #ifndef UTIL_H | |
18 | #define UTIL_H 1 | |
19 | ||
437d0d22 | 20 | #include <inttypes.h> |
a656cb77 | 21 | #include <limits.h> |
064af421 BP |
22 | #include <stdarg.h> |
23 | #include <stdbool.h> | |
24 | #include <stddef.h> | |
25 | #include <stdint.h> | |
26 | #include <stdio.h> | |
ccc09689 | 27 | #include <stdlib.h> |
064af421 BP |
28 | #include <string.h> |
29 | #include "compiler.h" | |
4e022ec0 | 30 | #include "openvswitch/types.h" |
064af421 BP |
31 | |
32 | #ifndef va_copy | |
33 | #ifdef __va_copy | |
34 | #define va_copy __va_copy | |
35 | #else | |
36 | #define va_copy(dst, src) ((dst) = (src)) | |
37 | #endif | |
38 | #endif | |
39 | ||
0b9275b2 BP |
40 | #ifdef __CHECKER__ |
41 | #define BUILD_ASSERT(EXPR) ((void) 0) | |
42 | #define BUILD_ASSERT_DECL(EXPR) extern int (*build_assert(void))[1] | |
43 | #elif !defined(__cplusplus) | |
064af421 BP |
44 | /* Build-time assertion building block. */ |
45 | #define BUILD_ASSERT__(EXPR) \ | |
46 | sizeof(struct { unsigned int build_assert_failed : (EXPR) ? 1 : -1; }) | |
47 | ||
48 | /* Build-time assertion for use in a statement context. */ | |
49 | #define BUILD_ASSERT(EXPR) (void) BUILD_ASSERT__(EXPR) | |
50 | ||
51 | /* Build-time assertion for use in a declaration context. */ | |
52 | #define BUILD_ASSERT_DECL(EXPR) \ | |
53 | extern int (*build_assert(void))[BUILD_ASSERT__(EXPR)] | |
54 | #else /* __cplusplus */ | |
55 | #include <boost/static_assert.hpp> | |
56 | #define BUILD_ASSERT BOOST_STATIC_ASSERT | |
57 | #define BUILD_ASSERT_DECL BOOST_STATIC_ASSERT | |
58 | #endif /* __cplusplus */ | |
59 | ||
320232ec BP |
60 | #ifdef __GNUC__ |
61 | #define BUILD_ASSERT_GCCONLY(EXPR) BUILD_ASSERT(EXPR) | |
62 | #define BUILD_ASSERT_DECL_GCCONLY(EXPR) BUILD_ASSERT_DECL(EXPR) | |
63 | #else | |
64 | #define BUILD_ASSERT_GCCONLY(EXPR) ((void) 0) | |
65 | #define BUILD_ASSERT_DECL_GCCONLY(EXPR) ((void) 0) | |
66 | #endif | |
67 | ||
4749f73d BP |
68 | /* Like the standard assert macro, except: |
69 | * | |
70 | * - Writes the failure message to the log. | |
71 | * | |
72 | * - Not affected by NDEBUG. */ | |
73 | #define ovs_assert(CONDITION) \ | |
74 | if (!OVS_LIKELY(CONDITION)) { \ | |
75 | ovs_assert_failure(SOURCE_LOCATOR, __func__, #CONDITION); \ | |
76 | } | |
77 | void ovs_assert_failure(const char *, const char *, const char *) NO_RETURN; | |
78 | ||
ebc56baa BP |
79 | /* Casts 'pointer' to 'type' and issues a compiler warning if the cast changes |
80 | * anything other than an outermost "const" or "volatile" qualifier. | |
81 | * | |
82 | * The cast to int is present only to suppress an "expression using sizeof | |
83 | * bool" warning from "sparse" (see | |
84 | * http://permalink.gmane.org/gmane.comp.parsers.sparse/2967). */ | |
85 | #define CONST_CAST(TYPE, POINTER) \ | |
86 | ((void) sizeof ((int) ((POINTER) == (TYPE) (POINTER))), \ | |
87 | (TYPE) (POINTER)) | |
88 | ||
064af421 BP |
89 | extern const char *program_name; |
90 | ||
878f1972 FL |
91 | #define __ARRAY_SIZE_NOCHECK(ARRAY) (sizeof(ARRAY) / sizeof((ARRAY)[0])) |
92 | #ifdef __GNUC__ | |
93 | /* return 0 for array types, 1 otherwise */ | |
94 | #define __ARRAY_CHECK(ARRAY) \ | |
95 | !__builtin_types_compatible_p(typeof(ARRAY), typeof(&ARRAY[0])) | |
96 | ||
97 | /* compile-time fail if not array */ | |
98 | #define __ARRAY_FAIL(ARRAY) (sizeof(char[-2*!__ARRAY_CHECK(ARRAY)])) | |
99 | #define __ARRAY_SIZE(ARRAY) \ | |
100 | __builtin_choose_expr(__ARRAY_CHECK(ARRAY), \ | |
101 | __ARRAY_SIZE_NOCHECK(ARRAY), __ARRAY_FAIL(ARRAY)) | |
102 | #else | |
103 | #define __ARRAY_SIZE(ARRAY) __ARRAY_SIZE_NOCHECK(ARRAY) | |
104 | #endif | |
105 | ||
ba25c9d1 | 106 | /* Returns the number of elements in ARRAY. */ |
878f1972 | 107 | #define ARRAY_SIZE(ARRAY) __ARRAY_SIZE(ARRAY) |
ba25c9d1 BP |
108 | |
109 | /* Returns X / Y, rounding up. X must be nonnegative to round correctly. */ | |
bbb18ba7 | 110 | #define DIV_ROUND_UP(X, Y) (((X) + ((Y) - 1)) / (Y)) |
ba25c9d1 BP |
111 | |
112 | /* Returns X rounded up to the nearest multiple of Y. */ | |
bbb18ba7 | 113 | #define ROUND_UP(X, Y) (DIV_ROUND_UP(X, Y) * (Y)) |
ba25c9d1 | 114 | |
f6e984d7 BP |
115 | /* Returns the least number that, when added to X, yields a multiple of Y. */ |
116 | #define PAD_SIZE(X, Y) (ROUND_UP(X, Y) - (X)) | |
117 | ||
ba25c9d1 | 118 | /* Returns X rounded down to the nearest multiple of Y. */ |
064af421 | 119 | #define ROUND_DOWN(X, Y) ((X) / (Y) * (Y)) |
ba25c9d1 BP |
120 | |
121 | /* Returns true if X is a power of 2, otherwise false. */ | |
064af421 BP |
122 | #define IS_POW2(X) ((X) && !((X) & ((X) - 1))) |
123 | ||
27527aa0 BP |
124 | static inline bool |
125 | is_pow2(uintmax_t x) | |
126 | { | |
127 | return IS_POW2(x); | |
128 | } | |
129 | ||
e93ab553 BP |
130 | /* Returns X rounded up to a power of 2. X must be a constant expression. */ |
131 | #define ROUND_UP_POW2(X) RUP2__(X) | |
132 | #define RUP2__(X) (RUP2_1(X) + 1) | |
133 | #define RUP2_1(X) (RUP2_2(X) | (RUP2_2(X) >> 16)) | |
134 | #define RUP2_2(X) (RUP2_3(X) | (RUP2_3(X) >> 8)) | |
135 | #define RUP2_3(X) (RUP2_4(X) | (RUP2_4(X) >> 4)) | |
136 | #define RUP2_4(X) (RUP2_5(X) | (RUP2_5(X) >> 2)) | |
137 | #define RUP2_5(X) (RUP2_6(X) | (RUP2_6(X) >> 1)) | |
138 | #define RUP2_6(X) ((X) - 1) | |
139 | ||
140 | /* Returns X rounded down to a power of 2. X must be a constant expression. */ | |
141 | #define ROUND_DOWN_POW2(X) RDP2__(X) | |
142 | #define RDP2__(X) (RDP2_1(X) - (RDP2_1(X) >> 1)) | |
143 | #define RDP2_1(X) (RDP2_2(X) | (RDP2_2(X) >> 16)) | |
144 | #define RDP2_2(X) (RDP2_3(X) | (RDP2_3(X) >> 8)) | |
145 | #define RDP2_3(X) (RDP2_4(X) | (RDP2_4(X) >> 4)) | |
146 | #define RDP2_4(X) (RDP2_5(X) | (RDP2_5(X) >> 2)) | |
147 | #define RDP2_5(X) ( (X) | ( (X) >> 1)) | |
148 | ||
e2051008 BP |
149 | /* This system's cache line size, in bytes. |
150 | * Being wrong hurts performance but not correctness. */ | |
151 | #define CACHE_LINE_SIZE 64 | |
152 | BUILD_ASSERT_DECL(IS_POW2(CACHE_LINE_SIZE)); | |
153 | ||
124f09c9 JR |
154 | static inline void |
155 | ovs_prefetch_range(const void *start, size_t size) | |
156 | { | |
157 | const char *addr = (const char *)start; | |
158 | size_t ofs; | |
159 | ||
160 | for (ofs = 0; ofs < size; ofs += CACHE_LINE_SIZE) { | |
161 | OVS_PREFETCH(addr + ofs); | |
162 | } | |
163 | } | |
164 | ||
064af421 BP |
165 | #ifndef MIN |
166 | #define MIN(X, Y) ((X) < (Y) ? (X) : (Y)) | |
167 | #endif | |
168 | ||
169 | #ifndef MAX | |
170 | #define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) | |
171 | #endif | |
172 | ||
428b2edd | 173 | #define OVS_NOT_REACHED() abort() |
064af421 | 174 | |
f89ffb0e BP |
175 | /* Expands to a string that looks like "<file>:<line>", e.g. "tmp.c:10". |
176 | * | |
177 | * See http://c-faq.com/ansi/stringize.html for an explanation of STRINGIZE and | |
178 | * STRINGIZE2. */ | |
179 | #define SOURCE_LOCATOR __FILE__ ":" STRINGIZE(__LINE__) | |
180 | #define STRINGIZE(ARG) STRINGIZE2(ARG) | |
181 | #define STRINGIZE2(ARG) #ARG | |
182 | ||
17e42975 BP |
183 | /* Given a pointer-typed lvalue OBJECT, expands to a pointer type that may be |
184 | * assigned to OBJECT. */ | |
185 | #ifdef __GNUC__ | |
186 | #define OVS_TYPEOF(OBJECT) typeof(OBJECT) | |
187 | #else | |
188 | #define OVS_TYPEOF(OBJECT) void * | |
189 | #endif | |
190 | ||
4e6ca956 BP |
191 | /* Given OBJECT of type pointer-to-structure, expands to the offset of MEMBER |
192 | * within an instance of the structure. | |
193 | * | |
194 | * The GCC-specific version avoids the technicality of undefined behavior if | |
195 | * OBJECT is null, invalid, or not yet initialized. This makes some static | |
196 | * checkers (like Coverity) happier. But the non-GCC version does not actually | |
197 | * dereference any pointer, so it would be surprising for it to cause any | |
198 | * problems in practice. | |
199 | */ | |
200 | #ifdef __GNUC__ | |
201 | #define OBJECT_OFFSETOF(OBJECT, MEMBER) offsetof(typeof(*(OBJECT)), MEMBER) | |
202 | #else | |
203 | #define OBJECT_OFFSETOF(OBJECT, MEMBER) \ | |
204 | ((char *) &(OBJECT)->MEMBER - (char *) (OBJECT)) | |
205 | #endif | |
206 | ||
064af421 BP |
207 | /* Given POINTER, the address of the given MEMBER in a STRUCT object, returns |
208 | the STRUCT object. */ | |
209 | #define CONTAINER_OF(POINTER, STRUCT, MEMBER) \ | |
26adc8dd | 210 | ((STRUCT *) (void *) ((char *) (POINTER) - offsetof (STRUCT, MEMBER))) |
064af421 | 211 | |
adf7cfd8 | 212 | /* Given POINTER, the address of the given MEMBER within an object of the type |
17e42975 BP |
213 | * that that OBJECT points to, returns OBJECT as an assignment-compatible |
214 | * pointer type (either the correct pointer type or "void *"). OBJECT must be | |
215 | * an lvalue. | |
adf7cfd8 BP |
216 | * |
217 | * This is the same as CONTAINER_OF except that it infers the structure type | |
218 | * from the type of '*OBJECT'. */ | |
219 | #define OBJECT_CONTAINING(POINTER, OBJECT, MEMBER) \ | |
17e42975 | 220 | ((OVS_TYPEOF(OBJECT)) (void *) \ |
4e6ca956 | 221 | ((char *) (POINTER) - OBJECT_OFFSETOF(OBJECT, MEMBER))) |
adf7cfd8 | 222 | |
772ec52b BP |
223 | /* Given POINTER, the address of the given MEMBER within an object of the type |
224 | * that that OBJECT points to, assigns the address of the outer object to | |
225 | * OBJECT, which must be an lvalue. | |
226 | * | |
33e191a0 | 227 | * Evaluates to (void) 0 as the result is not to be used. */ |
772ec52b | 228 | #define ASSIGN_CONTAINER(OBJECT, POINTER, MEMBER) \ |
33e191a0 | 229 | ((OBJECT) = OBJECT_CONTAINING(POINTER, OBJECT, MEMBER), (void) 0) |
772ec52b | 230 | |
db5a1019 AW |
231 | /* Given ATTR, and TYPE, cast the ATTR to TYPE by first casting ATTR to |
232 | * (void *). This is to suppress the alignment warning issued by clang. */ | |
233 | #define ALIGNED_CAST(TYPE, ATTR) ((TYPE) (void *) (ATTR)) | |
234 | ||
34582733 AS |
235 | /* Use "%"PRIuSIZE to format size_t with printf(). */ |
236 | #ifdef _WIN32 | |
237 | #define PRIdSIZE "Id" | |
238 | #define PRIiSIZE "Ii" | |
239 | #define PRIoSIZE "Io" | |
240 | #define PRIuSIZE "Iu" | |
241 | #define PRIxSIZE "Ix" | |
242 | #define PRIXSIZE "IX" | |
243 | #else | |
244 | #define PRIdSIZE "zd" | |
245 | #define PRIiSIZE "zi" | |
246 | #define PRIoSIZE "zo" | |
247 | #define PRIuSIZE "zu" | |
248 | #define PRIxSIZE "zx" | |
249 | #define PRIXSIZE "zX" | |
250 | #endif | |
251 | ||
064af421 BP |
252 | #ifdef __cplusplus |
253 | extern "C" { | |
254 | #endif | |
255 | ||
e385ef55 EJ |
256 | void set_program_name__(const char *name, const char *version, |
257 | const char *date, const char *time); | |
55d5bb44 | 258 | #define set_program_name(name) \ |
e385ef55 | 259 | set_program_name__(name, VERSION, __DATE__, __TIME__) |
064af421 | 260 | |
bc9fb3a9 | 261 | const char *get_subprogram_name(void); |
d710edc4 | 262 | void set_subprogram_name(const char *format, ...) PRINTF_FORMAT(1, 2); |
bc9fb3a9 | 263 | |
55d5bb44 JP |
264 | const char *get_program_version(void); |
265 | void ovs_print_version(uint8_t min_ofp, uint8_t max_ofp); | |
064af421 BP |
266 | |
267 | void out_of_memory(void) NO_RETURN; | |
268 | void *xmalloc(size_t) MALLOC_LIKE; | |
269 | void *xcalloc(size_t, size_t) MALLOC_LIKE; | |
ec6fde61 | 270 | void *xzalloc(size_t) MALLOC_LIKE; |
064af421 BP |
271 | void *xrealloc(void *, size_t); |
272 | void *xmemdup(const void *, size_t) MALLOC_LIKE; | |
273 | char *xmemdup0(const char *, size_t) MALLOC_LIKE; | |
274 | char *xstrdup(const char *) MALLOC_LIKE; | |
275 | char *xasprintf(const char *format, ...) PRINTF_FORMAT(1, 2) MALLOC_LIKE; | |
276 | char *xvasprintf(const char *format, va_list) PRINTF_FORMAT(1, 0) MALLOC_LIKE; | |
277 | void *x2nrealloc(void *p, size_t *n, size_t s); | |
278 | ||
2fec66db BP |
279 | void *xmalloc_cacheline(size_t) MALLOC_LIKE; |
280 | void *xzalloc_cacheline(size_t) MALLOC_LIKE; | |
281 | void free_cacheline(void *); | |
282 | ||
064af421 | 283 | void ovs_strlcpy(char *dst, const char *src, size_t size); |
71d7c22f | 284 | void ovs_strzcpy(char *dst, const char *src, size_t size); |
064af421 | 285 | |
c1c8308a BP |
286 | void ovs_abort(int err_no, const char *format, ...) |
287 | PRINTF_FORMAT(2, 3) NO_RETURN; | |
d41d4b71 BP |
288 | void ovs_abort_valist(int err_no, const char *format, va_list) |
289 | PRINTF_FORMAT(2, 0) NO_RETURN; | |
064af421 BP |
290 | void ovs_fatal(int err_no, const char *format, ...) |
291 | PRINTF_FORMAT(2, 3) NO_RETURN; | |
fcaddd4d BP |
292 | void ovs_fatal_valist(int err_no, const char *format, va_list) |
293 | PRINTF_FORMAT(2, 0) NO_RETURN; | |
064af421 | 294 | void ovs_error(int err_no, const char *format, ...) PRINTF_FORMAT(2, 3); |
c1c8308a BP |
295 | void ovs_error_valist(int err_no, const char *format, va_list) |
296 | PRINTF_FORMAT(2, 0); | |
c18ea70d | 297 | const char *ovs_retval_to_string(int); |
5fcbed74 | 298 | const char *ovs_strerror(int); |
064af421 BP |
299 | void ovs_hex_dump(FILE *, const void *, size_t, uintptr_t offset, bool ascii); |
300 | ||
301 | bool str_to_int(const char *, int base, int *); | |
302 | bool str_to_long(const char *, int base, long *); | |
303 | bool str_to_llong(const char *, int base, long long *); | |
4c21aa06 | 304 | bool str_to_uint(const char *, int base, unsigned int *); |
064af421 | 305 | |
037821cf | 306 | bool ovs_scan(const char *s, const char *format, ...) SCANF_FORMAT(2, 3); |
ed2232fc | 307 | |
f38b84ea BP |
308 | bool str_to_double(const char *, double *); |
309 | ||
310 | int hexit_value(int c); | |
bf971267 | 311 | unsigned int hexits_value(const char *s, size_t n, bool *ok); |
f38b84ea | 312 | |
44b4d050 BP |
313 | const char *english_list_delimiter(size_t index, size_t total); |
314 | ||
daf03c53 | 315 | char *get_cwd(void); |
29d4af60 | 316 | char *dir_name(const char *file_name); |
e1aff6f9 | 317 | char *base_name(const char *file_name); |
daf03c53 | 318 | char *abs_file_name(const char *dir, const char *file_name); |
29d4af60 | 319 | |
fee0c963 BP |
320 | char *follow_symlinks(const char *filename); |
321 | ||
c69ee87c | 322 | void ignore(bool x OVS_UNUSED); |
fe9d0898 BP |
323 | \f |
324 | /* Bitwise tests. */ | |
0ee140fb | 325 | |
d43d314e BP |
326 | /* Returns the number of trailing 0-bits in 'n'. Undefined if 'n' == 0. */ |
327 | #if __GNUC__ >= 4 | |
0ee140fb | 328 | static inline int |
d43d314e | 329 | raw_ctz(uint64_t n) |
0ee140fb | 330 | { |
d43d314e BP |
331 | /* With GCC 4.7 on 32-bit x86, if a 32-bit integer is passed as 'n', using |
332 | * a plain __builtin_ctzll() here always generates an out-of-line function | |
333 | * call. The test below helps it to emit a single 'bsf' instruction. */ | |
334 | return (__builtin_constant_p(n <= UINT32_MAX) && n <= UINT32_MAX | |
335 | ? __builtin_ctz(n) | |
336 | : __builtin_ctzll(n)); | |
0ee140fb | 337 | } |
8c947903 JR |
338 | |
339 | static inline int | |
340 | raw_clz64(uint64_t n) | |
341 | { | |
342 | return __builtin_clzll(n); | |
343 | } | |
0ee140fb BP |
344 | #else |
345 | /* Defined in util.c. */ | |
d43d314e | 346 | int raw_ctz(uint64_t n); |
8c947903 | 347 | int raw_clz64(uint64_t n); |
0ee140fb BP |
348 | #endif |
349 | ||
350 | /* Returns the number of trailing 0-bits in 'n', or 32 if 'n' is 0. */ | |
351 | static inline int | |
d578065e | 352 | ctz32(uint32_t n) |
0ee140fb BP |
353 | { |
354 | return n ? raw_ctz(n) : 32; | |
355 | } | |
356 | ||
cc4c738e JR |
357 | /* Returns the number of trailing 0-bits in 'n', or 64 if 'n' is 0. */ |
358 | static inline int | |
359 | ctz64(uint64_t n) | |
360 | { | |
d43d314e | 361 | return n ? raw_ctz(n) : 64; |
cc4c738e | 362 | } |
18b9283b | 363 | |
8c947903 JR |
364 | /* Returns the number of leading 0-bits in 'n', or 32 if 'n' is 0. */ |
365 | static inline int | |
366 | clz32(uint32_t n) | |
367 | { | |
368 | return n ? raw_clz64(n) - 32 : 32; | |
369 | } | |
370 | ||
371 | /* Returns the number of leading 0-bits in 'n', or 64 if 'n' is 0. */ | |
372 | static inline int | |
373 | clz64(uint64_t n) | |
374 | { | |
375 | return n ? raw_clz64(n) : 64; | |
376 | } | |
377 | ||
378 | /* Given a word 'n', calculates floor(log_2('n')). This is equivalent | |
379 | * to finding the bit position of the most significant one bit in 'n'. It is | |
380 | * an error to call this function with 'n' == 0. */ | |
381 | static inline int | |
382 | log_2_floor(uint64_t n) | |
383 | { | |
384 | return 63 - raw_clz64(n); | |
385 | } | |
386 | ||
387 | /* Given a word 'n', calculates ceil(log_2('n')). It is an error to | |
388 | * call this function with 'n' == 0. */ | |
389 | static inline int | |
390 | log_2_ceil(uint64_t n) | |
391 | { | |
392 | return log_2_floor(n) + !is_pow2(n); | |
393 | } | |
394 | ||
381657b3 JR |
395 | /* unsigned int count_1bits(uint64_t x): |
396 | * | |
397 | * Returns the number of 1-bits in 'x', between 0 and 64 inclusive. */ | |
398 | #if UINTPTR_MAX == UINT64_MAX | |
399 | static inline unsigned int | |
400 | count_1bits(uint64_t x) | |
401 | { | |
402 | #if __GNUC__ >= 4 && __POPCNT__ | |
403 | return __builtin_popcountll(x); | |
404 | #else | |
405 | /* This portable implementation is the fastest one we know of for 64 | |
406 | * bits, and about 3x faster than GCC 4.7 __builtin_popcountll(). */ | |
407 | const uint64_t h55 = UINT64_C(0x5555555555555555); | |
408 | const uint64_t h33 = UINT64_C(0x3333333333333333); | |
409 | const uint64_t h0F = UINT64_C(0x0F0F0F0F0F0F0F0F); | |
410 | const uint64_t h01 = UINT64_C(0x0101010101010101); | |
411 | x -= (x >> 1) & h55; /* Count of each 2 bits in-place. */ | |
412 | x = (x & h33) + ((x >> 2) & h33); /* Count of each 4 bits in-place. */ | |
413 | x = (x + (x >> 4)) & h0F; /* Count of each 8 bits in-place. */ | |
414 | return (x * h01) >> 56; /* Sum of all bytes. */ | |
415 | #endif | |
416 | } | |
417 | #else /* Not 64-bit. */ | |
418 | #if __GNUC__ >= 4 && __POPCNT__ | |
c3cc4d2d | 419 | static inline unsigned int |
381657b3 | 420 | count_1bits_32__(uint32_t x) |
c3cc4d2d | 421 | { |
c3cc4d2d | 422 | return __builtin_popcount(x); |
381657b3 | 423 | } |
c3cc4d2d | 424 | #else |
381657b3 JR |
425 | #define NEED_COUNT_1BITS_8 1 |
426 | extern const uint8_t count_1bits_8[256]; | |
427 | static inline unsigned int | |
428 | count_1bits_32__(uint32_t x) | |
429 | { | |
c3cc4d2d JR |
430 | /* This portable implementation is the fastest one we know of for 32 bits, |
431 | * and faster than GCC __builtin_popcount(). */ | |
432 | return (count_1bits_8[x & 0xff] + | |
433 | count_1bits_8[(x >> 8) & 0xff] + | |
434 | count_1bits_8[(x >> 16) & 0xff] + | |
435 | count_1bits_8[x >> 24]); | |
c3cc4d2d | 436 | } |
381657b3 | 437 | #endif |
c3cc4d2d JR |
438 | static inline unsigned int |
439 | count_1bits(uint64_t x) | |
440 | { | |
381657b3 | 441 | return count_1bits_32__(x) + count_1bits_32__(x >> 32); |
c3cc4d2d | 442 | } |
381657b3 | 443 | #endif |
8c947903 | 444 | |
fe9d0898 BP |
445 | /* Returns the rightmost 1-bit in 'x' (e.g. 01011000 => 00001000), or 0 if 'x' |
446 | * is 0. */ | |
447 | static inline uintmax_t | |
448 | rightmost_1bit(uintmax_t x) | |
449 | { | |
450 | return x & -x; | |
451 | } | |
452 | ||
453 | /* Returns 'x' with its rightmost 1-bit changed to a zero (e.g. 01011000 => | |
454 | * 01010000), or 0 if 'x' is 0. */ | |
455 | static inline uintmax_t | |
456 | zero_rightmost_1bit(uintmax_t x) | |
457 | { | |
458 | return x & (x - 1); | |
459 | } | |
35bedb61 BP |
460 | |
461 | /* Returns the index of the rightmost 1-bit in 'x' (e.g. 01011000 => 3), or 32 | |
462 | * if 'x' is 0. | |
463 | * | |
464 | * Unlike the other functions for rightmost 1-bits, this function only works | |
465 | * with 32-bit integers. */ | |
466 | static inline uint32_t | |
467 | rightmost_1bit_idx(uint32_t x) | |
468 | { | |
d578065e | 469 | return ctz32(x); |
35bedb61 BP |
470 | } |
471 | ||
d578065e | 472 | /* Returns the index of the leftmost 1-bit in 'x' (e.g. 01011000 => 6), or 32 |
35bedb61 BP |
473 | * if 'x' is 0. |
474 | * | |
475 | * This function only works with 32-bit integers. */ | |
476 | static inline uint32_t | |
477 | leftmost_1bit_idx(uint32_t x) | |
478 | { | |
479 | return x ? log_2_floor(x) : 32; | |
480 | } | |
fe9d0898 | 481 | \f |
75a75043 BP |
482 | bool is_all_zeros(const uint8_t *, size_t); |
483 | bool is_all_ones(const uint8_t *, size_t); | |
ddc4f8e2 BP |
484 | void bitwise_copy(const void *src, unsigned int src_len, unsigned int src_ofs, |
485 | void *dst, unsigned int dst_len, unsigned int dst_ofs, | |
486 | unsigned int n_bits); | |
6cc7ea5e BP |
487 | void bitwise_zero(void *dst_, unsigned int dst_len, unsigned dst_ofs, |
488 | unsigned int n_bits); | |
c2dd4932 BP |
489 | void bitwise_one(void *dst_, unsigned int dst_len, unsigned dst_ofs, |
490 | unsigned int n_bits); | |
79a010aa BP |
491 | bool bitwise_is_all_zeros(const void *, unsigned int len, unsigned int ofs, |
492 | unsigned int n_bits); | |
ddc4f8e2 BP |
493 | void bitwise_put(uint64_t value, |
494 | void *dst, unsigned int dst_len, unsigned int dst_ofs, | |
495 | unsigned int n_bits); | |
496 | uint64_t bitwise_get(const void *src, unsigned int src_len, | |
497 | unsigned int src_ofs, unsigned int n_bits); | |
75a75043 | 498 | |
5fd2f418 | 499 | void xsleep(unsigned int seconds); |
124f09c9 | 500 | |
06f14c92 GS |
501 | #ifdef _WIN32 |
502 | \f | |
315ea327 | 503 | char *ovs_format_message(int error); |
06f14c92 | 504 | char *ovs_lasterror_to_string(void); |
daa04db8 | 505 | int ftruncate(int fd, off_t length); |
06f14c92 GS |
506 | #endif |
507 | ||
064af421 BP |
508 | #ifdef __cplusplus |
509 | } | |
510 | #endif | |
511 | ||
512 | #endif /* util.h */ |