[OpenCL] Add builtin function extension handling

[svenvh]

Summary

Provide a mechanism to attach OpenCL extension information to builtin
functions, so that their use can be restricted according to the
extension(s) the builtin is part of.

Patch by Pierre Gondois and Sven van Haastregt.

[Anastasia]

LGTM! Thanks!

clang/lib/Sema/OpenCLBuiltins.td

51

Are we planning to add type extensions too? If not it might not be worth creating extra abstractions. :)

[Nicola]

Just a minor comment, can you address it before you submit? Thanks!

clang/lib/Sema/OpenCLBuiltins.td

1096

Should this be moved together with the other extensions defined above? It might make the file easier to navigate if all the extensions are in the same place (or all close to where they are used)

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

51

Yes, type extensions are planned.

1096

I'll move it to the top for now.

clang/lib/Sema/OpenCLBuiltins.td

 }
 def DefaultAS    : AddressSpace<"clang::LangAS::Default">;
 def PrivateAS    : AddressSpace<"clang::LangAS::opencl_private">;
 def GlobalAS     : AddressSpace<"clang::LangAS::opencl_global">;
 def ConstantAS   : AddressSpace<"clang::LangAS::opencl_constant">;
 def LocalAS      : AddressSpace<"clang::LangAS::opencl_local">;
 def GenericAS    : AddressSpace<"clang::LangAS::opencl_generic">;
 
+// OpenCL language extension.
+class AbstractExtension<string _Ext> {
+  // One or more OpenCL extensions, space separated.  Each extension must be
+  // a valid extension name for the opencl extension pragma.
+  string ExtName = _Ext;
+}
+
+// Extension associated to a builtin function.
+class FunctionExtension<string _Ext> : AbstractExtension<_Ext>;
+
+// FunctionExtension definitions.
+def FuncExtNone                          : FunctionExtension<"">;
+def FuncExtKhrSubgroups                  : FunctionExtension<"cl_khr_subgroups">;
+def FuncExtKhrGlobalInt32BaseAtomics     : FunctionExtension<"cl_khr_global_int32_base_atomics">;
+def FuncExtKhrGlobalInt32ExtendedAtomics : FunctionExtension<"cl_khr_global_int32_extended_atomics">;
 
 // Qualified Type.  These map to ASTContext::QualType.
 class QualType<string _Name, bit _IsAbstract=0> {
   // Name of the field or function in a clang::ASTContext
   // E.g. Name="IntTy" for the int type, and "getIntPtrType()" for an intptr_t
   string Name = _Name;
   // Some QualTypes in this file represent an abstract type for which there is
   // no corresponding AST QualType, e.g. a GenType or an `image2d_t` type

 //===----------------------------------------------------------------------===//
 class Builtin<string _Name, list<Type> _Signature, list<bit> _Attributes = Attr.None> {
   // Name of the builtin function
   string Name = _Name;
   // List of types used by the function. The first one is the return type and
   // the following are the arguments. The list must have at least one element
   // (the return type).
   list<Type> Signature = _Signature;
-  // OpenCL Extension to which the function belongs (cl_khr_subgroups, ...)
-  string Extension = "";
   // Function attribute __attribute__((pure))
   bit IsPure = _Attributes[0];
   // Function attribute __attribute__((const))
   bit IsConst = _Attributes[1];
   // Function attribute __attribute__((convergent))
   bit IsConv = _Attributes[2];
+  // OpenCL extensions to which the function belongs.
+  FunctionExtension Extension = FuncExtNone;
   // Version of OpenCL from which the function is available (e.g.: CL10).
   // MinVersion is inclusive.
   Version MinVersion = CL10;
   // Version of OpenCL from which the function is not supported anymore.
   // MaxVersion is exclusive.
   // CLAll makes the function available for all versions.
   Version MaxVersion = CLAll;
 }
foreach name = ["prefetch"] in {
   def : Builtin<name, [Void, PointerType<ConstType<AGenTypeN>, GlobalAS>, Size]>;
 }
 
 //--------------------------------------------------------------------
 // OpenCL v2.0 s6.13.11 - Atomics Functions.
 // Functions that use memory_order and cl_mem_fence_flags enums are not
 // declared here as the TableGen backend does not handle enums.
 
-// OpenCL v1.0 s9.5, s9.6, s9.7 - Atomic Functions for 32-bit integers.
+// OpenCL v1.0 s9.5, s9.6, s9.7 - Atomic Functions for 32-bit integers
 // --- Table 9.1 ---
+let Extension = FuncExtKhrGlobalInt32BaseAtomics in {
   foreach Type = [Int, UInt] in {
     foreach name = ["atom_add", "atom_sub", "atom_xchg"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type]>;
     }
     foreach name = ["atom_inc", "atom_dec"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>]>;
     }
     foreach name = ["atom_cmpxchg"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type, Type]>;
     }
   }
+}
 
 //--------------------------------------------------------------------
 // OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions
 // --- Table 19 ---
 foreach name = ["shuffle"] in {
   foreach VSize1 = [Vec2, Vec4, Vec8, Vec16] in {
     foreach VSize2 = [Vec2, Vec4, Vec8, Vec16] in {
       def : Builtin<name, [GenericType<"TLAll" # VSize1.Name, TLAll, VSize1>,
foreach name = ["work_group_reduce_", "work_group_scan_exclusive_",
                     "work_group_scan_inclusive_"] in {
       def : Builtin<name # op, [IntLongFloatGenType1, IntLongFloatGenType1], Attr.Convergent>;
     }
   }
 }
 
 
 // OpenCL v2.0 s9.17.3: Additions to section 6.13.1: Work-Item Functions
 let MinVersion = CL20 in {
-  let Extension = "cl_khr_subgroups" in {
+  let Extension = FuncExtKhrSubgroups in {
     def get_sub_group_size : Builtin<"get_sub_group_size", [UInt]>;
     def get_max_sub_group_size : Builtin<"get_max_sub_group_size", [UInt]>;
     def get_num_sub_groups : Builtin<"get_num_sub_groups", [UInt]>;
   }
 }

clang/lib/Sema/SemaLookup.cpp

for (unsigned A = 0; A < ArgTypes.size(); A++) {
       ArgList.push_back(ArgTypes[A][Idx]);
     }
 
     FunctionList.push_back(Context.getFunctionType(
         RetTypes[(RetTypes.size() != 1) ? IGenType : 0], ArgList, PI));
   }
 }
 
+/// Add extensions to the function declaration.
+/// \param S (in/out) The Sema instance.
+/// \param BIDecl (in) Description of the builtin.
+/// \param FDecl (in/out) FunctionDecl instance.
+static void AddOpenCLExtensions(Sema &S, const OpenCLBuiltinStruct &BIDecl,
+                                FunctionDecl *FDecl) {
+  // Fetch extension associated with a function prototype.
+  StringRef E = FunctionExtensionTable[BIDecl.Extension];
+  if (E != "")
+    S.setOpenCLExtensionForDecl(FDecl, E);
+}
+
 /// When trying to resolve a function name, if isOpenCLBuiltin() returns a
 /// non-null <Index, Len> pair, then the name is referencing an OpenCL
 /// builtin function.  Add all candidate signatures to the LookUpResult.
 ///
 /// \param S (in) The Sema instance.
 /// \param LR (inout) The LookupResult instance.
 /// \param II (in) The identifier being resolved.
 /// \param FctIndex (in) Starting index in the BuiltinTable.
for (unsigned Index = 0; Index < GenTypeMaxCnt; Index++) {
       if (OpenCLBuiltin.IsConst)
         NewOpenCLBuiltin->addAttr(ConstAttr::CreateImplicit(Context));
       if (OpenCLBuiltin.IsConv)
         NewOpenCLBuiltin->addAttr(ConvergentAttr::CreateImplicit(Context));
 
       if (!S.getLangOpts().OpenCLCPlusPlus)
         NewOpenCLBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context));
 
+      AddOpenCLExtensions(S, OpenCLBuiltin, NewOpenCLBuiltin);
+
       LR.addDecl(NewOpenCLBuiltin);
     }
   }
 
   // If we added overloads, need to resolve the lookup result.
   if (Len > 1 || HasGenType)
     LR.resolveKind();
 }

clang/test/SemaOpenCL/fdeclare-opencl-builtins.cl

 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CLC++ -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CLC++ -fdeclare-opencl-builtins -finclude-default-header
 
-#if defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= CL_VERSION_2_0
-// expected-no-diagnostics
-#endif
-
 // Test the -fdeclare-opencl-builtins option.
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
 #if __OPENCL_C_VERSION__ < CL_VERSION_1_2
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 #endif
 
 // Provide typedefs when invoking clang without -finclude-default-header.

 
 kernel void test_pointers(volatile global void *global_p, global const int4 *a) {
   int i;
   unsigned int ui;
 
   prefetch(a, 2);
 
   atom_add((volatile __global int *)global_p, i);
+#if !defined(__OPENCL_CPP_VERSION__) && __OPENCL_C_VERSION__ < CL_VERSION_1_1
+// expected-error@-2{{no matching function for call to 'atom_add'}}
+
+// There are two potential definitions of the function "atom_add", both are
+// currently disabled because the associated extension is disabled.
+// expected-note@-6{{candidate unavailable as it requires OpenCL extension 'cl_khr_global_int32_base_atomics' to be enabled}}
+// expected-note@-7{{candidate unavailable as it requires OpenCL extension 'cl_khr_global_int32_base_atomics' to be enabled}}
+#endif
+
+#if __OPENCL_C_VERSION__ < CL_VERSION_1_1
+#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable
+#endif
+
+  atom_add((volatile __global int *)global_p, i);
   atom_cmpxchg((volatile __global unsigned int *)global_p, ui, ui);
 }
 
 kernel void basic_conversion() {
   double d;
   float f;
   char2 c2;
   long2 l2;
kernel void basic_image_writeonly(write_only image1d_buffer_t image_write_only_image1d_buffer) {
   write_imageh(image_write_only_image1d_buffer, i, h4);
 }
 
 kernel void basic_subgroup(global uint *out) {
   out[0] = get_sub_group_size();
 #if !defined(__OPENCL_CPP_VERSION__) && __OPENCL_C_VERSION__ < CL_VERSION_2_0
 // expected-error@-2{{implicit declaration of function 'get_sub_group_size' is invalid in OpenCL}}
 // expected-error@-3{{implicit conversion changes signedness: 'int' to 'uint' (aka 'unsigned int')}}
+#elif defined(__OPENCL_CPP_VERSION__)
+// expected-error@-5{{no matching function for call to 'get_sub_group_size'}}
+// expected-note@-6{{candidate unavailable as it requires OpenCL extension 'cl_khr_subgroups' to be enabled}}
+#else
+// expected-error@-8{{use of declaration 'get_sub_group_size' requires cl_khr_subgroups extension to be enabled}}
 #endif
 }
 
 kernel void basic_vector_data() {
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
   generic void *generic_p;
 #endif
   constant void *constant_p;

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 // one of the signatures of "cos". The SignatureTable entry can be
 // referenced by other functions, e.g. "sin", to exploit the fact that
 // many OpenCL builtins share the same signature.
 //
 // The file generated by this TableGen emitter contains the following:
 //
 //  * Structs and enums to represent types and function signatures.
 //
+//  * const char *FunctionExtensionTable[]
+//    List of space-separated OpenCL extensions.  A builtin references an
+//    entry in this table when the builtin requires a particular (set of)
+//    extension(s) to be enabled.
+//
 //  * OpenCLTypeStruct TypeTable[]
 //    Type information for return types and arguments.
 //
 //  * unsigned SignatureTable[]
 //    A list of types representing function signatures.  Each entry is an index
 //    into the above TypeTable.  Multiple entries following each other form a
 //    signature, where the first entry is the return type and subsequent
 //    entries are the argument types.
private:
   // Group functions with the same list of signatures by populating the
   // SignatureListMap.
   // Some builtin functions have the same list of signatures, for example the
   // "sin" and "cos" functions. To save space in the BuiltinTable, the
   // "isOpenCLBuiltin" function will have the same output for these two
   // function names.
   void GroupBySignature();
 
+  // Emit the FunctionExtensionTable that lists all function extensions.
+  void EmitExtensionTable();
+
   // Emit the TypeTable containing all types used by OpenCL builtins.
   void EmitTypeTable();
 
   // Emit the SignatureTable. This table contains all the possible signatures.
   // A signature is stored as a list of indexes of the TypeTable.
   // The first index references the return type (mandatory), and the followings
   // reference its arguments.
   // E.g.:
   // 15, 2, 15 can represent a function with the signature:
   // int func(float, int)
   // The "int" type being at the index 15 in the TypeTable.
   void EmitSignatureTable();
 
   // Emit the BuiltinTable table. This table contains all the overloads of
   // each function, and is a struct OpenCLBuiltinDecl.
   // E.g.:
   // // 891 convert_float2_rtn
-  //   { 58, 2, 100, 0 },
+  //   { 58, 2, 3, 100, 0 },
   // This means that the signature of this convert_float2_rtn overload has
   // 1 argument (+1 for the return type), stored at index 58 in
-  // the SignatureTable.  The last two values represent the minimum (1.0) and
-  // maximum (0, meaning no max version) OpenCL version in which this overload
-  // is supported.
+  // the SignatureTable.  This prototype requires extension "3" in the
+  // FunctionExtensionTable.  The last two values represent the minimum (1.0)
+  // and maximum (0, meaning no max version) OpenCL version in which this
+  // overload is supported.
   void EmitBuiltinTable();
 
   // Emit a StringMatcher function to check whether a function name is an
   // OpenCL builtin function name.
   void EmitStringMatcher();
 
   // Emit a function returning the clang QualType instance associated with
   // the TableGen Record Type.
private:
   //                 <ptrToPrototype2, 79>>
   // ptrToPrototype1 has the following signature: <double, double>
   MapVector<StringRef, std::vector<std::pair<const Record *, unsigned>>>
       FctOverloadMap;
 
   // Contains the map of OpenCL types to their index in the TypeTable.
   MapVector<const Record *, unsigned> TypeMap;
 
+  // List of OpenCL function extensions mapping extension strings to
+  // an index into the FunctionExtensionTable.
+  StringMap<unsigned> FunctionExtensionIndex;
+
   // List of OpenCL type names in the same order as in enum OpenCLTypeID.
   // This list does not contain generic types.
   std::vector<const Record *> TypeList;
 
   // Same as TypeList, but for generic types only.
   std::vector<const Record *> GenTypeList;
 
   // Map an ordered vector of signatures to their original Record instances,
void BuiltinNameEmitter::Emit() {
   emitSourceFileHeader("OpenCL Builtin handling", OS);
 
   OS << "#include \"llvm/ADT/StringRef.h\"\n";
   OS << "using namespace clang;\n\n";
 
   // Emit enums and structs.
   EmitDeclarations();
 
+  // Parse the Records to populate the internal lists.
   GetOverloads();
   GroupBySignature();
 
   // Emit tables.
+  EmitExtensionTable();
   EmitTypeTable();
   EmitSignatureTable();
   EmitBuiltinTable();
 
+  // Emit functions.
   EmitStringMatcher();
-
   EmitQualTypeFinder();
 }
 
 void BuiltinNameEmitter::ExtractEnumTypes(std::vector<Record *> &Types,
                                           StringMap<bool> &TypesSeen,
                                           std::string &Output,
                                           std::vector<const Record *> &List) {
   raw_string_ostream SS(Output);
struct OpenCLBuiltinStruct {
   // index SigTableIndex is the return type.
   const unsigned NumTypes;
   // Function attribute __attribute__((pure))
   const bool IsPure;
   // Function attribute __attribute__((const))
   const bool IsConst;
   // Function attribute __attribute__((convergent))
   const bool IsConv;
+  // OpenCL extension(s) required for this overload.
+  const unsigned short Extension;
   // First OpenCL version in which this overload was introduced (e.g. CL20).
   const unsigned short MinVersion;
   // First OpenCL version in which this overload was removed (e.g. CL20).
   const unsigned short MaxVersion;
 };
 
 )";
 }
if (it == SignaturesList.end()) {
       CumulativeSignIndex += Signature.size();
     } else {
       SignIndex = it->second;
     }
     FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
   }
 }
 
+void BuiltinNameEmitter::EmitExtensionTable() {
+  OS << "static const char *FunctionExtensionTable[] = {\n";
+  unsigned Index = 0;
+  std::vector<Record *> FuncExtensions =
+      Records.getAllDerivedDefinitions("FunctionExtension");
+
+  for (const auto &FE : FuncExtensions) {
+    // Emit OpenCL extension table entry.
+    OS << "  // " << Index << ": " << FE->getName() << "\n"
+       << "  \"" << FE->getValueAsString("ExtName") << "\",\n";
+
+    // Record index of this extension.
+    FunctionExtensionIndex[FE->getName()] = Index++;
+  }
+  OS << "};\n\n";
+}
+
 void BuiltinNameEmitter::EmitTypeTable() {
   OS << "static const OpenCLTypeStruct TypeTable[] = {\n";
   for (const auto &T : TypeMap) {
     const char *AccessQual =
         StringSwitch<const char *>(T.first->getValueAsString("AccessQualifier"))
             .Case("RO", "OCLAQ_ReadOnly")
             .Case("WO", "OCLAQ_WriteOnly")
             .Case("RW", "OCLAQ_ReadWrite")
for (const auto &SLM : SignatureListMap) {
 
     OS << "  // " << (Index + 1) << ": ";
     for (const auto &Name : SLM.second.Names) {
       OS << Name << ", ";
     }
     OS << "\n";
 
     for (const auto &Overload : SLM.second.Signatures) {
+      StringRef ExtName = Overload.first->getValueAsDef("Extension")->getName();
       OS << "  { " << Overload.second << ", "
          << Overload.first->getValueAsListOfDefs("Signature").size() << ", "
          << (Overload.first->getValueAsBit("IsPure")) << ", "
          << (Overload.first->getValueAsBit("IsConst")) << ", "
          << (Overload.first->getValueAsBit("IsConv")) << ", "
+         << FunctionExtensionIndex[ExtName] << ", "
          << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("ID")
          << ", "
          << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID")
          << " },\n";
       Index++;
     }
   }
   OS << "};\n\n";
for (unsigned Index = 0; Index < Candidate->size(); Index++) {
     const Record *Rec2 = CandidateSigs[Index].first;
     if (Rec->getValueAsBit("IsPure") == Rec2->getValueAsBit("IsPure") &&
         Rec->getValueAsBit("IsConst") == Rec2->getValueAsBit("IsConst") &&
         Rec->getValueAsBit("IsConv") == Rec2->getValueAsBit("IsConv") &&
         Rec->getValueAsDef("MinVersion")->getValueAsInt("ID") ==
             Rec2->getValueAsDef("MinVersion")->getValueAsInt("ID") &&
         Rec->getValueAsDef("MaxVersion")->getValueAsInt("ID") ==
             Rec2->getValueAsDef("MaxVersion")->getValueAsInt("ID") &&
-        Rec->getValueAsString("Extension") ==
-            Rec2->getValueAsString("Extension")) {
+        Rec->getValueAsDef("Extension")->getName() ==
+            Rec2->getValueAsDef("Extension")->getName()) {
       return true;
     }
   }
   return false;
 }
 
 void BuiltinNameEmitter::GroupBySignature() {
   // List of signatures known to be emitted.