Compiler.h revision adf0c3d82dbff1480c63f1ebe68c7c1e6bb5828c 
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#ifndef __has_feature
19# define __has_feature(x) 0
20#endif
21
22/// LLVM_HAS_RVALUE_REFERENCES - Does the compiler provide r-value references?
23/// This implies that <utility> provides the one-argument std::move;  it
24/// does not imply the existence of any other C++ library features.
25#if (__has_feature(cxx_rvalue_references)   \
26     || defined(__GXX_EXPERIMENTAL_CXX0X__) \
27     || (defined(_MSC_VER) && _MSC_VER >= 1600))
28#define LLVM_USE_RVALUE_REFERENCES 1
29#else
30#define LLVM_USE_RVALUE_REFERENCES 0
31#endif
32
33/// llvm_move - Expands to ::std::move if the compiler supports
34/// r-value references; otherwise, expands to the argument.
35#if LLVM_USE_RVALUE_REFERENCES
36#define llvm_move(value) (::std::move(value))
37#else
38#define llvm_move(value) (value)
39#endif
40
41/// Expands to '&' if r-value references are supported.
42///
43/// This can be used to provide l-value/r-value overrides of member functions.
44/// The r-value override should be guarded by LLVM_USE_RVALUE_REFERENCES
45#if LLVM_USE_RVALUE_REFERENCES
46#define LLVM_LVALUE_FUNCTION &
47#else
48#define LLVM_LVALUE_FUNCTION
49#endif
50
51/// LLVM_DELETED_FUNCTION - Expands to = delete if the compiler supports it.
52/// Use to mark functions as uncallable. Member functions with this should
53/// be declared private so that some behavior is kept in C++03 mode.
54///
55/// class DontCopy {
56/// private:
57///   DontCopy(const DontCopy&) LLVM_DELETED_FUNCTION;
58///   DontCopy &operator =(const DontCopy&) LLVM_DELETED_FUNCTION;
59/// public:
60///   ...
61/// };
62#if (__has_feature(cxx_deleted_functions) \
63     || defined(__GXX_EXPERIMENTAL_CXX0X__))
64     // No version of MSVC currently supports this.
65#define LLVM_DELETED_FUNCTION = delete
66#else
67#define LLVM_DELETED_FUNCTION
68#endif
69
70/// LLVM_FINAL - Expands to 'final' if the compiler supports it.
71/// Use to mark classes or virtual methods as final.
72#if (__has_feature(cxx_override_control))
73#define LLVM_FINAL final
74#else
75#define LLVM_FINAL
76#endif
77
78/// LLVM_OVERRIDE - Expands to 'override' if the compiler supports it.
79/// Use to mark virtual methods as overriding a base class method.
80#if (__has_feature(cxx_override_control))
81#define LLVM_OVERRIDE override
82#else
83#define LLVM_OVERRIDE
84#endif
85
86/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
87/// into a shared library, then the class should be private to the library and
88/// not accessible from outside it.  Can also be used to mark variables and
89/// functions, making them private to any shared library they are linked into.
90#if (__GNUC__ >= 4) && !defined(__MINGW32__) && !defined(__CYGWIN__)
91#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
92#else
93#define LLVM_LIBRARY_VISIBILITY
94#endif
95
96#if (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
97#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
98#else
99#define LLVM_ATTRIBUTE_USED
100#endif
101
102// Some compilers warn about unused functions. When a function is sometimes
103// used or not depending on build settings (e.g. a function only called from
104// within "assert"), this attribute can be used to suppress such warnings.
105//
106// However, it shouldn't be used for unused *variables*, as those have a much
107// more portable solution:
108//   (void)unused_var_name;
109// Prefer cast-to-void wherever it is sufficient.
110#if (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
111#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
112#else
113#define LLVM_ATTRIBUTE_UNUSED
114#endif
115
116#if (__GNUC__ >= 4) && !defined(__MINGW32__) && !defined(__CYGWIN__)
117#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
118#else
119#define LLVM_ATTRIBUTE_WEAK
120#endif
121
122#ifdef __GNUC__ // aka 'CONST' but following LLVM Conventions.
123#define LLVM_READNONE __attribute__((__const__))
124#else
125#define LLVM_READNONE
126#endif
127
128#ifdef __GNUC__  // aka 'PURE' but following LLVM Conventions.
129#define LLVM_READONLY __attribute__((__pure__))
130#else
131#define LLVM_READONLY
132#endif
133
134#if (__GNUC__ >= 4)
135#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
136#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
137#else
138#define LLVM_LIKELY(EXPR) (EXPR)
139#define LLVM_UNLIKELY(EXPR) (EXPR)
140#endif
141
142
143// C++ doesn't support 'extern template' of template specializations.  GCC does,
144// but requires __extension__ before it.  In the header, use this:
145//   EXTERN_TEMPLATE_INSTANTIATION(class foo<bar>);
146// in the .cpp file, use this:
147//   TEMPLATE_INSTANTIATION(class foo<bar>);
148#ifdef __GNUC__
149#define EXTERN_TEMPLATE_INSTANTIATION(X) __extension__ extern template X
150#define TEMPLATE_INSTANTIATION(X) template X
151#else
152#define EXTERN_TEMPLATE_INSTANTIATION(X)
153#define TEMPLATE_INSTANTIATION(X)
154#endif
155
156/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
157/// mark a method "not for inlining".
158#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
159#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
160#elif defined(_MSC_VER)
161#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
162#else
163#define LLVM_ATTRIBUTE_NOINLINE
164#endif
165
166/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
167/// so, mark a method "always inline" because it is performance sensitive. GCC
168/// 3.4 supported this but is buggy in various cases and produces unimplemented
169/// errors, just use it in GCC 4.0 and later.
170#if __GNUC__ > 3
171#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
172#elif defined(_MSC_VER)
173#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
174#else
175#define LLVM_ATTRIBUTE_ALWAYS_INLINE
176#endif
177
178
179#ifdef __GNUC__
180#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
181#elif defined(_MSC_VER)
182#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
183#else
184#define LLVM_ATTRIBUTE_NORETURN
185#endif
186
187/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
188/// pedantic diagnostics.
189#ifdef __GNUC__
190#define LLVM_EXTENSION __extension__
191#else
192#define LLVM_EXTENSION
193#endif
194
195// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
196#if __has_feature(attribute_deprecated_with_message)
197# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
198  decl __attribute__((deprecated(message)))
199#elif defined(__GNUC__)
200# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
201  decl __attribute__((deprecated))
202#elif defined(_MSC_VER)
203# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
204  __declspec(deprecated(message)) decl
205#else
206# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
207  decl
208#endif
209
210/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
211/// to an expression which states that it is undefined behavior for the
212/// compiler to reach this point.  Otherwise is not defined.
213#if defined(__clang__) || (__GNUC__ > 4) \
214 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
215# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
216#endif
217
218/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
219/// which causes the program to exit abnormally.
220#if defined(__clang__) || (__GNUC__ > 4) \
221 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
222# define LLVM_BUILTIN_TRAP __builtin_trap()
223#else
224# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
225#endif
226
227#endif
228