From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: PJ Reiniger Date: Sat, 7 May 2022 22:28:13 -0400 Subject: [PATCH 06/30] \#ifdef guard safety Prevents redefinition if someone is pulling in real LLVM, since the macros are in global namespace --- llvm/include/llvm/Support/Compiler.h | 42 ++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/llvm/include/llvm/Support/Compiler.h b/llvm/include/llvm/Support/Compiler.h index ef9c0d1a73aec870b924faace3b4a32b187e197f..53c272034ae8f735d02556ced5bae93a1c8644c4 100644 --- a/llvm/include/llvm/Support/Compiler.h +++ b/llvm/include/llvm/Support/Compiler.h @@ -90,6 +90,7 @@ /// * 1928: VS2019, version 16.8 + 16.9 /// * 1929: VS2019, version 16.10 + 16.11 /// * 1930: VS2022, version 17.0 +#ifndef LLVM_MSC_PREREQ #ifdef _MSC_VER #define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version)) @@ -103,6 +104,7 @@ #else #define LLVM_MSC_PREREQ(version) 0 #endif +#endif /// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked /// into a shared library, then the class should be private to the library and @@ -127,17 +129,21 @@ #define LLVM_EXTERNAL_VISIBILITY #endif +#ifndef LLVM_PREFETCH #if defined(__GNUC__) #define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality) #else #define LLVM_PREFETCH(addr, rw, locality) #endif +#endif +#ifndef LLVM_ATTRIBUTE_USED #if __has_attribute(used) #define LLVM_ATTRIBUTE_USED __attribute__((__used__)) #else #define LLVM_ATTRIBUTE_USED #endif +#endif #if defined(__clang__) #define LLVM_DEPRECATED(MSG, FIX) __attribute__((deprecated(MSG, FIX))) @@ -166,11 +172,13 @@ // more portable solution: // (void)unused_var_name; // Prefer cast-to-void wherever it is sufficient. +#ifndef LLVM_ATTRIBUTE_UNUSED #if __has_attribute(unused) #define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__)) #else #define LLVM_ATTRIBUTE_UNUSED #endif +#endif // FIXME: Provide this for PE/COFF targets. #if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) && \ @@ -180,6 +188,7 @@ #define LLVM_ATTRIBUTE_WEAK #endif +#ifndef LLVM_READNONE // Prior to clang 3.2, clang did not accept any spelling of // __has_attribute(const), so assume it is supported. #if defined(__clang__) || defined(__GNUC__) @@ -188,13 +197,16 @@ #else #define LLVM_READNONE #endif +#endif +#ifndef LLVM_READONLY #if __has_attribute(pure) || defined(__GNUC__) // aka 'PURE' but following LLVM Conventions. #define LLVM_READONLY __attribute__((__pure__)) #else #define LLVM_READONLY #endif +#endif #if __has_attribute(minsize) #define LLVM_ATTRIBUTE_MINSIZE __attribute__((minsize)) @@ -202,6 +214,7 @@ #define LLVM_ATTRIBUTE_MINSIZE #endif +#ifndef LLVM_LIKELY #if __has_builtin(__builtin_expect) || defined(__GNUC__) #define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true) #define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false) @@ -209,9 +222,11 @@ #define LLVM_LIKELY(EXPR) (EXPR) #define LLVM_UNLIKELY(EXPR) (EXPR) #endif +#endif /// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, /// mark a method "not for inlining". +#ifndef LLVM_ATTRIBUTE_NOINLINE #if __has_attribute(noinline) #define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline)) #elif defined(_MSC_VER) @@ -219,9 +234,11 @@ #else #define LLVM_ATTRIBUTE_NOINLINE #endif +#endif /// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do /// so, mark a method "always inline" because it is performance sensitive. +#ifndef LLVM_ATTRIBUTE_ALWAYS_INLINE #if __has_attribute(always_inline) #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline)) #elif defined(_MSC_VER) @@ -229,6 +246,7 @@ #else #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline #endif +#endif /// LLVM_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do /// so, mark a method "no debug" because debug info makes the debugger @@ -239,6 +257,7 @@ #define LLVM_ATTRIBUTE_NODEBUG #endif +#ifndef LLVM_ATTRIBUTE_RETURNS_NONNULL #if __has_attribute(returns_nonnull) #define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull)) #elif defined(_MSC_VER) @@ -246,9 +265,11 @@ #else #define LLVM_ATTRIBUTE_RETURNS_NONNULL #endif +#endif /// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a /// pointer that does not alias any other valid pointer. +#ifndef LLVM_ATTRIBUTE_RETURNS_NOALIAS #ifdef __GNUC__ #define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__)) #elif defined(_MSC_VER) @@ -256,8 +277,10 @@ #else #define LLVM_ATTRIBUTE_RETURNS_NOALIAS #endif +#endif /// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements. +#ifndef LLVM_FALLTHROUGH #if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough) #define LLVM_FALLTHROUGH [[fallthrough]] #elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough) @@ -269,6 +292,7 @@ #else #define LLVM_FALLTHROUGH #endif +#endif /// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that /// they are constant initialized. @@ -297,11 +321,13 @@ /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress /// pedantic diagnostics. +#ifndef LLVM_EXTENSION #ifdef __GNUC__ #define LLVM_EXTENSION __extension__ #else #define LLVM_EXTENSION #endif +#endif /// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands /// to an expression which states that it is undefined behavior for the @@ -310,14 +336,17 @@ /// '#else' is intentionally left out so that other macro logic (e.g., /// LLVM_ASSUME_ALIGNED and llvm_unreachable()) can detect whether /// LLVM_BUILTIN_UNREACHABLE has a definition. +#ifndef LLVM_BUILTIN_UNREACHABLE #if __has_builtin(__builtin_unreachable) || defined(__GNUC__) # define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable() #elif defined(_MSC_VER) # define LLVM_BUILTIN_UNREACHABLE __assume(false) #endif +#endif /// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression /// which causes the program to exit abnormally. +#ifndef LLVM_BUILTIN_TRAP #if __has_builtin(__builtin_trap) || defined(__GNUC__) # define LLVM_BUILTIN_TRAP __builtin_trap() #elif defined(_MSC_VER) @@ -329,10 +358,12 @@ #else # define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0 #endif +#endif /// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to /// an expression which causes the program to break while running /// under a debugger. +#ifndef LLVM_BUILTIN_DEBUGTRAP #if __has_builtin(__builtin_debugtrap) # define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap() #elif defined(_MSC_VER) @@ -346,9 +377,11 @@ // program to abort if encountered. # define LLVM_BUILTIN_DEBUGTRAP #endif +#endif /// \macro LLVM_ASSUME_ALIGNED /// Returns a pointer with an assumed alignment. +#ifndef LLVM_ASSUME_ALIGNED #if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__) # define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a) #elif defined(LLVM_BUILTIN_UNREACHABLE) @@ -357,6 +390,7 @@ #else # define LLVM_ASSUME_ALIGNED(p, a) (p) #endif +#endif /// \macro LLVM_PACKED /// Used to specify a packed structure. @@ -376,6 +410,7 @@ /// long long l; /// }; /// LLVM_PACKED_END +#ifndef LLVM_PACKED #ifdef _MSC_VER # define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop)) # define LLVM_PACKED_START __pragma(pack(push, 1)) @@ -385,6 +420,7 @@ # define LLVM_PACKED_START _Pragma("pack(push, 1)") # define LLVM_PACKED_END _Pragma("pack(pop)") #endif +#endif /// \macro LLVM_MEMORY_SANITIZER_BUILD /// Whether LLVM itself is built with MemorySanitizer instrumentation. @@ -476,11 +512,13 @@ void AnnotateIgnoreWritesEnd(const char *file, int line); /// \macro LLVM_NO_SANITIZE /// Disable a particular sanitizer for a function. +#ifndef LLVM_NO_SANITIZE #if __has_attribute(no_sanitize) #define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND))) #else #define LLVM_NO_SANITIZE(KIND) #endif +#endif /// Mark debug helper function definitions like dump() that should not be /// stripped from debug builds. @@ -488,17 +526,20 @@ void AnnotateIgnoreWritesEnd(const char *file, int line); /// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always /// get stripped in release builds. // FIXME: Move this to a private config.h as it's not usable in public headers. +#ifndef LLVM_DUMP_METHOD #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED #else #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE #endif +#endif /// \macro LLVM_PRETTY_FUNCTION /// Gets a user-friendly looking function signature for the current scope /// using the best available method on each platform. The exact format of the /// resulting string is implementation specific and non-portable, so this should /// only be used, for example, for logging or diagnostics. +#ifndef LLVM_PRETTY_FUNCTION #if defined(_MSC_VER) #define LLVM_PRETTY_FUNCTION __FUNCSIG__ #elif defined(__GNUC__) || defined(__clang__) @@ -506,6 +547,7 @@ void AnnotateIgnoreWritesEnd(const char *file, int line); #else #define LLVM_PRETTY_FUNCTION __func__ #endif +#endif /// \macro LLVM_THREAD_LOCAL /// A thread-local storage specifier which can be used with globals,