1 //===- ClangOpenCLBuiltinEmitter.cpp - Generate Clang OpenCL Builtin handling 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 6 // See https://llvm.org/LICENSE.txt for license information. 7 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 8 // 9 //===----------------------------------------------------------------------===// 10 // 11 // This tablegen backend emits code for checking whether a function is an 12 // OpenCL builtin function. If so, all overloads of this function are 13 // added to the LookupResult. The generated include file is used by 14 // SemaLookup.cpp 15 // 16 // For a successful lookup of e.g. the "cos" builtin, isOpenCLBuiltin("cos") 17 // returns a pair <Index, Len>. 18 // BuiltinTable[Index] to BuiltinTable[Index + Len] contains the pairs 19 // <SigIndex, SigLen> of the overloads of "cos". 20 // SignatureTable[SigIndex] to SignatureTable[SigIndex + SigLen] contains 21 // one of the signatures of "cos". The SignatureTable entry can be 22 // referenced by other functions, e.g. "sin", to exploit the fact that 23 // many OpenCL builtins share the same signature. 24 // 25 // The file generated by this TableGen emitter contains the following: 26 // 27 // * Structs and enums to represent types and function signatures. 28 // 29 // * const char *FunctionExtensionTable[] 30 // List of space-separated OpenCL extensions. A builtin references an 31 // entry in this table when the builtin requires a particular (set of) 32 // extension(s) to be enabled. 33 // 34 // * OpenCLTypeStruct TypeTable[] 35 // Type information for return types and arguments. 36 // 37 // * unsigned SignatureTable[] 38 // A list of types representing function signatures. Each entry is an index 39 // into the above TypeTable. Multiple entries following each other form a 40 // signature, where the first entry is the return type and subsequent 41 // entries are the argument types. 42 // 43 // * OpenCLBuiltinStruct BuiltinTable[] 44 // Each entry represents one overload of an OpenCL builtin function and 45 // consists of an index into the SignatureTable and the number of arguments. 46 // 47 // * std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef Name) 48 // Find out whether a string matches an existing OpenCL builtin function 49 // name and return an index into BuiltinTable and the number of overloads. 50 // 51 // * void OCL2Qual(ASTContext&, OpenCLTypeStruct, std::vector<QualType>&) 52 // Convert an OpenCLTypeStruct type to a list of QualType instances. 53 // One OpenCLTypeStruct can represent multiple types, primarily when using 54 // GenTypes. 55 // 56 //===----------------------------------------------------------------------===// 57 58 #include "TableGenBackends.h" 59 #include "llvm/ADT/MapVector.h" 60 #include "llvm/ADT/STLExtras.h" 61 #include "llvm/ADT/SmallString.h" 62 #include "llvm/ADT/StringExtras.h" 63 #include "llvm/ADT/StringRef.h" 64 #include "llvm/ADT/StringSet.h" 65 #include "llvm/ADT/StringSwitch.h" 66 #include "llvm/Support/ErrorHandling.h" 67 #include "llvm/Support/raw_ostream.h" 68 #include "llvm/TableGen/Error.h" 69 #include "llvm/TableGen/Record.h" 70 #include "llvm/TableGen/StringMatcher.h" 71 #include "llvm/TableGen/TableGenBackend.h" 72 #include <set> 73 74 using namespace llvm; 75 76 namespace { 77 78 // A list of signatures that are shared by one or more builtin functions. 79 struct BuiltinTableEntries { 80 SmallVector<StringRef, 4> Names; 81 std::vector<std::pair<const Record *, unsigned>> Signatures; 82 }; 83 84 class BuiltinNameEmitter { 85 public: 86 BuiltinNameEmitter(RecordKeeper &Records, raw_ostream &OS) 87 : Records(Records), OS(OS) {} 88 89 // Entrypoint to generate the functions and structures for checking 90 // whether a function is an OpenCL builtin function. 91 void Emit(); 92 93 private: 94 // A list of indices into the builtin function table. 95 using BuiltinIndexListTy = SmallVector<unsigned, 11>; 96 97 // Contains OpenCL builtin functions and related information, stored as 98 // Record instances. They are coming from the associated TableGen file. 99 RecordKeeper &Records; 100 101 // The output file. 102 raw_ostream &OS; 103 104 // Helper function for BuiltinNameEmitter::EmitDeclarations. Generate enum 105 // definitions in the Output string parameter, and save their Record instances 106 // in the List parameter. 107 // \param Types (in) List containing the Types to extract. 108 // \param TypesSeen (inout) List containing the Types already extracted. 109 // \param Output (out) String containing the enums to emit in the output file. 110 // \param List (out) List containing the extracted Types, except the Types in 111 // TypesSeen. 112 void ExtractEnumTypes(std::vector<Record *> &Types, 113 StringMap<bool> &TypesSeen, std::string &Output, 114 std::vector<const Record *> &List); 115 116 // Emit the enum or struct used in the generated file. 117 // Populate the TypeList at the same time. 118 void EmitDeclarations(); 119 120 // Parse the Records generated by TableGen to populate the SignaturesList, 121 // FctOverloadMap and TypeMap. 122 void GetOverloads(); 123 124 // Compare two lists of signatures and check that e.g. the OpenCL version, 125 // function attributes, and extension are equal for each signature. 126 // \param Candidate (in) Entry in the SignatureListMap to check. 127 // \param SignatureList (in) List of signatures of the considered function. 128 // \returns true if the two lists of signatures are identical. 129 bool CanReuseSignature( 130 BuiltinIndexListTy *Candidate, 131 std::vector<std::pair<const Record *, unsigned>> &SignatureList); 132 133 // Group functions with the same list of signatures by populating the 134 // SignatureListMap. 135 // Some builtin functions have the same list of signatures, for example the 136 // "sin" and "cos" functions. To save space in the BuiltinTable, the 137 // "isOpenCLBuiltin" function will have the same output for these two 138 // function names. 139 void GroupBySignature(); 140 141 // Emit the FunctionExtensionTable that lists all function extensions. 142 void EmitExtensionTable(); 143 144 // Emit the TypeTable containing all types used by OpenCL builtins. 145 void EmitTypeTable(); 146 147 // Emit the SignatureTable. This table contains all the possible signatures. 148 // A signature is stored as a list of indexes of the TypeTable. 149 // The first index references the return type (mandatory), and the followings 150 // reference its arguments. 151 // E.g.: 152 // 15, 2, 15 can represent a function with the signature: 153 // int func(float, int) 154 // The "int" type being at the index 15 in the TypeTable. 155 void EmitSignatureTable(); 156 157 // Emit the BuiltinTable table. This table contains all the overloads of 158 // each function, and is a struct OpenCLBuiltinDecl. 159 // E.g.: 160 // // 891 convert_float2_rtn 161 // { 58, 2, 3, 100, 0 }, 162 // This means that the signature of this convert_float2_rtn overload has 163 // 1 argument (+1 for the return type), stored at index 58 in 164 // the SignatureTable. This prototype requires extension "3" in the 165 // FunctionExtensionTable. The last two values represent the minimum (1.0) 166 // and maximum (0, meaning no max version) OpenCL version in which this 167 // overload is supported. 168 void EmitBuiltinTable(); 169 170 // Emit a StringMatcher function to check whether a function name is an 171 // OpenCL builtin function name. 172 void EmitStringMatcher(); 173 174 // Emit a function returning the clang QualType instance associated with 175 // the TableGen Record Type. 176 void EmitQualTypeFinder(); 177 178 // Contains a list of the available signatures, without the name of the 179 // function. Each pair consists of a signature and a cumulative index. 180 // E.g.: <<float, float>, 0>, 181 // <<float, int, int, 2>>, 182 // <<float>, 5>, 183 // ... 184 // <<double, double>, 35>. 185 std::vector<std::pair<std::vector<Record *>, unsigned>> SignaturesList; 186 187 // Map the name of a builtin function to its prototypes (instances of the 188 // TableGen "Builtin" class). 189 // Each prototype is registered as a pair of: 190 // <pointer to the "Builtin" instance, 191 // cumulative index of the associated signature in the SignaturesList> 192 // E.g.: The function cos: (float cos(float), double cos(double), ...) 193 // <"cos", <<ptrToPrototype0, 5>, 194 // <ptrToPrototype1, 35>, 195 // <ptrToPrototype2, 79>> 196 // ptrToPrototype1 has the following signature: <double, double> 197 MapVector<StringRef, std::vector<std::pair<const Record *, unsigned>>> 198 FctOverloadMap; 199 200 // Contains the map of OpenCL types to their index in the TypeTable. 201 MapVector<const Record *, unsigned> TypeMap; 202 203 // List of OpenCL function extensions mapping extension strings to 204 // an index into the FunctionExtensionTable. 205 StringMap<unsigned> FunctionExtensionIndex; 206 207 // List of OpenCL type names in the same order as in enum OpenCLTypeID. 208 // This list does not contain generic types. 209 std::vector<const Record *> TypeList; 210 211 // Same as TypeList, but for generic types only. 212 std::vector<const Record *> GenTypeList; 213 214 // Map an ordered vector of signatures to their original Record instances, 215 // and to a list of function names that share these signatures. 216 // 217 // For example, suppose the "cos" and "sin" functions have only three 218 // signatures, and these signatures are at index Ix in the SignatureTable: 219 // cos | sin | Signature | Index 220 // float cos(float) | float sin(float) | Signature1 | I1 221 // double cos(double) | double sin(double) | Signature2 | I2 222 // half cos(half) | half sin(half) | Signature3 | I3 223 // 224 // Then we will create a mapping of the vector of signatures: 225 // SignatureListMap[<I1, I2, I3>] = < 226 // <"cos", "sin">, 227 // <Signature1, Signature2, Signature3>> 228 // The function "tan", having the same signatures, would be mapped to the 229 // same entry (<I1, I2, I3>). 230 MapVector<BuiltinIndexListTy *, BuiltinTableEntries> SignatureListMap; 231 }; 232 } // namespace 233 234 void BuiltinNameEmitter::Emit() { 235 emitSourceFileHeader("OpenCL Builtin handling", OS); 236 237 OS << "#include \"llvm/ADT/StringRef.h\"\n"; 238 OS << "using namespace clang;\n\n"; 239 240 // Emit enums and structs. 241 EmitDeclarations(); 242 243 // Parse the Records to populate the internal lists. 244 GetOverloads(); 245 GroupBySignature(); 246 247 // Emit tables. 248 EmitExtensionTable(); 249 EmitTypeTable(); 250 EmitSignatureTable(); 251 EmitBuiltinTable(); 252 253 // Emit functions. 254 EmitStringMatcher(); 255 EmitQualTypeFinder(); 256 } 257 258 void BuiltinNameEmitter::ExtractEnumTypes(std::vector<Record *> &Types, 259 StringMap<bool> &TypesSeen, 260 std::string &Output, 261 std::vector<const Record *> &List) { 262 raw_string_ostream SS(Output); 263 264 for (const auto *T : Types) { 265 if (TypesSeen.find(T->getValueAsString("Name")) == TypesSeen.end()) { 266 SS << " OCLT_" + T->getValueAsString("Name") << ",\n"; 267 // Save the type names in the same order as their enum value. Note that 268 // the Record can be a VectorType or something else, only the name is 269 // important. 270 List.push_back(T); 271 TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true)); 272 } 273 } 274 SS.flush(); 275 } 276 277 void BuiltinNameEmitter::EmitDeclarations() { 278 // Enum of scalar type names (float, int, ...) and generic type sets. 279 OS << "enum OpenCLTypeID {\n"; 280 281 StringMap<bool> TypesSeen; 282 std::string GenTypeEnums; 283 std::string TypeEnums; 284 285 // Extract generic types and non-generic types separately, to keep 286 // gentypes at the end of the enum which simplifies the special handling 287 // for gentypes in SemaLookup. 288 std::vector<Record *> GenTypes = 289 Records.getAllDerivedDefinitions("GenericType"); 290 ExtractEnumTypes(GenTypes, TypesSeen, GenTypeEnums, GenTypeList); 291 292 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type"); 293 ExtractEnumTypes(Types, TypesSeen, TypeEnums, TypeList); 294 295 OS << TypeEnums; 296 OS << GenTypeEnums; 297 OS << "};\n"; 298 299 // Structure definitions. 300 OS << R"( 301 // Image access qualifier. 302 enum OpenCLAccessQual : unsigned char { 303 OCLAQ_None, 304 OCLAQ_ReadOnly, 305 OCLAQ_WriteOnly, 306 OCLAQ_ReadWrite 307 }; 308 309 // Represents a return type or argument type. 310 struct OpenCLTypeStruct { 311 // A type (e.g. float, int, ...). 312 const OpenCLTypeID ID; 313 // Vector size (if applicable; 0 for scalars and generic types). 314 const unsigned VectorWidth; 315 // 0 if the type is not a pointer. 316 const bool IsPointer; 317 // 0 if the type is not const. 318 const bool IsConst; 319 // 0 if the type is not volatile. 320 const bool IsVolatile; 321 // Access qualifier. 322 const OpenCLAccessQual AccessQualifier; 323 // Address space of the pointer (if applicable). 324 const LangAS AS; 325 }; 326 327 // One overload of an OpenCL builtin function. 328 struct OpenCLBuiltinStruct { 329 // Index of the signature in the OpenCLTypeStruct table. 330 const unsigned SigTableIndex; 331 // Entries between index SigTableIndex and (SigTableIndex + NumTypes - 1) in 332 // the SignatureTable represent the complete signature. The first type at 333 // index SigTableIndex is the return type. 334 const unsigned NumTypes; 335 // Function attribute __attribute__((pure)) 336 const bool IsPure; 337 // Function attribute __attribute__((const)) 338 const bool IsConst; 339 // Function attribute __attribute__((convergent)) 340 const bool IsConv; 341 // OpenCL extension(s) required for this overload. 342 const unsigned short Extension; 343 // First OpenCL version in which this overload was introduced (e.g. CL20). 344 const unsigned short MinVersion; 345 // First OpenCL version in which this overload was removed (e.g. CL20). 346 const unsigned short MaxVersion; 347 }; 348 349 )"; 350 } 351 352 // Verify that the combination of GenTypes in a signature is supported. 353 // To simplify the logic for creating overloads in SemaLookup, only allow 354 // a signature to contain different GenTypes if these GenTypes represent 355 // the same number of actual scalar or vector types. 356 // 357 // Exit with a fatal error if an unsupported construct is encountered. 358 static void VerifySignature(const std::vector<Record *> &Signature, 359 const Record *BuiltinRec) { 360 unsigned GenTypeVecSizes = 1; 361 unsigned GenTypeTypes = 1; 362 363 for (const auto *T : Signature) { 364 // Check all GenericType arguments in this signature. 365 if (T->isSubClassOf("GenericType")) { 366 // Check number of vector sizes. 367 unsigned NVecSizes = 368 T->getValueAsDef("VectorList")->getValueAsListOfInts("List").size(); 369 if (NVecSizes != GenTypeVecSizes && NVecSizes != 1) { 370 if (GenTypeVecSizes > 1) { 371 // We already saw a gentype with a different number of vector sizes. 372 PrintFatalError(BuiltinRec->getLoc(), 373 "number of vector sizes should be equal or 1 for all gentypes " 374 "in a declaration"); 375 } 376 GenTypeVecSizes = NVecSizes; 377 } 378 379 // Check number of data types. 380 unsigned NTypes = 381 T->getValueAsDef("TypeList")->getValueAsListOfDefs("List").size(); 382 if (NTypes != GenTypeTypes && NTypes != 1) { 383 if (GenTypeTypes > 1) { 384 // We already saw a gentype with a different number of types. 385 PrintFatalError(BuiltinRec->getLoc(), 386 "number of types should be equal or 1 for all gentypes " 387 "in a declaration"); 388 } 389 GenTypeTypes = NTypes; 390 } 391 } 392 } 393 } 394 395 void BuiltinNameEmitter::GetOverloads() { 396 // Populate the TypeMap. 397 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type"); 398 unsigned I = 0; 399 for (const auto &T : Types) { 400 TypeMap.insert(std::make_pair(T, I++)); 401 } 402 403 // Populate the SignaturesList and the FctOverloadMap. 404 unsigned CumulativeSignIndex = 0; 405 std::vector<Record *> Builtins = Records.getAllDerivedDefinitions("Builtin"); 406 for (const auto *B : Builtins) { 407 StringRef BName = B->getValueAsString("Name"); 408 if (FctOverloadMap.find(BName) == FctOverloadMap.end()) { 409 FctOverloadMap.insert(std::make_pair( 410 BName, std::vector<std::pair<const Record *, unsigned>>{})); 411 } 412 413 auto Signature = B->getValueAsListOfDefs("Signature"); 414 // Reuse signatures to avoid unnecessary duplicates. 415 auto it = 416 std::find_if(SignaturesList.begin(), SignaturesList.end(), 417 [&](const std::pair<std::vector<Record *>, unsigned> &a) { 418 return a.first == Signature; 419 }); 420 unsigned SignIndex; 421 if (it == SignaturesList.end()) { 422 VerifySignature(Signature, B); 423 SignaturesList.push_back(std::make_pair(Signature, CumulativeSignIndex)); 424 SignIndex = CumulativeSignIndex; 425 CumulativeSignIndex += Signature.size(); 426 } else { 427 SignIndex = it->second; 428 } 429 FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex)); 430 } 431 } 432 433 void BuiltinNameEmitter::EmitExtensionTable() { 434 OS << "static const char *FunctionExtensionTable[] = {\n"; 435 unsigned Index = 0; 436 std::vector<Record *> FuncExtensions = 437 Records.getAllDerivedDefinitions("FunctionExtension"); 438 439 for (const auto &FE : FuncExtensions) { 440 // Emit OpenCL extension table entry. 441 OS << " // " << Index << ": " << FE->getName() << "\n" 442 << " \"" << FE->getValueAsString("ExtName") << "\",\n"; 443 444 // Record index of this extension. 445 FunctionExtensionIndex[FE->getName()] = Index++; 446 } 447 OS << "};\n\n"; 448 } 449 450 void BuiltinNameEmitter::EmitTypeTable() { 451 OS << "static const OpenCLTypeStruct TypeTable[] = {\n"; 452 for (const auto &T : TypeMap) { 453 const char *AccessQual = 454 StringSwitch<const char *>(T.first->getValueAsString("AccessQualifier")) 455 .Case("RO", "OCLAQ_ReadOnly") 456 .Case("WO", "OCLAQ_WriteOnly") 457 .Case("RW", "OCLAQ_ReadWrite") 458 .Default("OCLAQ_None"); 459 460 OS << " // " << T.second << "\n" 461 << " {OCLT_" << T.first->getValueAsString("Name") << ", " 462 << T.first->getValueAsInt("VecWidth") << ", " 463 << T.first->getValueAsBit("IsPointer") << ", " 464 << T.first->getValueAsBit("IsConst") << ", " 465 << T.first->getValueAsBit("IsVolatile") << ", " 466 << AccessQual << ", " 467 << T.first->getValueAsString("AddrSpace") << "},\n"; 468 } 469 OS << "};\n\n"; 470 } 471 472 void BuiltinNameEmitter::EmitSignatureTable() { 473 // Store a type (e.g. int, float, int2, ...). The type is stored as an index 474 // of a struct OpenCLType table. Multiple entries following each other form a 475 // signature. 476 OS << "static const unsigned SignatureTable[] = {\n"; 477 for (const auto &P : SignaturesList) { 478 OS << " // " << P.second << "\n "; 479 for (const Record *R : P.first) { 480 OS << TypeMap.find(R)->second << ", "; 481 } 482 OS << "\n"; 483 } 484 OS << "};\n\n"; 485 } 486 487 void BuiltinNameEmitter::EmitBuiltinTable() { 488 unsigned Index = 0; 489 490 OS << "static const OpenCLBuiltinStruct BuiltinTable[] = {\n"; 491 for (const auto &SLM : SignatureListMap) { 492 493 OS << " // " << (Index + 1) << ": "; 494 for (const auto &Name : SLM.second.Names) { 495 OS << Name << ", "; 496 } 497 OS << "\n"; 498 499 for (const auto &Overload : SLM.second.Signatures) { 500 StringRef ExtName = Overload.first->getValueAsDef("Extension")->getName(); 501 OS << " { " << Overload.second << ", " 502 << Overload.first->getValueAsListOfDefs("Signature").size() << ", " 503 << (Overload.first->getValueAsBit("IsPure")) << ", " 504 << (Overload.first->getValueAsBit("IsConst")) << ", " 505 << (Overload.first->getValueAsBit("IsConv")) << ", " 506 << FunctionExtensionIndex[ExtName] << ", " 507 << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("ID") 508 << ", " 509 << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID") 510 << " },\n"; 511 Index++; 512 } 513 } 514 OS << "};\n\n"; 515 } 516 517 bool BuiltinNameEmitter::CanReuseSignature( 518 BuiltinIndexListTy *Candidate, 519 std::vector<std::pair<const Record *, unsigned>> &SignatureList) { 520 assert(Candidate->size() == SignatureList.size() && 521 "signature lists should have the same size"); 522 523 auto &CandidateSigs = 524 SignatureListMap.find(Candidate)->second.Signatures; 525 for (unsigned Index = 0; Index < Candidate->size(); Index++) { 526 const Record *Rec = SignatureList[Index].first; 527 const Record *Rec2 = CandidateSigs[Index].first; 528 if (Rec->getValueAsBit("IsPure") == Rec2->getValueAsBit("IsPure") && 529 Rec->getValueAsBit("IsConst") == Rec2->getValueAsBit("IsConst") && 530 Rec->getValueAsBit("IsConv") == Rec2->getValueAsBit("IsConv") && 531 Rec->getValueAsDef("MinVersion")->getValueAsInt("ID") == 532 Rec2->getValueAsDef("MinVersion")->getValueAsInt("ID") && 533 Rec->getValueAsDef("MaxVersion")->getValueAsInt("ID") == 534 Rec2->getValueAsDef("MaxVersion")->getValueAsInt("ID") && 535 Rec->getValueAsDef("Extension")->getName() == 536 Rec2->getValueAsDef("Extension")->getName()) { 537 return true; 538 } 539 } 540 return false; 541 } 542 543 void BuiltinNameEmitter::GroupBySignature() { 544 // List of signatures known to be emitted. 545 std::vector<BuiltinIndexListTy *> KnownSignatures; 546 547 for (auto &Fct : FctOverloadMap) { 548 bool FoundReusableSig = false; 549 550 // Gather all signatures for the current function. 551 auto *CurSignatureList = new BuiltinIndexListTy(); 552 for (const auto &Signature : Fct.second) { 553 CurSignatureList->push_back(Signature.second); 554 } 555 // Sort the list to facilitate future comparisons. 556 std::sort(CurSignatureList->begin(), CurSignatureList->end()); 557 558 // Check if we have already seen another function with the same list of 559 // signatures. If so, just add the name of the function. 560 for (auto *Candidate : KnownSignatures) { 561 if (Candidate->size() == CurSignatureList->size() && 562 *Candidate == *CurSignatureList) { 563 if (CanReuseSignature(Candidate, Fct.second)) { 564 SignatureListMap.find(Candidate)->second.Names.push_back(Fct.first); 565 FoundReusableSig = true; 566 } 567 } 568 } 569 570 if (FoundReusableSig) { 571 delete CurSignatureList; 572 } else { 573 // Add a new entry. 574 SignatureListMap[CurSignatureList] = { 575 SmallVector<StringRef, 4>(1, Fct.first), Fct.second}; 576 KnownSignatures.push_back(CurSignatureList); 577 } 578 } 579 580 for (auto *I : KnownSignatures) { 581 delete I; 582 } 583 } 584 585 void BuiltinNameEmitter::EmitStringMatcher() { 586 std::vector<StringMatcher::StringPair> ValidBuiltins; 587 unsigned CumulativeIndex = 1; 588 589 for (const auto &SLM : SignatureListMap) { 590 const auto &Ovl = SLM.second.Signatures; 591 592 // A single signature list may be used by different builtins. Return the 593 // same <index, length> pair for each of those builtins. 594 for (const auto &FctName : SLM.second.Names) { 595 std::string RetStmt; 596 raw_string_ostream SS(RetStmt); 597 SS << "return std::make_pair(" << CumulativeIndex << ", " << Ovl.size() 598 << ");"; 599 SS.flush(); 600 ValidBuiltins.push_back(StringMatcher::StringPair(FctName, RetStmt)); 601 } 602 CumulativeIndex += Ovl.size(); 603 } 604 605 OS << R"( 606 // Find out whether a string matches an existing OpenCL builtin function name. 607 // Returns: A pair <0, 0> if no name matches. 608 // A pair <Index, Len> indexing the BuiltinTable if the name is 609 // matching an OpenCL builtin function. 610 static std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef Name) { 611 612 )"; 613 614 StringMatcher("Name", ValidBuiltins, OS).Emit(0, true); 615 616 OS << " return std::make_pair(0, 0);\n"; 617 OS << "} // isOpenCLBuiltin\n"; 618 } 619 620 void BuiltinNameEmitter::EmitQualTypeFinder() { 621 OS << R"( 622 623 // Convert an OpenCLTypeStruct type to a list of QualTypes. 624 // Generic types represent multiple types and vector sizes, thus a vector 625 // is returned. The conversion is done in two steps: 626 // Step 1: A switch statement fills a vector with scalar base types for the 627 // Cartesian product of (vector sizes) x (types) for generic types, 628 // or a single scalar type for non generic types. 629 // Step 2: Qualifiers and other type properties such as vector size are 630 // applied. 631 static void OCL2Qual(ASTContext &Context, const OpenCLTypeStruct &Ty, 632 llvm::SmallVectorImpl<QualType> &QT) { 633 // Number of scalar types in the GenType. 634 unsigned GenTypeNumTypes; 635 // Pointer to the list of vector sizes for the GenType. 636 llvm::ArrayRef<unsigned> GenVectorSizes; 637 )"; 638 639 // Generate list of vector sizes for each generic type. 640 for (const auto *VectList : Records.getAllDerivedDefinitions("IntList")) { 641 OS << " constexpr unsigned List" 642 << VectList->getValueAsString("Name") << "[] = {"; 643 for (const auto V : VectList->getValueAsListOfInts("List")) { 644 OS << V << ", "; 645 } 646 OS << "};\n"; 647 } 648 649 // Step 1. 650 // Start of switch statement over all types. 651 OS << "\n switch (Ty.ID) {\n"; 652 653 // Switch cases for image types (Image2d, Image3d, ...) 654 std::vector<Record *> ImageTypes = 655 Records.getAllDerivedDefinitions("ImageType"); 656 657 // Map an image type name to its 3 access-qualified types (RO, WO, RW). 658 std::map<StringRef, SmallVector<Record *, 3>> ImageTypesMap; 659 for (auto *IT : ImageTypes) { 660 auto Entry = ImageTypesMap.find(IT->getValueAsString("Name")); 661 if (Entry == ImageTypesMap.end()) { 662 SmallVector<Record *, 3> ImageList; 663 ImageList.push_back(IT); 664 ImageTypesMap.insert( 665 std::make_pair(IT->getValueAsString("Name"), ImageList)); 666 } else { 667 Entry->second.push_back(IT); 668 } 669 } 670 671 // Emit the cases for the image types. For an image type name, there are 3 672 // corresponding QualTypes ("RO", "WO", "RW"). The "AccessQualifier" field 673 // tells which one is needed. Emit a switch statement that puts the 674 // corresponding QualType into "QT". 675 for (const auto &ITE : ImageTypesMap) { 676 OS << " case OCLT_" << ITE.first.str() << ":\n" 677 << " switch (Ty.AccessQualifier) {\n" 678 << " case OCLAQ_None:\n" 679 << " llvm_unreachable(\"Image without access qualifier\");\n"; 680 for (const auto &Image : ITE.second) { 681 OS << StringSwitch<const char *>( 682 Image->getValueAsString("AccessQualifier")) 683 .Case("RO", " case OCLAQ_ReadOnly:\n") 684 .Case("WO", " case OCLAQ_WriteOnly:\n") 685 .Case("RW", " case OCLAQ_ReadWrite:\n") 686 << " QT.push_back(Context." 687 << Image->getValueAsDef("QTName")->getValueAsString("Name") << ");\n" 688 << " break;\n"; 689 } 690 OS << " }\n" 691 << " break;\n"; 692 } 693 694 // Switch cases for generic types. 695 for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) { 696 OS << " case OCLT_" << GenType->getValueAsString("Name") << ":\n"; 697 OS << " QT.append({"; 698 699 // Build the Cartesian product of (vector sizes) x (types). Only insert 700 // the plain scalar types for now; other type information such as vector 701 // size and type qualifiers will be added after the switch statement. 702 for (unsigned I = 0; I < GenType->getValueAsDef("VectorList") 703 ->getValueAsListOfInts("List") 704 .size(); 705 I++) { 706 for (const auto *T : 707 GenType->getValueAsDef("TypeList")->getValueAsListOfDefs("List")) { 708 OS << "Context." 709 << T->getValueAsDef("QTName")->getValueAsString("Name") << ", "; 710 } 711 } 712 OS << "});\n"; 713 // GenTypeNumTypes is the number of types in the GenType 714 // (e.g. float/double/half). 715 OS << " GenTypeNumTypes = " 716 << GenType->getValueAsDef("TypeList")->getValueAsListOfDefs("List") 717 .size() 718 << ";\n"; 719 // GenVectorSizes is the list of vector sizes for this GenType. 720 // QT contains GenTypeNumTypes * #GenVectorSizes elements. 721 OS << " GenVectorSizes = List" 722 << GenType->getValueAsDef("VectorList")->getValueAsString("Name") 723 << ";\n"; 724 OS << " break;\n"; 725 } 726 727 // Switch cases for non generic, non image types (int, int4, float, ...). 728 // Only insert the plain scalar type; vector information and type qualifiers 729 // are added in step 2. 730 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type"); 731 StringMap<bool> TypesSeen; 732 733 for (const auto *T : Types) { 734 // Check this is not an image type 735 if (ImageTypesMap.find(T->getValueAsString("Name")) != ImageTypesMap.end()) 736 continue; 737 // Check we have not seen this Type 738 if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end()) 739 continue; 740 TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true)); 741 742 // Check the Type does not have an "abstract" QualType 743 auto QT = T->getValueAsDef("QTName"); 744 if (QT->getValueAsBit("IsAbstract") == 1) 745 continue; 746 // Emit the cases for non generic, non image types. 747 OS << " case OCLT_" << T->getValueAsString("Name") << ":\n"; 748 OS << " QT.push_back(Context." << QT->getValueAsString("Name") 749 << ");\n"; 750 OS << " break;\n"; 751 } 752 753 // End of switch statement. 754 OS << " } // end of switch (Ty.ID)\n\n"; 755 756 // Step 2. 757 // Add ExtVector types if this was a generic type, as the switch statement 758 // above only populated the list with scalar types. This completes the 759 // construction of the Cartesian product of (vector sizes) x (types). 760 OS << " // Construct the different vector types for each generic type.\n"; 761 OS << " if (Ty.ID >= " << TypeList.size() << ") {"; 762 OS << R"( 763 for (unsigned I = 0; I < QT.size(); I++) { 764 // For scalars, size is 1. 765 if (GenVectorSizes[I / GenTypeNumTypes] != 1) { 766 QT[I] = Context.getExtVectorType(QT[I], 767 GenVectorSizes[I / GenTypeNumTypes]); 768 } 769 } 770 } 771 )"; 772 773 // Assign the right attributes to the types (e.g. vector size). 774 OS << R"( 775 // Set vector size for non-generic vector types. 776 if (Ty.VectorWidth > 1) { 777 for (unsigned Index = 0; Index < QT.size(); Index++) { 778 QT[Index] = Context.getExtVectorType(QT[Index], Ty.VectorWidth); 779 } 780 } 781 782 if (Ty.IsVolatile != 0) { 783 for (unsigned Index = 0; Index < QT.size(); Index++) { 784 QT[Index] = Context.getVolatileType(QT[Index]); 785 } 786 } 787 788 if (Ty.IsConst != 0) { 789 for (unsigned Index = 0; Index < QT.size(); Index++) { 790 QT[Index] = Context.getConstType(QT[Index]); 791 } 792 } 793 794 // Transform the type to a pointer as the last step, if necessary. 795 // Builtin functions only have pointers on [const|volatile], no 796 // [const|volatile] pointers, so this is ok to do it as a last step. 797 if (Ty.IsPointer != 0) { 798 for (unsigned Index = 0; Index < QT.size(); Index++) { 799 QT[Index] = Context.getAddrSpaceQualType(QT[Index], Ty.AS); 800 QT[Index] = Context.getPointerType(QT[Index]); 801 } 802 } 803 )"; 804 805 // End of the "OCL2Qual" function. 806 OS << "\n} // OCL2Qual\n"; 807 } 808 809 void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) { 810 BuiltinNameEmitter NameChecker(Records, OS); 811 NameChecker.Emit(); 812 } 813