upstream_utils/llvm_patches/0006-ifdef-guard-safety.patch

From 008e921f77933f475174d74a6b70309c6fbe0771 Mon Sep 17 00:00:00 2001
From: PJ Reiniger <pj.reiniger@gmail.com>
Date: Sat, 7 May 2022 22:28:13 -0400
Subject: [PATCH 06/28] \#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 | 50 ++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/llvm/include/llvm/Support/Compiler.h b/llvm/include/llvm/Support/Compiler.h
index ede1cb172..8b8260b50 100644
--- a/llvm/include/llvm/Support/Compiler.h
+++ b/llvm/include/llvm/Support/Compiler.h
@@ -86,6 +86,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))
 
@@ -99,6 +100,7 @@
 #else
 #define LLVM_MSC_PREREQ(version) 0
 #endif
+#endif
 
 /// Does the compiler support ref-qualifiers for *this?
 ///
@@ -112,11 +114,13 @@
 ///
 /// This can be used to provide lvalue/rvalue overrides of member functions.
 /// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
+#ifndef LLVM_LVALUE_FUNCTION
 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 #define LLVM_LVALUE_FUNCTION &
 #else
 #define LLVM_LVALUE_FUNCTION
 #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
@@ -140,21 +144,26 @@
 #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
 
 /// LLVM_NODISCARD - Warn if a type or return value is discarded.
 
 // Use the 'nodiscard' attribute in C++17 or newer mode.
+#ifndef LLVM_NODISCARD
 #if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
 #define LLVM_NODISCARD [[nodiscard]]
 #elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
@@ -168,6 +177,7 @@
 #else
 #define LLVM_NODISCARD
 #endif
+#endif
 
 // Indicate that a non-static, non-const C++ member function reinitializes
 // the entire object to a known state, independent of the previous state of
@@ -190,11 +200,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__) &&  \
@@ -204,6 +216,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__)
@@ -212,13 +225,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))
@@ -226,6 +242,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)
@@ -233,9 +250,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)
@@ -243,9 +262,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)
@@ -253,6 +274,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
@@ -263,6 +285,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)
@@ -270,9 +293,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)
@@ -280,8 +305,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)
@@ -293,6 +320,7 @@
 #else
 #define LLVM_FALLTHROUGH
 #endif
+#endif
 
 /// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
 /// they are constant initialized.
@@ -321,20 +349,25 @@
 
 /// 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_ATTRIBUTE_DEPRECATED(decl, "message")
 // This macro will be removed.
 // Use C++14's attribute instead: [[deprecated("message")]]
+#ifndef LLVM_ATTRIBUTE_DEPRECATED
 #define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl
+#endif
 
 /// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
 /// to an expression which states that it is undefined behavior for the
 /// compiler to reach this point.  Otherwise is not defined.
+#ifndef LLVM_BUILTIN_UNREACHABLE
 #if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
 # define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
 #elif defined(_MSC_VER)
@@ -342,9 +375,11 @@
 #else
 # define LLVM_BUILTIN_UNREACHABLE
 #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)
@@ -356,10 +391,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)
@@ -373,9 +410,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)
@@ -384,6 +423,7 @@
 #else
 # define LLVM_ASSUME_ALIGNED(p, a) (p)
 #endif
+#endif
 
 /// \macro LLVM_PACKED
 /// Used to specify a packed structure.
@@ -403,6 +443,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))
@@ -412,11 +453,13 @@
 # define LLVM_PACKED_START _Pragma("pack(push, 1)")
 # define LLVM_PACKED_END   _Pragma("pack(pop)")
 #endif
+#endif
 
 /// \macro LLVM_PTR_SIZE
 /// A constant integer equivalent to the value of sizeof(void*).
 /// Generally used in combination with alignas or when doing computation in the
 /// preprocessor.
+#ifndef LLVM_PTR_SIZE
 #ifdef __SIZEOF_POINTER__
 # define LLVM_PTR_SIZE __SIZEOF_POINTER__
 #elif defined(_WIN64)
@@ -428,6 +471,7 @@
 #else
 # define LLVM_PTR_SIZE sizeof(void *)
 #endif
+#endif
 
 /// \macro LLVM_MEMORY_SANITIZER_BUILD
 /// Whether LLVM itself is built with MemorySanitizer instrumentation.
@@ -498,11 +542,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.
@@ -510,17 +556,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__)
@@ -528,6 +577,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,