/* * Copyright © 2014 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #ifndef UTIL_MACROS_H #define UTIL_MACROS_H #include #include "c99_compat.h" #include "c11_compat.h" /* Compute the size of an array */ #ifndef ARRAY_SIZE # define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #endif /* For compatibility with Clang's __has_builtin() */ #ifndef __has_builtin # define __has_builtin(x) 0 #endif /** * __builtin_expect macros */ #if !defined(HAVE___BUILTIN_EXPECT) # define __builtin_expect(x, y) (x) #endif #ifndef likely # ifdef HAVE___BUILTIN_EXPECT # define likely(x) __builtin_expect(!!(x), 1) # define unlikely(x) __builtin_expect(!!(x), 0) # else # define likely(x) (x) # define unlikely(x) (x) # endif #endif /** * Static (compile-time) assertion. * Basically, use COND to dimension an array. If COND is false/zero the * array size will be -1 and we'll get a compilation error. */ #define STATIC_ASSERT(COND) \ do { \ (void) sizeof(char [1 - 2*!(COND)]); \ } while (0) /** * Unreachable macro. Useful for suppressing "control reaches end of non-void * function" warnings. */ #ifdef HAVE___BUILTIN_UNREACHABLE #define unreachable(str) \ do { \ assert(!str); \ __builtin_unreachable(); \ } while (0) #elif defined (_MSC_VER) #define unreachable(str) \ do { \ assert(!str); \ __assume(0); \ } while (0) #else #define unreachable(str) assert(!str) #endif /** * Assume macro. Useful for expressing our assumptions to the compiler, * typically for purposes of silencing warnings. */ #if __has_builtin(__builtin_assume) #define assume(expr) \ do { \ assert(expr); \ __builtin_assume(expr); \ } while (0) #elif defined HAVE___BUILTIN_UNREACHABLE #define assume(expr) ((expr) ? ((void) 0) \ : (assert(!"assumption failed"), \ __builtin_unreachable())) #elif defined (_MSC_VER) #define assume(expr) __assume(expr) #else #define assume(expr) assert(expr) #endif /* Attribute const is used for functions that have no effects other than their * return value, and only rely on the argument values to compute the return * value. As a result, calls to it can be CSEed. Note that using memory * pointed to by the arguments is not allowed for const functions. */ #ifdef HAVE_FUNC_ATTRIBUTE_CONST #define ATTRIBUTE_CONST __attribute__((__const__)) #else #define ATTRIBUTE_CONST #endif #ifdef HAVE_FUNC_ATTRIBUTE_FLATTEN #define FLATTEN __attribute__((__flatten__)) #else #define FLATTEN #endif #ifdef HAVE_FUNC_ATTRIBUTE_FORMAT #define PRINTFLIKE(f, a) __attribute__ ((format(__printf__, f, a))) #else #define PRINTFLIKE(f, a) #endif #ifdef HAVE_FUNC_ATTRIBUTE_MALLOC #define MALLOCLIKE __attribute__((__malloc__)) #else #define MALLOCLIKE #endif /* Forced function inlining */ /* Note: Clang also sets __GNUC__ (see other cases below) */ #ifndef ALWAYS_INLINE # if defined(__GNUC__) # define ALWAYS_INLINE inline __attribute__((always_inline)) # elif defined(_MSC_VER) # define ALWAYS_INLINE __forceinline # else # define ALWAYS_INLINE inline # endif #endif /* Used to optionally mark structures with misaligned elements or size as * packed, to trade off performance for space. */ #ifdef HAVE_FUNC_ATTRIBUTE_PACKED #define PACKED __attribute__((__packed__)) #else #define PACKED #endif /* Attribute pure is used for functions that have no effects other than their * return value. As a result, calls to it can be dead code eliminated. */ #ifdef HAVE_FUNC_ATTRIBUTE_PURE #define ATTRIBUTE_PURE __attribute__((__pure__)) #else #define ATTRIBUTE_PURE #endif #ifdef HAVE_FUNC_ATTRIBUTE_RETURNS_NONNULL #define ATTRIBUTE_RETURNS_NONNULL __attribute__((__returns_nonnull__)) #else #define ATTRIBUTE_RETURNS_NONNULL #endif #ifndef NORETURN # ifdef _MSC_VER # define NORETURN __declspec(noreturn) # elif defined HAVE_FUNC_ATTRIBUTE_NORETURN # define NORETURN __attribute__((__noreturn__)) # else # define NORETURN # endif #endif #ifdef __cplusplus /** * Macro function that evaluates to true if T is a trivially * destructible type -- that is, if its (non-virtual) destructor * performs no action and all member variables and base classes are * trivially destructible themselves. */ # if (defined(__clang__) && defined(__has_feature)) # if __has_feature(has_trivial_destructor) # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) # endif # elif defined(__GNUC__) # if ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))) # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) # endif # elif defined(_MSC_VER) && !defined(__INTEL_COMPILER) # define HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T) # endif # ifndef HAS_TRIVIAL_DESTRUCTOR /* It's always safe (if inefficient) to assume that a * destructor is non-trivial. */ # define HAS_TRIVIAL_DESTRUCTOR(T) (false) # endif #endif /** * PUBLIC/USED macros * * If we build the library with gcc's -fvisibility=hidden flag, we'll * use the PUBLIC macro to mark functions that are to be exported. * * We also need to define a USED attribute, so the optimizer doesn't * inline a static function that we later use in an alias. - ajax */ #ifndef PUBLIC # if defined(__GNUC__) # define PUBLIC __attribute__((visibility("default"))) # define USED __attribute__((used)) # elif defined(_MSC_VER) # define PUBLIC __declspec(dllexport) # define USED # else # define PUBLIC # define USED # endif #endif /** * UNUSED marks variables (or sometimes functions) that have to be defined, * but are sometimes (or always) unused beyond that. A common case is for * a function parameter to be used in some build configurations but not others. * Another case is fallback vfuncs that don't do anything with their params. * * Note that this should not be used for identifiers used in `assert()`; * see ASSERTED below. */ #ifdef HAVE_FUNC_ATTRIBUTE_UNUSED #define UNUSED __attribute__((unused)) #else #define UNUSED #endif /** * Use ASSERTED to indicate that an identifier is unused outside of an `assert()`, * so that assert-free builds don't get "unused variable" warnings. */ #ifdef NDEBUG #define ASSERTED UNUSED #else #define ASSERTED #endif #ifdef HAVE_FUNC_ATTRIBUTE_WARN_UNUSED_RESULT #define MUST_CHECK __attribute__((warn_unused_result)) #else #define MUST_CHECK #endif #if defined(__GNUC__) #define ATTRIBUTE_NOINLINE __attribute__((noinline)) #else #define ATTRIBUTE_NOINLINE #endif /** * Check that STRUCT::FIELD can hold MAXVAL. We use a lot of bitfields * in Mesa/gallium. We have to be sure they're of sufficient size to * hold the largest expected value. * Note that with MSVC, enums are signed and enum bitfields need one extra * high bit (always zero) to ensure the max value is handled correctly. * This macro will detect that with MSVC, but not GCC. */ #define ASSERT_BITFIELD_SIZE(STRUCT, FIELD, MAXVAL) \ do { \ ASSERTED STRUCT s; \ s.FIELD = (MAXVAL); \ assert((int) s.FIELD == (MAXVAL) && "Insufficient bitfield size!"); \ } while (0) /** Compute ceiling of integer quotient of A divided by B. */ #define DIV_ROUND_UP( A, B ) ( ((A) + (B) - 1) / (B) ) /** Clamp X to [MIN,MAX]. Turn NaN into MIN, arbitrarily. */ #define CLAMP( X, MIN, MAX ) ( (X)>(MIN) ? ((X)>(MAX) ? (MAX) : (X)) : (MIN) ) /** Minimum of two values: */ #define MIN2( A, B ) ( (A)<(B) ? (A) : (B) ) /** Maximum of two values: */ #define MAX2( A, B ) ( (A)>(B) ? (A) : (B) ) /** Minimum and maximum of three values: */ #define MIN3( A, B, C ) ((A) < (B) ? MIN2(A, C) : MIN2(B, C)) #define MAX3( A, B, C ) ((A) > (B) ? MAX2(A, C) : MAX2(B, C)) /** Align a value to a power of two */ #define ALIGN_POT(x, pot_align) (((x) + (pot_align) - 1) & ~((pot_align) - 1)) /** * Macro for declaring an explicit conversion operator. Defaults to an * implicit conversion if C++11 is not supported. */ #if __cplusplus >= 201103L #define EXPLICIT_CONVERSION explicit #elif defined(__cplusplus) #define EXPLICIT_CONVERSION #endif /** Set a single bit */ #define BITFIELD_BIT(b) (1u << (b)) /** Set all bits up to excluding bit b */ #define BITFIELD_MASK(b) \ ((b) == 32 ? (~0u) : BITFIELD_BIT((b) % 32) - 1) /** Set count bits starting from bit b */ #define BITFIELD_RANGE(b, count) \ (BITFIELD_MASK((b) + (count)) & ~BITFIELD_MASK(b)) /** Set a single bit */ #define BITFIELD64_BIT(b) (1ull << (b)) /** Set all bits up to excluding bit b */ #define BITFIELD64_MASK(b) \ ((b) == 64 ? (~0ull) : BITFIELD64_BIT(b) - 1) /** Set count bits starting from bit b */ #define BITFIELD64_RANGE(b, count) \ (BITFIELD64_MASK((b) + (count)) & ~BITFIELD64_MASK(b)) #endif /* UTIL_MACROS_H */