1 //===--- Builtins.cpp - Builtin function implementation -------------------===// 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 implements various things for builtin functions. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/Builtins.h" 14 #include "BuiltinTargetFeatures.h" 15 #include "clang/Basic/IdentifierTable.h" 16 #include "clang/Basic/LangOptions.h" 17 #include "clang/Basic/TargetInfo.h" 18 #include "llvm/ADT/StringRef.h" 19 using namespace clang; 20 21 const char *HeaderDesc::getName() const { 22 switch (ID) { 23 #define HEADER(ID, NAME) \ 24 case ID: \ 25 return NAME; 26 #include "clang/Basic/BuiltinHeaders.def" 27 #undef HEADER 28 }; 29 llvm_unreachable("Unknown HeaderDesc::HeaderID enum"); 30 } 31 32 static constexpr Builtin::Info BuiltinInfo[] = { 33 {"not a builtin function", nullptr, nullptr, nullptr, HeaderDesc::NO_HEADER, 34 ALL_LANGUAGES}, 35 #define BUILTIN(ID, TYPE, ATTRS) \ 36 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES}, 37 #define LANGBUILTIN(ID, TYPE, ATTRS, LANGS) \ 38 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANGS}, 39 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \ 40 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, LANGS}, 41 #include "clang/Basic/Builtins.inc" 42 }; 43 44 const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const { 45 if (ID < Builtin::FirstTSBuiltin) 46 return BuiltinInfo[ID]; 47 assert(((ID - Builtin::FirstTSBuiltin) < 48 (TSRecords.size() + AuxTSRecords.size())) && 49 "Invalid builtin ID!"); 50 if (isAuxBuiltinID(ID)) 51 return AuxTSRecords[getAuxBuiltinID(ID) - Builtin::FirstTSBuiltin]; 52 return TSRecords[ID - Builtin::FirstTSBuiltin]; 53 } 54 55 void Builtin::Context::InitializeTarget(const TargetInfo &Target, 56 const TargetInfo *AuxTarget) { 57 assert(TSRecords.empty() && "Already initialized target?"); 58 TSRecords = Target.getTargetBuiltins(); 59 if (AuxTarget) 60 AuxTSRecords = AuxTarget->getTargetBuiltins(); 61 } 62 63 bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) { 64 bool InStdNamespace = FuncName.consume_front("std-"); 65 for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; 66 ++i) { 67 if (FuncName == BuiltinInfo[i].Name && 68 (bool)strchr(BuiltinInfo[i].Attributes, 'z') == InStdNamespace) 69 return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr; 70 } 71 72 return false; 73 } 74 75 /// Is this builtin supported according to the given language options? 76 static bool builtinIsSupported(const Builtin::Info &BuiltinInfo, 77 const LangOptions &LangOpts) { 78 /* Builtins Unsupported */ 79 if (LangOpts.NoBuiltin && strchr(BuiltinInfo.Attributes, 'f') != nullptr) 80 return false; 81 /* CorBuiltins Unsupported */ 82 if (!LangOpts.Coroutines && (BuiltinInfo.Langs & COR_LANG)) 83 return false; 84 /* MathBuiltins Unsupported */ 85 if (LangOpts.NoMathBuiltin && BuiltinInfo.Header.ID == HeaderDesc::MATH_H) 86 return false; 87 /* GnuMode Unsupported */ 88 if (!LangOpts.GNUMode && (BuiltinInfo.Langs & GNU_LANG)) 89 return false; 90 /* MSMode Unsupported */ 91 if (!LangOpts.MicrosoftExt && (BuiltinInfo.Langs & MS_LANG)) 92 return false; 93 /* ObjC Unsupported */ 94 if (!LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG) 95 return false; 96 /* OpenCLC Unsupported */ 97 if (!LangOpts.OpenCL && (BuiltinInfo.Langs & ALL_OCL_LANGUAGES)) 98 return false; 99 /* OopenCL GAS Unsupported */ 100 if (!LangOpts.OpenCLGenericAddressSpace && (BuiltinInfo.Langs & OCL_GAS)) 101 return false; 102 /* OpenCL Pipe Unsupported */ 103 if (!LangOpts.OpenCLPipes && (BuiltinInfo.Langs & OCL_PIPE)) 104 return false; 105 106 // Device side enqueue is not supported until OpenCL 2.0. In 2.0 and higher 107 // support is indicated with language option for blocks. 108 109 /* OpenCL DSE Unsupported */ 110 if ((LangOpts.getOpenCLCompatibleVersion() < 200 || !LangOpts.Blocks) && 111 (BuiltinInfo.Langs & OCL_DSE)) 112 return false; 113 /* OpenMP Unsupported */ 114 if (!LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG) 115 return false; 116 /* CUDA Unsupported */ 117 if (!LangOpts.CUDA && BuiltinInfo.Langs == CUDA_LANG) 118 return false; 119 /* CPlusPlus Unsupported */ 120 if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG) 121 return false; 122 /* consteval Unsupported */ 123 if (!LangOpts.CPlusPlus20 && strchr(BuiltinInfo.Attributes, 'G') != nullptr) 124 return false; 125 return true; 126 } 127 128 /// initializeBuiltins - Mark the identifiers for all the builtins with their 129 /// appropriate builtin ID # and mark any non-portable builtin identifiers as 130 /// such. 131 void Builtin::Context::initializeBuiltins(IdentifierTable &Table, 132 const LangOptions& LangOpts) { 133 // Step #1: mark all target-independent builtins with their ID's. 134 for (unsigned i = Builtin::NotBuiltin+1; i != Builtin::FirstTSBuiltin; ++i) 135 if (builtinIsSupported(BuiltinInfo[i], LangOpts)) { 136 Table.get(BuiltinInfo[i].Name).setBuiltinID(i); 137 } 138 139 // Step #2: Register target-specific builtins. 140 for (unsigned i = 0, e = TSRecords.size(); i != e; ++i) 141 if (builtinIsSupported(TSRecords[i], LangOpts)) 142 Table.get(TSRecords[i].Name).setBuiltinID(i + Builtin::FirstTSBuiltin); 143 144 // Step #3: Register target-specific builtins for AuxTarget. 145 for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i) 146 Table.get(AuxTSRecords[i].Name) 147 .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size()); 148 149 // Step #4: Unregister any builtins specified by -fno-builtin-foo. 150 for (llvm::StringRef Name : LangOpts.NoBuiltinFuncs) { 151 bool InStdNamespace = Name.consume_front("std-"); 152 auto NameIt = Table.find(Name); 153 if (NameIt != Table.end()) { 154 unsigned ID = NameIt->second->getBuiltinID(); 155 if (ID != Builtin::NotBuiltin && isPredefinedLibFunction(ID) && 156 isInStdNamespace(ID) == InStdNamespace) { 157 NameIt->second->clearBuiltinID(); 158 } 159 } 160 } 161 } 162 163 unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const { 164 const char *WidthPos = ::strchr(getRecord(ID).Attributes, 'V'); 165 if (!WidthPos) 166 return 0; 167 168 ++WidthPos; 169 assert(*WidthPos == ':' && 170 "Vector width specifier must be followed by a ':'"); 171 ++WidthPos; 172 173 char *EndPos; 174 unsigned Width = ::strtol(WidthPos, &EndPos, 10); 175 assert(*EndPos == ':' && "Vector width specific must end with a ':'"); 176 return Width; 177 } 178 179 bool Builtin::Context::isLike(unsigned ID, unsigned &FormatIdx, 180 bool &HasVAListArg, const char *Fmt) const { 181 assert(Fmt && "Not passed a format string"); 182 assert(::strlen(Fmt) == 2 && 183 "Format string needs to be two characters long"); 184 assert(::toupper(Fmt[0]) == Fmt[1] && 185 "Format string is not in the form \"xX\""); 186 187 const char *Like = ::strpbrk(getRecord(ID).Attributes, Fmt); 188 if (!Like) 189 return false; 190 191 HasVAListArg = (*Like == Fmt[1]); 192 193 ++Like; 194 assert(*Like == ':' && "Format specifier must be followed by a ':'"); 195 ++Like; 196 197 assert(::strchr(Like, ':') && "Format specifier must end with a ':'"); 198 FormatIdx = ::strtol(Like, nullptr, 10); 199 return true; 200 } 201 202 bool Builtin::Context::isPrintfLike(unsigned ID, unsigned &FormatIdx, 203 bool &HasVAListArg) { 204 return isLike(ID, FormatIdx, HasVAListArg, "pP"); 205 } 206 207 bool Builtin::Context::isScanfLike(unsigned ID, unsigned &FormatIdx, 208 bool &HasVAListArg) { 209 return isLike(ID, FormatIdx, HasVAListArg, "sS"); 210 } 211 212 bool Builtin::Context::performsCallback(unsigned ID, 213 SmallVectorImpl<int> &Encoding) const { 214 const char *CalleePos = ::strchr(getRecord(ID).Attributes, 'C'); 215 if (!CalleePos) 216 return false; 217 218 ++CalleePos; 219 assert(*CalleePos == '<' && 220 "Callback callee specifier must be followed by a '<'"); 221 ++CalleePos; 222 223 char *EndPos; 224 int CalleeIdx = ::strtol(CalleePos, &EndPos, 10); 225 assert(CalleeIdx >= 0 && "Callee index is supposed to be positive!"); 226 Encoding.push_back(CalleeIdx); 227 228 while (*EndPos == ',') { 229 const char *PayloadPos = EndPos + 1; 230 231 int PayloadIdx = ::strtol(PayloadPos, &EndPos, 10); 232 Encoding.push_back(PayloadIdx); 233 } 234 235 assert(*EndPos == '>' && "Callback callee specifier must end with a '>'"); 236 return true; 237 } 238 239 bool Builtin::Context::canBeRedeclared(unsigned ID) const { 240 return ID == Builtin::NotBuiltin || ID == Builtin::BI__va_start || 241 ID == Builtin::BI__builtin_assume_aligned || 242 (!hasReferenceArgsOrResult(ID) && !hasCustomTypechecking(ID)) || 243 isInStdNamespace(ID); 244 } 245 246 bool Builtin::evaluateRequiredTargetFeatures( 247 StringRef RequiredFeatures, const llvm::StringMap<bool> &TargetFetureMap) { 248 // Return true if the builtin doesn't have any required features. 249 if (RequiredFeatures.empty()) 250 return true; 251 assert(!RequiredFeatures.contains(' ') && "Space in feature list"); 252 253 TargetFeatures TF(TargetFetureMap); 254 return TF.hasRequiredFeatures(RequiredFeatures); 255 } 256