[OpenCL] Handle TypeExtensions in OpenCLBuiltinFileEmitter

[svenvh]

Summary

Until now, any types that had TypeExtensions attached to them were not
guarded with those extensions. Extend the OpenCLBuiltinFileEmitter
such that all required extensions are emitted for the types of a
builtin function.

The clang-tblgen -gen-clang-opencl-builtin-tests emitter will now
produce e.g.:

#if defined(cl_khr_fp16) && defined(cl_khr_fp64)
half8 test11802_convert_half8_rtp(double8 arg1) {
  return convert_half8_rtp(arg1);
}
#endif // TypeExtension

[arkangath]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

296–306

Shouldn't what the return value means be documented here?

1200–1201

Seems to me that this is the only assignment to the OptionalEndif variable. In which case, can't it be a StringRef ? And the return of the function be StringRef too ?

[svenvh]

Use StringRef and extend comment.

[svenvh]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

296–306

Good catch, added.

1200–1201

Indeed; updated.

[arkangath]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

1183

Just in case if relevant, your "KeepEmpty" will default to true here.
I don't know if it is possible or not (not enough context for me), but could the .td file have "Extension0 Extention1" (two spaces) that could lead to one empty StringRef here?

1191

Arguably it _may_ be better to early-return here instead of increasing the indentation, but I'm not asking for a change; just suggesting.
The assigned values into OptionalEndif could be just returned directly rather than storing in a local variable, unless you're predicting further changes to this function benefit from this temporary existing.

[svenvh]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

1183

That would lead to generation of #if defined(Extension0) && defined(), which would cause a compilation error. I think that's not unreasonable behavior to keep, to enforce that extensions are separated by exactly one space in the .td file for the sake of consistency.

1191

You are right, that would align better with the style of emitExtensionGuard too; I'll apply your suggestion prior to committing.

[arkangath]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

1183

Ok, that's fine with me. I just wondered if it'd be easier to just set KeepEmpty=false on the split() call.

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 // clang/lib/Sema/OpenCLBuiltins.td and produce builtin handling code for
 // inclusion in SemaLookup.cpp, or a test file that calls all declared builtins.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TableGenBackends.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
protected:
   // Emit an #if guard for a Builtin's extension.  Return the corresponding
   // closing #endif, or an empty string if no extension #if guard was emitted.
   std::string emitExtensionGuard(const Record *Builtin);
 
   // Emit an #if guard for a Builtin's language version.  Return the
   // corresponding closing #endif, or an empty string if no version #if guard
   // was emitted.
   std::string emitVersionGuard(const Record *Builtin);
 
+  // Emit an #if guard for all type extensions required for the given type
+  // strings.  Return the corresponding closing #endif, or an empty string
+  // if no extension #if guard was emitted.
+  StringRef
+  emitTypeExtensionGuards(const SmallVectorImpl<std::string> &Signature);
+
+  // Map type strings to type extensions (e.g. "half2" -> "cl_khr_fp16").
+  StringMap<StringRef> TypeExtMap;
+
   // Contains OpenCL builtin functions and related information, stored as
   // Record instances. They are coming from the associated TableGen file.
   RecordKeeper &Records;
 
   // The output file.
   raw_ostream &OS;
 };
 
 // OpenCL builtin test generator.  This class processes the same TableGen input
for (const auto &Arg : Signature) {
     std::vector<int64_t> VectorList;
     TypeFlags Flags;
 
     getTypeLists(Arg, Flags, TypeList, VectorList);
 
     // Insert the Cartesian product of the types and vector sizes.
     for (const auto &Vector : VectorList) {
       for (const auto &Type : TypeList) {
-        ExpandedArg.push_back(getTypeString(Type, Flags, Vector));
+        std::string FullType = getTypeString(Type, Flags, Vector);
+        ExpandedArg.push_back(FullType);
+
+        // If the type requires an extension, add a TypeExtMap entry mapping
+        // the full type name to the extension.
+        StringRef Ext =
+            Arg->getValueAsDef("Extension")->getValueAsString("ExtName");
+        if (!Ext.empty() && TypeExtMap.find(FullType) == TypeExtMap.end()) {
+          TypeExtMap.insert({FullType, Ext});
+        }
       }
     }
     NumSignatures = std::max<unsigned>(NumSignatures, ExpandedArg.size());
     ExpandedGenTypes.push_back(ExpandedArg);
   }
 
   // Now the total number of signatures is known.  Populate the return list with
   // all signatures.
if (MaxVersion) {
     OS << "#if __OPENCL_C_VERSION__ < ";
     PrintOpenCLVersion(MaxVersion);
     OS << "\n";
     OptionalEndif = "#endif // MaxVersion\n" + OptionalEndif;
   }
   return OptionalEndif;
 }
 
+StringRef OpenCLBuiltinFileEmitterBase::emitTypeExtensionGuards(
+    const SmallVectorImpl<std::string> &Signature) {
+  StringRef OptionalEndif;
+  SmallSet<StringRef, 2> ExtSet;
+
+  // Iterate over all types to gather the set of required TypeExtensions.
+  for (const auto &Ty : Signature) {
+    StringRef TypeExt = TypeExtMap.lookup(Ty);
+    if (!TypeExt.empty()) {
+      // The TypeExtensions are space-separated in the .td file.
+      SmallVector<StringRef, 2> ExtVec;
+      TypeExt.split(ExtVec, " ");
+      for (const auto Ext : ExtVec) {
+        ExtSet.insert(Ext);
+      }
+    }
+  }
+
+  // Emit the #if when at least one extension is required.
+  if (!ExtSet.empty()) {
+    OS << "#if ";
+    bool isFirst = true;
+    for (const auto Ext : ExtSet) {
+      if (!isFirst)
+        OS << " && ";
+      OS << "defined(" << Ext << ")";
+      isFirst = false;
+    }
+    OS << "\n";
+    OptionalEndif = "#endif // TypeExtension\n";
+  }
+
+  return OptionalEndif;
+}
+
 void OpenCLBuiltinTestEmitter::emit() {
   emitSourceFileHeader("OpenCL Builtin exhaustive testing", OS);
 
   emitExtensionSetup();
 
   // Ensure each test has a unique name by numbering them.
   unsigned TestID = 0;
 
   // Iterate over all builtins.
   std::vector<Record *> Builtins = Records.getAllDerivedDefinitions("Builtin");
   for (const auto *B : Builtins) {
     StringRef Name = B->getValueAsString("Name");
 
     SmallVector<SmallVector<std::string, 2>, 4> FTypes;
     expandTypesInSignature(B->getValueAsListOfDefs("Signature"), FTypes);
 
     OS << "// Test " << Name << "\n";
 
     std::string OptionalExtensionEndif = emitExtensionGuard(B);
     std::string OptionalVersionEndif = emitVersionGuard(B);
 
     for (const auto &Signature : FTypes) {
+      StringRef OptionalTypeExtEndif = emitTypeExtensionGuards(Signature);
+
       // Emit function declaration.
       OS << Signature[0] << " test" << TestID++ << "_" << Name << "(";
       if (Signature.size() > 1) {
         for (unsigned I = 1; I < Signature.size(); I++) {
           if (I != 1)
             OS << ", ";
           OS << Signature[I] << " arg" << I;
         }
for (const auto &Signature : FTypes) {
         if (I != 1)
           OS << ", ";
         OS << "arg" << I;
       }
       OS << ");\n";
 
       // End of function body.
       OS << "}\n";
+      OS << OptionalTypeExtEndif;
     }
 
     OS << OptionalVersionEndif;
     OS << OptionalExtensionEndif;
   }
 }
 
 void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {