Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/Compiler.h
Line
Count
Source (jump to first uncovered line)
1
//===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines several macros, based on the current compiler.  This allows
11
// use of compiler-specific features in a way that remains portable.
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
#if defined(_MSC_VER)
21
#include <sal.h>
22
#endif
23
24
#ifndef __has_feature
25
# define __has_feature(x) 0
26
#endif
27
28
#ifndef __has_extension
29
# define __has_extension(x) 0
30
#endif
31
32
#ifndef __has_attribute
33
# define __has_attribute(x) 0
34
#endif
35
36
#ifndef __has_cpp_attribute
37
# define __has_cpp_attribute(x) 0
38
#endif
39
40
#ifndef __has_builtin
41
# define __has_builtin(x) 0
42
#endif
43
44
/// \macro LLVM_GNUC_PREREQ
45
/// \brief Extend the default __GNUC_PREREQ even if glibc's features.h isn't
46
/// available.
47
#ifndef LLVM_GNUC_PREREQ
48
# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
49
#  define LLVM_GNUC_PREREQ(maj, min, patch) \
50
    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
51
     ((maj) << 20) + ((min) << 10) + (patch))
52
# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
53
#  define LLVM_GNUC_PREREQ(maj, min, patch) \
54
    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
55
# else
56
#  define LLVM_GNUC_PREREQ(maj, min, patch) 0
57
# endif
58
#endif
59
60
/// \macro LLVM_MSC_PREREQ
61
/// \brief Is the compiler MSVC of at least the specified version?
62
/// The common \param version values to check for are:
63
///  * 1900: Microsoft Visual Studio 2015 / 14.0
64
#ifdef _MSC_VER
65
#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
66
67
// We require at least MSVC 2015.
68
#if !LLVM_MSC_PREREQ(1900)
69
#error LLVM requires at least MSVC 2015.
70
#endif
71
72
#else
73
#define LLVM_MSC_PREREQ(version) 0
74
#endif
75
76
/// \brief Does the compiler support ref-qualifiers for *this?
77
///
78
/// Sadly, this is separate from just rvalue reference support because GCC
79
/// and MSVC implemented this later than everything else.
80
#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1)
81
#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
82
#else
83
#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
84
#endif
85
86
/// Expands to '&' if ref-qualifiers for *this are supported.
87
///
88
/// This can be used to provide lvalue/rvalue overrides of member functions.
89
/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
90
#if LLVM_HAS_RVALUE_REFERENCE_THIS
91
#define LLVM_LVALUE_FUNCTION &
92
#else
93
#define LLVM_LVALUE_FUNCTION
94
#endif
95
96
/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
97
/// into a shared library, then the class should be private to the library and
98
/// not accessible from outside it.  Can also be used to mark variables and
99
/// functions, making them private to any shared library they are linked into.
100
/// On PE/COFF targets, library visibility is the default, so this isn't needed.
101
#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
102
    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(LLVM_ON_WIN32)
103
#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
104
#else
105
#define LLVM_LIBRARY_VISIBILITY
106
#endif
107
108
#if defined(__GNUC__)
109
#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
110
#else
111
#define LLVM_PREFETCH(addr, rw, locality)
112
#endif
113
114
#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
115
#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
116
#else
117
#define LLVM_ATTRIBUTE_USED
118
#endif
119
120
/// LLVM_NODISCARD - Warn if a type or return value is discarded.
121
#if __cplusplus > 201402L && __has_cpp_attribute(nodiscard)
122
#define LLVM_NODISCARD [[nodiscard]]
123
#elif !__cplusplus
124
// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
125
// error when __has_cpp_attribute is given a scoped attribute in C mode.
126
#define LLVM_NODISCARD
127
#elif __has_cpp_attribute(clang::warn_unused_result)
128
#define LLVM_NODISCARD [[clang::warn_unused_result]]
129
#else
130
#define LLVM_NODISCARD
131
#endif
132
133
// Some compilers warn about unused functions. When a function is sometimes
134
// used or not depending on build settings (e.g. a function only called from
135
// within "assert"), this attribute can be used to suppress such warnings.
136
//
137
// However, it shouldn't be used for unused *variables*, as those have a much
138
// more portable solution:
139
//   (void)unused_var_name;
140
// Prefer cast-to-void wherever it is sufficient.
141
#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
142
112
#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
143
#else
144
#define LLVM_ATTRIBUTE_UNUSED
145
#endif
146
147
// FIXME: Provide this for PE/COFF targets.
148
#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) &&                    \
149
    (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(LLVM_ON_WIN32))
150
#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
151
#else
152
#define LLVM_ATTRIBUTE_WEAK
153
#endif
154
155
// Prior to clang 3.2, clang did not accept any spelling of
156
// __has_attribute(const), so assume it is supported.
157
#if defined(__clang__) || defined(__GNUC__)
158
// aka 'CONST' but following LLVM Conventions.
159
#define LLVM_READNONE __attribute__((__const__))
160
#else
161
#define LLVM_READNONE
162
#endif
163
164
#if __has_attribute(pure) || defined(__GNUC__)
165
// aka 'PURE' but following LLVM Conventions.
166
#define LLVM_READONLY __attribute__((__pure__))
167
#else
168
#define LLVM_READONLY
169
#endif
170
171
#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
172
54.2G
#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
173
25.3G
#define LLVM_UNLIKELY(EXPR) 
__builtin_expect((bool)(25.3G
EXPR0
), false)
174
#else
175
#define LLVM_LIKELY(EXPR) (EXPR)
176
#define LLVM_UNLIKELY(EXPR) (EXPR)
177
#endif
178
179
/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
180
/// mark a method "not for inlining".
181
#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
182
#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
183
#elif defined(_MSC_VER)
184
#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
185
#else
186
#define LLVM_ATTRIBUTE_NOINLINE
187
#endif
188
189
/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
190
/// so, mark a method "always inline" because it is performance sensitive. GCC
191
/// 3.4 supported this but is buggy in various cases and produces unimplemented
192
/// errors, just use it in GCC 4.0 and later.
193
#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
194
#define LLVM_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
195
#elif defined(_MSC_VER)
196
#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
197
#else
198
#define LLVM_ATTRIBUTE_ALWAYS_INLINE
199
#endif
200
201
#ifdef __GNUC__
202
#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
203
#elif defined(_MSC_VER)
204
#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
205
#else
206
#define LLVM_ATTRIBUTE_NORETURN
207
#endif
208
209
#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
210
#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
211
#elif defined(_MSC_VER)
212
#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
213
#else
214
#define LLVM_ATTRIBUTE_RETURNS_NONNULL
215
#endif
216
217
/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
218
/// pointer that does not alias any other valid pointer.
219
#ifdef __GNUC__
220
#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
221
#elif defined(_MSC_VER)
222
#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
223
#else
224
#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
225
#endif
226
227
/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
228
#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
229
#define LLVM_FALLTHROUGH [[fallthrough]]
230
#elif __has_cpp_attribute(gnu::fallthrough)
231
#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
232
#elif !__cplusplus
233
// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
234
// error when __has_cpp_attribute is given a scoped attribute in C mode.
235
#define LLVM_FALLTHROUGH
236
#elif __has_cpp_attribute(clang::fallthrough)
237
243M
#define LLVM_FALLTHROUGH [[clang::fallthrough]]
238
#else
239
#define LLVM_FALLTHROUGH
240
#endif
241
242
/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
243
/// pedantic diagnostics.
244
#ifdef __GNUC__
245
15
#define LLVM_EXTENSION __extension__
246
#else
247
#define LLVM_EXTENSION
248
#endif
249
250
// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
251
#if __has_feature(attribute_deprecated_with_message)
252
# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
253
  decl __attribute__((deprecated(message)))
254
#elif defined(__GNUC__)
255
# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
256
  decl __attribute__((deprecated))
257
#elif defined(_MSC_VER)
258
# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
259
  __declspec(deprecated(message)) decl
260
#else
261
# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
262
  decl
263
#endif
264
265
/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
266
/// to an expression which states that it is undefined behavior for the
267
/// compiler to reach this point.  Otherwise is not defined.
268
#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
269
1.59k
# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
270
#elif defined(_MSC_VER)
271
# define LLVM_BUILTIN_UNREACHABLE __assume(false)
272
#endif
273
274
/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
275
/// which causes the program to exit abnormally.
276
#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
277
# define LLVM_BUILTIN_TRAP __builtin_trap()
278
#elif defined(_MSC_VER)
279
// The __debugbreak intrinsic is supported by MSVC, does not require forward
280
// declarations involving platform-specific typedefs (unlike RaiseException),
281
// results in a call to vectored exception handlers, and encodes to a short
282
// instruction that still causes the trapping behavior we want.
283
# define LLVM_BUILTIN_TRAP __debugbreak()
284
#else
285
# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
286
#endif
287
288
/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
289
/// an expression which causes the program to break while running
290
/// under a debugger.
291
#if __has_builtin(__builtin_debugtrap)
292
# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
293
#elif defined(_MSC_VER)
294
// The __debugbreak intrinsic is supported by MSVC and breaks while
295
// running under the debugger, and also supports invoking a debugger
296
// when the OS is configured appropriately.
297
# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
298
#else
299
// Just continue execution when built with compilers that have no
300
// support. This is a debugging aid and not intended to force the
301
// program to abort if encountered.
302
# define LLVM_BUILTIN_DEBUGTRAP
303
#endif
304
305
/// \macro LLVM_ASSUME_ALIGNED
306
/// \brief Returns a pointer with an assumed alignment.
307
#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
308
70.4M
# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
309
#elif defined(LLVM_BUILTIN_UNREACHABLE)
310
// As of today, clang does not support __builtin_assume_aligned.
311
# define LLVM_ASSUME_ALIGNED(p, a) \
312
           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
313
#else
314
# define LLVM_ASSUME_ALIGNED(p, a) (p)
315
#endif
316
317
/// \macro LLVM_ALIGNAS
318
/// \brief Used to specify a minimum alignment for a structure or variable.
319
#if __GNUC__ && !__has_feature(cxx_alignas) && !LLVM_GNUC_PREREQ(4, 8, 1)
320
# define LLVM_ALIGNAS(x) __attribute__((aligned(x)))
321
#else
322
# define LLVM_ALIGNAS(x) alignas(x)
323
#endif
324
325
/// \macro LLVM_PACKED
326
/// \brief Used to specify a packed structure.
327
/// LLVM_PACKED(
328
///    struct A {
329
///      int i;
330
///      int j;
331
///      int k;
332
///      long long l;
333
///   });
334
///
335
/// LLVM_PACKED_START
336
/// struct B {
337
///   int i;
338
///   int j;
339
///   int k;
340
///   long long l;
341
/// };
342
/// LLVM_PACKED_END
343
#ifdef _MSC_VER
344
# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
345
# define LLVM_PACKED_START __pragma(pack(push, 1))
346
# define LLVM_PACKED_END   __pragma(pack(pop))
347
#else
348
# define LLVM_PACKED(d) d __attribute__((packed))
349
# define LLVM_PACKED_START _Pragma("pack(push, 1)")
350
# define LLVM_PACKED_END   _Pragma("pack(pop)")
351
#endif
352
353
/// \macro LLVM_PTR_SIZE
354
/// \brief A constant integer equivalent to the value of sizeof(void*).
355
/// Generally used in combination with LLVM_ALIGNAS or when doing computation in
356
/// the preprocessor.
357
#ifdef __SIZEOF_POINTER__
358
# define LLVM_PTR_SIZE __SIZEOF_POINTER__
359
#elif defined(_WIN64)
360
# define LLVM_PTR_SIZE 8
361
#elif defined(_WIN32)
362
# define LLVM_PTR_SIZE 4
363
#elif defined(_MSC_VER)
364
# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
365
#else
366
# define LLVM_PTR_SIZE sizeof(void *)
367
#endif
368
369
/// \macro LLVM_MEMORY_SANITIZER_BUILD
370
/// \brief Whether LLVM itself is built with MemorySanitizer instrumentation.
371
#if __has_feature(memory_sanitizer)
372
# define LLVM_MEMORY_SANITIZER_BUILD 1
373
# include <sanitizer/msan_interface.h>
374
#else
375
# define LLVM_MEMORY_SANITIZER_BUILD 0
376
# define __msan_allocated_memory(p, size)
377
# define __msan_unpoison(p, size)
378
#endif
379
380
/// \macro LLVM_ADDRESS_SANITIZER_BUILD
381
/// \brief Whether LLVM itself is built with AddressSanitizer instrumentation.
382
#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
383
# define LLVM_ADDRESS_SANITIZER_BUILD 1
384
# include <sanitizer/asan_interface.h>
385
#else
386
# define LLVM_ADDRESS_SANITIZER_BUILD 0
387
# define __asan_poison_memory_region(p, size)
388
# define __asan_unpoison_memory_region(p, size)
389
#endif
390
391
/// \macro LLVM_THREAD_SANITIZER_BUILD
392
/// \brief Whether LLVM itself is built with ThreadSanitizer instrumentation.
393
#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
394
# define LLVM_THREAD_SANITIZER_BUILD 1
395
#else
396
# define LLVM_THREAD_SANITIZER_BUILD 0
397
#endif
398
399
#if LLVM_THREAD_SANITIZER_BUILD
400
// Thread Sanitizer is a tool that finds races in code.
401
// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
402
// tsan detects these exact functions by name.
403
#ifdef __cplusplus
404
extern "C" {
405
#endif
406
void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
407
void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
408
void AnnotateIgnoreWritesBegin(const char *file, int line);
409
void AnnotateIgnoreWritesEnd(const char *file, int line);
410
#ifdef __cplusplus
411
}
412
#endif
413
414
// This marker is used to define a happens-before arc. The race detector will
415
// infer an arc from the begin to the end when they share the same pointer
416
// argument.
417
# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
418
419
// This marker defines the destination of a happens-before arc.
420
# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
421
422
// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
423
# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
424
425
// Resume checking for racy writes.
426
# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
427
#else
428
# define TsanHappensBefore(cv)
429
# define TsanHappensAfter(cv)
430
# define TsanIgnoreWritesBegin()
431
# define TsanIgnoreWritesEnd()
432
#endif
433
434
/// \macro LLVM_NO_SANITIZE
435
/// \brief Disable a particular sanitizer for a function.
436
#if __has_attribute(no_sanitize)
437
#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
438
#else
439
#define LLVM_NO_SANITIZE(KIND)
440
#endif
441
442
/// \brief Mark debug helper function definitions like dump() that should not be
443
/// stripped from debug builds.
444
/// Note that you should also surround dump() functions with
445
/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
446
/// get stripped in release builds.
447
// FIXME: Move this to a private config.h as it's not usable in public headers.
448
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
449
#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
450
#else
451
#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
452
#endif
453
454
/// \macro LLVM_PRETTY_FUNCTION
455
/// \brief Gets a user-friendly looking function signature for the current scope
456
/// using the best available method on each platform.  The exact format of the
457
/// resulting string is implementation specific and non-portable, so this should
458
/// only be used, for example, for logging or diagnostics.
459
#if defined(_MSC_VER)
460
#define LLVM_PRETTY_FUNCTION __FUNCSIG__
461
#elif defined(__GNUC__) || defined(__clang__)
462
#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
463
#else
464
#define LLVM_PRETTY_FUNCTION __func__
465
#endif
466
467
/// \macro LLVM_THREAD_LOCAL
468
/// \brief A thread-local storage specifier which can be used with globals,
469
/// extern globals, and static globals.
470
///
471
/// This is essentially an extremely restricted analog to C++11's thread_local
472
/// support, and uses that when available. However, it falls back on
473
/// platform-specific or vendor-provided extensions when necessary. These
474
/// extensions don't support many of the C++11 thread_local's features. You
475
/// should only use this for PODs that you can statically initialize to
476
/// some constant value. In almost all circumstances this is most appropriate
477
/// for use with a pointer, integer, or small aggregation of pointers and
478
/// integers.
479
#if LLVM_ENABLE_THREADS
480
#if __has_feature(cxx_thread_local)
481
#define LLVM_THREAD_LOCAL thread_local
482
#elif defined(_MSC_VER)
483
// MSVC supports this with a __declspec.
484
#define LLVM_THREAD_LOCAL __declspec(thread)
485
#else
486
// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
487
// we only need the restricted functionality that provides.
488
#define LLVM_THREAD_LOCAL __thread
489
#endif
490
#else // !LLVM_ENABLE_THREADS
491
// If threading is disabled entirely, this compiles to nothing and you get
492
// a normal global variable.
493
#define LLVM_THREAD_LOCAL
494
#endif
495
496
/// \macro LLVM_ENABLE_EXCEPTIONS
497
/// \brief Whether LLVM is built with exception support.
498
#if __has_feature(cxx_exceptions)
499
#define LLVM_ENABLE_EXCEPTIONS 1
500
#elif defined(__GNUC__) && defined(__EXCEPTIONS)
501
#define LLVM_ENABLE_EXCEPTIONS 1
502
#elif defined(_MSC_VER) && defined(_CPPUNWIND)
503
#define LLVM_ENABLE_EXCEPTIONS 1
504
#endif
505
506
#endif