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_THREAD_SANITIZER_BUILD |
427 | /// Whether LLVM itself is built with ThreadSanitizer instrumentation. |
428 | #if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__) |
429 | # define LLVM_THREAD_SANITIZER_BUILD 1 |
430 | #else |
431 | # define LLVM_THREAD_SANITIZER_BUILD 0 |
432 | #endif |
433 | |
434 | #if LLVM_THREAD_SANITIZER_BUILD |
435 | // Thread Sanitizer is a tool that finds races in code. |
436 | // See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations . |
437 | // tsan detects these exact functions by name. |
438 | #ifdef __cplusplus |
439 | extern "C" { |
440 | #endif |
441 | void AnnotateHappensAfter(const char *file, int line, const volatile void *cv); |
442 | void AnnotateHappensBefore(const char *file, int line, const volatile void *cv); |
443 | void AnnotateIgnoreWritesBegin(const char *file, int line); |
444 | void AnnotateIgnoreWritesEnd(const char *file, int line); |
445 | #ifdef __cplusplus |
446 | } |
447 | #endif |
448 | |
449 | // This marker is used to define a happens-before arc. The race detector will |
450 | // infer an arc from the begin to the end when they share the same pointer |
451 | // argument. |
452 | # define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv) |
453 | |
454 | // This marker defines the destination of a happens-before arc. |
455 | # define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv) |
456 | |
457 | // Ignore any races on writes between here and the next TsanIgnoreWritesEnd. |
458 | # define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__) |
459 | |
460 | // Resume checking for racy writes. |
461 | # define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__) |
462 | #else |
463 | # define TsanHappensBefore(cv) |
464 | # define TsanHappensAfter(cv) |
465 | # define TsanIgnoreWritesBegin() |
466 | # define TsanIgnoreWritesEnd() |
467 | #endif |
468 | |
469 | /// \macro LLVM_NO_SANITIZE |
470 | /// Disable a particular sanitizer for a function. |
471 | #if __has_attribute(no_sanitize) |
472 | #define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND))) |
473 | #else |
474 | #define LLVM_NO_SANITIZE(KIND) |
475 | #endif |
476 | |
477 | /// Mark debug helper function definitions like dump() that should not be |
478 | /// stripped from debug builds. |
479 | /// Note that you should also surround dump() functions with |
480 | /// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always |
481 | /// get stripped in release builds. |
482 | // FIXME: Move this to a private config.h as it's not usable in public headers. |
483 | #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
484 | #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED |
485 | #else |
486 | #define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE |
487 | #endif |
488 | |
489 | /// \macro LLVM_PRETTY_FUNCTION |
490 | /// Gets a user-friendly looking function signature for the current scope |
491 | /// using the best available method on each platform. The exact format of the |
492 | /// resulting string is implementation specific and non-portable, so this should |
493 | /// only be used, for example, for logging or diagnostics. |
494 | #if defined(_MSC_VER) |
495 | #define LLVM_PRETTY_FUNCTION __FUNCSIG__ |
496 | #elif defined(__GNUC__) || defined(__clang__) |
497 | #define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__ |
498 | #else |
499 | #define LLVM_PRETTY_FUNCTION __func__ |
500 | #endif |
501 | |
502 | /// \macro LLVM_THREAD_LOCAL |
503 | /// A thread-local storage specifier which can be used with globals, |
504 | /// extern globals, and static globals. |
505 | /// |
506 | /// This is essentially an extremely restricted analog to C++11's thread_local |
507 | /// support. It uses thread_local if available, falling back on gcc __thread |
508 | /// if not. __thread doesn't support many of the C++11 thread_local's |
509 | /// features. You should only use this for PODs that you can statically |
510 | /// initialize to some constant value. In almost all circumstances this is most |
511 | /// appropriate for use with a pointer, integer, or small aggregation of |
512 | /// pointers and integers. |
513 | #if LLVM_ENABLE_THREADS |
514 | #if __has_feature(cxx_thread_local) || defined(_MSC_VER) |
515 | #define LLVM_THREAD_LOCAL thread_local |
516 | #else |
517 | // Clang, GCC, and other compatible compilers used __thread prior to C++11 and |
518 | // we only need the restricted functionality that provides. |
519 | #define LLVM_THREAD_LOCAL __thread |
520 | #endif |
521 | #else // !LLVM_ENABLE_THREADS |
522 | // If threading is disabled entirely, this compiles to nothing and you get |
523 | // a normal global variable. |
524 | #define LLVM_THREAD_LOCAL |
525 | #endif |
526 | |
527 | /// \macro LLVM_ENABLE_EXCEPTIONS |
528 | /// Whether LLVM is built with exception support. |
529 | #if __has_feature(cxx_exceptions) |
530 | #define LLVM_ENABLE_EXCEPTIONS 1 |
531 | #elif defined(__GNUC__) && defined(__EXCEPTIONS) |
532 | #define LLVM_ENABLE_EXCEPTIONS 1 |
533 | #elif defined(_MSC_VER) && defined(_CPPUNWIND) |
534 | #define LLVM_ENABLE_EXCEPTIONS 1 |
535 | #endif |
536 | |
537 | /// \macro LLVM_NO_PROFILE_INSTRUMENT_FUNCTION |
538 | /// Disable the profile instrument for a function. |
539 | #if __has_attribute(no_profile_instrument_function) |
540 | #define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION \ |
541 | __attribute__((no_profile_instrument_function)) |
542 | #else |
543 | #define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION |
544 | #endif |
545 | |
546 | #endif |
547 | |