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