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