1 /*
2 * Copyright © 2014 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #ifndef UTIL_MACROS_H
25 #define UTIL_MACROS_H
26
27 #include <stdio.h>
28 #include <assert.h>
29 #include <stdint.h>
30
31 /* Compute the size of an array */
32 #ifndef ARRAY_SIZE
33 # define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
34 #endif
35
36 /* For compatibility with Clang's __has_builtin() */
37 #ifndef __has_builtin
38 # define __has_builtin(x) 0
39 #endif
40
41 #ifndef __has_attribute
42 # define __has_attribute(x) 0
43 #endif
44
45 /**
46 * __builtin_expect macros
47 */
48 #if !defined(HAVE___BUILTIN_EXPECT)
49 # define __builtin_expect(x, y) (x)
50 #endif
51
52 #ifndef likely
53 # ifdef HAVE___BUILTIN_EXPECT
54 # define likely(x) __builtin_expect(!!(x), 1)
55 # define unlikely(x) __builtin_expect(!!(x), 0)
56 # else
57 # define likely(x) (x)
58 # define unlikely(x) (x)
59 # endif
60 #endif
61
62 /**
63 * __builtin_types_compatible_p compat
64 */
65 #if defined(__cplusplus) || !defined(HAVE___BUILTIN_TYPES_COMPATIBLE_P)
66 # define __builtin_types_compatible_p(type1, type2) (1)
67 #endif
68
69 /**
70 * Static (compile-time) assertion.
71 */
72 #define STATIC_ASSERT(cond) do { \
73 static_assert(cond, #cond); \
74 } while (0)
75
76 /**
77 * container_of - cast a member of a structure out to the containing structure
78 * @ptr: the pointer to the member.
79 * @type: the type of the container struct this is embedded in.
80 * @member: the name of the member within the struct.
81 */
82 #ifndef __GNUC__
83 /* a grown-up compiler is required for the extra type checking: */
84 # define container_of(ptr, type, member) \
85 (type*)((uint8_t *)ptr - offsetof(type, member))
86 #else
87 # define __same_type(a, b) \
88 __builtin_types_compatible_p(__typeof__(a), __typeof__(b))
89 # define container_of(ptr, type, member) ({ \
90 uint8_t *__mptr = (uint8_t *)(ptr); \
91 static_assert(__same_type(*(ptr), ((type *)0)->member) || \
92 __same_type(*(ptr), void), \
93 "pointer type mismatch in container_of()"); \
94 ((type *)(__mptr - offsetof(type, member))); \
95 })
96 #endif
97
98 /**
99 * Unreachable macro. Useful for suppressing "control reaches end of non-void
100 * function" warnings.
101 */
102 #if defined(HAVE___BUILTIN_UNREACHABLE) || __has_builtin(__builtin_unreachable)
103 #define unreachable(str) \
104 do { \
105 assert(!str); \
106 __builtin_unreachable(); \
107 } while (0)
108 #elif defined (_MSC_VER)
109 #define unreachable(str) \
110 do { \
111 assert(!str); \
112 __assume(0); \
113 } while (0)
114 #else
115 #define unreachable(str) assert(!str)
116 #endif
117
118 /**
119 * Assume macro. Useful for expressing our assumptions to the compiler,
120 * typically for purposes of silencing warnings.
121 */
122 #if __has_builtin(__builtin_assume)
123 #define assume(expr) \
124 do { \
125 assert(expr); \
126 __builtin_assume(expr); \
127 } while (0)
128 #elif defined HAVE___BUILTIN_UNREACHABLE
129 #define assume(expr) ((expr) ? ((void) 0) \
130 : (assert(!"assumption failed"), \
131 __builtin_unreachable()))
132 #elif defined (_MSC_VER)
133 #define assume(expr) __assume(expr)
134 #else
135 #define assume(expr) assert(expr)
136 #endif
137
138 /* Attribute const is used for functions that have no effects other than their
139 * return value, and only rely on the argument values to compute the return
140 * value. As a result, calls to it can be CSEed. Note that using memory
141 * pointed to by the arguments is not allowed for const functions.
142 */
143 #if !defined(__clang__) && defined(HAVE_FUNC_ATTRIBUTE_CONST)
144 #define ATTRIBUTE_CONST __attribute__((__const__))
145 #else
146 #define ATTRIBUTE_CONST
147 #endif
148
149 #ifdef HAVE_FUNC_ATTRIBUTE_FLATTEN
150 #define FLATTEN __attribute__((__flatten__))
151 #else
152 #define FLATTEN
153 #endif
154
155 #ifdef HAVE_FUNC_ATTRIBUTE_FORMAT
156 #if defined (__MINGW_PRINTF_FORMAT)
157 # define PRINTFLIKE(f, a) __attribute__ ((format(__MINGW_PRINTF_FORMAT, f, a)))
158 #else
159 # define PRINTFLIKE(f, a) __attribute__ ((format(__printf__, f, a)))
160 #endif
161 #else
162 #define PRINTFLIKE(f, a)
163 #endif
164
165 #ifdef HAVE_FUNC_ATTRIBUTE_MALLOC
166 #define MALLOCLIKE __attribute__((__malloc__))
167 #else
168 #define MALLOCLIKE
169 #endif
170
171 /* Forced function inlining */
172 /* Note: Clang also sets __GNUC__ (see other cases below) */
173 #ifndef ALWAYS_INLINE
174 # if defined(__GNUC__)
175 # define ALWAYS_INLINE inline __attribute__((always_inline))
176 # elif defined(_MSC_VER)
177 # define ALWAYS_INLINE __forceinline
178 # else
179 # define ALWAYS_INLINE inline
180 # endif
181 #endif
182
183 /* Used to optionally mark structures with misaligned elements or size as
184 * packed, to trade off performance for space.
185 */
186 #ifdef HAVE_FUNC_ATTRIBUTE_PACKED
187 #define PACKED __attribute__((__packed__))
188 #else
189 #define PACKED
190 #endif
191
192 /* Attribute pure is used for functions that have no effects other than their
193 * return value. As a result, calls to it can be dead code eliminated.
194 */
195 #ifdef HAVE_FUNC_ATTRIBUTE_PURE
196 #define ATTRIBUTE_PURE __attribute__((__pure__))
197 #else
198 #define ATTRIBUTE_PURE
199 #endif
200
201 #ifdef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL
202 #define ATTRIBUTE_RETURNS_NONNULL __attribute__((__returns_nonnull__))
203 #else
204 #define ATTRIBUTE_RETURNS_NONNULL
205 #endif
206
207 #ifndef NORETURN
208 # ifdef _MSC_VER
209 # define NORETURN __declspec(noreturn)
210 # elif defined HAVE_FUNC_ATTRIBUTE_NORETURN
211 # define NORETURN __attribute__((__noreturn__))
212 # else
213 # define NORETURN
214 # endif
215 #endif
216
217 #ifdef _MSC_VER
218 #define ALIGN16 __declspec(align(16))
219 #else
220 #define ALIGN16 __attribute__((aligned(16)))
221 #endif
222
223 #ifdef __cplusplus
224 /**
225 * Macro function that evaluates to true if T is a trivially
226 * destructible type -- that is, if its (non-virtual) destructor
227 * performs no action and all member variables and base classes are
228 * trivially destructible themselves.
229 */
230 # if (defined(__clang__) && defined(__has_feature))
231 # if __has_feature(has_trivial_destructor)
232 # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
233 # endif
234 # elif defined(__GNUC__)
235 # if ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
236 # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
237 # endif
238 # elif defined(_MSC_VER) && !defined(__INTEL_COMPILER)
239 # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
240 # endif
241 # ifndef HAS_TRIVIAL_DESTRUCTOR
242 /* It's always safe (if inefficient) to assume that a
243 * destructor is non-trivial.
244 */
245 # define HAS_TRIVIAL_DESTRUCTOR(T) (false)
246 # endif
247 #endif
248
249 /**
250 * PUBLIC/USED macros
251 *
252 * If we build the library with gcc's -fvisibility=hidden flag, we'll
253 * use the PUBLIC macro to mark functions that are to be exported.
254 *
255 * We also need to define a USED attribute, so the optimizer doesn't
256 * inline a static function that we later use in an alias. - ajax
257 */
258 #ifndef PUBLIC
259 # if defined(_WIN32)
260 # define PUBLIC __declspec(dllexport)
261 # define USED
262 # elif defined(__GNUC__)
263 # define PUBLIC __attribute__((visibility("default")))
264 # define USED __attribute__((used))
265 # else
266 # define PUBLIC
267 # define USED
268 # endif
269 #endif
270
271 /**
272 * UNUSED marks variables (or sometimes functions) that have to be defined,
273 * but are sometimes (or always) unused beyond that. A common case is for
274 * a function parameter to be used in some build configurations but not others.
275 * Another case is fallback vfuncs that don't do anything with their params.
276 *
277 * Note that this should not be used for identifiers used in `assert()`;
278 * see ASSERTED below.
279 */
280 #ifdef HAVE_FUNC_ATTRIBUTE_UNUSED
281 #define UNUSED __attribute__((unused))
282 #elif defined (_MSC_VER)
283 #define UNUSED __pragma(warning(suppress:4100 4101))
284 #else
285 #define UNUSED
286 #endif
287
288 /**
289 * Use ASSERTED to indicate that an identifier is unused outside of an `assert()`,
290 * so that assert-free builds don't get "unused variable" warnings.
291 */
292 #ifdef NDEBUG
293 #define ASSERTED UNUSED
294 #else
295 #define ASSERTED
296 #endif
297
298 #ifdef HAVE_FUNC_ATTRIBUTE_WARN_UNUSED_RESULT
299 #define MUST_CHECK __attribute__((warn_unused_result))
300 #else
301 #define MUST_CHECK
302 #endif
303
304 #if defined(__GNUC__)
305 #define ATTRIBUTE_NOINLINE __attribute__((noinline))
306 #elif defined(_MSC_VER)
307 #define ATTRIBUTE_NOINLINE __declspec(noinline)
308 #else
309 #define ATTRIBUTE_NOINLINE
310 #endif
311
312 /* Use as: enum name { X, Y } ENUM_PACKED; */
313 #if defined(__GNUC__)
314 #define ENUM_PACKED __attribute__((packed))
315 #else
316 #define ENUM_PACKED
317 #endif
318
319
320 /**
321 * Check that STRUCT::FIELD can hold MAXVAL. We use a lot of bitfields
322 * in Mesa/gallium. We have to be sure they're of sufficient size to
323 * hold the largest expected value.
324 * Note that with MSVC, enums are signed and enum bitfields need one extra
325 * high bit (always zero) to ensure the max value is handled correctly.
326 * This macro will detect that with MSVC, but not GCC.
327 */
328 #define ASSERT_BITFIELD_SIZE(STRUCT, FIELD, MAXVAL) \
329 do { \
330 ASSERTED STRUCT s; \
331 s.FIELD = (MAXVAL); \
332 assert((int) s.FIELD == (MAXVAL) && "Insufficient bitfield size!"); \
333 } while (0)
334
335
336 /** Compute ceiling of integer quotient of A divided by B. */
337 #define DIV_ROUND_UP( A, B ) ( ((A) + (B) - 1) / (B) )
338
339 /** Clamp X to [MIN,MAX]. Turn NaN into MIN, arbitrarily. */
340 #define CLAMP( X, MIN, MAX ) ( (X)>(MIN) ? ((X)>(MAX) ? (MAX) : (X)) : (MIN) )
341
342 /* Syntax sugar occuring frequently in graphics code */
343 #define SATURATE( X ) CLAMP(X, 0.0f, 1.0f)
344
345 /** Minimum of two values: */
346 #define MIN2( A, B ) ( (A)<(B) ? (A) : (B) )
347
348 /** Maximum of two values: */
349 #define MAX2( A, B ) ( (A)>(B) ? (A) : (B) )
350
351 /** Minimum and maximum of three values: */
352 #define MIN3( A, B, C ) ((A) < (B) ? MIN2(A, C) : MIN2(B, C))
353 #define MAX3( A, B, C ) ((A) > (B) ? MAX2(A, C) : MAX2(B, C))
354
355 /** Align a value to a power of two */
356 #define ALIGN_POT(x, pot_align) (((x) + (pot_align) - 1) & ~((pot_align) - 1))
357
358 /** Checks is a value is a power of two. Does not handle zero. */
359 #define IS_POT(v) (((v) & ((v) - 1)) == 0)
360
361 /**
362 * Macro for declaring an explicit conversion operator. Defaults to an
363 * implicit conversion if C++11 is not supported.
364 */
365 #if __cplusplus >= 201103L
366 #define EXPLICIT_CONVERSION explicit
367 #elif defined(__cplusplus)
368 #define EXPLICIT_CONVERSION
369 #endif
370
371 /** Set a single bit */
372 #define BITFIELD_BIT(b) (1u << (b))
373 /** Set all bits up to excluding bit b */
374 #define BITFIELD_MASK(b) \
375 ((b) == 32 ? (~0u) : BITFIELD_BIT((b) % 32) - 1)
376 /** Set count bits starting from bit b */
377 #define BITFIELD_RANGE(b, count) \
378 (BITFIELD_MASK((b) + (count)) & ~BITFIELD_MASK(b))
379
380 /** Set a single bit */
381 #define BITFIELD64_BIT(b) (1ull << (b))
382 /** Set all bits up to excluding bit b */
383 #define BITFIELD64_MASK(b) \
384 ((b) == 64 ? (~0ull) : BITFIELD64_BIT(b) - 1)
385 /** Set count bits starting from bit b */
386 #define BITFIELD64_RANGE(b, count) \
387 (BITFIELD64_MASK((b) + (count)) & ~BITFIELD64_MASK(b))
388
389 static inline int64_t
u_intN_max(unsigned bit_size)390 u_intN_max(unsigned bit_size)
391 {
392 assert(bit_size <= 64 && bit_size > 0);
393 return INT64_MAX >> (64 - bit_size);
394 }
395
396 static inline int64_t
u_intN_min(unsigned bit_size)397 u_intN_min(unsigned bit_size)
398 {
399 /* On 2's compliment platforms, which is every platform Mesa is likely to
400 * every worry about, stdint.h generally calculated INT##_MIN in this
401 * manner.
402 */
403 return (-u_intN_max(bit_size)) - 1;
404 }
405
406 static inline uint64_t
u_uintN_max(unsigned bit_size)407 u_uintN_max(unsigned bit_size)
408 {
409 assert(bit_size <= 64 && bit_size > 0);
410 return UINT64_MAX >> (64 - bit_size);
411 }
412
413 #ifndef __cplusplus
414 #ifdef _MSC_VER
415 #define alignof _Alignof
416 #define alignas _Alignas
417 #else
418 #include <stdalign.h>
419 #endif
420 #endif
421
422 /* Macros for static type-safety checking.
423 *
424 * https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
425 */
426
427 #if __has_attribute(capability)
428 typedef int __attribute__((capability("mutex"))) lock_cap_t;
429
430 #define guarded_by(l) __attribute__((guarded_by(l)))
431 #define acquire_cap(l) __attribute((acquire_capability(l), no_thread_safety_analysis))
432 #define release_cap(l) __attribute((release_capability(l), no_thread_safety_analysis))
433 #define assert_cap(l) __attribute((assert_capability(l), no_thread_safety_analysis))
434 #define requires_cap(l) __attribute((requires_capability(l)))
435 #define disable_thread_safety_analysis __attribute((no_thread_safety_analysis))
436
437 #else
438
439 typedef int lock_cap_t;
440
441 #define guarded_by(l)
442 #define acquire_cap(l)
443 #define release_cap(l)
444 #define assert_cap(l)
445 #define requires_cap(l)
446 #define disable_thread_safety_analysis
447
448 #endif
449
450 /* TODO: this could be different on non-x86 architectures. */
451 #define CACHE_LINE_SIZE 64
452
453 #define DO_PRAGMA(X) _Pragma (#X)
454
455 #if defined(__clang__)
456 #define PRAGMA_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
457 #define PRAGMA_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
458 #define PRAGMA_DIAGNOSTIC_ERROR(X) DO_PRAGMA( clang diagnostic error #X )
459 #define PRAGMA_DIAGNOSTIC_WARNING(X) DO_PRAGMA( clang diagnostic warning #X )
460 #define PRAGMA_DIAGNOSTIC_IGNORED(X) DO_PRAGMA( clang diagnostic ignored #X )
461 #elif defined(__GNUC__)
462 #define PRAGMA_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
463 #define PRAGMA_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
464 #define PRAGMA_DIAGNOSTIC_ERROR(X) DO_PRAGMA( GCC diagnostic error #X )
465 #define PRAGMA_DIAGNOSTIC_WARNING(X) DO_PRAGMA( GCC diagnostic warning #X )
466 #define PRAGMA_DIAGNOSTIC_IGNORED(X) DO_PRAGMA( GCC diagnostic ignored #X )
467 #else
468 #define PRAGMA_DIAGNOSTIC_PUSH
469 #define PRAGMA_DIAGNOSTIC_POP
470 #define PRAGMA_DIAGNOSTIC_ERROR(X)
471 #define PRAGMA_DIAGNOSTIC_WARNING(X)
472 #define PRAGMA_DIAGNOSTIC_IGNORED(X)
473 #endif
474
475 #endif /* UTIL_MACROS_H */
476