1 //===--- Builtins.h - Builtin function header -------------------*- 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 /// \file 11 /// \brief Defines enum values for all the target-independent builtin 12 /// functions. 13 /// 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CLANG_BASIC_BUILTINS_H 17 #define LLVM_CLANG_BASIC_BUILTINS_H 18 19 #include "llvm/ADT/ArrayRef.h" 20 #include <cstring> 21 22 // VC++ defines 'alloca' as an object-like macro, which interferes with our 23 // builtins. 24 #undef alloca 25 26 namespace clang { 27 class TargetInfo; 28 class IdentifierTable; 29 class ASTContext; 30 class QualType; 31 class LangOptions; 32 33 enum LanguageID { 34 GNU_LANG = 0x1, // builtin requires GNU mode. 35 C_LANG = 0x2, // builtin for c only. 36 CXX_LANG = 0x4, // builtin for cplusplus only. 37 OBJC_LANG = 0x8, // builtin for objective-c and objective-c++ 38 MS_LANG = 0x10, // builtin requires MS mode. 39 OCLC20_LANG = 0x20, // builtin for OpenCL C 2.0 only. 40 OCLC1X_LANG = 0x40, // builtin for OpenCL C 1.x only. 41 OMP_LANG = 0x80, // builtin requires OpenMP. 42 ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages. 43 ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG, // builtin requires GNU mode. 44 ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG, // builtin requires MS mode. 45 ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC20_LANG // builtin for OCLC languages. 46 }; 47 48 namespace Builtin { 49 enum ID { 50 NotBuiltin = 0, // This is not a builtin function. 51 #define BUILTIN(ID, TYPE, ATTRS) BI##ID, 52 #include "clang/Basic/Builtins.def" 53 FirstTSBuiltin 54 }; 55 56 struct Info { 57 const char *Name, *Type, *Attributes, *HeaderName; 58 LanguageID Langs; 59 const char *Features; 60 }; 61 62 /// \brief Holds information about both target-independent and 63 /// target-specific builtins, allowing easy queries by clients. 64 /// 65 /// Builtins from an optional auxiliary target are stored in 66 /// AuxTSRecords. Their IDs are shifted up by TSRecords.size() and need to 67 /// be translated back with getAuxBuiltinID() before use. 68 class Context { 69 llvm::ArrayRef<Info> TSRecords; 70 llvm::ArrayRef<Info> AuxTSRecords; 71 72 public: 73 Context() {} 74 75 /// \brief Perform target-specific initialization 76 /// \param AuxTarget Target info to incorporate builtins from. May be nullptr. 77 void InitializeTarget(const TargetInfo &Target, const TargetInfo *AuxTarget); 78 79 /// \brief Mark the identifiers for all the builtins with their 80 /// appropriate builtin ID # and mark any non-portable builtin identifiers as 81 /// such. 82 void initializeBuiltins(IdentifierTable &Table, const LangOptions& LangOpts); 83 84 /// \brief Return the identifier name for the specified builtin, 85 /// e.g. "__builtin_abs". 86 const char *getName(unsigned ID) const { 87 return getRecord(ID).Name; 88 } 89 90 /// \brief Get the type descriptor string for the specified builtin. 91 const char *getTypeString(unsigned ID) const { 92 return getRecord(ID).Type; 93 } 94 95 /// \brief Return true if this function is a target-specific builtin. 96 bool isTSBuiltin(unsigned ID) const { 97 return ID >= Builtin::FirstTSBuiltin; 98 } 99 100 /// \brief Return true if this function has no side effects. 101 bool isPure(unsigned ID) const { 102 return strchr(getRecord(ID).Attributes, 'U') != nullptr; 103 } 104 105 /// \brief Return true if this function has no side effects and doesn't 106 /// read memory. 107 bool isConst(unsigned ID) const { 108 return strchr(getRecord(ID).Attributes, 'c') != nullptr; 109 } 110 111 /// \brief Return true if we know this builtin never throws an exception. 112 bool isNoThrow(unsigned ID) const { 113 return strchr(getRecord(ID).Attributes, 'n') != nullptr; 114 } 115 116 /// \brief Return true if we know this builtin never returns. 117 bool isNoReturn(unsigned ID) const { 118 return strchr(getRecord(ID).Attributes, 'r') != nullptr; 119 } 120 121 /// \brief Return true if we know this builtin can return twice. 122 bool isReturnsTwice(unsigned ID) const { 123 return strchr(getRecord(ID).Attributes, 'j') != nullptr; 124 } 125 126 /// \brief Returns true if this builtin does not perform the side-effects 127 /// of its arguments. 128 bool isUnevaluated(unsigned ID) const { 129 return strchr(getRecord(ID).Attributes, 'u') != nullptr; 130 } 131 132 /// \brief Return true if this is a builtin for a libc/libm function, 133 /// with a "__builtin_" prefix (e.g. __builtin_abs). 134 bool isLibFunction(unsigned ID) const { 135 return strchr(getRecord(ID).Attributes, 'F') != nullptr; 136 } 137 138 /// \brief Determines whether this builtin is a predefined libc/libm 139 /// function, such as "malloc", where we know the signature a 140 /// priori. 141 bool isPredefinedLibFunction(unsigned ID) const { 142 return strchr(getRecord(ID).Attributes, 'f') != nullptr; 143 } 144 145 /// \brief Returns true if this builtin requires appropriate header in other 146 /// compilers. In Clang it will work even without including it, but we can emit 147 /// a warning about missing header. 148 bool isHeaderDependentFunction(unsigned ID) const { 149 return strchr(getRecord(ID).Attributes, 'h') != nullptr; 150 } 151 152 /// \brief Determines whether this builtin is a predefined compiler-rt/libgcc 153 /// function, such as "__clear_cache", where we know the signature a 154 /// priori. 155 bool isPredefinedRuntimeFunction(unsigned ID) const { 156 return strchr(getRecord(ID).Attributes, 'i') != nullptr; 157 } 158 159 /// \brief Determines whether this builtin has custom typechecking. 160 bool hasCustomTypechecking(unsigned ID) const { 161 return strchr(getRecord(ID).Attributes, 't') != nullptr; 162 } 163 164 /// \brief Determines whether this builtin has a result or any arguments which 165 /// are pointer types. 166 bool hasPtrArgsOrResult(unsigned ID) const { 167 return strchr(getRecord(ID).Type, '*') != nullptr; 168 } 169 170 /// \brief Completely forget that the given ID was ever considered a builtin, 171 /// e.g., because the user provided a conflicting signature. 172 void forgetBuiltin(unsigned ID, IdentifierTable &Table); 173 174 /// \brief If this is a library function that comes from a specific 175 /// header, retrieve that header name. 176 const char *getHeaderName(unsigned ID) const { 177 return getRecord(ID).HeaderName; 178 } 179 180 /// \brief Determine whether this builtin is like printf in its 181 /// formatting rules and, if so, set the index to the format string 182 /// argument and whether this function as a va_list argument. 183 bool isPrintfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg); 184 185 /// \brief Determine whether this builtin is like scanf in its 186 /// formatting rules and, if so, set the index to the format string 187 /// argument and whether this function as a va_list argument. 188 bool isScanfLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg); 189 190 /// \brief Return true if this function has no side effects and doesn't 191 /// read memory, except for possibly errno. 192 /// 193 /// Such functions can be const when the MathErrno lang option is disabled. 194 bool isConstWithoutErrno(unsigned ID) const { 195 return strchr(getRecord(ID).Attributes, 'e') != nullptr; 196 } 197 198 const char *getRequiredFeatures(unsigned ID) const { 199 return getRecord(ID).Features; 200 } 201 202 /// \brief Return true if builtin ID belongs to AuxTarget. 203 bool isAuxBuiltinID(unsigned ID) const { 204 return ID >= (Builtin::FirstTSBuiltin + TSRecords.size()); 205 } 206 207 /// Return real buitin ID (i.e. ID it would have furing compilation 208 /// for AuxTarget). 209 unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSRecords.size(); } 210 211 /// Returns true if this is a libc/libm function without the '__builtin_' 212 /// prefix. 213 static bool isBuiltinFunc(const char *Name); 214 215 private: 216 const Info &getRecord(unsigned ID) const; 217 218 /// \brief Is this builtin supported according to the given language options? 219 bool builtinIsSupported(const Builtin::Info &BuiltinInfo, 220 const LangOptions &LangOpts); 221 222 /// \brief Helper function for isPrintfLike and isScanfLike. 223 bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg, 224 const char *Fmt) const; 225 }; 226 227 } 228 229 /// \brief Kinds of BuiltinTemplateDecl. 230 enum BuiltinTemplateKind : int { 231 /// \brief This names the __make_integer_seq BuiltinTemplateDecl. 232 BTK__make_integer_seq, 233 234 /// \brief This names the __type_pack_element BuiltinTemplateDecl. 235 BTK__type_pack_element 236 }; 237 238 } // end namespace clang 239 #endif 240
