[OpenCL] Add extension handling for builtin functions

[svenvh]

Summary

Add the possibilty to bind functions or types to an OpenCL extension
(e.g.: cl_khr_fp16 for the "half" type, or
cl_khr_global_int32_base_atomics for functions).

Type extensions currently added are:
*cl_khr_fp16
*cl_khr_fp64
*cl_khr_gl_msaa_sharing

Function extensions currently added are:
*cl_khr_global_int32_base_atomics
*cl_khr_global_int32_extended_atomics

This mimics the following pragma:
\#pragma OPENCL EXTENSION <ExtName> : [begin|end]

The previously defined atomic functions are updated accordingly.

This depends on:
-1, splitting opencl-c.h file: https://reviews.llvm.org/D63256/new/
-2, Adding generic types: https://reviews.llvm.org/D63434
-3, Adding const, volatile and pointer types: https://reviews.llvm.org/D63442
-4, Adding image types: https://reviews.llvm.org/D63480
-5, Adding version handling: https://reviews.llvm.org/D63504

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

63

Btw you are adding not only halfs. Please reflect this in the description of this review.

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

35

Can extend tests for half and doubles too?

[Pierre]

Update the commit message to specify which extensions are added, and add tests for the half and double type extensions

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

35

This is curious that the error message is different for half and double types, when the issue is similar.

[Pierre]

Rebase from previous patches.

[Pierre]

Rebase on previous versions.

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

45

should be used.

257–258

I am confused why do we need type extensions because we are not actually adding types in tablegen?

clang/lib/Sema/SemaLookup.cpp

773

-> static?

773

-> AddOpenCLExtensions?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

47

I think it's good to add line like above:

// Hold information...

55

I think it's good to add line like above:

// Hold information...

216

This is a map, not a list.

[svenvh]

Closing as this has been covered by D100209.

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">;
 
+// Extension to OpenCL language.
+// The AbstractExtension class is designed to be abstract: only instances of
+// TypeExtension and FctExtension should used.
+// Functions can belong to an extension because:
+//   * one of its return type/ argumentsthe belongs to an extension
+//     E.g.: "cl_khr_fp16", associated with the "half" type.
+//   * the function is itself part of an extension
+//     E.g.: "cl_khr_subgroups" for the "get_sub_group_size" function
+class AbstractExtension<string _ID, string _Ext> {
+  // Custom name represetning the set of extensions in the ExtName field.
+  string ID = _ID;
+  // Name of the OpenCL extensions, space separated and less than 64 chars long.
+  string ExtName = _Ext;
+}
+class TypeExtension<string _ID, string _Ext> : AbstractExtension<_ID, _Ext>;
+class FctExtension<string _ID, string _Ext> : AbstractExtension<_ID, _Ext>;
+
+// TypeExtension definitions
+def NoTypeExt   : TypeExtension<"null" ,"">;
+def Fp16TypeExt : TypeExtension<"fp16", "cl_khr_fp16">;
+def Fp64TypeExt : TypeExtension<"fp64", "cl_khr_fp64">;
+def MsaaTypeExt : TypeExtension<"msaa", "cl_khr_gl_msaa_sharing">;
+
+// FctExtension definitions
+def NoFctExt               : FctExtension<"null" ,"">;
+def GlobalInt32BaseAtomicsFctExt     : FctExtension<"GlobalInt32BaseAtomicsFctExt", "cl_khr_global_int32_base_atomics">;
+def GlobalInt32ExtendedAtomicsFctExt : FctExtension<"GlobalInt32ExtendedAtomicsFctExt", "cl_khr_global_int32_extended_atomics">;
+// Multiple extensions
+def GlobalInt32BaseAndExtendedAtomicsFctExt : FctExtension<"GlobalInt32BaseAndExtendedAtomicsFctExt", "cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics">;
+
 
 // Qualified Type. Allow to retrieve an ASTContext QualType.
 class QualType<string _Name, int _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 QualType should not be used as such. This is a mean to identify them.
   bit IsAbstract = _IsAbstract;
class Type<string _Name, QualType _QTName> {
   // "const" qualifier.
   bit IsConst = 0;
   // "volatile" qualifier.
   bit IsVolatile = 0;
   // Address space associated.
   string AddrSpace = DefaultAS.Name;
   // Access qualifier. Must be one of ("RO", "WO", "RW").
   string AccessQualifier = "";
+  // TypeExtension, if this type can only be used in one extension
+  TypeExtension Extension = NoTypeExt;
 }
 
 // OpenCL vector types (e.g.: int2, int3, int16, float8, ...).
 class VectorType<Type _Ty, int _VecWidth> : Type<_Ty.Name, _Ty.QTName> {
   let VecWidth = _VecWidth;
   // Inherited fields
   let IsPointer = _Ty.IsPointer;
   let IsConst = _Ty.IsConst;

 //===----------------------------------------------------------------------===//
 class Builtin<string _Name, list<Type> _Signature> {
   // 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 = "";
+  // OpenCL extensions to which the function belongs (e.g.: cl_khr_subgroups)
+  FctExtension Extension = NoFctExt;
   // 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;
 }
 
 //===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL C types
 //===----------------------------------------------------------------------===//
 
 // OpenCL v1.0/1.2/2.0 s6.1.1: Built-in Scalar Data Types.
 def bool_t      : Type<"bool", QualType<"BoolTy">>;
 def char_t      : Type<"char", QualType<"CharTy">>;
 def uchar_t     : Type<"uchar", QualType<"UnsignedCharTy">>;
 def short_t     : Type<"short", QualType<"ShortTy">>;
 def ushort_t    : Type<"ushort", QualType<"UnsignedShortTy">>;
 def int_t       : Type<"int", QualType<"IntTy">>;
 def uint_t      : Type<"uint", QualType<"UnsignedIntTy">>;
 def long_t      : Type<"long", QualType<"LongTy">>;
 def ulong_t     : Type<"ulong", QualType<"UnsignedLongTy">>;
 def float_t     : Type<"float", QualType<"FloatTy">>;
-def double_t    : Type<"double", QualType<"DoubleTy">>;
-def half_t      : Type<"half", QualType<"HalfTy">>;
+let Extension = Fp64TypeExt in {
+  def double_t  : Type<"double", QualType<"DoubleTy">>;
+}
+let Extension = Fp16TypeExt in {
+  def half_t    : Type<"half", QualType<"HalfTy">>;
+}
 def size_t      : Type<"size_t",  QualType<"getSizeType()">>;
 def ptrdiff_t   : Type<"ptrdiff_t", QualType<"getPointerDiffType()">>;
 def intptr_t    : Type<"intptr_t", QualType<"getIntPtrType()">>;
 def uintptr_t   : Type<"uintptr_t", QualType<"getUIntPtrType()">>;
 def void_t      : Type<"void", QualType<"VoidTy">>;
 
 // OpenCL v1.0/1.2/2.0/2.0 s6.1.2: Built-in Vector Data Types.
 // VectorTypes are dynamically defined. See the OpenCL 2.0 : 6.13.7 section of
 // this file as example.
 
 
 // OpenCL v1.0/1.2/2.0 : 6.1.3 : Other Built-in Data Types
 // These definitions are "abstract". They should not be used as such.
 // They need an access qualifier specified (RO/WO/RW).
 // See the OpenCL extension v2.2 s5.1.9 of this file as example.
 def image2d_t             : Type<"image2d_t", QualType<"OCLImage2d", 1>>;
 def image3d_t             : Type<"image3d_t", QualType<"OCLImage3d", 1>>;
 def image2d_array_t       : Type<"image2d_array_t", QualType<"OCLImage2dArray", 1>>;
 def image1d_t             : Type<"image1d_t", QualType<"OCLImage1d", 1>>;
 def image1d_buffer_t      : Type<"image1d_buffer_t", QualType<"OCLImage1dBuffer", 1>>;
 def image1d_array_t       : Type<"image1d_array_t", QualType<"OCLImage1dArray", 1>>;
 def image2d_depth_t       : Type<"image2d_depth_t", QualType<"OCLImage2dDepth", 1>>;
 def image2d_array_depth_t : Type<"image2d_array_depth_t", QualType<"OCLImage2dArrayDepth", 1>>;
+let Extension = MsaaTypeExt in {
   def image2d_msaa_t             : Type<"image2d_msaa_t", QualType<"OCLImage2dMSAA", 1>>;
   def image2d_array_msaa_t       : Type<"image2d_array_msaa_t", QualType<"OCLImage2dArrayMSAA", 1>>;
   def image2d_msaa_depth_t       : Type<"image2d_msaa_depth_t", QualType<"OCLImage2dMSAADepth", 1>>;
   def image2d_array_msaa_depth_t : Type<"image2d_array_msaa_depth_t", QualType<"OCLImage2dArrayMSAADepth", 1>>;
+}
 def sampler_t         : Type<"sampler_t", QualType<"OCLSamplerTy">>;
 def event_t           : Type<"event_t", QualType<"OCLEventTy">>;
 
 // Generic types and lists of int.
 // Lists of int.
 def ListNNonZero : IntList<"ListNNonZero", [2, 3, 4, 8, 16]>;
 def ListN        : IntList<"ListN", [0, 2, 3, 4, 8, 16]>;
 // GenTypes lists.

 }
 
 
 //--------------------------------------------------------------------
 // OpenCL v2.0 s6.13.11 - Atomics Functions.
 // Functions are using memory_order and cl_mem_fence_flags typedefs,
 // which make them not declarable here.
 
-// 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 = GlobalInt32BaseAtomicsFctExt in {
   foreach Type = [int_t, uint_t] 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.2 s6.12.2: Math Functions
 foreach name = ["acos", "acosh", "acospi",
                 "asin", "asinh", "asinpi",
                 "atan", "atanh", "atanpi"] in {
   def : Builtin<name, [FGenTypeN, FGenTypeN]>;
 }
 

clang/lib/Sema/SemaLookup.cpp

for (unsigned IGenType = 0; IGenType < GenTypeMaxCnt; IGenType++) {
 
     FunctionList.push_back(
         Context.getFunctionType(
             RetTypes[(RetTypes.size() != 1) ? IGenType : 0],
             ArgList, PI));
   }
 }
 
+
+/// Helper function to add extensions to the function declaration.
+///
+/// \param S (in/out) The Sema instance
+///
+/// \param Decl (in) Prototype of the considered function
+///
+/// \param FctDecl (in) FunctionDecl instance
+///
+/// \param Index (in) Index of the Gentype processed
+void AddExtensions(Sema &S,
+                   const OpenCLBuiltinStruct &Decl,
+                   FunctionDecl *FctDecl,
+                   unsigned Index) {
+  std::vector<std::string> ExtensionList;
+
+  // Fetch extensions associated with a function prototype,
+  // (e.g. cl_khr_subgroups)
+  ExtensionList.push_back(FctExtensionTable[Decl.Extension]);
+
+  // Fetch extensions associated with a type
+  // (e.g. cl_khr_fp16 for "half")
+  for (unsigned I = 0; I < Decl.NumTypes; I++) {
+    std::vector<std::string> TmpExtList = GetTypeExtensions(
+        TypeTable[SignatureTable[Decl.SignTableIndex + I].TypeTableIndex].ID);
+    ExtensionList.push_back(TmpExtList[Index%TmpExtList.size()]);
+  }
+
+  if (ExtensionList.size()) {
+    for (const auto &E : ExtensionList) {
+      if (E != "")
+        S.setOpenCLExtensionForDecl(FctDecl, E);
+    }
+  }
+}
+
+
 /// When trying to resolve a function name, if the isOpenCLBuiltin function
 /// defined in "OpenCLBuiltins.inc" returns a non-null <Index, Len> pair, then
 /// the name is referencing an OpenCL builtin function. Thus, all its
 /// signatures are added to the LookUpResult.
 ///
 /// \param S The sema instance.
 ///
 /// \param LR The lookupResult instance.
for (unsigned Index = 0; Index < GenTypeMaxCnt; Index++) {
                                                   /*TInfo=*/nullptr,
                                                   SC_None, nullptr);
           Parm->setScopeInfo(0, IParm);
           ParmList.push_back(Parm);
         }
         NewOpenCLBuiltin->setParams(ParmList);
       }
       NewOpenCLBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context));
+
+      // Add extensions
+      AddExtensions(S, OpenCLBuiltin, NewOpenCLBuiltin, Index);
+
       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 -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header
 
-#if __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.

 typedef __SIZE_TYPE__ size_t;
 #endif
 
 
 kernel void basic_atomic(volatile __global void* global_p) {
   int i;
   unsigned int ui;
 
   atom_add((volatile __global int *) global_p, i);
+#if __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_floating_point_extension() {
+  #pragma OPENCL EXTENSION cl_khr_fp16 : disable
+  #pragma OPENCL EXTENSION cl_khr_fp64 : disable
+
+  half h;
+  // expected-error@-1{{declaring variable of type 'half' is not allowed}}
+
+  double d;
+  #if __OPENCL_C_VERSION__ < CL_VERSION_1_2
+  // expected-error@-2{{use of type 'double' requires cl_khr_fp64 extension to be enabled}}
+  #endif
+
+  #pragma OPENCL EXTENSION cl_khr_fp16 : enable
+  #pragma OPENCL EXTENSION cl_khr_fp64 : enable
+}
 
 
 kernel void basic_conversion() {
   double d;
   float f;
   char2 c2;
   long2 l2;
   float4 f4;

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 // );
 //
 // struct OpenCLBuiltinStruct {
 //   Hold information about builtin functions, where to find the return type and
 //   types of the arguments.
 // };
 //
 // static const OpenCLTypeStruct TypeTable[] = {
 //  {OCLT_double, 2}, // This represents the double2 type.
 //  Other types with their vector size.
 // };
 //
 // static const OpenCLSignatureStruct SignatureTable[] = {
 //   0, 2, 15, // This is a signature
 //   Other indexes of a struct OpenCLTypeStruct table, allowing to build a
 //   signature.
 // };
 //
 // static const OpenCLBuiltinStruct BuiltinTable[] = {
 // // 957 convert_float2_rtn
 //   { 58, 2 }, // The "convert_float2_rtn" function has one signature at the
 //              // index 58 of the SignatureTable, and it uses the 2 values
 //              // after this index.
 //   { 202, 2 },
 //   { 346, 2 },
private:
   //
   // \param List (out) List to fill with the extracted types.
   void EmitTypesEnum(std::vector<Record *> &Types,
     StringMap<bool> &TypesSeen,
     std::string &Output,
     std::vector<const Record *> &List);
 
   // Emit the enum or struct used in the file generated
-  // Populate the TypeList  at the same time.
+  // Populate the TypeExtensionList and FctExtensionList at the same time.
   void EmitDeclarations();
 
   // Parse the Records generated by TableGen to populate the SignaturesList,
   // FctOverloadMap and TypeMap.
   void GetOverloads();
 
+  // Emit the FctExtensionTable and the TypeExtensionTable.
+  // FctExtensionTable maps enums OpenCLFctExtensionID to their extension.
+  // TypeExtensionTable maps OpenCLTypeID enums (not being generic types) to
+  // their extension.
+  // GenTypeExtensionTable maps OpenCLTypeID enums (generic type indexes) to
+  // their extension.
+  void EmitExtensionTable();
+
   // Emit the TypeTable. This table contains all the possible types. A type can
   // have several attributes (e.g. the size of the vector (if applicable),
   // if this is a pointer type, a const type, ...).
   // E.g.:
   // { OCLT_char, 3, 0, 0, 0, 0, clang::LangAS::Default},
   // is describing the type "char", being a vector of 3 elements. See the
   // struct OpenCLTypeStruct for more information.
   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.:
   // 12, 15, 12 can represent a function with the signature:
   // int func(float, int)
   // The "int" type being at the index 12 in the TypeTable.
   void EmitSignatureTable();
 
-  // Emit the OpenCLBuiltins table. This table contains all overloads of
-  // each function, and is a struct OpenCLBuiltinDecl.
+  // Emit the BuiltinTable table. This table contains all the overloads of
+  // each function.
   // E.g.:
   // // acos
   //   { 2, 0, "", 100 },
   // This means that the signature of this acos overload has 1 argument (+1 for
   // the return type), stored at index 0 in the OpenCLSignature table.
   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.
   void EmitQualTypeFinder();
 
+  // Build a function returning the list of extension associated with the Types
+  // used in its signature. The prototype of the function created is:
+  // static std::vector<std::string> GetTypeExtensions(enum OpenCLTypeID ID);
+  void EmitExtensionFinder();
+
   // Contains a list of the available signatures, without the name of the
   // function. Each pair consists of a signature and a cumulative index.
   // E.g.:  <<float, float>, 0>,
   //        <<float, int, int, 2>>,
   //        <<float>, 5>,
   //        ...
   //        <<double, double>, 35>.
   std::vector<std::pair<std::vector<Record *>, unsigned>> SignaturesList;
private:
   // Contains the map of the possible OpenCL types to their index in the
   // TypeTable.
   // E.g.: <<Type<Name="float">, 0>,
   //       <VectorType<Name="float", VectSize=2>, 1>,
   //       <Type<Name="int">, 2>,
   //       ...>
   MapVector<const Record *, unsigned> TypeMap;
 
+  // List of the possible OpenCL function extensions, in the same order as in
+  // the enum OpenCLFctExtensionID.
+  // E,g, <<FctExtension<name="cl_khr_subgroups">>,
+  //       ...>
+  MapVector<const Record *, unsigned> FctExtensionList;
+
   // List of the possible OpenCL type names in the same order as in their
   // enum OpenCLTypeID. This list doesn't contain generic types.
+  // It allows to associate a type name to the extension it is bound to.
+  // Records can be a subclass of the Type class (i.e.: a VectorType), the only
+  // two fields that matter are the name and TypeExtension.
   // Generic types are not part of this list.
-  // E.g.: <Type<name="half">,
-  //       <VectorType<name="double">,
+  // E.g.: <Type<name="half", TypeExtension="cl_khr_fp16">,
+  //       <VectorType<name="double", TypeExtension="cl_khr_fp64">,
   //       ...>
-  std::vector<const Record *> TypeList;
+  std::vector<const Record *> TypeExtensionList;
 
-  // Same as TypeList, but for generic types only.
-  std::vector<const Record *> GenTypeList;
+  // Same as TypeExtensionList, but for generic types only.
+  std::vector<const Record *> GenTypeExtensionList;
 };
 } // namespace
 
 void BuiltinNameEmitter::Emit() {
   emitSourceFileHeader("OpenCL Builtin handling", OS);
 
   OS << "#include \"llvm/ADT/StringRef.h\"\n";
   OS << "using namespace clang;\n\n";
 
+  // Emit the enum and struct
   EmitDeclarations();
 
+  // Parse the Records to populate the internal lists
   GetOverloads();
 
   // Emit data strucures.
+  EmitExtensionTable();
   EmitTypeTable();
   EmitSignatureTable();
-
   EmitBuiltinTable();
 
+  // Emit functions
   EmitStringMatcher();
-
   EmitQualTypeFinder();
+  EmitExtensionFinder();
 }
 
 
 void BuiltinNameEmitter::EmitTypesEnum(std::vector<Record *> &Types,
                                        StringMap<bool> &TypesSeen,
                                        std::string &Output,
                                        std::vector<const Record *> &List) {
   raw_string_ostream SS(Output);
void BuiltinNameEmitter::EmitDeclarations() {
   std::string TypeEnums;
 
   // Generic types need to be last in the enum definition, but parsed first.
   std::vector<Record *> GenTypes =
       Records.getAllDerivedDefinitions("GenericType");
   EmitTypesEnum(GenTypes,
                 TypesSeen,
                 GenTypeEnums,
-                GenTypeList);
+                GenTypeExtensionList);
 
   std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
   EmitTypesEnum(Types,
                 TypesSeen,
                 TypeEnums,
-                TypeList);
+                TypeExtensionList);
 
   OS << TypeEnums;
   OS << GenTypeEnums;
   OS << "};\n\n";
 
+
+  // Enum of the possible extensions associated with functions.
+  unsigned Index = 0;
+  OS << "enum OpenCLFctExtensionID {\n";
+  std::vector<Record *> FctExtensions =
+      Records.getAllDerivedDefinitions("FctExtension");
+  for (const auto *FE : FctExtensions) {
+    OS << "  OCLE_" + FE->getValueAsString("ID") << ",\n";
+    // Save the extension names and their index at the same time
+    FctExtensionList.insert(std::make_pair(FE, Index++));
+  }
+  OS << "};\n\n";
+
   // Strucure definitions.
   OS << R"(
 
 // Store information about types. A function signature reference entries in a
 // table of this strucure.
 struct OpenCLTypeStruct {
   // A type (e.g.: float, int, ...).
   OpenCLTypeID ID;

 // OpenCLBuiltinStruct table allows to have all the overloads.
 struct OpenCLBuiltinStruct {
   // Index of the signature in the OpenCLTypeStruct table.
   unsigned SignTableIndex;
   // Type between indexes SignTableIndex and (SignTableIndex + NumTypes - 1) in
   // the SignatureTable must be considered to build the signature.
   // The first type at index SignTableIndex is the return type.
   unsigned NumTypes;
+  // Extension to which the signature belongs (e.g.: cl_khr_subgroups)
+  enum OpenCLFctExtensionID Extension;
   // Version in which it was introduced (e.g.: CL20). MinVersion is inclusive.
   unsigned MinVersion;
   // Version in which it was introduced (e.g.: CL20). MaxVersion is exclusive.
   unsigned MaxVersion;
 };
 
 )";
 }
for (const auto *B : Builtins) {
     } else {
       SignIndex = it->second;
     }
     FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
   }
 }
 
 
+void BuiltinNameEmitter::EmitExtensionTable() {
+  // Emit the table of extension names bound to functions
+  // E.g.: cl_khr_subgroups
+  OS << "static const char FctExtensionTable[][128] = {\n";
+  for (const auto &FE : FctExtensionList) {
+    OS << "// " << FE.second
+       << " : OCLE_" << FE.first->getValueAsString("ID") << "\n";
+    OS << "\""  << FE.first->getValueAsString("ExtName") << "\",\n";
+  }
+  OS << "};\n\n";
+
+  // Emit the table of extension names bound to types.
+  // E.g.: cl_khr_fp64
+  unsigned Index = 0;
+
+  OS << "static const char TypeExtensionTable[][32] = {\n";
+  for (const auto &TE : TypeExtensionList) {
+    OS << "// " << Index++
+       << " : OCLT_" << TE->getValueAsString("Name") << "\n";
+    OS << "\""
+       << TE->getValueAsDef("Extension")->getValueAsString("ExtName")
+       << "\",\n";
+  }
+  OS << "};\n\n";
+}
+
+
 void BuiltinNameEmitter::EmitTypeTable() {
   // Access Qualifier
   unsigned AQ;
   std::string AQName;
 
   OS << "static const OpenCLTypeStruct TypeTable[] = {\n";
   for (const auto &T : TypeMap) {
     AQ = 0;
void BuiltinNameEmitter::EmitBuiltinTable() {
   for (const auto &FOM : FctOverloadMap) {
 
     OS << "// " << Index << " " << FOM.first << "\n";
 
     for (const auto &Overload : FOM.second) {
       OS << "  { "
          << Overload.second << ", "
          << Overload.first->getValueAsListOfDefs("Signature").size() << ", "
+         << "OCLE_" << Overload.first->getValueAsDef("Extension")->getValueAsString("ID") << ", "
          << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("Name") << ", "
          << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("Name")
          << " },\n";
          Index++;
     }
   }
   OS << "};\n\n";
 }
)";
   OS << R"(
     default:
       QT.push_back(Context.VoidTy);
   } // switch (Ty.ID)
 
 )";
 
   OS << "  // Generate the different vector sizes for each type of the generic type\n";
-  OS << "  if (Ty.ID >= " << TypeList.size() << ") {\n";
+  OS << "  if (Ty.ID >= " << TypeExtensionList.size() << ") {\n";
   OS << R"(
     for (unsigned I = 0; I < QT.size(); I++) {
       if ((*GenVectorPossibility)[I/GenTypePossibility] != 0) {
         QT[I] = Context.getExtVectorType(
                           QT[I],
                           (*GenVectorPossibility)[I/GenTypePossibility]);
       }
     }
)";
 
   return QT;
 } // OCL2Qual
 
 )";
 }
 
 
+void BuiltinNameEmitter::EmitExtensionFinder() {
+  OS << R"(
+static std::vector<std::string> GetTypeExtensions(enum OpenCLTypeID ID) {
+  std::vector<std::string> ExtensionList;
+)";
+
+  OS << "  if (ID < " << TypeExtensionList.size() << ") {\n";
+
+  OS << R"(
+    ExtensionList.push_back(TypeExtensionTable[ID]);
+    return ExtensionList;
+  } else {
+    switch (ID) {
+)";
+
+  for (const auto &GT : GenTypeExtensionList) {
+    OS << "      case OCLT_" << GT->getValueAsString("Name") << ":\n";
+    for (const auto &TE :
+            GT->getValueAsDef("TypeListField")->getValueAsListOfDefs("List")) {
+      OS << "        ExtensionList.push_back(TypeExtensionTable[OCLT_"
+         << TE->getValueAsString("Name") << "]);\n";
+    }
+    OS << "        break;\n";
+  }
+  OS << R"(
+    default:
+      break;
+    }
+  }
+  return ExtensionList;
+}
+)";
+}
+
+
 namespace clang {
 
 void EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
   BuiltinNameEmitter NameChecker(Records, OS);
   NameChecker.Emit();
 }
 
 } // end namespace clang