Coverage Report

Created: 2020-09-15 12:33

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
Line
Count
Source (jump to first uncovered line)
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
0
      : 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
0
void BuiltinNameEmitter::Emit() {
235
0
  emitSourceFileHeader("OpenCL Builtin handling", OS);
236
0
237
0
  OS << "#include \"llvm/ADT/StringRef.h\"\n";
238
0
  OS << "using namespace clang;\n\n";
239
0
240
  // Emit enums and structs.
241
0
  EmitDeclarations();
242
0
243
  // Parse the Records to populate the internal lists.
244
0
  GetOverloads();
245
0
  GroupBySignature();
246
0
247
  // Emit tables.
248
0
  EmitExtensionTable();
249
0
  EmitTypeTable();
250
0
  EmitSignatureTable();
251
0
  EmitBuiltinTable();
252
0
253
  // Emit functions.
254
0
  EmitStringMatcher();
255
0
  EmitQualTypeFinder();
256
0
}
257
258
void BuiltinNameEmitter::ExtractEnumTypes(std::vector<Record *> &Types,
259
                                          StringMap<bool> &TypesSeen,
260
                                          std::string &Output,
261
0
                                          std::vector<const Record *> &List) {
262
0
  raw_string_ostream SS(Output);
263
0
264
0
  for (const auto *T : Types) {
265
0
    if (TypesSeen.find(T->getValueAsString("Name")) == TypesSeen.end()) {
266
0
      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
0
      List.push_back(T);
271
0
      TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
272
0
    }
273
0
  }
274
0
  SS.flush();
275
0
}
276
277
0
void BuiltinNameEmitter::EmitDeclarations() {
278
  // Enum of scalar type names (float, int, ...) and generic type sets.
279
0
  OS << "enum OpenCLTypeID {\n";
280
0
281
0
  StringMap<bool> TypesSeen;
282
0
  std::string GenTypeEnums;
283
0
  std::string TypeEnums;
284
0
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
0
  std::vector<Record *> GenTypes =
289
0
      Records.getAllDerivedDefinitions("GenericType");
290
0
  ExtractEnumTypes(GenTypes, TypesSeen, GenTypeEnums, GenTypeList);
291
0
292
0
  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
293
0
  ExtractEnumTypes(Types, TypesSeen, TypeEnums, TypeList);
294
0
295
0
  OS << TypeEnums;
296
0
  OS << GenTypeEnums;
297
0
  OS << "};\n";
298
0
299
  // Structure definitions.
300
0
  OS << R"(
301
0
// Image access qualifier.
302
0
enum OpenCLAccessQual : unsigned char {
303
0
  OCLAQ_None,
304
0
  OCLAQ_ReadOnly,
305
0
  OCLAQ_WriteOnly,
306
0
  OCLAQ_ReadWrite
307
0
};
308
0
309
0
// Represents a return type or argument type.
310
0
struct OpenCLTypeStruct {
311
0
  // A type (e.g. float, int, ...).
312
0
  const OpenCLTypeID ID;
313
0
  // Vector size (if applicable; 0 for scalars and generic types).
314
0
  const unsigned VectorWidth;
315
0
  // 0 if the type is not a pointer.
316
0
  const bool IsPointer : 1;
317
0
  // 0 if the type is not const.
318
0
  const bool IsConst : 1;
319
0
  // 0 if the type is not volatile.
320
0
  const bool IsVolatile : 1;
321
0
  // Access qualifier.
322
0
  const OpenCLAccessQual AccessQualifier;
323
0
  // Address space of the pointer (if applicable).
324
0
  const LangAS AS;
325
0
};
326
0
327
0
// One overload of an OpenCL builtin function.
328
0
struct OpenCLBuiltinStruct {
329
0
  // Index of the signature in the OpenCLTypeStruct table.
330
0
  const unsigned SigTableIndex;
331
0
  // Entries between index SigTableIndex and (SigTableIndex + NumTypes - 1) in
332
0
  // the SignatureTable represent the complete signature.  The first type at
333
0
  // index SigTableIndex is the return type.
334
0
  const unsigned NumTypes;
335
0
  // Function attribute __attribute__((pure))
336
0
  const bool IsPure : 1;
337
0
  // Function attribute __attribute__((const))
338
0
  const bool IsConst : 1;
339
0
  // Function attribute __attribute__((convergent))
340
0
  const bool IsConv : 1;
341
0
  // OpenCL extension(s) required for this overload.
342
0
  const unsigned short Extension;
343
0
  // First OpenCL version in which this overload was introduced (e.g. CL20).
344
0
  const unsigned short MinVersion;
345
0
  // First OpenCL version in which this overload was removed (e.g. CL20).
346
0
  const unsigned short MaxVersion;
347
0
};
348
0
349
0
)";
350
0
}
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
0
                            const Record *BuiltinRec) {
360
0
  unsigned GenTypeVecSizes = 1;
361
0
  unsigned GenTypeTypes = 1;
362
0
363
0
  for (const auto *T : Signature) {
364
    // Check all GenericType arguments in this signature.
365
0
    if (T->isSubClassOf("GenericType")) {
366
      // Check number of vector sizes.
367
0
      unsigned NVecSizes =
368
0
          T->getValueAsDef("VectorList")->getValueAsListOfInts("List").size();
369
0
      if (NVecSizes != GenTypeVecSizes && NVecSizes != 1) {
370
0
        if (GenTypeVecSizes > 1) {
371
          // We already saw a gentype with a different number of vector sizes.
372
0
          PrintFatalError(BuiltinRec->getLoc(),
373
0
              "number of vector sizes should be equal or 1 for all gentypes "
374
0
              "in a declaration");
375
0
        }
376
0
        GenTypeVecSizes = NVecSizes;
377
0
      }
378
0
379
      // Check number of data types.
380
0
      unsigned NTypes =
381
0
          T->getValueAsDef("TypeList")->getValueAsListOfDefs("List").size();
382
0
      if (NTypes != GenTypeTypes && NTypes != 1) {
383
0
        if (GenTypeTypes > 1) {
384
          // We already saw a gentype with a different number of types.
385
0
          PrintFatalError(BuiltinRec->getLoc(),
386
0
              "number of types should be equal or 1 for all gentypes "
387
0
              "in a declaration");
388
0
        }
389
0
        GenTypeTypes = NTypes;
390
0
      }
391
0
    }
392
0
  }
393
0
}
394
395
0
void BuiltinNameEmitter::GetOverloads() {
396
  // Populate the TypeMap.
397
0
  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
398
0
  unsigned I = 0;
399
0
  for (const auto &T : Types) {
400
0
    TypeMap.insert(std::make_pair(T, I++));
401
0
  }
402
0
403
  // Populate the SignaturesList and the FctOverloadMap.
404
0
  unsigned CumulativeSignIndex = 0;
405
0
  std::vector<Record *> Builtins = Records.getAllDerivedDefinitions("Builtin");
406
0
  for (const auto *B : Builtins) {
407
0
    StringRef BName = B->getValueAsString("Name");
408
0
    if (FctOverloadMap.find(BName) == FctOverloadMap.end()) {
409
0
      FctOverloadMap.insert(std::make_pair(
410
0
          BName, std::vector<std::pair<const Record *, unsigned>>{}));
411
0
    }
412
0
413
0
    auto Signature = B->getValueAsListOfDefs("Signature");
414
    // Reuse signatures to avoid unnecessary duplicates.
415
0
    auto it =
416
0
        std::find_if(SignaturesList.begin(), SignaturesList.end(),
417
0
                     [&](const std::pair<std::vector<Record *>, unsigned> &a) {
418
0
                       return a.first == Signature;
419
0
                     });
420
0
    unsigned SignIndex;
421
0
    if (it == SignaturesList.end()) {
422
0
      VerifySignature(Signature, B);
423
0
      SignaturesList.push_back(std::make_pair(Signature, CumulativeSignIndex));
424
0
      SignIndex = CumulativeSignIndex;
425
0
      CumulativeSignIndex += Signature.size();
426
0
    } else {
427
0
      SignIndex = it->second;
428
0
    }
429
0
    FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
430
0
  }
431
0
}
432
433
0
void BuiltinNameEmitter::EmitExtensionTable() {
434
0
  OS << "static const char *FunctionExtensionTable[] = {\n";
435
0
  unsigned Index = 0;
436
0
  std::vector<Record *> FuncExtensions =
437
0
      Records.getAllDerivedDefinitions("FunctionExtension");
438
0
439
0
  for (const auto &FE : FuncExtensions) {
440
    // Emit OpenCL extension table entry.
441
0
    OS << "  // " << Index << ": " << FE->getName() << "\n"
442
0
       << "  \"" << FE->getValueAsString("ExtName") << "\",\n";
443
0
444
    // Record index of this extension.
445
0
    FunctionExtensionIndex[FE->getName()] = Index++;
446
0
  }
447
0
  OS << "};\n\n";
448
0
}
449
450
0
void BuiltinNameEmitter::EmitTypeTable() {
451
0
  OS << "static const OpenCLTypeStruct TypeTable[] = {\n";
452
0
  for (const auto &T : TypeMap) {
453
0
    const char *AccessQual =
454
0
        StringSwitch<const char *>(T.first->getValueAsString("AccessQualifier"))
455
0
            .Case("RO", "OCLAQ_ReadOnly")
456
0
            .Case("WO", "OCLAQ_WriteOnly")
457
0
            .Case("RW", "OCLAQ_ReadWrite")
458
0
            .Default("OCLAQ_None");
459
0
460
0
    OS << "  // " << T.second << "\n"
461
0
       << "  {OCLT_" << T.first->getValueAsString("Name") << ", "
462
0
       << T.first->getValueAsInt("VecWidth") << ", "
463
0
       << T.first->getValueAsBit("IsPointer") << ", "
464
0
       << T.first->getValueAsBit("IsConst") << ", "
465
0
       << T.first->getValueAsBit("IsVolatile") << ", "
466
0
       << AccessQual << ", "
467
0
       << T.first->getValueAsString("AddrSpace") << "},\n";
468
0
  }
469
0
  OS << "};\n\n";
470
0
}
471
472
0
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
0
  OS << "static const unsigned short SignatureTable[] = {\n";
477
0
  for (const auto &P : SignaturesList) {
478
0
    OS << "  // " << P.second << "\n  ";
479
0
    for (const Record *R : P.first) {
480
0
      unsigned Entry = TypeMap.find(R)->second;
481
0
      if (Entry > USHRT_MAX) {
482
        // Report an error when seeing an entry that is too large for the
483
        // current index type (unsigned short).  When hitting this, the type
484
        // of SignatureTable will need to be changed.
485
0
        PrintFatalError("Entry in SignatureTable exceeds limit.");
486
0
      }
487
0
      OS << Entry << ", ";
488
0
    }
489
0
    OS << "\n";
490
0
  }
491
0
  OS << "};\n\n";
492
0
}
493
494
0
void BuiltinNameEmitter::EmitBuiltinTable() {
495
0
  unsigned Index = 0;
496
0
497
0
  OS << "static const OpenCLBuiltinStruct BuiltinTable[] = {\n";
498
0
  for (const auto &SLM : SignatureListMap) {
499
0
500
0
    OS << "  // " << (Index + 1) << ": ";
501
0
    for (const auto &Name : SLM.second.Names) {
502
0
      OS << Name << ", ";
503
0
    }
504
0
    OS << "\n";
505
0
506
0
    for (const auto &Overload : SLM.second.Signatures) {
507
0
      StringRef ExtName = Overload.first->getValueAsDef("Extension")->getName();
508
0
      OS << "  { " << Overload.second << ", "
509
0
         << Overload.first->getValueAsListOfDefs("Signature").size() << ", "
510
0
         << (Overload.first->getValueAsBit("IsPure")) << ", "
511
0
         << (Overload.first->getValueAsBit("IsConst")) << ", "
512
0
         << (Overload.first->getValueAsBit("IsConv")) << ", "
513
0
         << FunctionExtensionIndex[ExtName] << ", "
514
0
         << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("ID")
515
0
         << ", "
516
0
         << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID")
517
0
         << " },\n";
518
0
      Index++;
519
0
    }
520
0
  }
521
0
  OS << "};\n\n";
522
0
}
523
524
bool BuiltinNameEmitter::CanReuseSignature(
525
    BuiltinIndexListTy *Candidate,
526
0
    std::vector<std::pair<const Record *, unsigned>> &SignatureList) {
527
0
  assert(Candidate->size() == SignatureList.size() &&
528
0
         "signature lists should have the same size");
529
0
530
0
  auto &CandidateSigs =
531
0
      SignatureListMap.find(Candidate)->second.Signatures;
532
0
  for (unsigned Index = 0; Index < Candidate->size(); Index++) {
533
0
    const Record *Rec = SignatureList[Index].first;
534
0
    const Record *Rec2 = CandidateSigs[Index].first;
535
0
    if (Rec->getValueAsBit("IsPure") == Rec2->getValueAsBit("IsPure") &&
536
0
        Rec->getValueAsBit("IsConst") == Rec2->getValueAsBit("IsConst") &&
537
0
        Rec->getValueAsBit("IsConv") == Rec2->getValueAsBit("IsConv") &&
538
0
        Rec->getValueAsDef("MinVersion")->getValueAsInt("ID") ==
539
0
            Rec2->getValueAsDef("MinVersion")->getValueAsInt("ID") &&
540
0
        Rec->getValueAsDef("MaxVersion")->getValueAsInt("ID") ==
541
0
            Rec2->getValueAsDef("MaxVersion")->getValueAsInt("ID") &&
542
0
        Rec->getValueAsDef("Extension")->getName() ==
543
0
            Rec2->getValueAsDef("Extension")->getName()) {
544
0
      return true;
545
0
    }
546
0
  }
547
0
  return false;
548
0
}
549
550
0
void BuiltinNameEmitter::GroupBySignature() {
551
  // List of signatures known to be emitted.
552
0
  std::vector<BuiltinIndexListTy *> KnownSignatures;
553
0
554
0
  for (auto &Fct : FctOverloadMap) {
555
0
    bool FoundReusableSig = false;
556
0
557
    // Gather all signatures for the current function.
558
0
    auto *CurSignatureList = new BuiltinIndexListTy();
559
0
    for (const auto &Signature : Fct.second) {
560
0
      CurSignatureList->push_back(Signature.second);
561
0
    }
562
    // Sort the list to facilitate future comparisons.
563
0
    llvm::sort(*CurSignatureList);
564
0
565
    // Check if we have already seen another function with the same list of
566
    // signatures.  If so, just add the name of the function.
567
0
    for (auto *Candidate : KnownSignatures) {
568
0
      if (Candidate->size() == CurSignatureList->size() &&
569
0
          *Candidate == *CurSignatureList) {
570
0
        if (CanReuseSignature(Candidate, Fct.second)) {
571
0
          SignatureListMap.find(Candidate)->second.Names.push_back(Fct.first);
572
0
          FoundReusableSig = true;
573
0
        }
574
0
      }
575
0
    }
576
0
577
0
    if (FoundReusableSig) {
578
0
      delete CurSignatureList;
579
0
    } else {
580
      // Add a new entry.
581
0
      SignatureListMap[CurSignatureList] = {
582
0
          SmallVector<StringRef, 4>(1, Fct.first), Fct.second};
583
0
      KnownSignatures.push_back(CurSignatureList);
584
0
    }
585
0
  }
586
0
587
0
  for (auto *I : KnownSignatures) {
588
0
    delete I;
589
0
  }
590
0
}
591
592
0
void BuiltinNameEmitter::EmitStringMatcher() {
593
0
  std::vector<StringMatcher::StringPair> ValidBuiltins;
594
0
  unsigned CumulativeIndex = 1;
595
0
596
0
  for (const auto &SLM : SignatureListMap) {
597
0
    const auto &Ovl = SLM.second.Signatures;
598
0
599
    // A single signature list may be used by different builtins.  Return the
600
    // same <index, length> pair for each of those builtins.
601
0
    for (const auto &FctName : SLM.second.Names) {
602
0
      std::string RetStmt;
603
0
      raw_string_ostream SS(RetStmt);
604
0
      SS << "return std::make_pair(" << CumulativeIndex << ", " << Ovl.size()
605
0
         << ");";
606
0
      SS.flush();
607
0
      ValidBuiltins.push_back(
608
0
          StringMatcher::StringPair(std::string(FctName), RetStmt));
609
0
    }
610
0
    CumulativeIndex += Ovl.size();
611
0
  }
612
0
613
0
  OS << R"(
614
0
// Find out whether a string matches an existing OpenCL builtin function name.
615
0
// Returns: A pair <0, 0> if no name matches.
616
0
//          A pair <Index, Len> indexing the BuiltinTable if the name is
617
0
//          matching an OpenCL builtin function.
618
0
static std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef Name) {
619
0
620
0
)";
621
0
622
0
  StringMatcher("Name", ValidBuiltins, OS).Emit(0, true);
623
0
624
0
  OS << "  return std::make_pair(0, 0);\n";
625
0
  OS << "} // isOpenCLBuiltin\n";
626
0
}
627
628
0
void BuiltinNameEmitter::EmitQualTypeFinder() {
629
0
  OS << R"(
630
0
631
0
// Convert an OpenCLTypeStruct type to a list of QualTypes.
632
0
// Generic types represent multiple types and vector sizes, thus a vector
633
0
// is returned. The conversion is done in two steps:
634
0
// Step 1: A switch statement fills a vector with scalar base types for the
635
0
//         Cartesian product of (vector sizes) x (types) for generic types,
636
0
//         or a single scalar type for non generic types.
637
0
// Step 2: Qualifiers and other type properties such as vector size are
638
0
//         applied.
639
0
static void OCL2Qual(ASTContext &Context, const OpenCLTypeStruct &Ty,
640
0
                     llvm::SmallVectorImpl<QualType> &QT) {
641
0
  // Number of scalar types in the GenType.
642
0
  unsigned GenTypeNumTypes;
643
0
  // Pointer to the list of vector sizes for the GenType.
644
0
  llvm::ArrayRef<unsigned> GenVectorSizes;
645
0
)";
646
0
647
  // Generate list of vector sizes for each generic type.
648
0
  for (const auto *VectList : Records.getAllDerivedDefinitions("IntList")) {
649
0
    OS << "  constexpr unsigned List"
650
0
       << VectList->getValueAsString("Name") << "[] = {";
651
0
    for (const auto V : VectList->getValueAsListOfInts("List")) {
652
0
      OS << V << ", ";
653
0
    }
654
0
    OS << "};\n";
655
0
  }
656
0
657
  // Step 1.
658
  // Start of switch statement over all types.
659
0
  OS << "\n  switch (Ty.ID) {\n";
660
0
661
  // Switch cases for image types (Image2d, Image3d, ...)
662
0
  std::vector<Record *> ImageTypes =
663
0
      Records.getAllDerivedDefinitions("ImageType");
664
0
665
  // Map an image type name to its 3 access-qualified types (RO, WO, RW).
666
0
  std::map<StringRef, SmallVector<Record *, 3>> ImageTypesMap;
667
0
  for (auto *IT : ImageTypes) {
668
0
    auto Entry = ImageTypesMap.find(IT->getValueAsString("Name"));
669
0
    if (Entry == ImageTypesMap.end()) {
670
0
      SmallVector<Record *, 3> ImageList;
671
0
      ImageList.push_back(IT);
672
0
      ImageTypesMap.insert(
673
0
          std::make_pair(IT->getValueAsString("Name"), ImageList));
674
0
    } else {
675
0
      Entry->second.push_back(IT);
676
0
    }
677
0
  }
678
0
679
  // Emit the cases for the image types.  For an image type name, there are 3
680
  // corresponding QualTypes ("RO", "WO", "RW").  The "AccessQualifier" field
681
  // tells which one is needed.  Emit a switch statement that puts the
682
  // corresponding QualType into "QT".
683
0
  for (const auto &ITE : ImageTypesMap) {
684
0
    OS << "    case OCLT_" << ITE.first.str() << ":\n"
685
0
       << "      switch (Ty.AccessQualifier) {\n"
686
0
       << "        case OCLAQ_None:\n"
687
0
       << "          llvm_unreachable(\"Image without access qualifier\");\n";
688
0
    for (const auto &Image : ITE.second) {
689
0
      OS << StringSwitch<const char *>(
690
0
                Image->getValueAsString("AccessQualifier"))
691
0
                .Case("RO", "        case OCLAQ_ReadOnly:\n")
692
0
                .Case("WO", "        case OCLAQ_WriteOnly:\n")
693
0
                .Case("RW", "        case OCLAQ_ReadWrite:\n")
694
0
         << "          QT.push_back(Context."
695
0
         << Image->getValueAsDef("QTName")->getValueAsString("Name") << ");\n"
696
0
         << "          break;\n";
697
0
    }
698
0
    OS << "      }\n"
699
0
       << "      break;\n";
700
0
  }
701
0
702
  // Switch cases for generic types.
703
0
  for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) {
704
0
    OS << "    case OCLT_" << GenType->getValueAsString("Name") << ":\n";
705
0
    OS << "      QT.append({";
706
0
707
    // Build the Cartesian product of (vector sizes) x (types).  Only insert
708
    // the plain scalar types for now; other type information such as vector
709
    // size and type qualifiers will be added after the switch statement.
710
0
    for (unsigned I = 0; I < GenType->getValueAsDef("VectorList")
711
0
                                 ->getValueAsListOfInts("List")
712
0
                                 .size();
713
0
         I++) {
714
0
      for (const auto *T :
715
0
           GenType->getValueAsDef("TypeList")->getValueAsListOfDefs("List")) {
716
0
        OS << "Context."
717
0
           << T->getValueAsDef("QTName")->getValueAsString("Name") << ", ";
718
0
      }
719
0
    }
720
0
    OS << "});\n";
721
    // GenTypeNumTypes is the number of types in the GenType
722
    // (e.g. float/double/half).
723
0
    OS << "      GenTypeNumTypes = "
724
0
       << GenType->getValueAsDef("TypeList")->getValueAsListOfDefs("List")
725
0
              .size()
726
0
       << ";\n";
727
    // GenVectorSizes is the list of vector sizes for this GenType.
728
    // QT contains GenTypeNumTypes * #GenVectorSizes elements.
729
0
    OS << "      GenVectorSizes = List"
730
0
       << GenType->getValueAsDef("VectorList")->getValueAsString("Name")
731
0
       << ";\n";
732
0
    OS << "      break;\n";
733
0
  }
734
0
735
  // Switch cases for non generic, non image types (int, int4, float, ...).
736
  // Only insert the plain scalar type; vector information and type qualifiers
737
  // are added in step 2.
738
0
  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
739
0
  StringMap<bool> TypesSeen;
740
0
741
0
  for (const auto *T : Types) {
742
    // Check this is not an image type
743
0
    if (ImageTypesMap.find(T->getValueAsString("Name")) != ImageTypesMap.end())
744
0
      continue;
745
    // Check we have not seen this Type
746
0
    if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end())
747
0
      continue;
748
0
    TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
749
0
750
    // Check the Type does not have an "abstract" QualType
751
0
    auto QT = T->getValueAsDef("QTName");
752
0
    if (QT->getValueAsBit("IsAbstract") == 1)
753
0
      continue;
754
    // Emit the cases for non generic, non image types.
755
0
    OS << "    case OCLT_" << T->getValueAsString("Name") << ":\n";
756
0
    OS << "      QT.push_back(Context." << QT->getValueAsString("Name")
757
0
       << ");\n";
758
0
    OS << "      break;\n";
759
0
  }
760
0
761
  // End of switch statement.
762
0
  OS << "  } // end of switch (Ty.ID)\n\n";
763
0
764
  // Step 2.
765
  // Add ExtVector types if this was a generic type, as the switch statement
766
  // above only populated the list with scalar types.  This completes the
767
  // construction of the Cartesian product of (vector sizes) x (types).
768
0
  OS << "  // Construct the different vector types for each generic type.\n";
769
0
  OS << "  if (Ty.ID >= " << TypeList.size() << ") {";
770
0
  OS << R"(
771
0
    for (unsigned I = 0; I < QT.size(); I++) {
772
0
      // For scalars, size is 1.
773
0
      if (GenVectorSizes[I / GenTypeNumTypes] != 1) {
774
0
        QT[I] = Context.getExtVectorType(QT[I],
775
0
                          GenVectorSizes[I / GenTypeNumTypes]);
776
0
      }
777
0
    }
778
0
  }
779
0
)";
780
0
781
  // Assign the right attributes to the types (e.g. vector size).
782
0
  OS << R"(
783
0
  // Set vector size for non-generic vector types.
784
0
  if (Ty.VectorWidth > 1) {
785
0
    for (unsigned Index = 0; Index < QT.size(); Index++) {
786
0
      QT[Index] = Context.getExtVectorType(QT[Index], Ty.VectorWidth);
787
0
    }
788
0
  }
789
0
790
0
  if (Ty.IsVolatile != 0) {
791
0
    for (unsigned Index = 0; Index < QT.size(); Index++) {
792
0
      QT[Index] = Context.getVolatileType(QT[Index]);
793
0
    }
794
0
  }
795
0
796
0
  if (Ty.IsConst != 0) {
797
0
    for (unsigned Index = 0; Index < QT.size(); Index++) {
798
0
      QT[Index] = Context.getConstType(QT[Index]);
799
0
    }
800
0
  }
801
0
802
0
  // Transform the type to a pointer as the last step, if necessary.
803
0
  // Builtin functions only have pointers on [const|volatile], no
804
0
  // [const|volatile] pointers, so this is ok to do it as a last step.
805
0
  if (Ty.IsPointer != 0) {
806
0
    for (unsigned Index = 0; Index < QT.size(); Index++) {
807
0
      QT[Index] = Context.getAddrSpaceQualType(QT[Index], Ty.AS);
808
0
      QT[Index] = Context.getPointerType(QT[Index]);
809
0
    }
810
0
  }
811
0
)";
812
0
813
  // End of the "OCL2Qual" function.
814
0
  OS << "\n} // OCL2Qual\n";
815
0
}
816
817
0
void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
818
0
  BuiltinNameEmitter NameChecker(Records, OS);
819
0
  NameChecker.Emit();
820
0
}