[OpenCL] Add generic type handling for builtin functions

[svenvh]

Summary

Generic types are an abstraction of type sets. It mimics the way functions
are defined in the OpenCL specification.
E.g.: floatN can abstract all the vector sizes of the float type.

This allows to stick more closely to the specification, which uses generic
types; factorize definitions of functions with numerous prototypes in the
tablegen file; reduce the memory impact of functions with numerous prototypes.

This patch depends on https://reviews.llvm.org/D63256/new/

[Pierre]

Add context lines.

[Anastasia]

Generic types are an abstraction of type sets. It mimics the way functions
are defined in the OpenCL specification.

It would be good to add a spec reference where it is described.

Also can you please provide more explanation of how generic type works in the TableGen. I also feel you should add more documentation in the code about it.

clang/lib/Sema/OpenCLBuiltins.td

63

Remove "I" at the end?

63

The child class list might get outdated?

May be it's better to say that child classes represent concrete types. i.e. VectorType, PointerType, ImageType, GenericType, etc.

64

I don't get this comment.

107

A GenericType is an abstract type that defines a set of types as a combination of types and vector sizes both defined in list components of GenericType.

144

we don't have OpenCL C v2.2 spec.

165

Is there any reason to keep this comment here? Can it be moved to the example?

224

any reason the name starts from lower case here?

230

We don't have language spec 2.2, the same for the line below.

269

Space missing between "fGenTypeN,fGenTypeN"

clang/lib/Sema/SemaLookup.cpp

675

for the return type...

676

of a function.

679

I would suggest OpenCLBuiltin as Decl is often uses as a name for regular declarations.

681

I am confused about this wording. Shouldn't one argument have only one type?

687

I would suggest some more descriptive name i.e GetQualTypesForOpenCLBuiltin

687

Should this be static function?

698

Please use . in the comments

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

49

What does abstract type mean here?

clang/lib/Sema/SemaLookup.cpp

738

should this be a static function?

738

How about SortOpenCLBuiltinFctTypes? Also does it do any sorting? If not may be it should be GetOpenCLBuiltinFctOverloads?

778

Can we rename this into InsertOCLBuiltinDeclarationsFromTable

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

117

do we do any sorting?

141–153

reference -> represent?

148

references -> represents?

149

reference -> represent?

290

Why is this being changed? Does it relate to GenericType?

298

I just realized that we don't describe at a high level what this code generates. May be it's good to add a comment that describes the general structure of generated code.

It can be done as a separate patch though but I find it hard to review without understanding the overall structure.

442–457

Can you document what this function does? I can't quite get why it returns a vector.

469

Can you add a comment here:
// Start of switch statement over all possible types used in Builtin functions

535

Does abstract mean generic type?

562

end of switch statement?

566

I can't understand what this code does...

[Pierre]

clang/lib/Sema/OpenCLBuiltins.td

49

This is to compare with the CanQualType instances in ASTContext.h (and BuiltinTypes.def and OpenCLImageTypes.def).
Some types in this .td file don't represent a real type, as defined in the files referenced above. This is the case for the generic types, representing multiple types and vector size, but also for the image types in D63480.
This isAbstract field is meant to identify the Type instances (of the .td file) that cannot be mapped to an existing ASTContext CanQualType.

For a function using the float Type in the .td file, this type will generate the following code in OpenCLBuiltins.inc (see line 443 of ClangOpenCLBuiltinEmitter.cpp):

case OCLT_float:
  QT.push_back(Context.FloatTy);
  break;

For a function using the generic type FGenTypeN , this type will generate the following code:

case OCLT_FGenTypeN:
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  GenTypePossibility = 3;
  GenVectorPossibility = &ListListN;
  break;

GenTypePossibility and GenVectorPossibility can be ignored for now. FGenTypeN cannot be mapped to one CanQualType.
It is currently possible to identify instances of the GenericType class for now (and remove the IsAbstract field), but some instances of the futur-defined image types will cause troubles. Indeed, some Type instances will have to be ignored, and this is a way to select which types to ignore.

63

The child classes are VectorType, PointerType, ImageType and GenericType, I don't get what is outdated?

64

This means that VectorType classes should only be defined when used the definition of a builtin function, and not as below:

def int2_t : VectorType<int_t, 2>;

I changed it.

165

In the OpenCL C specification, vector types are defined just after the non-vector types. Having this comment here makes it easier to find than having it in the definition of one builtin function (I think)

224

No reason, this has been changed

clang/lib/Sema/SemaLookup.cpp

675

I think this is of

681

A generic type can abstract multiple types, cf the definition of fGenTypeN in the .td file line 221. In this case, GenTypeMaxCnt's value will be 3

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

117

I changed to "extract"

141–153

I changed to "represent"

148

I used reference because the numbers are indexes in another table (the TypeTable)

149

Same

290

I removed the enum. The "0 otherwise" is important because generic types can have different vector sizes, but the vector sizes of generic types are not handled with this field: this field is irrelevant for generic types.

298

I added a paragraph in the header of this file. I am not sure this was what you wanted.

535

See comment l.49 of OpenCLBuiltins.td

566

(l.459) TypeList contains all the types, excepted generic types.
If the type currently handled is a non-generic type, then its VectorWidth field in the TypeTable will be set to its vectorwidth, and the code below (line 476) will set its vectorwidth.
If this is a generic type, the VectorWidth field in the TypeTable is not relevant. The vectorwidth of the available types will be set with the code line 461.

For the generic type FGenTypeN, the types float, double and half can have the following vector width: scalar, 2, 3, 4, 6, 8, 16.
We first populate the list of QualType QT with the right types (regardless the vector width).
There are three different types available, so we set GenTypePossibility to 3.
The vectorwidth we want these types to have is stored in GenVectorPossibility, referencing ListListN (={0, 2, 3, 4, 8, 16})

case OCLT_FGenTypeN:
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  GenTypePossibility = 3;
  GenVectorPossibility = &ListListN;
  break;

Then, we need to set the right vectorwidths for each element of QT. l.462 is checking this is not a scalar (GenVectorPossibility[Idx] != 0). If this is not a scalar, we set the vectorwidth to the element of GenVectorPossibility at index I/GenTypePossibility.
The order of element in QT is therefore important.

[Pierre]

clang/lib/Sema/SemaLookup.cpp

683

I will change meaningfull -> meaningful in the next correction (and the other occurrences of the same word)

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

49

Ok, can you update the comment by saying something like that the abstract types cannot be mapped to any CanQualType...

49

case OCLT_FGenTypeN:
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  QT.push_back(Context.FloatTy);
  QT.push_back(Context.DoubleTy);
  QT.push_back(Context.HalfTy);
  GenTypePossibility = 3;
  GenVectorPossibility = &ListListN;
  break;

Hmm it seems you are repeatedly adding the same thing.

QT.push_back(Context.FloatTy);
QT.push_back(Context.DoubleTy);
QT.push_back(Context.HalfTy);

63

Just add etc. at the end in case we add extra types later and this comment will become outdated.

118

Possible types -> Possible element types

163–166

You now have 2.0 twice!

165

Well the code doesn't really have sections to refer to. So how do I find the section you mention? In fact right now if I search for 6.13.7 I don't find anything.

It is not common to refer to sections in the code because it doesn't have structural documentation as spec would have. Does it make sense?

171–176

why are you changing this?

206

What does 0 mean here? And why do we need his list?

208

Why some names start with capital letter and some not?

clang/lib/Sema/SemaLookup.cpp

675

Possibly both fit. For would read nicer because you would avoid repetition of of article. :p

676

Sorry it might be better to change to:

of a function -> for OpenCL library functions

728

for the OpenCL library functions.

763–764

I think you need to start from something like - Helper function ...

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

33

does this include GenType?

37

Can you explain this a bit more please?

What is the index here? You probably need to copy some similar description as below.

42

This included GenTypes right? Btw can we have GenTypes and concrete VectorTypes here too?

46

Can you add a high level description please?

52

What do the numbers correspond to?

59

what are the 2 values used for?

173

Ok, how about we add a section describing how all these containers relate to each other?
Just to make clear why we have SignaturesList and FctOverloadMap that both contain signatures of functions but yet they are different data structures.

Feel free to use type aliases for something like std::pair<const Record *, unsigned> or std::pair<std::vector<Record *>, unsigned> that might help understanding the purpose of different data structures you define.

302

Does the struct contain just one field?

309

SignTableIndex -> SigTableIndex?

Otherwise it reads as sign.

336

I think type aliases would make this more concise and clean.

554

What is GenVectorPossibility and GenTypePossibility?

565–566

Can you document somewhere the structure of OCL2Qual. I am not getting here are we inside or outside of switch statement...

[Pierre]

Add examples of generated code.

[Pierre]

Corrections.

clang/lib/Sema/OpenCLBuiltins.td

49

Yes,

QT.push_back(Context.FloatTy);
QT.push_back(Context.DoubleTy);
QT.push_back(Context.HalfTy);

is added the same number of times as the number of elements in ListListN.

It is still possible to create for loops, but I thought it would be slightly more easier to understand this than for loops (at first sight).
The cost of having for loops instead of raw push_back like this will be similar for generic types with few elements. I think the overall cost in size of generated code is slightly worse with for loops.

63

Actually, its child classes are not concrete types, cf the GenType. I changed it to something else.

165

I changed it to something less specific.

171–176

These type definitions need to be excluded by being declared as abstract not to cause trouble. They will need to be abstract to be handled in the image type patch. This also allows to keep the builtin functions using image types as such, and with no harm.

206

What does 0 mean here?

0 was for a scalar. I changed it to 1.

And why do we need his list?

This list is needed in the definition of the fmax and fmin functions. The GenType_float_ListNNonZero for instance is used and uses it.

208

I changed to CamelCase wherever this was possible. The image types and address spaces qualifiers have not been changed in this patch, ut this will be in the appropriate patches.

clang/lib/Sema/SemaLookup.cpp

676

So in the end I kept "of" then "for" to avoid repetition :D

763–764

InsertOCLBuiltinDeclarationsFromTable will also uses a few helper functions. In the end we will only have helper functions, and I think this is actually the only real function of the -fdeclare-opencl-... feature

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

33

Yes, GenTypes are also hold inside this structure.

37

This was deleted because the struct was unnecessary (replaced by an array of unsigned)

42

Yes, GenTypes are also held inside this structure, but if this is a genType, the "VectorWidth" field is not relevant.

I added a comment // Size of the vector (if applicable, 0 otherwise and for generic types). in the definition of the structure. I didn't go into details in the outline of the structure of the file.

46

I added a more high level description just above while describing the struct itself.
cf

// struct OpenCLTypeStruct {
//   Hold information about types (vector size, ...)
// };

In this part of the file, outlining the structure of the generated output, the first sections are enum/structure definitions, then comes the instances of the structures defines in the first section, and finally functions.

52

They are indexes in the struct OpenCLTypeStruct TypeTable.

For instance, if
{OCLT_double, 2} were at index 0,
{OCLT_int, 2} were at index 2,
{OCLT_float, 1} were at index 15,

then 0, 2, 15 would be a the signature:
double2 function( int2, float) ;

59

They are referencing the SignatureTable, cf the comment on the right of the values

173

I can typedef the Record * to a name showing a bit more what is inside the Record *. For instance:
typedef Record * Type if the Record is hiding a Type, or
typedef Record * Signature if this is a signature.

I agree this is currently not explicit at all, but aliasing the whole structures can be even more misleading since all these structure represent really similar things. I will do the aliasing it in the next version.

302

Yes, it was. I changed it to an array of unsigned.

336

cf comment on line 373.

554

GenTypePossibility is the number of different types held in the GenType. If the gentype contains float/half, then GenTypePossibility = 2
GenTypePossibility is a pointer to the vector sizes available for this GenType. If the is ListListN (= {1, 2, 3, 4, 8, 16, }), then these vector sizes will be generated for the types held in the Generic Type.

I added comments with generated code to be more explicit.

562

It was at :
} // switch (Ty.ID)
I added another comment.

565–566

I added a description in the description of the generated code outline (beginning of the file).
I also refactored one part of the function to make it a bit clearer.

[Pierre]

Forgot one change.

[svenvh]

It seems Phabricator got a bit confused as the latest diff did not include full context (use git diff -U999999).

clang/lib/Sema/OpenCLBuiltins.td

65

customed -> custom

247

Any reason to change indentation/line breaks here? The previous version looked easier to read imho.

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

93

I'm not sure if having large chunks of commented out code is a good idea. It gets outdated easily, only leading to confusion. If anyone is interested to see the details of the generated code, they can always look in the generated file. I think it would be better to only describe the high level structure and the reason for generating the code in the chosen way.

565–566

Again I feel this is too much code that might get outdated. It would be better to describe *why* it's generated this way because anyone can already see *what* is generated in the .inc file.

[svenvh]

Continuing in https://reviews.llvm.org/D65456

clang/lib/Sema/OpenCLBuiltins.td

 //==--- OpenCLBuiltins.td - OpenCL builtin declarations -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains TableGen definitions for OpenCL builtin function
-// declarations.  In case of an unresolved function name in OpenCL, Clang will
+// declarations. In case of an unresolved function name in OpenCL, Clang will
 // check for a function described in this file when -fdeclare-opencl-builtins
 // is specified.
 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //              Definitions of miscellaneous basic entities.
 //===----------------------------------------------------------------------===//

 def default_as    : AddressSpace<"clang::LangAS::Default">;
 def private_as    : AddressSpace<"clang::LangAS::opencl_private">;
 def global_as     : AddressSpace<"clang::LangAS::opencl_global">;
 def constant_as   : AddressSpace<"clang::LangAS::opencl_constant">;
 def local_as      : AddressSpace<"clang::LangAS::opencl_local">;
 def generic_as    : AddressSpace<"clang::LangAS::opencl_generic">;
 
 
-// Qualified Type. Allow to retrieve one ASTContext QualType.
-class QualType<string _Name> {
+// 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;
 }
 
-// Helper class to store type access qualifiers (volatile, const, ...).
-class Qualifier<string _QualName> {
-  string QualName = _QualName;
+
+// Store a list of integer.
+class IntList<string _Name, list<int> _List> {
+  string Name = _Name;
+  list<int> List = _List;
 }
 
 //===----------------------------------------------------------------------===//
 //                      OpenCL C classes for types
 //===----------------------------------------------------------------------===//
-// OpenCL types (int, float, ...)
+// OpenCL C types (int, float, ...).
+// Its Child classes represent concrete types.
+// I.e.: VectorType, PointerType, ImageType and GenericType.
+// Instances of these child classes should be declared right in Builtin
+// function arguments.
+// See the definition of the "read_imagef" function as example.
 class Type<string _Name, QualType _QTName> {
   // Name of the Type
   string Name = _Name;
   // QualType associated with this type
   QualType QTName = _QTName;
   // Size of the vector (if applicable)
   int VecWidth = 0;
   // Is pointer
   bit IsPointer = 0;
-  // List of qualifiers associated with the type (volatile, ...)
-  list<Qualifier> QualList = [];
-  // Address space
-  string AddrSpace = "clang::LangAS::Default";
   // Access qualifier. Must be one of ("RO", "WO", "RW").
   string AccessQualifier = "";
+  // Address space associated.
+  string AddrSpace = "clang::LangAS::Default";
 }
 
 // OpenCL vector types (e.g. int2, int3, int16, float8, ...)
 class VectorType<Type _Ty, int _VecWidth> : Type<_Ty.Name, _Ty.QTName> {
   int VecWidth = _VecWidth;
 }
 
 // OpenCL pointer types (e.g. int*, float*, ...)
 class PointerType<Type _Ty, AddressSpace _AS = global_as> :
                                       Type<_Ty.Name, _Ty.QTName> {
   bit IsPointer = 1;
   string AddrSpace = _AS.AddrSpace;
 }
 
 // OpenCL image types (e.g. image2d_t, ...)
 class ImageType<Type _Ty, QualType _QTName, string _AccessQualifier> :
                                               Type<_Ty.Name, _QTName> {
   let AccessQualifier = _AccessQualifier;
 }
 
+// Store a list of Types.
+class TypeList<string _Name, list<Type> _Type> {
+  string Name = _Name;
+  list<Type> List = _Type;
+}
+
+// A GenericType is an abstract type that defines a set of types as a
+// combination of types and vector sizes both defined in list components of
+// GenericType.
+// E.g.: If TypeListField = <int, float> and VectorList = <0, 2, 4>, then
+//       then gentype will represent <int, int2, int4, float, float2, float4>
+// _Ty          : Name of the GenType
+// _TypeList    : Types this GenericType can be
+// _VectorList  : Sizes of the vector for each type of the _TypeList. 0 being a
+//                scalar.
+class GenericType<string _Ty, TypeList _TypeList, IntList _VectorList> :
+                                            Type<_Ty, QualType<"null", 1>> {
+  // Possible types of the generic type.
+  TypeList TypeListField = _TypeList;
+  // Possible vector sizes of the types in the TypeListField.
+  IntList VectorList = _VectorList;
+}
+
 //===----------------------------------------------------------------------===//
 //                      OpenCL C class for builtin functions
 //===----------------------------------------------------------------------===//
 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 Version to which the function belongs (CL10, ...)
   Version Version = CL10;
 }
 
 //===----------------------------------------------------------------------===//
-//                           Multiclass definitions
-//===----------------------------------------------------------------------===//
-// multiclass BifN: Creates Builtin class instances for OpenCL builtin
-//                  functions with N arguments.
-// _Name      : Name of the function
-// _Signature : Signature of the function (list of the Type used by the
-//              function, the first one being the return type).
-// _IsVector  : List of bit indicating if the type in the _Signature at the
-//              same index is to be a vector in the multiple overloads. The
-//              list must have at least one non-zero value.
-multiclass Bif0<string _Name, list<Type> _Signature, list<bit> _IsVector> {
-  def : Builtin<_Name, _Signature>;
-  foreach v = [2, 3, 4, 8, 16] in {
-    def : Builtin<_Name,
-                  [!if(_IsVector[0], VectorType<_Signature[0], v>, _Signature[0])]>;
-  }
-}
-multiclass Bif1<string _Name, list<Type> _Signature, list<bit> _IsVector> {
-  def : Builtin<_Name, _Signature>;
-  foreach v = [2, 3, 4, 8, 16] in {
-    def : Builtin<_Name,
-                  [!if(_IsVector[0], VectorType<_Signature[0], v>, _Signature[0]),
-                  !if(_IsVector[1], VectorType<_Signature[1], v>, _Signature[1])]>;
-  }
-}
-multiclass Bif2<string _Name, list<Type> _Signature, list<bit> _IsVector> {
-  def : Builtin<_Name, _Signature>;
-  foreach v = [2, 3, 4, 8, 16] in {
-    def : Builtin<_Name,
-                  [!if(_IsVector[0], VectorType<_Signature[0], v>, _Signature[0]),
-                  !if(_IsVector[1], VectorType<_Signature[1], v>, _Signature[1]),
-                  !if(_IsVector[2], VectorType<_Signature[2], v>, _Signature[2])]>;
-  }
-}
-multiclass Bif3<string _Name, list<Type> _Signature, list<bit> _IsVector> {
-  def : Builtin<_Name, _Signature>;
-  foreach v = [2, 3, 4, 8, 16] in {
-    def : Builtin<_Name,
-                  [!if(_IsVector[0], VectorType<_Signature[0], v>, _Signature[0]),
-                  !if(_IsVector[1], VectorType<_Signature[1], v>, _Signature[1]),
-                  !if(_IsVector[2], VectorType<_Signature[2], v>, _Signature[2]),
-                  !if(_IsVector[3], VectorType<_Signature[3], v>, _Signature[3])]>;
-  }
-}
-//===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL C types
 //===----------------------------------------------------------------------===//
-// OpenCL v1.2 s6.1.1: Built-in Scalar Data 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">>;
 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.2 s6.1.2: Built-in Vector Data Types
-foreach v = [2, 3, 4, 8, 16] in {
-  def char#v#_t    : VectorType<char_t, v>;
-  def uchar#v#_t   : VectorType<uchar_t, v>;
-  def short#v#_t   : VectorType<short_t, v>;
-  def ushort#v#_t  : VectorType<ushort_t, v>;
-  def "int"#v#_t   : VectorType<int_t, v>;
-  def uint#v#_t    : VectorType<uint_t, v>;
-  def long#v#_t    : VectorType<long_t, v>;
-  def ulong#v#_t   : VectorType<ulong_t, v>;
-  def float#v#_t   : VectorType<float_t, v>;
-  def double#v#_t  : VectorType<double_t, v>;
-  def half#v#_t    : VectorType<half_t, v>;
-}
+// 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.2 s6.1.3: Other Built-in Data Types
 // These definitions with a "null" name are "abstract". They should not
 // be used in definitions of Builtin functions.
-def image2d_t         : Type<"image2d_t", QualType<"null">>;
-def image3d_t         : Type<"image3d_t", QualType<"null">>;
-def image2d_array_t   : Type<"image2d_array_t", QualType<"null">>;
-def image1d_t         : Type<"image1d_t", QualType<"null">>;
-def image1d_buffer_t  : Type<"image1d_buffer_t", QualType<"null">>;
-def image1d_array_t   : Type<"image1d_array_t", QualType<"null">>;
+def image2d_t         : Type<"image2d_t", QualType<"null", 1>>;
+def image3d_t         : Type<"image3d_t", QualType<"null", 1>>;
+def image2d_array_t   : Type<"image2d_array_t", QualType<"null", 1>>;
+def image1d_t         : Type<"image1d_t", QualType<"null", 1>>;
+def image1d_buffer_t  : Type<"image1d_buffer_t", QualType<"null", 1>>;
+def image1d_array_t   : Type<"image1d_array_t", QualType<"null", 1>>;
 // Unlike the few functions above, the following definitions can be used
 // in definitions of Builtin functions (they have a QualType with a name).
 foreach v = ["RO", "WO", "RW"] in {
   def image2d_#v#_t       : ImageType<image2d_t,
                                       QualType<"OCLImage2d"#v#"Ty">,
                                       v>;
   def image3d_#v#_t       : ImageType<image3d_t,
                                       QualType<"OCLImage3d"#v#"Ty">,
foreach v = ["RO", "WO", "RW"] in {
   def image1d_array#v#_t  : ImageType<image1d_array_t,
                                       QualType<"OCLImage1dArray"#v#"Ty">,
                                       v>;
 }
 
 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]>;
+
+// Generate basic GenTypes. Names are like: genType_char_zeroList.
+foreach Type = [char_t, uchar_t, short_t, ushort_t,
+                int_t, uint_t, long_t, ulong_t,
+                float_t, double_t, half_t] in {
+  foreach List = [ListN, ListNNonZero] in {
+    def "genType_"#Type.Name#_#List :
+              GenericType<"genType_"#Type.Name#_#List,
+                          TypeList<"GL"#Type.Name, [Type]>,
+                          List>;
+  }
+}
+
+// GenType lists definitions.
+def GLFoatTypes : TypeList<"FoatTypes", [float_t, double_t, half_t]>;
+
+// GenType definitions.
+def FGenTypeN           : GenericType<"FGenTypeN", GLFoatTypes, ListN>;
+
 //===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL builtin functions
 //===----------------------------------------------------------------------===//
-// OpenCL v1.2 s6.2.3: Explicit Conversions
-// Generate the convert_ builtins.
-foreach RType = [float_t, double_t, char_t, uchar_t, short_t, ushort_t,
-                int_t, uint_t, long_t, ulong_t] in {
-  foreach IType = [float_t, double_t, char_t, uchar_t, short_t, ushort_t,
-                   int_t, uint_t, long_t, ulong_t] in {
+//--------------------------------------------------------------------
+// OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions.
+// OpenCL v2.0 Extensions s5.1.1 and s6.1.1 - Conversions.
+
+// Generate the convert_* builtins functions.
+foreach RType = [float_t, double_t, half_t, char_t, uchar_t, short_t,
+                 ushort_t, int_t, uint_t, long_t, ulong_t] in {
+  foreach IType = [float_t, double_t, half_t, char_t, uchar_t, short_t,
+                   ushort_t, int_t, uint_t, long_t, ulong_t] in {
     foreach sat = ["", "_sat"] in {
-      foreach rte = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
-        def : Builtin<"convert_"  # RType.Name # sat # rte, [RType, IType]>;
+      foreach rnd = ["", "_rte", "_rtn", "_rtp", "_rtz"] in {
+        def : Builtin<"convert_"#RType.Name#sat#rnd, [RType, IType]>;
         foreach v = [2, 3, 4, 8, 16] in {
-          def : Builtin<"convert_" # RType.Name # v # sat # rte,
+          def : Builtin<"convert_"#RType.Name#v#sat#rnd,
                         [VectorType<RType, v>,
-                         VectorType<IType, v>]>;
+                          VectorType<IType,
+                          v>]>;
         }
       }
     }
   }
 }
 
+
 // OpenCL v1.2 s6.12.1: Work-Item Functions
 def get_work_dim : Builtin<"get_work_dim", [uint_t]>;
 foreach name = ["get_global_size", "get_global_id", "get_local_size",
                 "get_local_id", "get_num_groups", "get_group_id",
                 "get_global_offset"] in {
   def : Builtin<name, [size_t, uint_t]>;
 }
 
 // OpenCL v1.2 s6.12.2: Math Functions
 foreach name = ["acos", "acosh", "acospi",
                 "asin", "asinh", "asinpi",
                 "atan", "atanh", "atanpi"] in {
-  foreach type = [float_t, double_t, half_t] in {
-    defm : Bif1<name, [type, type], [1, 1]>;
-  }
+  def : Builtin<name, [FGenTypeN, FGenTypeN]>;
 }
 
 foreach name = ["atan2", "atan2pi"] in {
-  foreach type = [float_t, double_t, half_t] in {
-    defm : Bif2<name, [type, type, type], [1, 1, 1]>;
-  }
+  def : Builtin<name, [FGenTypeN, FGenTypeN, FGenTypeN]>;
 }
 
 foreach name = ["fmax", "fmin"] in {
-  foreach type = [float_t, double_t, half_t] in {
-    defm : Bif2<name, [type, type, type], [1, 1, 1]>;
-    defm : Bif2<name, [type, type, type], [1, 1, 0]>;
-  }
+  def : Builtin<name, [FGenTypeN, FGenTypeN, FGenTypeN]>;
+  def : Builtin<name, [genType_float_ListNNonZero, genType_float_ListNNonZero, float_t]>;
+  def : Builtin<name, [genType_double_ListNNonZero, genType_double_ListNNonZero, double_t]>;
+  def : Builtin<name, [genType_half_ListNNonZero, genType_half_ListNNonZero, half_t]>;
 }
 
 // OpenCL v1.2 s6.12.14: Built-in Image Read Functions
 def read_imagef : Builtin<"read_imagef",
-                          [float4_t, image2d_RO_t, VectorType<int_t, 2>]>;
+                          [VectorType<float_t, 4>, image2d_RO_t, VectorType<int_t, 2>]>;
 def write_imagef : Builtin<"write_imagef",
                            [void_t,
                             image2d_WO_t,
                             VectorType<int_t, 2>,
                             VectorType<float_t, 4>]>;
 
 
 // OpenCL v2.0 s9.17.3: Additions to section 6.13.1: Work-Item Functions
 let Version = CL20 in {
   let Extension = "cl_khr_subgroups" in {
     def get_sub_group_size : Builtin<"get_sub_group_size", [uint_t]>;
     def get_max_sub_group_size : Builtin<"get_max_sub_group_size", [uint_t]>;
     def get_num_sub_groups : Builtin<"get_num_sub_groups", [uint_t]>;
   }
 }

clang/lib/Sema/SemaLookup.cpp

 
 LLVM_DUMP_METHOD void LookupResult::dump() {
   llvm::errs() << "lookup results for " << getLookupName().getAsString()
                << ":\n";
   for (NamedDecl *D : *this)
     D->dump();
 }
 
-/// When trying to resolve a function name, if the isOpenCLBuiltin function
-/// defined in "OpenCLBuiltins.inc" returns a non-null <Index, Len>, then the
-/// identifier is referencing an OpenCL builtin function. Thus, all its
-/// prototypes are added to the LookUpResult.
-///
-/// \param S The Sema instance
-/// \param LR  The LookupResult instance
-/// \param II  The identifier being resolved
-/// \param Index  The list of prototypes starts at Index in OpenCLBuiltins[]
-/// \param Len  The list of prototypes has Len elements
-static void InsertOCLBuiltinDeclarations(Sema &S, LookupResult &LR,
-                                         IdentifierInfo *II, unsigned Index,
-                                         unsigned Len) {
+/// Helper function to get the QualType instances of the return type and
+/// arguments of a function.
+/// \param Context (in) The Context instance.
+///
+/// \param OpenCLBuiltin (in) The signature currently handled.
+///
+/// \param GenTypeMaxCnt (out) Maximum number of types contained in a generic
+///        type used as return type or as argument.
+///        Only meaningfull for generic types, otherwise equals 1.
+///
+/// \param RetTypes (out) List of the possible return types.
+///
+/// \param ArgTypes (out) List of the possible types for the arguments.
+static void GetQualTypesForOpenCLBuiltin(
+                  ASTContext &Context,
+                  const OpenCLBuiltinStruct &OpenCLBuiltin,
+                  unsigned &GenTypeMaxCnt,
+                  std::vector<QualType> &RetTypes,
+                  SmallVector<std::vector<QualType>, 5> &ArgTypes) {
+  // Get the QualType instances of the return types.
+  RetTypes = OCL2Qual(
+      Context,
+      TypeTable[SignatureTable[OpenCLBuiltin.SignTableIndex].TypeTableIndex]);
+  GenTypeMaxCnt = RetTypes.size();
+
+  // Get the QualType instances of the arguments.
+  // First type is the return type, skip it.
+  for (unsigned Index = 1; Index < OpenCLBuiltin.NumTypes; Index++) {
+    std::vector<QualType> Ty = OCL2Qual(
+      Context,
+      TypeTable[SignatureTable[OpenCLBuiltin.SignTableIndex + Index].TypeTableIndex]);
+    ArgTypes.push_back(Ty);
+    GenTypeMaxCnt = (Ty.size() > GenTypeMaxCnt) ? Ty.size() : GenTypeMaxCnt;
+  }
 
-  for (unsigned i = 0; i < Len; ++i) {
-    OpenCLBuiltinDecl &Decl = OpenCLBuiltins[Index - 1 + i];
-    ASTContext &Context = S.Context;
+  // Check that that lengths of the gentypes are compatibles.
+  if ((GenTypeMaxCnt % RetTypes.size()) != 0) {
+    goto error_handler;
+  }
+  for (unsigned Index = 0; Index < ArgTypes.size(); Index++) {
+    unsigned TypeCntAtIndex = ArgTypes[Index].size();
+    if ((GenTypeMaxCnt % TypeCntAtIndex) != 0) {
+      goto error_handler;
+    }
+  }
 
-    // Ignore this BIF if the version is incorrect.
-    if (Context.getLangOpts().OpenCLVersion < Decl.Version)
-      continue;
+  return;
+
+error_handler:
+  llvm_unreachable("Lengths of genTypes used are incompatible in the "\
+                   "definition of the builtin function");
+}
 
-    FunctionProtoType::ExtProtoInfo PI;
-    PI.Variadic = false;
+/// Helper function to create a list of the possible signatures for the
+/// function.
+/// \param Context (in) The Context instance.
+///
+/// \param GenTypeMaxCnt (out)Maximum number of types contained in a generic
+///        type used as return type or as argument.
+///        Only meaningfull for generic types, otherwise equals 1.
+///
+/// \param FunctionList (out) List of the function declarations.
+///
+/// \param RetTypes (in) List of the possible return types.
+///
+/// \param ArgTypes (in) List of the possible types for the arguments.
+static void GetOpenCLBuiltinFctOverloads(ASTContext &Context,
+                  unsigned GenTypeMaxCnt,
+                  std::vector<QualType> &FunctionList,
+                  std::vector<QualType> &RetTypes,
+                  SmallVector<std::vector<QualType>, 5> &ArgTypes) {
 
-    // Defined in "OpenCLBuiltins.inc"
-    QualType RT = OCL2Qual(Context, OpenCLSignature[Decl.ArgTableIndex]);
+  for (unsigned IGenType = 0; IGenType < GenTypeMaxCnt; IGenType++) {
+    SmallVector<QualType, 5> ArgList;
 
-    SmallVector<QualType, 5> ArgTypes;
-    for (unsigned I = 1; I < Decl.NumArgs; I++) {
-      QualType Ty = OCL2Qual(Context, OpenCLSignature[Decl.ArgTableIndex + I]);
-      ArgTypes.push_back(Ty);
+    for (unsigned I = 0; I < ArgTypes.size(); I++) {
+      ArgList.push_back(ArgTypes[I][IGenType%ArgTypes[I].size()]);
     }
 
-    QualType R = Context.getFunctionType(RT, ArgTypes, PI);
-    SourceLocation Loc = LR.getNameLoc();
+    FunctionList.push_back(
+        Context.getFunctionType(
+            RetTypes[(RetTypes.size() != 1) ? IGenType : 0],
+            ArgList, PI));
+  }
+}
 
-    // TODO: This part is taken from Sema::LazilyCreateBuiltin,
-    // maybe refactor it.
-    DeclContext *Parent = Context.getTranslationUnitDecl();
-    FunctionDecl *New = FunctionDecl::Create(Context, Parent, Loc, Loc, II, R,
-                                             /*TInfo=*/nullptr, SC_Extern,
-                                             false, R->isFunctionProtoType());
-    New->setImplicit();
-
-    // Create Decl objects for each parameter, adding them to the
-    // FunctionDecl.
-    if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
-      SmallVector<ParmVarDecl *, 16> Params;
-      for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
-        ParmVarDecl *Parm =
-            ParmVarDecl::Create(Context, New, SourceLocation(),
-                                SourceLocation(), nullptr, FT->getParamType(i),
-                                /*TInfo=*/nullptr, SC_None, nullptr);
-        Parm->setScopeInfo(0, i);
-        Params.push_back(Parm);
-      }
-      New->setParams(Params);
+/// 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.
+///
+/// \param II The identifier being resolved.
+///
+/// \param FctIndex The list of signatures is starting at this index in the
+/// OpenCLBuiltins table.
+///
+/// \param Len The list of signatures has Len elements.
+static void InsertOCLBuiltinDeclarationsFromTable(Sema &S,
+                                                  LookupResult &LR,
+                                                  IdentifierInfo *II,
+                                                  const unsigned FctIndex,
+                                                  const unsigned Len) {
+  // "Generic types" (gentypes) are abstract types regrouping a set of types.
+  // It allows factoring types when declaring OpenCL builtin function overloads.
+  // E.G.: The following gentype abstacts vectors of the float type.
+  // genFloatN = {float, float2, float3, float4, float8, float16}
+
+  // Maximum number of types contained in a generic type used as return type or
+  // as argument.
+  // Only meaningfull for generic types, otherwise equals 1.
+  unsigned GenTypeMaxCnt;
+  // The function has been declared using generic types.
+  bool HasGenType = false;
+
+  for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
+    const OpenCLBuiltinStruct &OpenCLBuiltin =
+                                      BuiltinTable[FctIndex + SignatureIndex];
+    ASTContext &Context = S.Context;
+
+    std::vector<QualType> RetTypes;
+    SmallVector<std::vector<QualType>, 5> ArgTypes;
+
+    GetQualTypesForOpenCLBuiltin(Context, OpenCLBuiltin, GenTypeMaxCnt,
+                                 RetTypes, ArgTypes);
+
+    if (GenTypeMaxCnt > 1) {
+      HasGenType = true;
     }
 
-    New->addAttr(OverloadableAttr::CreateImplicit(Context));
+    // Create function overload for each type combination.
+    std::vector<QualType> FunctionList;
+    GetOpenCLBuiltinFctOverloads(Context, GenTypeMaxCnt, FunctionList,
+                                 RetTypes, ArgTypes);
 
-    if (strlen(Decl.Extension))
-      S.setOpenCLExtensionForDecl(New, Decl.Extension);
+    SourceLocation Loc = LR.getNameLoc();
+    DeclContext *Parent = Context.getTranslationUnitDecl();
+    FunctionDecl *NewOpenCLBuiltin;
 
-    LR.addDecl(New);
+    for (unsigned Index = 0; Index < GenTypeMaxCnt; Index++) {
+      NewOpenCLBuiltin = FunctionDecl::Create(Context, Parent,
+                                   Loc, Loc, II, FunctionList[Index],
+                                   /*TInfo=*/nullptr, SC_Extern, false,
+                                   FunctionList[Index]->isFunctionProtoType());
+      NewOpenCLBuiltin->setImplicit();
+
+      // Create Decl objects for each parameter, adding them to the FunctionDecl.
+      if (const FunctionProtoType *FP =
+            dyn_cast<FunctionProtoType>(FunctionList[Index])) {
+        SmallVector<ParmVarDecl*, 16> ParmList;
+        for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
+          ParmVarDecl *Parm = ParmVarDecl::Create(Context, NewOpenCLBuiltin,
+                                                  SourceLocation(),
+                                                  SourceLocation(),
+                                                  nullptr,
+                                                  FP->getParamType(IParm),
+                                                  /*TInfo=*/nullptr,
+                                                  SC_None, nullptr);
+          Parm->setScopeInfo(0, IParm);
+          ParmList.push_back(Parm);
+        }
+        NewOpenCLBuiltin->setParams(ParmList);
+      }
+      NewOpenCLBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context));
+      LR.addDecl(NewOpenCLBuiltin);
+    }
   }
 
   // If we added overloads, need to resolve the lookup result.
-  if (Len > 1)
+  if (Len > 1 || HasGenType)
     LR.resolveKind();
 }
 
 /// Lookup a builtin function, when name lookup would otherwise
 /// fail.
 static bool LookupBuiltin(Sema &S, LookupResult &R) {
   Sema::LookupNameKind NameKind = R.getLookupKind();
 
if (II) {
           return true;
         }
       }
 
       // Check if this is an OpenCL Builtin, and if so, insert its overloads.
       if (S.getLangOpts().OpenCL && S.getLangOpts().DeclareOpenCLBuiltins) {
         auto Index = isOpenCLBuiltin(II->getName());
         if (Index.first) {
-          InsertOCLBuiltinDeclarations(S, R, II, Index.first, Index.second);
+          InsertOCLBuiltinDeclarationsFromTable(S, R, II,
+                                                Index.first - 1,
+                                                Index.second);
           return true;
         }
       }
 
       // If this is a builtin on this (or all) targets, create the decl.
       if (unsigned BuiltinID = II->getBuiltinID()) {
         // In C++ and OpenCL (spec v1.2 s6.9.f), we don't have any predefined
         // library functions like 'malloc'. Instead, we'll just error.

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

 // 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
+// expected-no-diagnostics
 
 // Test the -fdeclare-opencl-builtins option.
 
 // Provide typedefs when invoking clang without -finclude-default-header.
 #ifdef NO_HEADER
+typedef char char2 __attribute__((ext_vector_type(2)));
 typedef float float4 __attribute__((ext_vector_type(4)));
-typedef int int4 __attribute__((ext_vector_type(4)));
 typedef int int2 __attribute__((ext_vector_type(2)));
+typedef int int4 __attribute__((ext_vector_type(4)));
+typedef long long2 __attribute__((ext_vector_type(2)));
 typedef unsigned int uint;
 typedef __SIZE_TYPE__ size_t;
 #endif
 
-kernel void basic_conversion(global float4 *buf, global int4 *res) {
-  res[0] = convert_int4(buf[0]);
+kernel void basic_conversion() {
+  double d;
+  float f;
+  char2 c2;
+  long2 l2;
+  float4 f4;
+  int4 i4;
+
+  f = convert_float(d);
+  d = convert_double_sat_rtp(f);
+  l2 = convert_long2_rtz(c2);
+  i4 = convert_int4_sat(f4);
 }
 
 kernel void basic_readonly_image_type(__read_only image2d_t img, int2 coord, global float4 *out) {
   out[0] = read_imagef(img, coord);
 }
 
 kernel void basic_subgroup(global uint *out) {
   out[0] = get_sub_group_size();
-// expected-error@-1{{use of declaration 'get_sub_group_size' requires cl_khr_subgroups extension to be enabled}}
-#pragma OPENCL EXTENSION cl_khr_subgroups : enable
-  out[1] = get_sub_group_size();
 }

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 // returns a pair <Index, Len>.
 // OpenCLBuiltins[Index] to OpenCLBuiltins[Index + Len] contains the pairs
 // <SigIndex, SigLen> of the overloads of "cos".
 // OpenCLSignature[SigIndex] to OpenCLSignature[SigIndex + SigLen] contains
 // one of the signatures of "cos". The OpenCLSignature entry can be
 // referenced by other functions, i.e. "sin", since multiple OpenCL builtins
 // share the same signature.
 //===----------------------------------------------------------------------===//
+//
+// The code generated in "OpenCLBuiltins.inc" has the following structure:
+// enum OpenCLTypeID {
+//   OCLT_double,
+//   Other types ...
+// };
+//
+// struct OpenCLTypeStruct {
+//   Hold information about types (vector size, ...)
+// };
+//
+// struct OpenCLSignatureStruct {
+//   Hold indexes of a struct OpenCLTypeStruct table. A list of indexes
+//   is used to represent a function signature.
+// );
+//
+// 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 },
+//   { 490, 2 },
+//   Other functions
+// };
+//
+// static std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name) {
+//   Find out whether a string matches an existing OpenCL builtin function name.
+// };
+//
+// static std::vector<QualType>
+// OCL2Qual(ASTContext &Context, OpenCLTypeStruct Ty) {
+//   Convert OpenCLTypeStruct types to llvm CanQualType instances.
+// };
+//
+//===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/StringMatcher.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <set>
 
 using namespace llvm;
 
 namespace {
 class BuiltinNameEmitter {
 public:
   BuiltinNameEmitter(RecordKeeper &Records, raw_ostream &OS)
       : Records(Records), OS(OS) {}
 
   // Entrypoint to generate the functions and structures for checking
   // whether a function is an OpenCL builtin function.
   void Emit();
 
 private:
   // 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;
 
-  // Emit the enums and structs.
+
+  // Helper function for BuiltinNameEmitter::EmitDeclarations. It generates enum
+  // definitions in the Output string parameter, and save their Record instance
+  // in the List parameter.
+  // \param Types (in) List containing the Types to extract.
+  //
+  // \param TypesSeen (out) List containing the Types already extracted.
+  //
+  // \param Output (out) String containing the enums to emit in the output file.
+  //
+  // \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.
   void EmitDeclarations();
 
-  // Parse the Records generated by TableGen and populate OverloadInfo and
-  // SignatureSet.
+  // Parse the Records generated by TableGen to populate the SignaturesList,
+  // FctOverloadMap and TypeMap.
   void GetOverloads();
 
-  // Emit the OpenCLSignature table. This table contains all possible
-  // signatures, and is a struct OpenCLType. A signature is composed of a
-  // return type (mandatory), followed by zero or more argument types.
+  // 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
-  // { OCLT_uchar, 4, clang::LangAS::Default, false },
-  // { OCLT_float, 4, clang::LangAS::Default, false },
-  // This means that index 12 represents a signature
-  //   - returning a uchar vector of 4 elements, and
-  //   - taking as first argument a float vector of 4 elements.
+  // 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.
   // E.g.:
   // // acos
   //   { 2, 0, "", 100 },
-  // This means that the signature of this acos overload is defined in OpenCL
-  // version 1.0 (100) and does not belong to any extension ("").  It has a
-  // 1 argument (+1 for the return type), stored at index 0 in the
-  // OpenCLSignature table.
+  // 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();
 
   // 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>> SignatureSet;
+  std::vector<std::pair<std::vector<Record *>, unsigned>> SignaturesList;
 
   // Map the name of a builtin function to its prototypes (instances of the
   // TableGen "Builtin" class).
   // Each prototype is registered as a pair of:
   //   <pointer to the "Builtin" instance,
-  //    cumulative index of the associated signature in the SignatureSet>
+  //    cumulative index of the associated signature in the SignaturesList>
   // E.g.:  The function cos: (float cos(float), double cos(double), ...)
   //        <"cos", <<ptrToPrototype0, 5>,
   //                <ptrToPrototype1, 35>>
   //                <ptrToPrototype2, 79>>
   // ptrToPrototype1 has the following signature: <double, double>
   MapVector<StringRef, std::vector<std::pair<const Record *, unsigned>>>
-      OverloadInfo;
+        FctOverloadMap;
+
+  // 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 type names in the same order as in their
+  // enum OpenCLTypeID. This list doesn't contain generic types.
+  // Generic types are not part of this list.
+  // E.g.: <Type<name="half">,
+  //       <VectorType<name="double">,
+  //       ...>
+  std::vector<const Record *> TypeList;
+
+  // Same as TypeList, but for generic types only.
+  std::vector<const Record *> GenTypeList;
 };
 } // namespace
 
 void BuiltinNameEmitter::Emit() {
   emitSourceFileHeader("OpenCL Builtin handling", OS);
 
   OS << "#include \"llvm/ADT/StringRef.h\"\n";
   OS << "using namespace clang;\n\n";
 
   EmitDeclarations();
 
   GetOverloads();
 
+  // Emit data strucures.
+  EmitTypeTable();
   EmitSignatureTable();
 
   EmitBuiltinTable();
 
   EmitStringMatcher();
 
   EmitQualTypeFinder();
 }
 
-void BuiltinNameEmitter::EmitDeclarations() {
-  OS << "enum OpenCLTypeID {\n";
-  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
-  StringMap<bool> TypesSeen;
+
+void BuiltinNameEmitter::EmitTypesEnum(std::vector<Record *> &Types,
+                                       StringMap<bool> &TypesSeen,
+                                       std::string &Output,
+                                       std::vector<const Record *> &List) {
+  raw_string_ostream SS(Output);
+
   for (const auto *T : Types) {
-    if (TypesSeen.find(T->getValueAsString("Name")) == TypesSeen.end())
-      OS << "  OCLT_" + T->getValueAsString("Name") << ",\n";
+    if (TypesSeen.find(T->getValueAsString("Name")) == TypesSeen.end()) {
+      SS << "  OCLT_" + T->getValueAsString("Name") << ",\n";
+      // Save the type names in the same order as their enum value. Note that
+      // the Record can be a VectorType or something else, only the name is
+      // important.
+      List.push_back(T);
       TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
     }
-  OS << "};\n";
+  }
+  SS.flush();
+}
+
+
+void BuiltinNameEmitter::EmitDeclarations() {
+  // Enum of the possible type names (float, int, ...).
+  // Associated vector types (int2, int3, ...) are not considered.
+  OS << "enum OpenCLTypeID {\n";
 
+  StringMap<bool> TypesSeen;
+  std::string GenTypeEnums;
+  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);
+
+  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
+  EmitTypesEnum(Types,
+                TypesSeen,
+                TypeEnums,
+                TypeList);
+
+  OS << TypeEnums;
+  OS << GenTypeEnums;
+  OS << "};\n\n";
+
+  // Strucure definitions.
   OS << R"(
 
-// Type used in a prototype of an OpenCL builtin function.
-struct OpenCLType {
+// 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;
-  // Size of vector (if applicable)
+  // Size of the vector (if applicable, 0 otherwise and for generic types).
   unsigned VectorWidth;
-  // Address space of the pointer (if applicable)
-  LangAS AS;
-  // Whether the type is a pointer
-  bool isPointer;
 };
 
-// One overload of an OpenCL builtin function.
-struct OpenCLBuiltinDecl {
-  // Number of arguments for the signature
-  unsigned NumArgs;
-  // Index in the OpenCLSignature table to get the required types
-  unsigned ArgTableIndex;
-  // Extension to which it belongs (e.g. cl_khr_subgroups)
-  const char *Extension;
-  // Version in which it was introduced (e.g. CL20)
-  unsigned Version;
+// Store a type (i.e. int, float, int2, ...). The type is stored as an index of
+// a struct OpenCLType table. Multiple entries following each other form a
+// signature.
+struct OpenCLSignatureStruct {
+  // Type, stored as an index of a struct OpenCLType table.
+  unsigned TypeTableIndex;
+};
+
+// Store one overload of an OpenCL builtin function. Multiple entries of a
+// 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;
 };
 
 )";
 }
 
+
 void BuiltinNameEmitter::GetOverloads() {
+  // Populate the TypeMap.
+  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
+  unsigned I = 0;
+  for (const auto &T : Types) {
+    TypeMap.insert(std::make_pair(T, I++));
+  }
+
+  // Populate the SignaturesList and the FctOverloadMap.
   unsigned CumulativeSignIndex = 0;
   std::vector<Record *> Builtins = Records.getAllDerivedDefinitions("Builtin");
   for (const auto *B : Builtins) {
     StringRef BName = B->getValueAsString("Name");
-    if (OverloadInfo.find(BName) == OverloadInfo.end()) {
-      OverloadInfo.insert(std::make_pair(
-          BName, std::vector<std::pair<const Record *, unsigned>>{}));
+    if (FctOverloadMap.find(BName) == FctOverloadMap.end()) {
+      FctOverloadMap.insert(std::make_pair(
+                        BName,
+                        std::vector<std::pair<const Record *, unsigned>>{}));
     }
 
     auto Signature = B->getValueAsListOfDefs("Signature");
-    auto it =
-        std::find_if(SignatureSet.begin(), SignatureSet.end(),
+    auto it = std::find_if(
+                     SignaturesList.begin(),
+                     SignaturesList.end(),
                      [&](const std::pair<std::vector<Record *>, unsigned> &a) {
                        return a.first == Signature;
                      });
     unsigned SignIndex;
-    if (it == SignatureSet.end()) {
-      SignatureSet.push_back(std::make_pair(Signature, CumulativeSignIndex));
+    if (it == SignaturesList.end()) {
+      SignaturesList.push_back(std::make_pair(Signature, CumulativeSignIndex));
       SignIndex = CumulativeSignIndex;
       CumulativeSignIndex += Signature.size();
     } else {
       SignIndex = it->second;
     }
-    OverloadInfo[BName].push_back(std::make_pair(B, SignIndex));
+    FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
   }
 }
 
+
+void BuiltinNameEmitter::EmitTypeTable() {
+  OS << "static const OpenCLTypeStruct TypeTable[] = {\n";
+  for (const auto &T : TypeMap) {
+    OS << "// " << T.second << "\n";
+    OS << "{ OCLT_" << T.first->getValueAsString("Name") << ", "
+       << T.first->getValueAsInt("VecWidth") << "},\n";
+  }
+  OS << "};\n\n";
+}
+
+
 void BuiltinNameEmitter::EmitSignatureTable() {
-  OS << "OpenCLType OpenCLSignature[] = {\n";
-  for (auto &P : SignatureSet) {
+  std::vector<std::vector<Record *>> Signature;
+
+  OS << "static const OpenCLSignatureStruct SignatureTable[] = {\n";
+  for (const auto &P : SignaturesList) {
     OS << "// " << P.second << "\n";
-    for (Record *R : P.first) {
-      OS << "{ OCLT_" << R->getValueAsString("Name") << ", "
-         << R->getValueAsInt("VecWidth") << ", "
-         << R->getValueAsString("AddrSpace") << ", "
-         << R->getValueAsBit("IsPointer") << "},";
-      OS << "\n";
+    for (const Record *R : P.first) {
+      OS << TypeMap.find(R)->second << ", ";
     }
+    OS << "\n";
   }
   OS << "};\n\n";
 }
 
+
 void BuiltinNameEmitter::EmitBuiltinTable() {
-  OS << "OpenCLBuiltinDecl OpenCLBuiltins[] = {\n";
-  for (auto &i : OverloadInfo) {
-    StringRef Name = i.first;
-    OS << "// " << Name << "\n";
-    for (auto &Overload : i.second) {
-      OS << "  { " << Overload.first->getValueAsListOfDefs("Signature").size()
-         << ", " << Overload.second << ", " << '"'
-         << Overload.first->getValueAsString("Extension") << "\", "
-         << Overload.first->getValueAsDef("Version")->getValueAsInt("Version")
+  unsigned Index = 0;
+
+  OS << "static const OpenCLBuiltinStruct BuiltinTable[] = {\n";
+  for (const auto &FOM : FctOverloadMap) {
+
+    OS << "// " << Index << " " << FOM.first << "\n";
+
+    for (const auto &Overload : FOM.second) {
+      OS << "  { "
+         << Overload.second << ", "
+         << Overload.first->getValueAsListOfDefs("Signature").size()
          << " },\n";
+         Index++;
     }
   }
   OS << "};\n\n";
 }
 
+
 void BuiltinNameEmitter::EmitStringMatcher() {
   std::vector<StringMatcher::StringPair> ValidBuiltins;
   unsigned CumulativeIndex = 1;
-  for (auto &i : OverloadInfo) {
+  for (auto &i : FctOverloadMap) {
     auto &Ov = i.second;
     std::string RetStmt;
     raw_string_ostream SS(RetStmt);
     SS << "return std::make_pair(" << CumulativeIndex << ", " << Ov.size()
        << ");";
     SS.flush();
     CumulativeIndex += Ov.size();
 
     ValidBuiltins.push_back(StringMatcher::StringPair(i.first, RetStmt));
   }
 
+
   OS << R"(
-// Return 0 if name is not a recognized OpenCL builtin, or an index
-// into a table of declarations if it is an OpenCL builtin.
-std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name) {
+/// Find out whether a string matches an existing OpenCL builtin function name.
+/// \param name The string to look for.
+///
+/// \returns A pair <0, 0> if no name matches.
+///          A pair <Index, Len> indexing the BuiltinTable if the name is
+///          matching an OpenCL builtin function.
+static std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name) {
 
 )";
 
   StringMatcher("name", ValidBuiltins, OS).Emit(0, true);
 
   OS << "  return std::make_pair(0, 0);\n";
-  OS << "}\n";
+  OS << "} // isOpenCLBuiltin \n";
 }
 
+
 void BuiltinNameEmitter::EmitQualTypeFinder() {
   OS << R"(
 
-static QualType OCL2Qual(ASTContext &Context, OpenCLType Ty) {
-  QualType RT = Context.VoidTy;
-  switch (Ty.ID) {
+/// Convert an OpenCLTypeStruct type to a llvm CanQualType.
+/// Generic types contain multiple types and vector sizes, thus a vector
+/// is returned.
+/// \param Context (in) The Context instance.
+///
+/// \param Ty (in) The OpenCLTypeStruct instance we want to convert.
+///
+/// \returns A vector of QualType corresponding to the given OpenCLTypeStruct.
+static std::vector<QualType>
+OCL2Qual(ASTContext &Context, const OpenCLTypeStruct &Ty) {
+  std::vector<QualType> QT;
+
+  // A generic type asbtracts multiple types and vectorized types (int, int4,
+  // float, ...). These variables help doing this.
+  unsigned GenTypePossibility;
+  llvm::SmallVector<unsigned, 6> *GenVectorPossibility;
 )";
 
+  // Generate the possible vector sizes for each generic type.
+  // The genererated code for the ListListN list is:
+  // llvm::SmallVector<unsigned, 6> ListListN{0, 2, 3, 4, 8, 16, };
+  for (const auto *VectList : Records.getAllDerivedDefinitions("IntList")) {
+    OS << "  llvm::SmallVector<unsigned, 6> List"
+       << VectList->getValueAsString("Name") << "{";
+    for (const auto V : VectList->getValueAsListOfInts("List")) {
+      OS << V << ", ";
+    }
+    OS << "};\n";
+  }
+
+  // Start of switch statement over all possible types used in Builtin
+  // functions.
+  OS << "\n\n  switch (Ty.ID) {\n";
+
+  // Switch case for generic types.
+  // The genererated code for the FGenTypeN generic type is:
+  // case OCLT_FGenTypeN:
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   QT.push_back(Context.FloatTy);
+  //   QT.push_back(Context.DoubleTy);
+  //   QT.push_back(Context.HalfTy);
+  //   GenTypePossibility = 3;
+  //   GenVectorPossibility = &ListListN;
+  //   break;
+  for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) {
+    OS << "    case OCLT_" << GenType->getValueAsString("Name") << ":\n";
+
+    for (uint I = 0;
+         I < GenType->getValueAsDef("VectorList")->getValueAsListOfInts("List").size();
+         I++) {
+      for (const auto *T :
+          GenType->getValueAsDef("TypeListField")->getValueAsListOfDefs("List")) {
+        OS << "      QT.push_back(Context."
+           << T->getValueAsDef("QTName")->getValueAsString("Name")
+           << ");\n";
+      }
+    }
+
+    OS << "      GenTypePossibility = "
+       << GenType->getValueAsDef("TypeListField")->getValueAsListOfDefs("List").size()
+       << ";\n";
+    OS << "      GenVectorPossibility = &List"
+       << GenType->getValueAsDef("VectorList")->getValueAsString("Name")
+       << ";\n";
+    OS << "      break;\n";
+  }
+
+  // Switch case for non generic, non image types (int, int4, float, ...).
   std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
   StringMap<bool> TypesSeen;
 
   for (const auto *T : Types) {
     // Check we have not seen this Type
     if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end())
       continue;
     TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
 
     // Check the Type does not have an "abstract" QualType
     auto QT = T->getValueAsDef("QTName");
-    if (QT->getValueAsString("Name") == "null")
+    if (QT->getValueAsBit("IsAbstract") == 1)
       continue;
-
-    OS << "  case OCLT_" << T->getValueAsString("Name") << ":\n";
-    OS << "    RT = Context." << QT->getValueAsString("Name") << ";\n";
-    OS << "    break;\n";
+    // Emit the cases for non generic, non image types.
+    OS << "    case OCLT_" << T->getValueAsString("Name") << ":\n";
+    OS << "      QT.push_back(Context." << QT->getValueAsString("Name") << ");\n";
+    OS << "      break;\n";
   }
-  OS << "  }\n";
 
-  // Special cases
   OS << R"(
-  if (Ty.VectorWidth > 0)
-    RT = Context.getExtVectorType(RT, Ty.VectorWidth);
+    default:
+      QT.push_back(Context.VoidTy);
+  } // switch (Ty.ID)
+
+)";
 
-  if (Ty.isPointer) {
-    RT = Context.getAddrSpaceQualType(RT, Ty.AS);
-    RT = Context.getPointerType(RT);
+  OS << "  // Generate the different vector sizes for each type of the generic type\n";
+  OS << "  if (Ty.ID >= " << TypeList.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]);
+      }
+    }
   }
+)";
+
+  // Give the right attributes to the types (vector size, pointer type, const,
+  // volatile).
+  OS << R"(
+  unsigned Index = 0;
 
-  return RT;
+  if (Ty.VectorWidth > 0) {
+    for(Index = 0; Index < QT.size(); Index++) {
+      QT[Index] = Context.getExtVectorType(QT[Index], Ty.VectorWidth);
+    }
   }
+
+  return QT;
+} // OCL2Qual
+
 )";
 }
 
+
 namespace clang {
 
 void EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
   BuiltinNameEmitter NameChecker(Records, OS);
   NameChecker.Emit();
 }
 
 } // end namespace clang