Prototype OpenCL BIFs using Tablegen

[Pierre]

Summary

This is a re-upload of the patch from Joey GOULY, posted at: https://reviews.llvm.org/D53023 . I am re-uploading it because I will continue his work on this, and it is better if I have control on the post on phabricator.
This patch contains a prototype to generate OpenCL builtin functions with Tablegen. Not all builtin functions have been implemented. This prototype is intented to replace the use of the opencl-c.h file currently included in all OpenCL programs. To recall, this file contains contains all the overloaded builtin functions. Using clang-tblgen would allow to factorize all these function declarations and include them only if they are called.

A copy-paste from the original description:

This is the prototype for the approach that was mentioned by Anastasia in http://lists.llvm.org/pipermail/cfe-dev/2018-September/059529.html

The tablegen file describes the BIFs and all their overloads, in hopefully a concise manner.

There are 3 things generated from the OpenCLBuiltins.td file.

1. OpenCLArgTypes[], this is a table containing all the different types of overloads. This is a separate table so it can be shared by the BIFs.
2. OpenCLBuiltins[], this is a table that contains all the overloads for the BIFs.
3. isOpenCLBuiltin, this is a function that uses a trie-like switch/case to determine if a StringRef is the name of a BIF.

Just a quick snippet of the above:

OpenCLType OpenCLArgTypes[] = {
// 0
{ OCLT_float, 0, 0, clang::LangAS::Default, },
// 1
{ OCLT_float, 2, 0, clang::LangAS::Default, },

OpenCLBuiltinDecl OpenCLBuiltins[] = {
// acos
  { { OCLT_float, 0, 0, clang::LangAS::Default, }, 1, 0, "", 100,  },
  { { OCLT_float, 2, 0, clang::LangAS::Default, }, 1, 1, "", 100,  },

std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name) {
  switch (name.size()) {
  default: break;
  case 3:  // 1 string to match.
    if (memcmp(name.data()+0, "foo", 3) != 0)
      break;
    return std::make_pair(707, 2);   // "foo"
}

While it's a prototype, I have tried to keep it as clean as possible.

TODO:

1. Bit-pack the tables to reduce the size.
2. Include the return type in the ArgTypes table to reduce the size.
3. Measure the performance / size impact
4. Auto-generate parts of OCL2Qual, to reduce repeated typing
5. OCL2Qual does not support pointers-to-pointers currently, but I believe no BIFs use that.
6. InsertBuiltinDeclarations builds up an AST function declaration manually, perhaps there is a helper function for this.
7. There is a FIXME in SemaDecl.cpp that needs to be implemented.

[Pierre]

Deleted blank line

[Anastasia]

Not related to this patch but it might be good to start thinking about testing this functionality properly. In the past we haven't tested the header because it would take a lot of testing time. So I would suggest we keep a light minimal basic testing in regular clang tests as is, but then we either add special build target to tests extra header functionality or add special cmake option (i.e. LLVM_INCLUDE_OPENCL_BIFS_TESTS) that would enable such testing with regular check-clang. I assume the latter can even be used to avoid generating the extra tables from TableGen minimizing the impact on the clang binary size for the situations OpenCL isn't required in the installation.

Any thoughts?

clang/include/clang/Basic/OpenCLBuiltins.td

11

I would add a comment describing each section:

• Defining classes
• Instantiating types
• Defining buintin functions
• etc...

Also I am a bit lost in the structure here. I think we should group functionality in sections + document each (as requested above).

16

can be renamed to addrSpace

17

why is the naming here follows different convention?

51

may be this can go below or above?

66

half?

83

again the name is not coherent with the rest.

126

I think we need a real BIF here or it has to be removed from the commit for now?

clang/lib/Sema/SemaLookup.cpp

675

Does this mean we have to produce this in ClangOpenCLBuiltinEmitter.cpp?

762

@joey are you suggesting to use a common helper function?

777

Variable naming convention is not followed!

clang/test/SemaOpenCL/builtin-new.cl

16

I guess we need to find an actual function here. How about ctz?

Although, it doesn't have to be CL2.0 actually.

31

I think different overloads can be available in different CL version. @svenvh can we already handle this?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

13

Builtin -> builtin function

35

I think this file deserves more documentation...

[Pierre]

In this new patch:

• Documentation has been added
• The multiclasses in OpenCLBuiltins.td filehave been slighly changed to have a more generic way to generate function prototypes
• In ClangOpenCLBuiltinEmitter.cpp, the code of the Emit() function has been shifted to functions
• In SemaLookUp.cpp, the OCL2Qual function, used to retrieve the QualType instance of a type, is now generated by Tablegen backend

[Pierre]

Other comments:
1-
When a header file is included, its function declarations are decorated with the "nounwind" attribute, meaning that the function is not supposed to throw an exception. This decorator is currently not added with the new mechanism.
The "readnone" decorator is also present for these builtin functions and added somewhere y clang, but not added with the new mechanism.
This can be tested with the following command line, on an .cl file containing a function calling a builtin function (e.g.: acos):

clang -cc1 -cl-std=CL2.0 -emit-llvm -O0 -I<path_to>/llvm-project/clang/lib/Headers <your_file.cl>  [-fadd-opencl-builtins|-finclude-default-header]

2-
When the function definition is inserted, it seems to be actually just resolving the identifier for the current lookup. Calling the same builtin function multiple times currently result in multiple lookup. Maybe there is a way to add the function declaration for the scope/file, so the lookup is only performed one time for each function. This part is done around the code taken from Sema::LazilyCreateBuiltin function, and I will spend more time on it.
3-
I haven't looked at the test file yet.
4-
If you have any suggestion/comment, feel free to share.

clang/include/clang/Basic/OpenCLBuiltins.td

66

The signature of OpenCL builtin functions taking/returning half types are not part of OpenCL by default, this is part of OpenCL 2.0 extensions (cf https://www.khronos.org/registry/OpenCL/specs/opencl-2.0-extensions.pdf)

clang/lib/Sema/SemaLookup.cpp

675

Yes I think so, I have made a change in this way

[Nicola]

clang/include/clang/Basic/OpenCLBuiltins.td

140–144

I think the CL standard (1.2, section 6.2.3.2) specifies that RoundingModes should be available on all convert_ functions, not only selectively based on types: "Conversions may have an optional rounding mode modifier described in table 6.6. "

211–212

Can half and double types and builtins be made dependent on extensions or configurable? The half datatype needs the cl_khr_fp16 extension, while double needs CL_DEVICE_DOUBLE_FP_CONFIG or cl_khr_fp64

[Pierre]

I also think we could reduce the size of the tables.
To sum up how this is working right now:

1. The isOpenCLBuiltin(char* functionName) funcion is called to determine if a function is part of OpenCL builtin functions. If so, it returns its associated pair (index, number of signatures) in the OpenCLBuiltinDecl, otherwise it returns 0.
2. The OpenCLBuiltinDecl table is storing, for each OpenCL builtin function, the list of the possible signature associated for this function (e.g. cos can be "float cos(float)", "double cos(double)", ...). The available signatures are stored in the OpenCLSignature table. In the OpenCLBuiltinDecl are stored the indexes corresponding to the possible signature for each function.
3. The OpenCLSignature is storing the possible signatures.

E.g.: For the prototype float cos(float):

1. isOpenCLBuiltin("cos") is returning the pair (345, 18)
2. OpenCLBuiltinDecl[345] to OpenCLBuiltinDecl[345+18] are the available signatures of the builtin function "cos". Let say OpenCLBuiltinDecl[346] is containing our "float cos(float)" prototype. OpenCLBuiltinDecl[346] is containing the pair (123, 2), indexing the OpenCLSignature table and how many entries we have to read.
3. OpenCLSignature[123] is storing the return type of the function, so the "float" type. OpenCLSignature[124] is containing the type of the first argument, so the float type again. We are not looking further in the table because we are only looking for 2 types.

---

In the "float cos(float)" prototype, the information about the "float" type is duplicated. Plus, this "float" type is also the same as in the "float sin(float)" function. A third table, storing the different types, would discard duplicated definitions of types. The OpenCLSignature would store indexes of the required types, and the third table the type itself. This third table would be called OpenCLTypes, and would be as:

struct OpenCLTypes {
  // A type (e.g.: float, int, ...)
  OpenCLTypeID ID;
  // Size of the vector (if applicable)
  unsigned VectorWidth;
  // 0 if the type is not a pointer
  unsigned isPointer;
  // Address space of the pointer (if applicable)
  clang::LangAS AS;
}

and OpenCLSignature:

struct OpenCLSignature {
unsigned OpenCLTypesIndex
}

---

Another way to save space would be to group functions. The "sin" and "cos" functions are similar (identical, we could say), regarding their use/ signature. However, they have two distinct lists of signatures in the OpenCLBuiltinDecl table. The consequence would be that isOpenCLBuiltin("cos") and isOpenCLBuiltin("sin") would give the same output. Such group of functions could be created manually by adding an attribute in the OpenCLBuiltins.td file, or automatically generated in the ClangOpenCLBuiltinEmitter.cpp file. The first solution would however make the feature potentially less understandable/ more complex to add new functions. The second solution is complex to implement/ could require a lot of time to process.

[Anastasia]

In D60763#1478672, @Pierre wrote:

I also think we could reduce the size of the tables.
To sum up how this is working right now:

1. The isOpenCLBuiltin(char* functionName) funcion is called to determine if a function is part of OpenCL builtin functions. If so, it returns its associated pair (index, number of signatures) in the OpenCLBuiltinDecl, otherwise it returns 0.
2. The OpenCLBuiltinDecl table is storing, for each OpenCL builtin function, the list of the possible signature associated for this function (e.g. cos can be "float cos(float)", "double cos(double)", ...). The available signatures are stored in the OpenCLSignature table. In the OpenCLBuiltinDecl are stored the indexes corresponding to the possible signature for each function.
3. The OpenCLSignature is storing the possible signatures.

E.g.: For the prototype float cos(float):

1. isOpenCLBuiltin("cos") is returning the pair (345, 18)
2. OpenCLBuiltinDecl[345] to OpenCLBuiltinDecl[345+18] are the available signatures of the builtin function "cos". Let say OpenCLBuiltinDecl[346] is containing our "float cos(float)" prototype. OpenCLBuiltinDecl[346] is containing the pair (123, 2), indexing the OpenCLSignature table and how many entries we have to read.
3. OpenCLSignature[123] is storing the return type of the function, so the "float" type. OpenCLSignature[124] is containing the type of the first argument, so the float type again. We are not looking further in the table because we are only looking for 2 types.

---

In the "float cos(float)" prototype, the information about the "float" type is duplicated. Plus, this "float" type is also the same as in the "float sin(float)" function. A third table, storing the different types, would discard duplicated definitions of types. The OpenCLSignature would store indexes of the required types, and the third table the type itself. This third table would be called OpenCLTypes, and would be as:

struct OpenCLTypes {
  // A type (e.g.: float, int, ...)
  OpenCLTypeID ID;
  // Size of the vector (if applicable)
  unsigned VectorWidth;
  // 0 if the type is not a pointer
  unsigned isPointer;
  // Address space of the pointer (if applicable)
  clang::LangAS AS;
}

and OpenCLSignature:

struct OpenCLSignature {
unsigned OpenCLTypesIndex
}

---

Another way to save space would be to group functions. The "sin" and "cos" functions are similar (identical, we could say), regarding their use/ signature. However, they have two distinct lists of signatures in the OpenCLBuiltinDecl table. The consequence would be that isOpenCLBuiltin("cos") and isOpenCLBuiltin("sin") would give the same output. Such group of functions could be created manually by adding an attribute in the OpenCLBuiltins.td file, or automatically generated in the ClangOpenCLBuiltinEmitter.cpp file. The first solution would however make the feature potentially less understandable/ more complex to add new functions. The second solution is complex to implement/ could require a lot of time to process.

I think it would be a good idea to investigate explore the solution you are proposing, but I suggest to do it once we add more functionality so we can benchmark a bit more.

Btw, can you upload a full diff next time please.

clang/include/clang/Basic/OpenCLBuiltins.td

11

I would rather use the header comment to just describe what the purpose and overall functionality of this file is at a high level. There is a danger of structures to get outdated quite quickly.

48

I think we don't have to say what ASes are not supported, they will evolve and this will become outdated anyway.

[Anastasia]

clang/include/clang/Basic/OpenCLBuiltins.td

63

Qualtype -> QualType

65

I don't think "field" and "func" are clear at this point.

99

ab - > an

I would say here something like - some types can have an access qualifier...

211–212

half and double types are already activated by an extension in Clang. This behavior isn't modified here.

As for builtins there is Extension field in Builtin, but I think it's not used in conversion functions at the moment. I guess we should update that.

246

Can you clarify this comment please?

326

I think we now need to use some real function here

331

I think this is no longer an example so we can change this something like Built-in Subroups Extension...

Also this should probably moved to the bottom.

clang/lib/Sema/SemaLookup.cpp

675

this should be documented - at least we should say what this function can be used for.

But I think parameters are not entirely clear too.

680

'it' is not clear here.

694

I think we should explain where this function definition comes from.

clang/test/SemaOpenCL/builtin-new.cl

9

I would suggest to name each function based on what it's intended to test i.e. common, version, extensions...

In the future we might partition it even further based on builtin function kind: convert, math, etc... but perhaps we can think about it later.

15

this isn't a valid builtin

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

14

We should explain the overall concept i.e. this class contains functionality to emit builtin functions in a some format. Explanation of the format can probably be done inline with class members...

We should also say where and how the generated code is used.

41

What is the Record here?

44

I think this class should be documented better to describe what it generates and in what format inline with each member. See some comments below.

51

regardless -> without ?

52

consists in -> consists of

58

I think it's worth checking whether inner vector is a good candidate for using SmallVector of llvm. We can probably just use it with size 3 by default since size is normally between 1-3. Although we could as well add a TODO and address it later if we encounter performance problems.

61

Why not to just refer to the data structure above or we can alternatively just typedef the vector?

75

I think this comment belong to above.

Actually let's document all methods in a class definition consistently.

96

The same - can be moved about the function definition.

139

This belongs to method description too.

171

-> method description

182

Is this even used?

202

-> method description

231

Variable name should start upper case.

247

I think this file needs clang-format.

260

-> method definition

[Pierre]

Requested changes have been made in this diff. Some comments/ TODO have not been done yet. They will be done in a next patch. This first patch is meant to start introducing the feature in Clang.
This patch integrates the new command line option introduced in https://reviews.llvm.org/D60764

clang/include/clang/Basic/OpenCLBuiltins.td

65

This field wasn't necessary and has been removed

211–212

An "Extension" field will be added in the next patch, so it will be possible to retrieve an extension of a prototype from the types the prototype is using.
E.g.: In the definition of the prototype half cos(half), the prototype will have the extension "cl_khr_fp16" because it uses the "half" type.

This scheme is present for the "half" and "double" types, but also for the "image2d_depth_t" types (extension "image2d_depth_t") and others.

306

I removed the TODO and let the functions with the half prototypes. The fact that prototypes using the "half" types are part of the "cl_khr_fp16" extension (same for the "double" type, and other types) .

326

I changed it to a real function, but this should be changed anyway in the next patch

331

I would like to let it as an example for now because there is only one function using the Extension field

clang/test/SemaOpenCL/builtin-new.cl

31

I wrote a TODO to check this later

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

58

I added a TODO

61

I explained a bit more the purpose of the two fields in the comments.
SignatureSet is storing a list of <pointer to the signature, Index>. Tablegen is storing lists of types as objects that we can reference.
OverloadInfo is storing, for each function having the same name, a list of the following pair:
<A pointer to the TableGen "Builtin" instance,
the "Index" of its signature in the SignatureSet>

Thus, this "Index" value allows functions with different names to have the same signature. By signature I mean the list of types is uses (for float cos(float), the signature would be [float, float])

I am not sure I answered the question, but I don't think it is possible to merge the SignatureSet and the OverloadInfo structures

182

Actually no

[Anastasia]

The overall structure looks very clear now! I just have a couple of nitpicks! Thank you!

clang/include/clang/Basic/OpenCLBuiltins.td

12

-> contains definition of OpenCL builtin functions

14

-> check whether the function is an OpenCL builtin.

15

We should say that it doesn't contain all function from the spec i.e. we skip those that don't have overloads or that are added as Clang Builtins.

18

Can you explain this comment please? At this point it almost feels like you are adding Clang Builtin here. May be you should refer to definition of OpenCL Builtin in this file.

19

I am not getting this comment. May be we can just leave it out?

27

I feel this comment is too abstract. May be you want to say something like - definitions of misc basic entities?

70

Btw there are classes above too! May be this could be a section about Classes of OpenCL/C type?

124

-> Multiclass definitions of functions with various number of parameters?

169

This is also too abstract. How about - Definitions of builtin functions?

244

found in -> from

306

Why examples? I think at this point we shouldn't have examples as this is not a prototype. Also you seem to be using real function, so just remove the Examples. :)

clang/lib/Sema/SemaLookup.cpp

679

This does not match Clang documentation format. Can you please align with other functions in this file.

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

98

Should we remove the TODO?

[Pierre]

Corrections from the comments on the previous version.

clang/include/clang/Basic/OpenCLBuiltins.td

18

I deleted this comment aswell, I feel it only adds confusion

[AlexeySotkin]

clang/include/clang/Basic/OpenCLBuiltins.td

299–303

It seems like there is something wrong with access qualifiers for images. I have applied this patch and tried to compile the following code:

typedef int int2 __attribute__((ext_vector_type(2)));
typedef float float4 __attribute__((ext_vector_type(4)));

void kernel k(write_only image2d_t image, int2 coord, float4 data) {
  write_imagef(image, coord, data);
}

I got the following output:

clang -cc1 -triple spir /work/tmp/tmp.cl -emit-llvm -o -  -fadd-opencl-builtins
/work/tmp/tmp.cl:5:16: error: passing '__write_only image2d_t' to parameter of incompatible type '__read_only image2d_t'
  write_imagef(image, coord, data);
                         ^~~~~
1 error generated.

[Anastasia]

clang/include/clang/Basic/OpenCLBuiltins.td

14

How about - Clang will check for functions described in this file?

27

simple -> basic

244

ping!

306

Why Examples?

308

Let's remove Example please!

313

Please rename Example here too! We can just say something like builting functions that belong to extensions.

clang/lib/Sema/SemaLookup.cpp

679

Ping. The format here still doesn't match the rest. Here is an example how we document functions.

6205 /// Look up the special member function that would be called by a special
6206 /// member function for a subobject of class type.
6207 ///
6208 /// \param Class The class type of the subobject.
6209 /// \param CSM The kind of special member function.
6210 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
6211 /// \param ConstRHS True if this is a copy operation with a const object
6212 ///        on its RHS, that is, if the argument to the outer special member
6213 ///        function is 'const' and this is not a field marked 'mutable'.
6214 static Sema::SpecialMemberOverloadResult lookupCallFromSpecialMember(
6215     Sema &S, CXXRecordDecl *Class, Sema::CXXSpecialMember CSM,
6216     unsigned FieldQuals, bool ConstRHS) {

clang/test/SemaOpenCL/builtin-new.cl

16

I think we should name the functions based on what BIFs they tests. Otherwise it will become too hard to navigate and track.

29

Is this TODO still needed?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

98

ping!

line 97 now.

108

Is this TODO still relevant?

127

This should be moved above?

[Pierre]

clang/include/clang/Basic/OpenCLBuiltins.td

299–303

What you are saying is right. This patch is incomplete and some features are missing/ broken.
I have a new version of the tablegen builtin feature where the access qualifiers are actually taken into account, but I cannot extract only this from my version. This would imply uploading the whole new version.
The new version will hopefully be on top of this patch, making access qualifiers work.

[Pierre]

The wrong patch was uploaded. Sorry for this.

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

108

This is still relevant, but not for this patch I think.

[Anastasia]

LGTM! Thanks!

Please address the minor nitpicks suggested here in your final commit.

clang/include/clang/Basic/OpenCLBuiltins.td

17

I don't think we plan to modify opencl-c.h due to compatibility issues. I think we should factor out functionality that will be required by both TableGen mode and regular include mode into something like opencl-common.h.

67

OpenCL/C -> OpenCL C

107

-> OpenCL C

169

-> OpenCL C

clang/test/SemaOpenCL/builtin-new.cl

19

basic_extension -> basic_subgroup

[AlexeySotkin]

clang/include/clang/Basic/OpenCLBuiltins.td

299–303

Thanks, Pierre. I'd like to start early testing of image builtins with this prototype. Do you have an idea when you will have image builtins done in this (or other) patch?
If it is not going to happen in the nearest future, would you mind if I'll propose some changes for this patch/prototype meanwhile?

[svenvh]

clang/include/clang/Basic/OpenCLBuiltins.td

299–303

We're planning to commit the basic infrastructure early next week, which should make it easier to extend this work and enable contributions from the wider community.

[svenvh]

Looks good overall, I'd like to propose a few more minor changes to this patch before landing:

• isPointer can be a bit / bool instead of an int / unsigned.
• Renaming the command line option from -fadd-declare-builtins to -fdeclare-opencl-builtins should hopefully convey the meaning of the option a bit better.
• Drop the spurious ; in OCL2Qual.
• Emit spaces instead of tabs for OCL2Qual, like the rest of the generated file.
• Bring the format of OpenCL spec references into alignment with the rest of clang (e.g. OpenCL v2.0 s9.17.3).
• Adding (experimental) to the help text of -fdeclare-opencl-builtins.

[thakis]

From what I can tell, the only client of OpenCLBuiltins.td is currently lib/Sema. Do you expect that to change? If not, does it make more sense to move the .td file to there?

Do you expect OpenCLBuiltins.td to include other files in the future? At the moment, the -I ${CMAKE_CURRENT_SOURCE_DIR}/../../ bit in the cmake file isn't needed for anything.

[Pierre]

In D60763#1527870, @thakis wrote:

From what I can tell, the only client of OpenCLBuiltins.td is currently lib/Sema. Do you expect that to change? If not, does it make more sense to move the .td file to there?

Do you expect OpenCLBuiltins.td to include other files in the future? At the moment, the -I ${CMAKE_CURRENT_SOURCE_DIR}/../../ bit in the cmake file isn't needed for anything.

OpenCLBuiltins.td is currently only targeting lib/Sema and will be moved there.
OpenCLBuiltins.td is not expected to include other files, this will be changed aswell.

[Nicola]

A bit late to the review, but I've noticed a couple of issues with some of the implemented builtins:

• The fmin/fmax builtins are defined twice for scalar types, does this create problems in overload resolution when using them?
• The convert_ builtins don't have support for half types (which is present in the opencl-c.h header. Is that intended?

[Pierre]

In D60763#1529279, @Nicola wrote:

A bit late to the review, but I've noticed a couple of issues with some of the implemented builtins:

• The fmin/fmax builtins are defined twice for scalar types, does this create problems in overload resolution when using them?
• The convert_ builtins don't have support for half types (which is present in the opencl-c.h header. Is that intended?

Both your comments are rights. Some builtin functions are currently a faulty/missing. I am currently updating the functions so that they match the OpenCL C specification.
convert_half will be present, and the way builtin functions are defined in the .td file will change a bit.
The new version should be available by the end of the week.

clang/include/clang/Basic/CMakeLists.txt

   TARGET ClangAttrHasAttributeImpl
   )
 
+clang_tablegen(OpenCLBuiltins.inc
+  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../ -gen-clang-opencl-builtins
+  SOURCE OpenCLBuiltins.td
+  TARGET ClangOpenCLBuiltinsImpl
+  )
+
 # ARM NEON
 clang_tablegen(arm_neon.inc -gen-arm-neon-sema
   SOURCE arm_neon.td

clang/include/clang/Basic/OpenCLBuiltins.td

+//==--- OpenCLBuiltins.td - OpenCL builtin definitions --------------------===//
+//
+//                     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
+//
+//===----------------------------------------------------------------------===//
+//
+//  The file is organized as:
+//    -Base definitions: base classes/ definitions required in sections below
+//    -Classes
+//    -Multiclasses
+//    -Definitions:
+//      *Type
+//        -6.1.1    : Built-in Scalar Data Types
+//        -6.1.2    : Built-in Vector Data Types
+//        -6.1.3    : Other Built-in Data Types
+//      *Builtin
+//        -6.2.3    : Explicit Conversions
+//        -6.12.1   : Work-Item Functions
+//        -6.12.2   : Math Functions
+//        -6.12.14  : Built-in Image Read Functions
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+//                            Base definitions
+//===----------------------------------------------------------------------===//
+// Versions of OpenCL
+class Version<int _Version> {
+  int Version = _Version;
+}
+def CL10: Version<100>;
+def CL11: Version<110>;
+def CL12: Version<120>;
+def CL20: Version<200>;
+
+// Address spaces. Pointer types need to be assigned an address space. It can be
+// one of:
+// 0 :: Default
+// 0 :: opencl_private
+// 1 :: opencl_global
+// 2 :: opencl_constant
+// 3 :: opencl_local
+// 4 :: opencl_generic
+// (Following address spaces are not available for OpenCL)
+// 5 :: cuda_device
+// 6 :: cuda_constant
+// 7 :: cuda_shared
+class AddressSpace<string _AS> {
+  string AddrSpace = _AS;
+}
+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 _AccessMethod,string _Name> {
+  // How to get the QualType. Can be one of ("field", "func")
+  string AccessMethod = _AccessMethod;
+  // Name of the field / function
+  string Name = _Name;
+}
+
+// Helper class to store type  access qualifiers (volatile, const, ...)
+class Qualifier<string _QualName> {
+  string QualName = _QualName;
+}
+
+//===----------------------------------------------------------------------===//
+//                            Classes
+//===----------------------------------------------------------------------===//
+// OpenCL types (int, float, ...)
+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
+  int IsPointer = 0;
+  // List of qualifiers associated with the type (volatile, ...)
+  list<Qualifier> QualList = [];
+  // Address space associated
+  string AddrSpace = "clang::LangAS::Default";
+  // Functions returning a floating point number can be postfixed with the
+  // rounding method used (_rte, _rtp, _rtn, _rtz) to round the result.
+  int HasRounding = 0;
+  // Functions returning an integer type number (char, int, long, ...) can be
+  // postfixed with _sat to saturate the result.
+  int HasSat = 0;
+  // Function arguments can have ab access qualifiers (read_only, ...). Can be
+  // one of ("RO", "WO", "RW")
+  string AccessQualifier = "";
+}
+
+// OpenCL vector types (int2, int3, int16, float8, ...)
+class VectorType<Type _Ty, int _VecWidth> : Type<_Ty.Name, _Ty.QTName> {
+  int VecWidth = _VecWidth;
+}
+
+// OpenCL pointer types (int*, float*, ...)
+class PointerType<Type _Ty, AddressSpace _AS = global_as> :
+                                      Type<_Ty.Name, _Ty.QTName> {
+  int IsPointer = 1;
+  string AddrSpace = _AS.AddrSpace;
+}
+
+// OpenCL image types (image2d_t, ...)
+class ImageType<Type _Ty, QualType _QTName, string _AccessQualifier> :
+                                              Type<_Ty.Name, _QTName> {
+  let AccessQualifier = _AccessQualifier;
+}
+
+// OpenCL builtin functions (sin, cos, convert_char. ...)
+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 elements
+  // (the return type).
+  list<Type> Signature = _Signature;
+  // Extension of OpenCL to which the function belongs (cl_khr_subgroups, ...)
+  string Extension = "";
+  // Version of OpenCL to which the function belongs (CL10, ...)
+  Version Version = CL10;
+}
+
+// Helper classes for the convert_* BIFs.
+class SatModes<Type _Ty> {
+  list<string> Modes = !if(_Ty.HasSat, ["", "_sat"], [""]);
+}
+class RoundingModes<Type _Ty1, Type _Ty2> {
+  list<string> Modes = !if(!or(_Ty1.HasRounding, _Ty2.HasRounding),
+                          ["", "_rte", "_rtz", "_rtp", "_rtn"],
+                          [""]);
+}
+
+//===----------------------------------------------------------------------===//
+//                            Multiclass definitions
+//===----------------------------------------------------------------------===//
+// multiclass BifX: Creates builtins class instances for OpenCL builtin
+//                  functions with X arguments.
+// _Name      :: Name of the FunctionNoProto
+// _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
+//===----------------------------------------------------------------------===//
+// ========== Type definitions ==========
+// Types available in OpenCL
+
+// 6.1.1 : Built-in Scalar Data Types
+def bool_t        : Type<"bool", QualType<"field", "BoolTy">>;
+let HasSat = 1 in {
+  def char_t    : Type<"char", QualType<"field", "CharTy">>;
+  def uchar_t   : Type<"uchar", QualType<"field", "UnsignedCharTy">>;
+  def short_t   : Type<"short", QualType<"field", "ShortTy">>;
+  def ushort_t  : Type<"ushort", QualType<"field", "UnsignedShortTy">>;
+  def int_t     : Type<"int", QualType<"field", "IntTy">>;
+  def uint_t    : Type<"uint", QualType<"field", "UnsignedIntTy">>;
+  def long_t    : Type<"long", QualType<"field", "LongTy">>;
+  def ulong_t   : Type<"ulong", QualType<"field", "UnsignedLongTy">>;
+}
+let HasRounding = 1 in {
+  def float_t   : Type<"float", QualType<"field", "FloatTy">>;
+  def double_t  : Type<"double", QualType<"field", "DoubleTy">>;
+  def half_t    : Type<"half", QualType<"field", "HalfTy">>;
+}
+def size_t        : Type<"size_t",  QualType<"func", "getSizeType">>;
+def ptrdiff_t     : Type<"ptrdiff_t", QualType<"func", "getPointerDiffType">>;
+def intptr_t      : Type<"intptr_t", QualType<"func", "getIntPtrType">>;
+def uintptr_t     : Type<"uintptr_t", QualType<"func", "getUIntPtrType">>;
+def void_t        : Type<"void", QualType<"field", "VoidTy">>;
+
+// 6.1.2 : Built-in Vector Data Types
+// TODO: Can maybe be generated from the original definition in the .def file
+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>;
+  let HasRounding = 1 in {
+    def float#v#_t   : VectorType<float_t, v>;
+    def double#v#_t  : VectorType<double_t, v>;
+    def half#v#_t    : VectorType<half_t, v>;   // TODO halfx is not part of the OpenCL1.2 spec
+  }
+}
+
+// 6.1.3 : Other Built-in Data Types
+// These first definition without a real QualType are "abstract".
+def image2d_t         : Type<"image2d_t", QualType<"null", "null""Ty">>;
+def image3d_t         : Type<"image3d_t", QualType<"null", "null""Ty">>;
+def image2d_array_t   : Type<"image2d_array_t", QualType<"null", "null">>;
+def image1d_t         : Type<"image1d_t", QualType<"null", "null">>;
+def image1d_buffer_t  : Type<"image1d_buffer_t", QualType<"null", "null">>;
+def image1d_array_t   : Type<"image1d_array_t", QualType<"null", "null">>;
+// These definitions are used: the QualType is defined.
+foreach v = ["RO", "WO", "RW"] in {
+    def image2d_#v#_t       : ImageType<image2d_t, QualType<"field",
+                                                    "OCLImage2d"#v#"Ty">,
+                                                    v>;
+    def image3d_#v#_t       : ImageType<image3d_t, QualType<"field",
+                                                    "OCLImage3d"#v#"Ty">,
+                                                    v>;
+    def image2d_array#v#_t  : ImageType<image2d_array_t, QualType<"field",
+                                                    "OCLImage2dArray"#v#"Ty">,
+                                                    v>;
+    def image1d_#v#_t       : ImageType<image1d_t, QualType<"field",
+                                                    "OCLImage1d"#v#"Ty">,
+                                                    v>;
+    def image1d_buffer#v#_t : ImageType<image1d_buffer_t, QualType<"field",
+                                                    "OCLImage1dBuffer"#v#"Ty">,
+                                                    v>;
+    def image1d_array#v#_t  : ImageType<image1d_array_t, QualType<"field",
+                                                    "OCLImage1dArray"#v#"Ty">,
+                                                    v>;
+}
+
+def sampler_t         : Type<"sampler_t", QualType<"field", "OCLSamplerTy">>;
+def event_t           : Type<"event_t", QualType<"field", "OCLEventTy">>;
+
+// ========== Builtin definitions ==========
+// This section defines builtin functions found in the OpenCL 1.2 specification
+
+// 6.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 {
+    foreach sat = SatModes<RType>.Modes in {
+      foreach rte = RoundingModes<RType, IType>.Modes in {
+        def : Builtin<"convert_"  # RType.Name # sat # rte,
+                                            [RType, IType]>;
+        foreach v = [2, 3, 4, 8, 16] in {
+          def : Builtin<"convert_" # RType.Name # v # sat # rte,
+                                                            [VectorType<RType, v>,
+                                                              VectorType<IType,
+                                                              v>]>;
+        }
+      }
+    }
+  }
+}
+// 6.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]>;
+}
+
+// 6.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 {  // TODO halfx is not part of the OpenCL1.2 spec
+    defm : Bif1<name, [type, type], [1, 1]>;
+  }
+}
+
+foreach name = ["atan2", "atan2pi"] in {
+  foreach type = [float_t, double_t, half_t] in {  // TODO halfx is not part of the OpenCL1.2 spec
+    defm : Bif2<name, [type, type, type], [1, 1, 1]>;
+  }
+}
+
+foreach name = ["fmax", "fmin"] in {
+  foreach type = [float_t, double_t, half_t] in {  // TODO halfx is not part of the OpenCL1.2 spec
+    defm : Bif2<name, [type, type, type], [1, 1, 1]>;
+    defm : Bif2<name, [type, type, type], [1, 1, 0]>;
+  }
+}
+
+
+// example 'foo', to show using 'version'
+def : Builtin<"foo_version", [int_t, PointerType<int_t, global_as>]>;
+let Version = CL20 in {
+  def : Builtin<"foo_version", [int_t, PointerType<int_t, constant_as>]>;
+}
+
+// Example showing 'Extension'
+let Extension = "cl_khr_subgroups" in {
+  def get_sub_group_size : Builtin<"get_sub_group_size", [uint_t]>;
+}
+// 6.12.14 : Built-in Image Read Functions
+def read_imagef : Builtin<"read_imagef",
+                          [float4_t, 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>]>;

clang/lib/Sema/SemaLookup.cpp

 #include <utility>
 #include <vector>
 
+#include "clang/Basic/OpenCLBuiltins.inc"
+
 using namespace clang;
 using namespace sema;
 

     D->dump();
 }
 
+static void InsertOCLBuiltinDeclarations(Sema &S,
+                                         LookupResult &LR,
+                                         IdentifierInfo *II,
+                                         unsigned Index,
+                                         unsigned Len) {
+  // Once it is known the identifier is referencing an OpenCL builting function,
+  // add all its prototypes to the LookUpResult.
+
+  for (unsigned i = 0; i < Len; ++i) {
+    OpenCLBuiltinDecl &Decl = OpenCLBuiltins[Index - 1 + i];
+    ASTContext &Context = S.Context;
+
+    // Ignore this BIF if the version is incorrect.
+    if (Context.getLangOpts().OpenCLVersion < Decl.Version)
+      continue;
+
+    FunctionProtoType::ExtProtoInfo PI;
+    PI.Variadic = false;
+
+    QualType RT = OCL2Qual(Context, OpenCLSignature[Decl.ArgTableIndex]);
+
+    SmallVector<QualType, 5> ArgTypes;
+    for (unsigned I = 1; I < Decl.NumArgs; I++) {
+      QualType Ty = OCL2Qual(Context, OpenCLSignature[Decl.ArgTableIndex + I]);
+      ArgTypes.push_back(Ty);
+    }
+
+    QualType R = Context.getFunctionType(RT, ArgTypes, PI);
+    SourceLocation Loc = LR.getNameLoc();
+
+    // 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);
+    }
+
+    New->addAttr(OverloadableAttr::CreateImplicit(Context));
+
+    if (strlen(Decl.Extension))
+      S.setOpenCLExtensionForDecl(New, Decl.Extension);
+
+    LR.addDecl(New);
+  }
+
+  // If we added overloads, need to resolve the lookup result.
+  if (Len > 1)
+    LR.resolveKind();
+}
+
 /// Lookup a builtin function, when name lookup would otherwise
 /// fail.
 static bool LookupBuiltin(Sema &S, LookupResult &R) {

         }
       }
 
+      // Check if this is an OpenCL Builtin, and if so, insert the declarations.
+      if (S.getLangOpts().OpenCL) {
+        auto Index = isOpenCLBuiltin(II->getName());
+        if (Index.first) {
+          InsertOCLBuiltinDeclarations(S, R, II, Index.first, 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

clang/test/SemaOpenCL/builtin-new.cl

+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL1.2 -DCL12
+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DCL20
+
+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 unsigned int uint;
+
+kernel void test(global float4* buf, global int4* res)
+{
+  res[0] = convert_int4(buf[0]);
+}
+
+kernel void test2(global int* bar) {
+  bar[0] = foo_version(bar);
+}
+
+kernel void test3(constant int* bar, global int* baz) {
+  baz[0] = foo_version(bar);
+#ifdef CL12
+// expected-error@-2{{passing '__constant int *' to parameter of type '__global int *' changes address space of pointer}}
+#endif
+}
+
+kernel void test4(image2d_t img, int2 coord, global float4* out) {
+  out[0] = read_imagef(img, coord);
+}
+
+kernel void test5(write_only image2d_t img, int2 coord, float4 colour) {
+  write_imagef(img, coord, colour);
+}
+
+#ifdef CL20
+kernel void test6(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();
+}
+#endif

clang/utils/TableGen/CMakeLists.txt

   ClangCommentHTMLTagsEmitter.cpp
   ClangDataCollectorsEmitter.cpp
   ClangDiagnosticsEmitter.cpp
+  ClangOpenCLBuiltinEmitter.cpp
   ClangOptionDocEmitter.cpp
   ClangSACheckersEmitter.cpp
   NeonEmitter.cpp

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

+//===- ClangOpenCLBuiltinEmitter.cpp - Generate Clang OpenCL Builtin handling
+//=-*- C++ -*--=//
+//
+//                     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 tablegen backend emits Clang OpenCL builtin functions checking code.
+//
+//===----------------------------------------------------------------------===//
+
+#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) {}
+
+  void Emit();
+
+private:
+  RecordKeeper &Records;
+  raw_ostream &OS;
+
+  void EmitDeclarations();
+  void GetOverloads();
+  void EmitSignatureTable();
+  void EmitBuiltinTable();
+  void EmitStringMatcher();
+  void EmitQualTypeFinder();
+
+  // Contains a list of the available signatures, regardless the name of the
+  // function. Each pair consists in 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;
+
+  // Map the name of a builtin function to its signatures.
+  // Each signature is registered as a pair of:
+  // <pointer to a list of types (a signature),
+  // cumulative index of the associated signature in the SignatureSet>
+  // E.g.:  The function cos: (float cos(float), double cos(double), ...)
+  //        <"cos", <<ptrToSignature5, 5>,
+  //                <ptrToSignature35, 35>>
+  //                <ptrToSignature79, 79>>
+  // ptrToSignature35 points here to the following list: <double, double>
+  MapVector<StringRef, std::vector<std::pair<const Record *, unsigned>>>
+        OverloadInfo;
+};
+} // namespace
+
+void BuiltinNameEmitter::Emit() {
+  // Generate the file containing OpenCL builtin functions checking code.
+
+  emitSourceFileHeader("OpenCL Builtin handling", OS);
+
+  OS << "#include \"llvm/ADT/StringRef.h\"\n\n";
+
+  EmitDeclarations();
+
+  GetOverloads();
+
+  EmitSignatureTable();
+
+  EmitBuiltinTable();
+
+  EmitStringMatcher();
+
+  EmitQualTypeFinder();
+}
+
+
+void BuiltinNameEmitter::EmitDeclarations() {
+  // Emit the enum/ struct used in the file generated
+
+  OS << "enum OpenCLTypeID {\n";
+  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
+  StringMap<bool> TypesSeen;
+  for (const auto *T : Types) {
+    if (TypesSeen.find(T->getValueAsString("Name")) == TypesSeen.end())
+      OS << "  OCLT_" + T->getValueAsString("Name") << ",\n";
+    TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
+  }
+  OS << "};\n";
+
+  OS << R"(
+
+// Store information about a type used in a prototype of an OpenCL builtin
+// functions. With a table of this struct, a signature can be retrieved.
+struct OpenCLType {
+  // A type (e.g.: float, int, ...)
+  OpenCLTypeID ID;
+  // Size of the vector (if applicable)
+  unsigned VectorWidth;
+  // 0 if the type is not a pointer
+  unsigned isPointer;
+  // Address space of the pointer (if applicable)
+  clang::LangAS AS;
+};
+
+// Store 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;
+};
+
+)";
+}
+
+void BuiltinNameEmitter::GetOverloads() {
+  // Parse the Records generated by TableGen to feed the OverloadInfo and
+  // SignatureSet
+
+  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>>{}));
+    }
+
+    auto Signature = B->getValueAsListOfDefs("Signature");
+    auto it =
+        std::find_if(SignatureSet.begin(), SignatureSet.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));
+      SignIndex = CumulativeSignIndex;
+      CumulativeSignIndex += Signature.size();
+    } else {
+      SignIndex = it->second;
+    }
+    OverloadInfo[BName].push_back(std::make_pair(B, SignIndex));
+  }
+}
+
+
+void BuiltinNameEmitter::EmitSignatureTable() {
+  // Emit the OpenCLSignature table. This table contains all the possible
+  // signature, and is a struct OpenCLType. A signature is composed of a
+  // return type (mandatory), and arguments of the function.
+  // E.g.:
+  // // 12
+  // { OCLT_uchar, 4, 0, clang::LangAS::Default, },
+  // { OCLT_float, 4, 0, clang::LangAS::Default, },
+  // This means that at the index 12 in the table, is available the signature:
+  //    -returning a uchar vector of 4 elements.
+  //    -taking as first argument a float vector of 4 elements.
+
+  std::vector<std::vector<Record *>> Signature;
+
+  OS << "OpenCLType OpenCLSignature[] = {\n";
+  for (auto &P : SignatureSet) {
+    OS << "// " << P.second << "\n";
+    for (Record *R : P.first) {
+      OS << "{ OCLT_" << R->getValueAsString("Name") << ", "
+         << R->getValueAsInt("VecWidth") << ", "
+         << R->getValueAsInt("IsPointer") << ", " << R->getValueAsString("AddrSpace")
+         << ", "
+         << "}, ";
+      OS << "\n";
+    }
+  }
+  OS << "};\n\n";
+}
+
+
+
+void BuiltinNameEmitter::EmitBuiltinTable() {
+  // Emit the OpenCLBuiltins table. This table contains all the overloads of
+  // each function, and is a struct OpenCLBuiltinDecl.
+  // E.g.:
+  // // acos
+  //   { 1, 0, "", 100 },
+  // This means that the signature of acos, defined in OpenCL version 1.0 and
+  // not belonging to any extension, has a signature with 1 argument, stored at
+  // index 0 in the OpenCLSignature table.
+
+  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")
+         << " },\n";
+    }
+  }
+  OS << "};\n\n";
+}
+
+void BuiltinNameEmitter::EmitStringMatcher() {
+  // Construct a StringMatcher function to check whether a function is part of
+  // OpenCL builtin functions. The prototype of the function is:
+  // std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name);
+  std::vector<StringMatcher::StringPair> validBuiltins;
+  unsigned CumulativeIndex = 1;
+  for (auto &i : OverloadInfo) {
+    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) { ;
+
+)";
+
+  StringMatcher("name", validBuiltins, OS).Emit(0, true);
+
+  OS << "  return std::make_pair(0, 0);\n";
+  OS << "}\n";
+}
+
+void BuiltinNameEmitter::EmitQualTypeFinder() {
+  // Construct a function returning the clang QualType instance associated with
+  // the TableGen Record Type. The prototype of the function is:
+  // static QualType OCL2Qual(ASTContext &Context, OpenCLType Ty);
+  // TODO: Should not need clang::
+  OS << R"(
+
+static clang::QualType OCL2Qual(clang::ASTContext &Context, OpenCLType Ty) {
+  clang::QualType RT = Context.VoidTy;
+  switch (Ty.ID) {;
+
+)";
+
+  std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
+  StringMap<bool> TypesSeen;
+
+  for (const auto *T : Types) {
+    // Check we haven't seen this Type
+    if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end())
+      continue;
+    TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));
+
+    // Check the Type doesn't have an "abstract" QualType
+    auto QT = T->getValueAsDef("QTName");
+    if (QT->getValueAsString("AccessMethod") == "null")
+      continue;
+
+    OS << "\t\tcase OCLT_" << T->getValueAsString("Name") << ":\n";
+    if (QT->getValueAsString("AccessMethod") == "field") {
+      OS << "\t\t\tRT = Context." << QT->getValueAsString("Name") << ";\n";
+    } else {
+      OS << "\t\t\tRT = Context." << QT->getValueAsString("Name") << "();\n";
+    }
+    OS << "\t\t\tbreak;\n";
+  }
+  OS << "\t}\n";
+
+  // Special cases
+  OS << R"(
+
+  if (Ty.VectorWidth > 0)
+    RT = Context.getExtVectorType(RT, Ty.VectorWidth);
+
+  if (Ty.isPointer != 0) {
+    RT = Context.getAddrSpaceQualType(RT, Ty.AS);
+    RT = Context.getPointerType(RT);
+  }
+
+  return RT;
+}
+
+)";
+}
+
+namespace clang {
+
+void EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
+  BuiltinNameEmitter NameChecker(Records, OS);
+  NameChecker.Emit();
+}
+
+} // end namespace clang

clang/utils/TableGen/TableGen.cpp

   GenDiagDocs,
   GenOptDocs,
   GenDataCollectors,
-  GenTestPragmaAttributeSupportedAttributes
+  GenTestPragmaAttributeSupportedAttributes,
+  GenClangOpenCLBuiltins,
 };
 
 namespace {

         clEnumValN(GenTestPragmaAttributeSupportedAttributes,
                    "gen-clang-test-pragma-attribute-supported-attributes",
                    "Generate a list of attributes supported by #pragma clang "
-                   "attribute for testing purposes")));
+                   "attribute for testing purposes"),
+        clEnumValN(GenClangOpenCLBuiltins, "gen-clang-opencl-builtins",
+                   "Generate OpenCL builtin handlers")));
 
 cl::opt<std::string>
 ClangComponent("clang-component",

   case GenTestPragmaAttributeSupportedAttributes:
     EmitTestPragmaAttributeSupportedAttributes(Records, OS);
     break;
+  case GenClangOpenCLBuiltins:
+    EmitClangOpenCLBuiltins(Records, OS);
+    break;
   }
 
   return false;

clang/utils/TableGen/TableGenBackends.h

 void EmitTestPragmaAttributeSupportedAttributes(llvm::RecordKeeper &Records,
                                                 llvm::raw_ostream &OS);
 
+void EmitClangOpenCLBuiltins(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 } // end namespace clang
 
 #endif