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// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
43// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
44#ifndef LLVM_HAS_CPP_ATTRIBUTE
45#if defined(__cplusplus) && defined(__has_cpp_attribute)
46# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
47#else
48# define LLVM_HAS_CPP_ATTRIBUTE(x) 0
49#endif
50#endif
51
52/// \macro LLVM_GNUC_PREREQ
53/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
54/// available.
55#ifndef LLVM_GNUC_PREREQ
56# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
57# define LLVM_GNUC_PREREQ(maj, min, patch) \
58 ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
59 ((maj) << 20) + ((min) << 10) + (patch))
60# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
61# define LLVM_GNUC_PREREQ(maj, min, patch) \
62 ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
63# else
64# define LLVM_GNUC_PREREQ(maj, min, patch) 0
65# endif
66#endif
67
68/// \macro LLVM_MSC_PREREQ
69/// Is the compiler MSVC of at least the specified version?
70/// The common \param version values to check for are:
71/// * 1910: VS2017, version 15.1 & 15.2
72/// * 1911: VS2017, version 15.3 & 15.4
73/// * 1912: VS2017, version 15.5
74/// * 1913: VS2017, version 15.6
75/// * 1914: VS2017, version 15.7
76/// * 1915: VS2017, version 15.8
77/// * 1916: VS2017, version 15.9
78/// * 1920: VS2019, version 16.0
79/// * 1921: VS2019, version 16.1
80/// * 1922: VS2019, version 16.2
81/// * 1923: VS2019, version 16.3
82/// * 1924: VS2019, version 16.4
83/// * 1925: VS2019, version 16.5
84/// * 1926: VS2019, version 16.6
85/// * 1927: VS2019, version 16.7
86/// * 1928: VS2019, version 16.8 + 16.9
87/// * 1929: VS2019, version 16.10 + 16.11
88/// * 1930: VS2022, version 17.0
89#ifdef _MSC_VER
90#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
91
92// We require at least VS 2019.
93#if !defined(LLVM_FORCE_USE_OLD_TOOLCHAIN)
94#if !LLVM_MSC_PREREQ(1920)
95#error LLVM requires at least VS 2019.
96#endif
97#endif
98
99#else
100#define LLVM_MSC_PREREQ(version) 0
101#endif
102
103/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
104/// into a shared library, then the class should be private to the library and
105/// not accessible from outside it. Can also be used to mark variables and
106/// functions, making them private to any shared library they are linked into.
107/// On PE/COFF targets, library visibility is the default, so this isn't needed.
108///
109/// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
110/// this attribute will be made public and visible outside of any shared library
111/// they are linked in to.
112
113#if LLVM_HAS_CPP_ATTRIBUTE(gnu::visibility) && defined(__GNUC__) && \
114 !defined(__clang__)
115#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN [[gnu::visibility("hidden")]]
116#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT [[gnu::visibility("default")]]
117#elif __has_attribute(visibility)
118#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
119#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT __attribute__((visibility("default")))
120#else
121#define LLVM_ATTRIBUTE_VISIBILITY_HIDDEN
122#define LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
123#endif
124
125#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
126#define LLVM_EXTERNAL_VISIBILITY LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
127#else
128#define LLVM_EXTERNAL_VISIBILITY
129#endif
130
131#if (!(defined(_WIN32) || defined(__CYGWIN__)) || \
132 (defined(__MINGW32__) && defined(__clang__)))
133#define LLVM_LIBRARY_VISIBILITY LLVM_ATTRIBUTE_VISIBILITY_HIDDEN
134// Clang compilers older then 15 do not support gnu style attributes on
135// namespaces.
136#if defined(__clang__) && __clang_major__ < 15
137#define LLVM_LIBRARY_VISIBILITY_NAMESPACE [[gnu::visibility("hidden")]]
138#else
139#define LLVM_LIBRARY_VISIBILITY_NAMESPACE LLVM_ATTRIBUTE_VISIBILITY_HIDDEN
140#endif
141#define LLVM_ALWAYS_EXPORT LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
142#elif defined(_WIN32)
143#define LLVM_ALWAYS_EXPORT __declspec(dllexport)
144#define LLVM_LIBRARY_VISIBILITY
145#define LLVM_LIBRARY_VISIBILITY_NAMESPACE
146#else
147#define LLVM_LIBRARY_VISIBILITY
148#define LLVM_ALWAYS_EXPORT
149#define LLVM_LIBRARY_VISIBILITY_NAMESPACE
150#endif
151
152/// LLVM_ABI is the main export/visibility macro to mark something as explicitly
153/// exported when llvm is built as a shared library with everything else that is
154/// unannotated will have internal visibility.
155///
156/// LLVM_ABI_EXPORT is for the special case for things like plugin symbol
157/// declarations or definitions where we don't want the macro to be switching
158/// between dllexport and dllimport on windows based on what codebase is being
159/// built, it will only be dllexport. For non windows platforms this macro
160/// behaves the same as LLVM_ABI.
161///
162/// LLVM_EXPORT_TEMPLATE is used on explicit template instantiations in source
163/// files that were declared extern in a header. This macro is only set as a
164/// compiler export attribute on windows, on other platforms it does nothing.
165///
166/// LLVM_TEMPLATE_ABI is for annotating extern template declarations in headers
167/// for both functions and classes. On windows its turned in to dllimport for
168/// library consumers, for other platforms its a default visibility attribute.
169///
170/// LLVM_C_ABI is used to annotated functions and data that need to be exported
171/// for the libllvm-c API. This used both for the llvm-c headers and for the
172/// functions declared in the different Target's c++ source files that don't
173/// include the header forward declaring them.
174#ifndef LLVM_ABI_GENERATING_ANNOTATIONS
175// Marker to add to classes or functions in public headers that should not have
176// export macros added to them by the clang tool
177#define LLVM_ABI_NOT_EXPORTED
178#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS) || \
179 defined(LLVM_ENABLE_PLUGINS)
180// Some libraries like those for tablegen are linked in to tools that used
181// in the build so can't depend on the llvm shared library. If export macros
182// were left enabled when building these we would get duplicate or
183// missing symbol linker errors on windows.
184#if defined(LLVM_BUILD_STATIC)
185#define LLVM_ABI
186#define LLVM_TEMPLATE_ABI
187#define LLVM_EXPORT_TEMPLATE
188#define LLVM_ABI_EXPORT
189#elif defined(_WIN32) && !defined(__MINGW32__)
190#if defined(LLVM_EXPORTS)
191#define LLVM_ABI __declspec(dllexport)
192#define LLVM_TEMPLATE_ABI
193#define LLVM_EXPORT_TEMPLATE __declspec(dllexport)
194#else
195#define LLVM_ABI __declspec(dllimport)
196#define LLVM_TEMPLATE_ABI __declspec(dllimport)
197#define LLVM_EXPORT_TEMPLATE
198#endif
199#define LLVM_ABI_EXPORT __declspec(dllexport)
200#elif defined(__ELF__) || defined(__MINGW32__) || defined(_AIX) || \
201 defined(__MVS__)
202#define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
203#define LLVM_TEMPLATE_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
204#define LLVM_EXPORT_TEMPLATE
205#define LLVM_ABI_EXPORT LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
206#elif defined(__MACH__) || defined(__WASM__) || defined(__EMSCRIPTEN__)
207#define LLVM_ABI LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
208#define LLVM_TEMPLATE_ABI
209#define LLVM_EXPORT_TEMPLATE
210#define LLVM_ABI_EXPORT LLVM_ATTRIBUTE_VISIBILITY_DEFAULT
211#endif
212#else
213#define LLVM_ABI
214#define LLVM_TEMPLATE_ABI
215#define LLVM_EXPORT_TEMPLATE
216#define LLVM_ABI_EXPORT
217#endif
218#define LLVM_C_ABI LLVM_ABI
219#endif
220
221#if defined(__GNUC__)
222#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
223#else
224#define LLVM_PREFETCH(addr, rw, locality)
225#endif
226
227#if __has_attribute(used)
228#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
229#else
230#define LLVM_ATTRIBUTE_USED
231#endif
232
233#if defined(__clang__)
234#define LLVM_DEPRECATED(MSG, FIX) __attribute__((deprecated(MSG, FIX)))
235#else
236#define LLVM_DEPRECATED(MSG, FIX) [[deprecated(MSG)]]
237#endif
238
239// clang-format off
240#if defined(__clang__) || defined(__GNUC__)
241#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH \
242 _Pragma("GCC diagnostic push") \
243 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
244#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP \
245 _Pragma("GCC diagnostic pop")
246#elif defined(_MSC_VER)
247#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH \
248 _Pragma("warning(push)") \
249 _Pragma("warning(disable : 4996)")
250#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP \
251 _Pragma("warning(pop)")
252#else
253#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH
254#define LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP
255#endif
256// clang-format on
257
258// Indicate that a non-static, non-const C++ member function reinitializes
259// the entire object to a known state, independent of the previous state of
260// the object.
261//
262// The clang-tidy check bugprone-use-after-move recognizes this attribute as a
263// marker that a moved-from object has left the indeterminate state and can be
264// reused.
265#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
266#define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
267#else
268#define LLVM_ATTRIBUTE_REINITIALIZES
269#endif
270
271// Some compilers warn about unused functions. When a function is sometimes
272// used or not depending on build settings (e.g. a function only called from
273// within "assert"), this attribute can be used to suppress such warnings.
274//
275// However, it shouldn't be used for unused *variables*, as those have a much
276// more portable solution:
277// (void)unused_var_name;
278// Prefer cast-to-void wherever it is sufficient.
279#if __has_attribute(unused)
280#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
281#else
282#define LLVM_ATTRIBUTE_UNUSED
283#endif
284
285// FIXME: Provide this for PE/COFF targets.
286#if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) && \
287 !defined(_WIN32)
288#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
289#else
290#define LLVM_ATTRIBUTE_WEAK
291#endif
292
293// Prior to clang 3.2, clang did not accept any spelling of
294// __has_attribute(const), so assume it is supported.
295#if defined(__clang__) || defined(__GNUC__)
296// aka 'CONST' but following LLVM Conventions.
297#define LLVM_READNONE __attribute__((__const__))
298#else
299#define LLVM_READNONE
300#endif
301
302#if __has_attribute(pure) || defined(__GNUC__)
303// aka 'PURE' but following LLVM Conventions.
304#define LLVM_READONLY __attribute__((__pure__))
305#else
306#define LLVM_READONLY
307#endif
308
309#if __has_attribute(minsize)
310#define LLVM_ATTRIBUTE_MINSIZE __attribute__((minsize))
311#else
312#define LLVM_ATTRIBUTE_MINSIZE
313#endif
314
315#if __has_builtin(__builtin_expect) || defined(__GNUC__)
316#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
317#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
318#else
319#define LLVM_LIKELY(EXPR) (EXPR)
320#define LLVM_UNLIKELY(EXPR) (EXPR)
321#endif
322
323/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
324/// mark a method "not for inlining".
325#if __has_attribute(noinline)
326#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
327#elif defined(_MSC_VER)
328#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
329#else
330#define LLVM_ATTRIBUTE_NOINLINE
331#endif
332
333/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
334/// so, mark a method "always inline" because it is performance sensitive.
335#if __has_attribute(always_inline)
336#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
337#elif defined(_MSC_VER)
338#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
339#else
340#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
341#endif
342
343/// LLVM_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do
344/// so, mark a method "no debug" because debug info makes the debugger
345/// experience worse.
346#if __has_attribute(nodebug)
347#define LLVM_ATTRIBUTE_NODEBUG __attribute__((nodebug))
348#else
349#define LLVM_ATTRIBUTE_NODEBUG
350#endif
351
352#if __has_attribute(returns_nonnull)
353#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
354#elif defined(_MSC_VER)
355#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
356#else
357#define LLVM_ATTRIBUTE_RETURNS_NONNULL
358#endif
359
360/// LLVM_ATTRIBUTE_RESTRICT - Annotates a pointer to tell the compiler that
361/// it is not aliased in the current scope.
362#if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
363#define LLVM_ATTRIBUTE_RESTRICT __restrict
364#else
365#define LLVM_ATTRIBUTE_RESTRICT
366#endif
367
368/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
369/// pointer that does not alias any other valid pointer.
370#ifdef __GNUC__
371#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
372#elif defined(_MSC_VER)
373#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
374#else
375#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
376#endif
377
378/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
379#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
380#define LLVM_FALLTHROUGH [[fallthrough]]
381#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
382#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
383#elif __has_attribute(fallthrough)
384#define LLVM_FALLTHROUGH __attribute__((fallthrough))
385#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
386#define LLVM_FALLTHROUGH [[clang::fallthrough]]
387#else
388#define LLVM_FALLTHROUGH
389#endif
390
391/// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
392/// they are constant initialized.
393#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
394#define LLVM_REQUIRE_CONSTANT_INITIALIZATION \
395 [[clang::require_constant_initialization]]
396#else
397#define LLVM_REQUIRE_CONSTANT_INITIALIZATION
398#endif
399
400/// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable
401/// lifetime warnings.
402#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner)
403#define LLVM_GSL_OWNER [[gsl::Owner]]
404#else
405#define LLVM_GSL_OWNER
406#endif
407
408/// LLVM_GSL_POINTER - Apply this to non-owning classes like
409/// StringRef to enable lifetime warnings.
410#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer)
411#define LLVM_GSL_POINTER [[gsl::Pointer]]
412#else
413#define LLVM_GSL_POINTER
414#endif
415
416#if LLVM_HAS_CPP_ATTRIBUTE(clang::lifetimebound)
417#define LLVM_LIFETIME_BOUND [[clang::lifetimebound]]
418#else
419#define LLVM_LIFETIME_BOUND
420#endif
421
422#if LLVM_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L
423#define LLVM_CTOR_NODISCARD [[nodiscard]]
424#else
425#define LLVM_CTOR_NODISCARD
426#endif
427
428/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
429/// pedantic diagnostics.
430#ifdef __GNUC__
431#define LLVM_EXTENSION __extension__
432#else
433#define LLVM_EXTENSION
434#endif
435
436/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
437/// to an expression which states that it is undefined behavior for the
438/// compiler to reach this point. Otherwise is not defined.
439///
440/// '#else' is intentionally left out so that other macro logic (e.g.,
441/// LLVM_ASSUME_ALIGNED and llvm_unreachable()) can detect whether
442/// LLVM_BUILTIN_UNREACHABLE has a definition.
443#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
444# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
445#elif defined(_MSC_VER)
446# define LLVM_BUILTIN_UNREACHABLE __assume(false)
447#endif
448
449/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
450/// which causes the program to exit abnormally.
451#if __has_builtin(__builtin_trap) || defined(__GNUC__)
452# define LLVM_BUILTIN_TRAP __builtin_trap()
453#elif defined(_MSC_VER)
454// The __debugbreak intrinsic is supported by MSVC, does not require forward
455// declarations involving platform-specific typedefs (unlike RaiseException),
456// results in a call to vectored exception handlers, and encodes to a short
457// instruction that still causes the trapping behavior we want.
458# define LLVM_BUILTIN_TRAP __debugbreak()
459#else
460# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
461#endif
462
463/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
464/// an expression which causes the program to break while running
465/// under a debugger.
466#if __has_builtin(__builtin_debugtrap)
467# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
468#elif defined(_MSC_VER)
469// The __debugbreak intrinsic is supported by MSVC and breaks while
470// running under the debugger, and also supports invoking a debugger
471// when the OS is configured appropriately.
472# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
473#else
474// Just continue execution when built with compilers that have no
475// support. This is a debugging aid and not intended to force the
476// program to abort if encountered.
477# define LLVM_BUILTIN_DEBUGTRAP
478#endif
479
480/// \macro LLVM_ASSUME_ALIGNED
481/// Returns a pointer with an assumed alignment.
482#if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__)
483# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
484#elif defined(LLVM_BUILTIN_UNREACHABLE)
485# define LLVM_ASSUME_ALIGNED(p, a) \
486 (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
487#else
488# define LLVM_ASSUME_ALIGNED(p, a) (p)
489#endif
490
491/// \macro LLVM_PACKED
492/// Used to specify a packed structure.
493/// LLVM_PACKED(
494/// struct A {
495/// int i;
496/// int j;
497/// int k;
498/// long long l;
499/// });
500///
501/// LLVM_PACKED_START
502/// struct B {
503/// int i;
504/// int j;
505/// int k;
506/// long long l;
507/// };
508/// LLVM_PACKED_END
509#ifdef _MSC_VER
510# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
511# define LLVM_PACKED_START __pragma(pack(push, 1))
512# define LLVM_PACKED_END __pragma(pack(pop))
513#else
514# define LLVM_PACKED(d) d __attribute__((packed))
515# define LLVM_PACKED_START _Pragma("pack(push, 1)")
516# define LLVM_PACKED_END _Pragma("pack(pop)")
517#endif
518
519/// \macro LLVM_MEMORY_SANITIZER_BUILD
520/// Whether LLVM itself is built with MemorySanitizer instrumentation.
521#if __has_feature(memory_sanitizer)
522# define LLVM_MEMORY_SANITIZER_BUILD 1
523# include <sanitizer/msan_interface.h>
524# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
525#else
526# define LLVM_MEMORY_SANITIZER_BUILD 0
527# define __msan_allocated_memory(p, size)
528# define __msan_unpoison(p, size)
529# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
530#endif
531
532/// \macro LLVM_ADDRESS_SANITIZER_BUILD
533/// Whether LLVM itself is built with AddressSanitizer instrumentation.
534#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
535# define LLVM_ADDRESS_SANITIZER_BUILD 1
536#if __has_include(<sanitizer/asan_interface.h>)
537# include <sanitizer/asan_interface.h>
538#else
539// These declarations exist to support ASan with MSVC. If MSVC eventually ships
540// asan_interface.h in their headers, then we can remove this.
541#ifdef __cplusplus
542extern "C" {
543#endif
544void __asan_poison_memory_region(void const volatile *addr, size_t size);
545void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
546#ifdef __cplusplus
547} // extern "C"
548#endif
549#endif
550#else
551# define LLVM_ADDRESS_SANITIZER_BUILD 0
552# define __asan_poison_memory_region(p, size)
553# define __asan_unpoison_memory_region(p, size)
554#endif
555
556/// \macro LLVM_HWADDRESS_SANITIZER_BUILD
557/// Whether LLVM itself is built with HWAddressSanitizer instrumentation.
558#if __has_feature(hwaddress_sanitizer)
559#define LLVM_HWADDRESS_SANITIZER_BUILD 1
560#else
561#define LLVM_HWADDRESS_SANITIZER_BUILD 0
562#endif
563
564/// \macro LLVM_THREAD_SANITIZER_BUILD
565/// Whether LLVM itself is built with ThreadSanitizer instrumentation.
566#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
567# define LLVM_THREAD_SANITIZER_BUILD 1
568#else
569# define LLVM_THREAD_SANITIZER_BUILD 0
570#endif
571
572#if LLVM_THREAD_SANITIZER_BUILD
573// Thread Sanitizer is a tool that finds races in code.
574// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
575// tsan detects these exact functions by name.
576#ifdef __cplusplus
577extern "C" {
578#endif
579void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
580void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
581void AnnotateIgnoreWritesBegin(const char *file, int line);
582void AnnotateIgnoreWritesEnd(const char *file, int line);
583#ifdef __cplusplus
584}
585#endif
586
587// This marker is used to define a happens-before arc. The race detector will
588// infer an arc from the begin to the end when they share the same pointer
589// argument.
590# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
591
592// This marker defines the destination of a happens-before arc.
593# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
594
595// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
596# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
597
598// Resume checking for racy writes.
599# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
600#else
601# define TsanHappensBefore(cv)
602# define TsanHappensAfter(cv)
603# define TsanIgnoreWritesBegin()
604# define TsanIgnoreWritesEnd()
605#endif
606
607/// \macro LLVM_NO_SANITIZE
608/// Disable a particular sanitizer for a function.
609#if __has_attribute(no_sanitize)
610#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
611#else
612#define LLVM_NO_SANITIZE(KIND)
613#endif
614
615/// Mark debug helper function definitions like dump() that should not be
616/// stripped from debug builds.
617/// Note that you should also surround dump() functions with
618/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
619/// get stripped in release builds.
620// FIXME: Move this to a private config.h as it's not usable in public headers.
621#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
622#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
623#else
624#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
625#endif
626
627/// \macro LLVM_PRETTY_FUNCTION
628/// Gets a user-friendly looking function signature for the current scope
629/// using the best available method on each platform. The exact format of the
630/// resulting string is implementation specific and non-portable, so this should
631/// only be used, for example, for logging or diagnostics.
632#if defined(_MSC_VER)
633#define LLVM_PRETTY_FUNCTION __FUNCSIG__
634#elif defined(__GNUC__) || defined(__clang__)
635#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
636#else
637#define LLVM_PRETTY_FUNCTION __func__
638#endif
639
640/// \macro LLVM_THREAD_LOCAL
641/// A thread-local storage specifier which can be used with globals,
642/// extern globals, and static globals.
643///
644/// This is essentially an extremely restricted analog to C++11's thread_local
645/// support. It uses thread_local if available, falling back on gcc __thread
646/// if not. __thread doesn't support many of the C++11 thread_local's
647/// features. You should only use this for PODs that you can statically
648/// initialize to some constant value. In almost all circumstances this is most
649/// appropriate for use with a pointer, integer, or small aggregation of
650/// pointers and integers.
651#if LLVM_ENABLE_THREADS
652#if __has_feature(cxx_thread_local) || defined(_MSC_VER)
653#define LLVM_THREAD_LOCAL thread_local
654#else
655// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
656// we only need the restricted functionality that provides.
657#define LLVM_THREAD_LOCAL __thread
658#endif
659#else // !LLVM_ENABLE_THREADS
660// If threading is disabled entirely, this compiles to nothing and you get
661// a normal global variable.
662#define LLVM_THREAD_LOCAL
663#endif
664
665/// \macro LLVM_ENABLE_EXCEPTIONS
666/// Whether LLVM is built with exception support.
667#if __has_feature(cxx_exceptions)
668#define LLVM_ENABLE_EXCEPTIONS 1
669#elif defined(__GNUC__) && defined(__EXCEPTIONS)
670#define LLVM_ENABLE_EXCEPTIONS 1
671#elif defined(_MSC_VER) && defined(_CPPUNWIND)
672#define LLVM_ENABLE_EXCEPTIONS 1
673#endif
674
675/// \macro LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
676/// Disable the profile instrument for a function.
677#if __has_attribute(no_profile_instrument_function)
678#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION \
679 __attribute__((no_profile_instrument_function))
680#else
681#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
682#endif
683
684/// \macro LLVM_PREFERRED_TYPE
685/// Adjust type of bit-field in debug info.
686#if __has_attribute(preferred_type)
687#define LLVM_PREFERRED_TYPE(T) __attribute__((preferred_type(T)))
688#else
689#define LLVM_PREFERRED_TYPE(T)
690#endif
691
692#endif
693

source code of include/llvm-20/llvm/Support/Compiler.h