Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file defines several macros, based on the current compiler.  This allows
  10. // use of compiler-specific features in a way that remains portable. This header
  11. // can be included from either C or C++.
  12. //
  13. //===----------------------------------------------------------------------===//
  14.  
  15. #ifndef LLVM_SUPPORT_COMPILER_H
  16. #define LLVM_SUPPORT_COMPILER_H
  17.  
  18. #include "llvm/Config/llvm-config.h"
  19.  
  20. #include <stddef.h>
  21.  
  22. #if defined(_MSC_VER)
  23. #include <sal.h>
  24. #endif
  25.  
  26. #ifndef __has_feature
  27. # define __has_feature(x) 0
  28. #endif
  29.  
  30. #ifndef __has_extension
  31. # define __has_extension(x) 0
  32. #endif
  33.  
  34. #ifndef __has_attribute
  35. # define __has_attribute(x) 0
  36. #endif
  37.  
  38. #ifndef __has_builtin
  39. # define __has_builtin(x) 0
  40. #endif
  41.  
  42. #ifndef __has_include
  43. # define __has_include(x) 0
  44. #endif
  45.  
  46. // Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
  47. // C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
  48. #ifndef LLVM_HAS_CPP_ATTRIBUTE
  49. #if defined(__cplusplus) && defined(__has_cpp_attribute)
  50. # define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
  51. #else
  52. # define LLVM_HAS_CPP_ATTRIBUTE(x) 0
  53. #endif
  54. #endif
  55.  
  56. /// \macro LLVM_GNUC_PREREQ
  57. /// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
  58. /// available.
  59. #ifndef LLVM_GNUC_PREREQ
  60. # if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
  61. #  define LLVM_GNUC_PREREQ(maj, min, patch) \
  62.     ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
  63.      ((maj) << 20) + ((min) << 10) + (patch))
  64. # elif defined(__GNUC__) && defined(__GNUC_MINOR__)
  65. #  define LLVM_GNUC_PREREQ(maj, min, patch) \
  66.     ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
  67. # else
  68. #  define LLVM_GNUC_PREREQ(maj, min, patch) 0
  69. # endif
  70. #endif
  71.  
  72. /// \macro LLVM_MSC_PREREQ
  73. /// Is the compiler MSVC of at least the specified version?
  74. /// The common \param version values to check for are:
  75. /// * 1910: VS2017, version 15.1 & 15.2
  76. /// * 1911: VS2017, version 15.3 & 15.4
  77. /// * 1912: VS2017, version 15.5
  78. /// * 1913: VS2017, version 15.6
  79. /// * 1914: VS2017, version 15.7
  80. /// * 1915: VS2017, version 15.8
  81. /// * 1916: VS2017, version 15.9
  82. /// * 1920: VS2019, version 16.0
  83. /// * 1921: VS2019, version 16.1
  84. /// * 1922: VS2019, version 16.2
  85. /// * 1923: VS2019, version 16.3
  86. /// * 1924: VS2019, version 16.4
  87. /// * 1925: VS2019, version 16.5
  88. /// * 1926: VS2019, version 16.6
  89. /// * 1927: VS2019, version 16.7
  90. /// * 1928: VS2019, version 16.8 + 16.9
  91. /// * 1929: VS2019, version 16.10 + 16.11
  92. /// * 1930: VS2022, version 17.0
  93. #ifdef _MSC_VER
  94. #define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
  95.  
  96. // We require at least VS 2019.
  97. #if !defined(LLVM_FORCE_USE_OLD_TOOLCHAIN)
  98. #if !LLVM_MSC_PREREQ(1920)
  99. #error LLVM requires at least VS 2019.
  100. #endif
  101. #endif
  102.  
  103. #else
  104. #define LLVM_MSC_PREREQ(version) 0
  105. #endif
  106.  
  107. /// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
  108. /// into a shared library, then the class should be private to the library and
  109. /// not accessible from outside it.  Can also be used to mark variables and
  110. /// functions, making them private to any shared library they are linked into.
  111. /// On PE/COFF targets, library visibility is the default, so this isn't needed.
  112. ///
  113. /// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
  114. /// this attribute will be made public and visible outside of any shared library
  115. /// they are linked in to.
  116. #if __has_attribute(visibility) &&                                             \
  117.     (!(defined(_WIN32) || defined(__CYGWIN__)) ||                              \
  118.      (defined(__MINGW32__) && defined(__clang__)))
  119. #define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
  120. #if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
  121. #define LLVM_EXTERNAL_VISIBILITY __attribute__((visibility("default")))
  122. #else
  123. #define LLVM_EXTERNAL_VISIBILITY
  124. #endif
  125. #else
  126. #define LLVM_LIBRARY_VISIBILITY
  127. #define LLVM_EXTERNAL_VISIBILITY
  128. #endif
  129.  
  130. #if defined(__GNUC__)
  131. #define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
  132. #else
  133. #define LLVM_PREFETCH(addr, rw, locality)
  134. #endif
  135.  
  136. #if __has_attribute(used)
  137. #define LLVM_ATTRIBUTE_USED __attribute__((__used__))
  138. #else
  139. #define LLVM_ATTRIBUTE_USED
  140. #endif
  141.  
  142. #if defined(__clang__)
  143. #define LLVM_DEPRECATED(MSG, FIX) __attribute__((deprecated(MSG, FIX)))
  144. #else
  145. #define LLVM_DEPRECATED(MSG, FIX) [[deprecated(MSG)]]
  146. #endif
  147.  
  148. // Indicate that a non-static, non-const C++ member function reinitializes
  149. // the entire object to a known state, independent of the previous state of
  150. // the object.
  151. //
  152. // The clang-tidy check bugprone-use-after-move recognizes this attribute as a
  153. // marker that a moved-from object has left the indeterminate state and can be
  154. // reused.
  155. #if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
  156. #define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
  157. #else
  158. #define LLVM_ATTRIBUTE_REINITIALIZES
  159. #endif
  160.  
  161. // Some compilers warn about unused functions. When a function is sometimes
  162. // used or not depending on build settings (e.g. a function only called from
  163. // within "assert"), this attribute can be used to suppress such warnings.
  164. //
  165. // However, it shouldn't be used for unused *variables*, as those have a much
  166. // more portable solution:
  167. //   (void)unused_var_name;
  168. // Prefer cast-to-void wherever it is sufficient.
  169. #if __has_attribute(unused)
  170. #define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
  171. #else
  172. #define LLVM_ATTRIBUTE_UNUSED
  173. #endif
  174.  
  175. // FIXME: Provide this for PE/COFF targets.
  176. #if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) &&  \
  177.     !defined(_WIN32)
  178. #define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
  179. #else
  180. #define LLVM_ATTRIBUTE_WEAK
  181. #endif
  182.  
  183. // Prior to clang 3.2, clang did not accept any spelling of
  184. // __has_attribute(const), so assume it is supported.
  185. #if defined(__clang__) || defined(__GNUC__)
  186. // aka 'CONST' but following LLVM Conventions.
  187. #define LLVM_READNONE __attribute__((__const__))
  188. #else
  189. #define LLVM_READNONE
  190. #endif
  191.  
  192. #if __has_attribute(pure) || defined(__GNUC__)
  193. // aka 'PURE' but following LLVM Conventions.
  194. #define LLVM_READONLY __attribute__((__pure__))
  195. #else
  196. #define LLVM_READONLY
  197. #endif
  198.  
  199. #if __has_attribute(minsize)
  200. #define LLVM_ATTRIBUTE_MINSIZE __attribute__((minsize))
  201. #else
  202. #define LLVM_ATTRIBUTE_MINSIZE
  203. #endif
  204.  
  205. #if __has_builtin(__builtin_expect) || defined(__GNUC__)
  206. #define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
  207. #define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
  208. #else
  209. #define LLVM_LIKELY(EXPR) (EXPR)
  210. #define LLVM_UNLIKELY(EXPR) (EXPR)
  211. #endif
  212.  
  213. /// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
  214. /// mark a method "not for inlining".
  215. #if __has_attribute(noinline)
  216. #define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
  217. #elif defined(_MSC_VER)
  218. #define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
  219. #else
  220. #define LLVM_ATTRIBUTE_NOINLINE
  221. #endif
  222.  
  223. /// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
  224. /// so, mark a method "always inline" because it is performance sensitive.
  225. #if __has_attribute(always_inline)
  226. #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
  227. #elif defined(_MSC_VER)
  228. #define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
  229. #else
  230. #define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
  231. #endif
  232.  
  233. /// LLVM_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do
  234. /// so, mark a method "no debug" because debug info makes the debugger
  235. /// experience worse.
  236. #if __has_attribute(nodebug)
  237. #define LLVM_ATTRIBUTE_NODEBUG __attribute__((nodebug))
  238. #else
  239. #define LLVM_ATTRIBUTE_NODEBUG
  240. #endif
  241.  
  242. #if __has_attribute(returns_nonnull)
  243. #define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
  244. #elif defined(_MSC_VER)
  245. #define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
  246. #else
  247. #define LLVM_ATTRIBUTE_RETURNS_NONNULL
  248. #endif
  249.  
  250. /// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
  251. /// pointer that does not alias any other valid pointer.
  252. #ifdef __GNUC__
  253. #define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
  254. #elif defined(_MSC_VER)
  255. #define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
  256. #else
  257. #define LLVM_ATTRIBUTE_RETURNS_NOALIAS
  258. #endif
  259.  
  260. /// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
  261. #if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
  262. #define LLVM_FALLTHROUGH [[fallthrough]]
  263. #elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
  264. #define LLVM_FALLTHROUGH [[gnu::fallthrough]]
  265. #elif __has_attribute(fallthrough)
  266. #define LLVM_FALLTHROUGH __attribute__((fallthrough))
  267. #elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
  268. #define LLVM_FALLTHROUGH [[clang::fallthrough]]
  269. #else
  270. #define LLVM_FALLTHROUGH
  271. #endif
  272.  
  273. /// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
  274. /// they are constant initialized.
  275. #if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
  276. #define LLVM_REQUIRE_CONSTANT_INITIALIZATION                                   \
  277.   [[clang::require_constant_initialization]]
  278. #else
  279. #define LLVM_REQUIRE_CONSTANT_INITIALIZATION
  280. #endif
  281.  
  282. /// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable
  283. /// lifetime warnings.
  284. #if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner)
  285. #define LLVM_GSL_OWNER [[gsl::Owner]]
  286. #else
  287. #define LLVM_GSL_OWNER
  288. #endif
  289.  
  290. /// LLVM_GSL_POINTER - Apply this to non-owning classes like
  291. /// StringRef to enable lifetime warnings.
  292. #if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer)
  293. #define LLVM_GSL_POINTER [[gsl::Pointer]]
  294. #else
  295. #define LLVM_GSL_POINTER
  296. #endif
  297.  
  298. /// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
  299. /// pedantic diagnostics.
  300. #ifdef __GNUC__
  301. #define LLVM_EXTENSION __extension__
  302. #else
  303. #define LLVM_EXTENSION
  304. #endif
  305.  
  306. /// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
  307. /// to an expression which states that it is undefined behavior for the
  308. /// compiler to reach this point.  Otherwise is not defined.
  309. ///
  310. /// '#else' is intentionally left out so that other macro logic (e.g.,
  311. /// LLVM_ASSUME_ALIGNED and llvm_unreachable()) can detect whether
  312. /// LLVM_BUILTIN_UNREACHABLE has a definition.
  313. #if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
  314. # define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
  315. #elif defined(_MSC_VER)
  316. # define LLVM_BUILTIN_UNREACHABLE __assume(false)
  317. #endif
  318.  
  319. /// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
  320. /// which causes the program to exit abnormally.
  321. #if __has_builtin(__builtin_trap) || defined(__GNUC__)
  322. # define LLVM_BUILTIN_TRAP __builtin_trap()
  323. #elif defined(_MSC_VER)
  324. // The __debugbreak intrinsic is supported by MSVC, does not require forward
  325. // declarations involving platform-specific typedefs (unlike RaiseException),
  326. // results in a call to vectored exception handlers, and encodes to a short
  327. // instruction that still causes the trapping behavior we want.
  328. # define LLVM_BUILTIN_TRAP __debugbreak()
  329. #else
  330. # define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
  331. #endif
  332.  
  333. /// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
  334. /// an expression which causes the program to break while running
  335. /// under a debugger.
  336. #if __has_builtin(__builtin_debugtrap)
  337. # define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
  338. #elif defined(_MSC_VER)
  339. // The __debugbreak intrinsic is supported by MSVC and breaks while
  340. // running under the debugger, and also supports invoking a debugger
  341. // when the OS is configured appropriately.
  342. # define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
  343. #else
  344. // Just continue execution when built with compilers that have no
  345. // support. This is a debugging aid and not intended to force the
  346. // program to abort if encountered.
  347. # define LLVM_BUILTIN_DEBUGTRAP
  348. #endif
  349.  
  350. /// \macro LLVM_ASSUME_ALIGNED
  351. /// Returns a pointer with an assumed alignment.
  352. #if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__)
  353. # define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
  354. #elif defined(LLVM_BUILTIN_UNREACHABLE)
  355. # define LLVM_ASSUME_ALIGNED(p, a) \
  356.            (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
  357. #else
  358. # define LLVM_ASSUME_ALIGNED(p, a) (p)
  359. #endif
  360.  
  361. /// \macro LLVM_PACKED
  362. /// Used to specify a packed structure.
  363. /// LLVM_PACKED(
  364. ///    struct A {
  365. ///      int i;
  366. ///      int j;
  367. ///      int k;
  368. ///      long long l;
  369. ///   });
  370. ///
  371. /// LLVM_PACKED_START
  372. /// struct B {
  373. ///   int i;
  374. ///   int j;
  375. ///   int k;
  376. ///   long long l;
  377. /// };
  378. /// LLVM_PACKED_END
  379. #ifdef _MSC_VER
  380. # define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
  381. # define LLVM_PACKED_START __pragma(pack(push, 1))
  382. # define LLVM_PACKED_END   __pragma(pack(pop))
  383. #else
  384. # define LLVM_PACKED(d) d __attribute__((packed))
  385. # define LLVM_PACKED_START _Pragma("pack(push, 1)")
  386. # define LLVM_PACKED_END   _Pragma("pack(pop)")
  387. #endif
  388.  
  389. /// \macro LLVM_MEMORY_SANITIZER_BUILD
  390. /// Whether LLVM itself is built with MemorySanitizer instrumentation.
  391. #if __has_feature(memory_sanitizer)
  392. # define LLVM_MEMORY_SANITIZER_BUILD 1
  393. # include <sanitizer/msan_interface.h>
  394. # define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
  395. #else
  396. # define LLVM_MEMORY_SANITIZER_BUILD 0
  397. # define __msan_allocated_memory(p, size)
  398. # define __msan_unpoison(p, size)
  399. # define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
  400. #endif
  401.  
  402. /// \macro LLVM_ADDRESS_SANITIZER_BUILD
  403. /// Whether LLVM itself is built with AddressSanitizer instrumentation.
  404. #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
  405. # define LLVM_ADDRESS_SANITIZER_BUILD 1
  406. #if __has_include(<sanitizer/asan_interface.h>)
  407. # include <sanitizer/asan_interface.h>
  408. #else
  409. // These declarations exist to support ASan with MSVC. If MSVC eventually ships
  410. // asan_interface.h in their headers, then we can remove this.
  411. #ifdef __cplusplus
  412. extern "C" {
  413. #endif
  414. void __asan_poison_memory_region(void const volatile *addr, size_t size);
  415. void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
  416. #ifdef __cplusplus
  417. } // extern "C"
  418. #endif
  419. #endif
  420. #else
  421. # define LLVM_ADDRESS_SANITIZER_BUILD 0
  422. # define __asan_poison_memory_region(p, size)
  423. # define __asan_unpoison_memory_region(p, size)
  424. #endif
  425.  
  426. /// \macro LLVM_HWADDRESS_SANITIZER_BUILD
  427. /// Whether LLVM itself is built with HWAddressSanitizer instrumentation.
  428. #if __has_feature(hwaddress_sanitizer)
  429. #define LLVM_HWADDRESS_SANITIZER_BUILD 1
  430. #else
  431. #define LLVM_HWADDRESS_SANITIZER_BUILD 0
  432. #endif
  433.  
  434. /// \macro LLVM_THREAD_SANITIZER_BUILD
  435. /// Whether LLVM itself is built with ThreadSanitizer instrumentation.
  436. #if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
  437. # define LLVM_THREAD_SANITIZER_BUILD 1
  438. #else
  439. # define LLVM_THREAD_SANITIZER_BUILD 0
  440. #endif
  441.  
  442. #if LLVM_THREAD_SANITIZER_BUILD
  443. // Thread Sanitizer is a tool that finds races in code.
  444. // See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
  445. // tsan detects these exact functions by name.
  446. #ifdef __cplusplus
  447. extern "C" {
  448. #endif
  449. void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
  450. void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
  451. void AnnotateIgnoreWritesBegin(const char *file, int line);
  452. void AnnotateIgnoreWritesEnd(const char *file, int line);
  453. #ifdef __cplusplus
  454. }
  455. #endif
  456.  
  457. // This marker is used to define a happens-before arc. The race detector will
  458. // infer an arc from the begin to the end when they share the same pointer
  459. // argument.
  460. # define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
  461.  
  462. // This marker defines the destination of a happens-before arc.
  463. # define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
  464.  
  465. // Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
  466. # define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
  467.  
  468. // Resume checking for racy writes.
  469. # define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
  470. #else
  471. # define TsanHappensBefore(cv)
  472. # define TsanHappensAfter(cv)
  473. # define TsanIgnoreWritesBegin()
  474. # define TsanIgnoreWritesEnd()
  475. #endif
  476.  
  477. /// \macro LLVM_NO_SANITIZE
  478. /// Disable a particular sanitizer for a function.
  479. #if __has_attribute(no_sanitize)
  480. #define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
  481. #else
  482. #define LLVM_NO_SANITIZE(KIND)
  483. #endif
  484.  
  485. /// Mark debug helper function definitions like dump() that should not be
  486. /// stripped from debug builds.
  487. /// Note that you should also surround dump() functions with
  488. /// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
  489. /// get stripped in release builds.
  490. // FIXME: Move this to a private config.h as it's not usable in public headers.
  491. #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  492. #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
  493. #else
  494. #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
  495. #endif
  496.  
  497. /// \macro LLVM_PRETTY_FUNCTION
  498. /// Gets a user-friendly looking function signature for the current scope
  499. /// using the best available method on each platform.  The exact format of the
  500. /// resulting string is implementation specific and non-portable, so this should
  501. /// only be used, for example, for logging or diagnostics.
  502. #if defined(_MSC_VER)
  503. #define LLVM_PRETTY_FUNCTION __FUNCSIG__
  504. #elif defined(__GNUC__) || defined(__clang__)
  505. #define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
  506. #else
  507. #define LLVM_PRETTY_FUNCTION __func__
  508. #endif
  509.  
  510. /// \macro LLVM_THREAD_LOCAL
  511. /// A thread-local storage specifier which can be used with globals,
  512. /// extern globals, and static globals.
  513. ///
  514. /// This is essentially an extremely restricted analog to C++11's thread_local
  515. /// support. It uses thread_local if available, falling back on gcc __thread
  516. /// if not. __thread doesn't support many of the C++11 thread_local's
  517. /// features. You should only use this for PODs that you can statically
  518. /// initialize to some constant value. In almost all circumstances this is most
  519. /// appropriate for use with a pointer, integer, or small aggregation of
  520. /// pointers and integers.
  521. #if LLVM_ENABLE_THREADS
  522. #if __has_feature(cxx_thread_local) || defined(_MSC_VER)
  523. #define LLVM_THREAD_LOCAL thread_local
  524. #else
  525. // Clang, GCC, and other compatible compilers used __thread prior to C++11 and
  526. // we only need the restricted functionality that provides.
  527. #define LLVM_THREAD_LOCAL __thread
  528. #endif
  529. #else // !LLVM_ENABLE_THREADS
  530. // If threading is disabled entirely, this compiles to nothing and you get
  531. // a normal global variable.
  532. #define LLVM_THREAD_LOCAL
  533. #endif
  534.  
  535. /// \macro LLVM_ENABLE_EXCEPTIONS
  536. /// Whether LLVM is built with exception support.
  537. #if __has_feature(cxx_exceptions)
  538. #define LLVM_ENABLE_EXCEPTIONS 1
  539. #elif defined(__GNUC__) && defined(__EXCEPTIONS)
  540. #define LLVM_ENABLE_EXCEPTIONS 1
  541. #elif defined(_MSC_VER) && defined(_CPPUNWIND)
  542. #define LLVM_ENABLE_EXCEPTIONS 1
  543. #endif
  544.  
  545. /// \macro LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
  546. /// Disable the profile instrument for a function.
  547. #if __has_attribute(no_profile_instrument_function)
  548. #define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION                                    \
  549.   __attribute__((no_profile_instrument_function))
  550. #else
  551. #define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
  552. #endif
  553.  
  554. #endif
  555.