1 //===- ClangOpenCLBuiltinEmitter.cpp - Generate Clang OpenCL Builtin handling
3 // The LLVM Compiler Infrastructure
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
9 //===----------------------------------------------------------------------===//
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
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.
25 // The file generated by this TableGen emitter contains the following:
27 // * Structs and enums to represent types and function signatures.
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.
34 // * OpenCLTypeStruct TypeTable[]
35 // Type information for return types and arguments.
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.
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.
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.
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
56 //===----------------------------------------------------------------------===//
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"
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;
84 class BuiltinNameEmitter {
86 BuiltinNameEmitter(RecordKeeper &Records, raw_ostream &OS)
87 : Records(Records), OS(OS) {}
89 // Entrypoint to generate the functions and structures for checking
90 // whether a function is an OpenCL builtin function.
94 // A list of indices into the builtin function table.
95 using BuiltinIndexListTy = SmallVector<unsigned, 11>;
97 // Contains OpenCL builtin functions and related information, stored as
98 // Record instances. They are coming from the associated TableGen file.
99 RecordKeeper &Records;
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
112 void ExtractEnumTypes(std::vector<Record *> &Types,
113 StringMap<bool> &TypesSeen, std::string &Output,
114 std::vector<const Record *> &List);
116 // Emit the enum or struct used in the generated file.
117 // Populate the TypeList at the same time.
118 void EmitDeclarations();
120 // Parse the Records generated by TableGen to populate the SignaturesList,
121 // FctOverloadMap and TypeMap.
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);
133 // Group functions with the same list of signatures by populating the
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
139 void GroupBySignature();
141 // Emit the FunctionExtensionTable that lists all function extensions.
142 void EmitExtensionTable();
144 // Emit the TypeTable containing all types used by OpenCL builtins.
145 void EmitTypeTable();
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.
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();
157 // Emit the BuiltinTable table. This table contains all the overloads of
158 // each function, and is a struct OpenCLBuiltinDecl.
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();
170 // Emit a StringMatcher function to check whether a function name is an
171 // OpenCL builtin function name.
172 void EmitStringMatcher();
174 // Emit a function returning the clang QualType instance associated with
175 // the TableGen Record Type.
176 void EmitQualTypeFinder();
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>>,
184 // <<double, double>, 35>.
185 std::vector<std::pair<std::vector<Record *>, unsigned>> SignaturesList;
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>>>
200 // Contains the map of OpenCL types to their index in the TypeTable.
201 MapVector<const Record *, unsigned> TypeMap;
203 // List of OpenCL function extensions mapping extension strings to
204 // an index into the FunctionExtensionTable.
205 StringMap<unsigned> FunctionExtensionIndex;
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;
211 // Same as TypeList, but for generic types only.
212 std::vector<const Record *> GenTypeList;
214 // Map an ordered vector of signatures to their original Record instances,
215 // and to a list of function names that share these signatures.
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
224 // Then we will create a mapping of the vector of signatures:
225 // SignatureListMap[<I1, I2, I3>] = <
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;
234 void BuiltinNameEmitter::Emit() {
235 emitSourceFileHeader("OpenCL Builtin handling", OS);
237 OS << "#include \"llvm/ADT/StringRef.h\"\n";
238 OS << "using namespace clang;\n\n";
240 // Emit enums and structs.
243 // Parse the Records to populate the internal lists.
248 EmitExtensionTable();
250 EmitSignatureTable();
255 EmitQualTypeFinder();
258 void BuiltinNameEmitter::ExtractEnumTypes(std::vector<Record *> &Types,
259 StringMap<bool> &TypesSeen,
261 std::vector<const Record *> &List) {
262 raw_string_ostream SS(Output);
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
271 TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
277 void BuiltinNameEmitter::EmitDeclarations() {
278 // Enum of scalar type names (float, int, ...) and generic type sets.
279 OS << "enum OpenCLTypeID {\n";
281 StringMap<bool> TypesSeen;
282 std::string GenTypeEnums;
283 std::string TypeEnums;
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);
292 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
293 ExtractEnumTypes(Types, TypesSeen, TypeEnums, TypeList);
299 // Structure definitions.
301 // Image access qualifier.
302 enum OpenCLAccessQual : unsigned char {
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.
319 // 0 if the type is not volatile.
320 const bool IsVolatile;
322 const OpenCLAccessQual AccessQualifier;
323 // Address space of the pointer (if applicable).
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))
337 // Function attribute __attribute__((const))
339 // Function attribute __attribute__((convergent))
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;
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.
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;
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.
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 "
376 GenTypeVecSizes = NVecSizes;
379 // Check number of data types.
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 "
389 GenTypeTypes = NTypes;
395 void BuiltinNameEmitter::GetOverloads() {
396 // Populate the TypeMap.
397 std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
399 for (const auto &T : Types) {
400 TypeMap.insert(std::make_pair(T, I++));
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>>{}));
413 auto Signature = B->getValueAsListOfDefs("Signature");
414 // Reuse signatures to avoid unnecessary duplicates.
416 std::find_if(SignaturesList.begin(), SignaturesList.end(),
417 [&](const std::pair<std::vector<Record *>, unsigned> &a) {
418 return a.first == Signature;
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();
427 SignIndex = it->second;
429 FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
433 void BuiltinNameEmitter::EmitExtensionTable() {
434 OS << "static const char *FunctionExtensionTable[] = {\n";
436 std::vector<Record *> FuncExtensions =
437 Records.getAllDerivedDefinitions("FunctionExtension");
439 for (const auto &FE : FuncExtensions) {
440 // Emit OpenCL extension table entry.
441 OS << " // " << Index << ": " << FE->getName() << "\n"
442 << " \"" << FE->getValueAsString("ExtName") << "\",\n";
444 // Record index of this extension.
445 FunctionExtensionIndex[FE->getName()] = Index++;
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");
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";
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
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 << ", ";
487 void BuiltinNameEmitter::EmitBuiltinTable() {
490 OS << "static const OpenCLBuiltinStruct BuiltinTable[] = {\n";
491 for (const auto &SLM : SignatureListMap) {
493 OS << " // " << (Index + 1) << ": ";
494 for (const auto &Name : SLM.second.Names) {
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")
509 << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID")
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");
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()) {
543 void BuiltinNameEmitter::GroupBySignature() {
544 // List of signatures known to be emitted.
545 std::vector<BuiltinIndexListTy *> KnownSignatures;
547 for (auto &Fct : FctOverloadMap) {
548 bool FoundReusableSig = false;
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);
555 // Sort the list to facilitate future comparisons.
556 std::sort(CurSignatureList->begin(), CurSignatureList->end());
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;
570 if (FoundReusableSig) {
571 delete CurSignatureList;
574 SignatureListMap[CurSignatureList] = {
575 SmallVector<StringRef, 4>(1, Fct.first), Fct.second};
576 KnownSignatures.push_back(CurSignatureList);
580 for (auto *I : KnownSignatures) {
585 void BuiltinNameEmitter::EmitStringMatcher() {
586 std::vector<StringMatcher::StringPair> ValidBuiltins;
587 unsigned CumulativeIndex = 1;
589 for (const auto &SLM : SignatureListMap) {
590 const auto &Ovl = SLM.second.Signatures;
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) {
596 raw_string_ostream SS(RetStmt);
597 SS << "return std::make_pair(" << CumulativeIndex << ", " << Ovl.size()
600 ValidBuiltins.push_back(StringMatcher::StringPair(FctName, RetStmt));
602 CumulativeIndex += Ovl.size();
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) {
614 StringMatcher("Name", ValidBuiltins, OS).Emit(0, true);
616 OS << " return std::make_pair(0, 0);\n";
617 OS << "} // isOpenCLBuiltin\n";
620 void BuiltinNameEmitter::EmitQualTypeFinder() {
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
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;
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")) {
650 // Start of switch statement over all types.
651 OS << "\n switch (Ty.ID) {\n";
653 // Switch cases for image types (Image2d, Image3d, ...)
654 std::vector<Record *> ImageTypes =
655 Records.getAllDerivedDefinitions("ImageType");
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));
667 Entry->second.push_back(IT);
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"
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({";
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")
707 GenType->getValueAsDef("TypeList")->getValueAsListOfDefs("List")) {
709 << T->getValueAsDef("QTName")->getValueAsString("Name") << ", ";
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")
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")
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;
733 for (const auto *T : Types) {
734 // Check this is not an image type
735 if (ImageTypesMap.find(T->getValueAsString("Name")) != ImageTypesMap.end())
737 // Check we have not seen this Type
738 if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end())
740 TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
742 // Check the Type does not have an "abstract" QualType
743 auto QT = T->getValueAsDef("QTName");
744 if (QT->getValueAsBit("IsAbstract") == 1)
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")
753 // End of switch statement.
754 OS << " } // end of switch (Ty.ID)\n\n";
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() << ") {";
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]);
773 // Assign the right attributes to the types (e.g. vector size).
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);
782 if (Ty.IsVolatile != 0) {
783 for (unsigned Index = 0; Index < QT.size(); Index++) {
784 QT[Index] = Context.getVolatileType(QT[Index]);
788 if (Ty.IsConst != 0) {
789 for (unsigned Index = 0; Index < QT.size(); Index++) {
790 QT[Index] = Context.getConstType(QT[Index]);
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]);
805 // End of the "OCL2Qual" function.
806 OS << "\n} // OCL2Qual\n";
809 void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
810 BuiltinNameEmitter NameChecker(Records, OS);