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