[OpenCL] Add version handling and add vector ld/st builtins

[svenvh]

Summary

Allow setting a MinVersion, stating from which OpenCL version a
builtin function is available, and a MaxVersion, stating from which
OpenCL version a builtin function should not be available anymore.

Guard some definitions of the "work-item" builtin functions according
to the OpenCL versions from which they are available.

Add the "vector data load and store" builtin functions (e.g. vload/vstore),
whose signatures differ before and after OpenCL 2.0 in the pointer
argument address spaces.

Patch by Pierre Gondois and Sven van Haastregt.

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

188

Would it make sense to rename this to CLAny or CLAll instead? Although do we even need to add a name for this or may be rather keep as numeric value representing default initialization?

314

Table 15 from?

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

101

This should also work in CL2 right?

[Pierre]

Corrections on names, wrong OpenCL versions in comment, missing comma ...

clang/lib/Sema/OpenCLBuiltins.td

188

Indeed, it makes more sense to rename it CLAny or CLAll. It also might be possible not to define this version (and not to give a name). I would prefer to use a name though. I changed it to CLAll for now.

314

This is from OpenCL v2.0 s6.13.7. This was just a hint to help find back the definition in the specification. I didn't want to have too many ornaments around these hints. Should I give the exact chapter each time?

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

101

This is correct, I removed the condition.

[Pierre]

Rebase on previous patches.

[svenvh]

Rebasing and improving comments.

[Anastasia]

LGTM! Thanks!

clang/lib/Sema/OpenCLBuiltins.td

362

I wish TableGen had templates :)

463–464

Some of these image BIFs are also conditional on CL version. Do you plan it in a separate patch?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

196–197

Is 891 relevant here?

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

463–464

There is some followup work for this needed indeed. I believe that all image builtins that you are thinking of in your comment, take an image type that is only available in specific OpenCL versions. For example the image builtins taking a read_write image will be declared in CL1.1 mode currently, but they won't be accessible for any input programs because the read_write image types are unavailable in CL1.1 mode.

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

196–197

Not in particular (it is the index of the table entry), but this brings the comment in sync with what is being generated. The change on this line should have been part of r369253 actually.

clang/lib/Sema/OpenCLBuiltins.td

 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //              Definitions of miscellaneous basic entities.
 //===----------------------------------------------------------------------===//
 // Versions of OpenCL
 class Version<int _Version> {
-  int Version = _Version;
+  int Name = _Version;
 }
-def CL10: Version<100>;
-def CL11: Version<110>;
-def CL12: Version<120>;
-def CL20: Version<200>;
+def CLAll   : Version<000>;
+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.
 class AddressSpace<string _AS> {
   string Name = _AS;
 }
 def DefaultAS    : AddressSpace<"clang::LangAS::Default">;
 def PrivateAS    : AddressSpace<"clang::LangAS::opencl_private">;
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;
+  // Version of OpenCL from which the function is available (e.g.: CL10).
+  // MinVersion is inclusive.
+  Version MinVersion = CL10;
+  // Version of OpenCL from which the function is not supported anymore.
+  // MaxVersion is exclusive.
+  // CLAll makes the function available for all versions.
+  Version MaxVersion = CLAll;
 }
 
 //===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL C types
 //===----------------------------------------------------------------------===//
 
 // OpenCL v1.0/1.2/2.0 s6.1.1: Built-in Scalar Data Types.
 def Bool      : Type<"bool", QualType<"BoolTy">>;
foreach sat = ["", "_sat"] in {
                           VectorType<IType,
                           v>]>;
         }
       }
     }
   }
 }
 
+//--------------------------------------------------------------------
+// OpenCL v1.1 s6.11.1, v1.2 s6.12.1, v2.0 s6.13.1 - Work-item Functions
+// --- Table 7 ---
+def : Builtin<"get_work_dim", [UInt]>;
+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, UInt]>;
+}
+
+let MinVersion = CL20 in {
+  def : Builtin<"get_enqueued_local_size", [Size, UInt]>;
+  foreach name = ["get_global_linear_id", "get_local_linear_id"] in {
+    def : Builtin<name, [Size]>;
+  }
+}
+
+//--------------------------------------------------------------------
+// OpenCL v1.1 s6.11.7, v1.2 s6.12.7, v2.0 s6.13.7 - Vector Data Load and Store Functions
+// OpenCL Extension v1.1 s9.3.6 and s9.6.6, v1.2 s9.5.6, v2.0 s9.4.6, v2.2 s5.1.6 and 6.1.6 - Vector Data Load and Store Functions
+// --- Table 15 ---
+// --- 3 arguments ---
+// Variants for OpenCL versions below 2.0, using pointers to the global, local
+// and private address spaces
+let MaxVersion = CL20 in {
+  foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
+    foreach VSize = [2, 3, 4, 8, 16] in {
+      foreach name = ["vload"#VSize] in {
+        def : Builtin<name, [VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, AS>]>;
+        def : Builtin<name, [VectorType<UChar, VSize>, Size, PointerType<ConstType<UChar>, AS>]>;
+        def : Builtin<name, [VectorType<Short, VSize>, Size, PointerType<ConstType<Short>, AS>]>;
+        def : Builtin<name, [VectorType<UShort, VSize>, Size, PointerType<ConstType<UShort>, AS>]>;
+        def : Builtin<name, [VectorType<Int, VSize>, Size, PointerType<ConstType<Int>, AS>]>;
+        def : Builtin<name, [VectorType<UInt, VSize>, Size, PointerType<ConstType<UInt>, AS>]>;
+        def : Builtin<name, [VectorType<Long, VSize>, Size, PointerType<ConstType<Long>, AS>]>;
+        def : Builtin<name, [VectorType<ULong, VSize>, Size, PointerType<ConstType<ULong>, AS>]>;
+        def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Float>, AS>]>;
+        def : Builtin<name, [VectorType<Double, VSize>, Size, PointerType<ConstType<Double>, AS>]>;
+        def : Builtin<name, [VectorType<Half, VSize>, Size, PointerType<ConstType<Half>, AS>]>;
+      }
+      foreach name = ["vstore"#VSize] in {
+        def : Builtin<name, [Void, VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, AS>]>;
+        def : Builtin<name, [Void, VectorType<UChar, VSize>, Size, PointerType<ConstType<UChar>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Short, VSize>, Size, PointerType<ConstType<Short>, AS>]>;
+        def : Builtin<name, [Void, VectorType<UShort, VSize>, Size, PointerType<ConstType<UShort>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Int, VSize>, Size, PointerType<ConstType<Int>, AS>]>;
+        def : Builtin<name, [Void, VectorType<UInt, VSize>, Size, PointerType<ConstType<UInt>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Long, VSize>, Size, PointerType<ConstType<Long>, AS>]>;
+        def : Builtin<name, [Void, VectorType<ULong, VSize>, Size, PointerType<ConstType<ULong>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Float, VSize>, Size, PointerType<ConstType<Float>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Double, VSize>, Size, PointerType<ConstType<Double>, AS>]>;
+        def : Builtin<name, [Void, VectorType<Half, VSize>, Size, PointerType<ConstType<Half>, AS>]>;
+      }
+      foreach name = ["vloada_half"#VSize] in {
+        def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Half>, AS>]>;
+      }
+      foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+        foreach name = ["vstorea_half"#VSize#rnd] in {
+          def : Builtin<name, [Void, VectorType<Float, VSize>, Size, PointerType<Half, AS>]>;
+          def : Builtin<name, [Void, VectorType<Double, VSize>, Size, PointerType<Half, AS>]>;
+        }
+      }
+    }
+  }
+}
+// Variants for OpenCL versions above 2.0, using pointers to the generic
+// address space
+let MinVersion = CL20 in {
+  foreach VSize = [2, 3, 4, 8, 16] in {
+    foreach name = ["vload"#VSize] in {
+      def : Builtin<name, [VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, GenericAS>]>;
+      def : Builtin<name, [VectorType<UChar, VSize>, Size, PointerType<ConstType<UChar>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Short, VSize>, Size, PointerType<ConstType<Short>, GenericAS>]>;
+      def : Builtin<name, [VectorType<UShort, VSize>, Size, PointerType<ConstType<UShort>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Int, VSize>, Size, PointerType<ConstType<Int>, GenericAS>]>;
+      def : Builtin<name, [VectorType<UInt, VSize>, Size, PointerType<ConstType<UInt>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Long, VSize>, Size, PointerType<ConstType<Long>, GenericAS>]>;
+      def : Builtin<name, [VectorType<ULong, VSize>, Size, PointerType<ConstType<ULong>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Float>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Double, VSize>, Size, PointerType<ConstType<Double>, GenericAS>]>;
+      def : Builtin<name, [VectorType<Half, VSize>, Size, PointerType<ConstType<Half>, GenericAS>]>;
+    }
+    foreach name = ["vstore"#VSize] in {
+      def : Builtin<name, [Void, VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<UChar, VSize>, Size, PointerType<ConstType<UChar>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Short, VSize>, Size, PointerType<ConstType<Short>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<UShort, VSize>, Size, PointerType<ConstType<UShort>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Int, VSize>, Size, PointerType<ConstType<Int>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<UInt, VSize>, Size, PointerType<ConstType<UInt>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Long, VSize>, Size, PointerType<ConstType<Long>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<ULong, VSize>, Size, PointerType<ConstType<ULong>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Float, VSize>, Size, PointerType<ConstType<Float>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Double, VSize>, Size, PointerType<ConstType<Double>, GenericAS>]>;
+      def : Builtin<name, [Void, VectorType<Half, VSize>, Size, PointerType<ConstType<Half>, GenericAS>]>;
+    }
+    foreach name = ["vloada_half"#VSize] in {
+      def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Half>, GenericAS>]>;
+    }
+    foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+      foreach name = ["vstorea_half"#VSize#rnd] in {
+        def : Builtin<name, [Void, VectorType<Float, VSize>, Size, PointerType<Half, GenericAS>]>;
+        def : Builtin<name, [Void, VectorType<Double, VSize>, Size, PointerType<Half, GenericAS>]>;
+      }
+    }
+  }
+}
+// Variants using pointers to the constant address space
+foreach VSize = [2, 3, 4, 8, 16] in {
+  foreach name = ["vload"#VSize] in {
+    def : Builtin<name, [VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<UChar, VSize>, Size, PointerType<ConstType<UChar>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Short, VSize>, Size, PointerType<ConstType<Short>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<UShort, VSize>, Size, PointerType<ConstType<UShort>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Int, VSize>, Size, PointerType<ConstType<Int>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<UInt, VSize>, Size, PointerType<ConstType<UInt>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Long, VSize>, Size, PointerType<ConstType<Long>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<ULong, VSize>, Size, PointerType<ConstType<ULong>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Float>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Double, VSize>, Size, PointerType<ConstType<Double>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<Half, VSize>, Size, PointerType<ConstType<Half>, ConstantAS>]>;
+  }
+  foreach name = ["vloada_half"#VSize] in {
+    def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Half>, ConstantAS>]>;
+  }
+  foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+    foreach name = ["vstorea_half"#VSize#rnd] in {
+      def : Builtin<name, [Void, VectorType<Float, VSize>, Size, PointerType<Half, ConstantAS>]>;
+      def : Builtin<name, [Void, VectorType<Double, VSize>, Size, PointerType<Half, ConstantAS>]>;
+    }
+  }
+}
 
 //--------------------------------------------------------------------
 // OpenCL v2.0 s6.13.11 - Atomics Functions.
 // Functions are using memory_order and cl_mem_fence_flags typedefs,
 // which make them not declarable here.
 
 // OpenCL v1.0 s9.5, s9.6, s9.7 - Atomic Functions for 32-bit integers.
 // --- Table 9.1 ---
 foreach Type = [Int, UInt] in {
   foreach name = ["atom_add", "atom_sub", "atom_xchg"] in {
     def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type]>;
   }
   foreach name = ["atom_inc", "atom_dec"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>]>;
   }
   foreach name = ["atom_cmpxchg"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type, Type]>;
   }
 }
 
 
-// OpenCL v1.2 s6.12.1: Work-Item Functions
-def get_work_dim : Builtin<"get_work_dim", [UInt]>;
-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, UInt]>;
-}
-
 // OpenCL v1.2 s6.12.2: Math Functions
 foreach name = ["acos", "acosh", "acospi",
                 "asin", "asinh", "asinpi",
                 "atan", "atanh", "atanpi"] in {
   def : Builtin<name, [FGenTypeN, FGenTypeN]>;
 }
 
 foreach name = ["atan2", "atan2pi"] in {
   def : Builtin<name, [FGenTypeN, FGenTypeN, FGenTypeN]>;
 }
 
 foreach name = ["fmax", "fmin"] in {
   def : Builtin<name, [FGenTypeN, FGenTypeN, FGenTypeN]>;
   def : Builtin<name, [GenTypeFloatListNNoScalar, GenTypeFloatListNNoScalar, Float]>;
   def : Builtin<name, [GenTypeDoubleListNNoScalar, GenTypeDoubleListNNoScalar, Double]>;
   def : Builtin<name, [GenTypeHalfListNNoScalar, GenTypeHalfListNNoScalar, Half]>;
 }
 
 
 // OpenCL extension v2.0 s5.1.9 : Built-in Image Read Functions
 // --- Table 8 ---
 foreach aQual = ["RO"] in {
   foreach name = ["read_imageh"] in {
     foreach Type1 = [Int, Float] in {
       foreach Type2 = [Image2d, Image1dArray] in {
         def : Builtin<name, [VectorType<Half, 4>, ImageType<Type2, aQual>, Sampler, VectorType<Type1, 2>]>;
       }
foreach name = ["write_imageh"] in {
     def : Builtin<name, [Void, ImageType<Image2d, aQual>, VectorType<Int, 2>, VectorType<Half, 4>]>;
     def : Builtin<name, [Void, ImageType<Image2dArray, aQual>, VectorType<Int, 4>, VectorType<Half, 4>]>;
     def : Builtin<name, [Void, ImageType<Image1d, aQual>, Int, VectorType<Half, 4>]>;
     def : Builtin<name, [Void, ImageType<Image1dBuffer, aQual>, Int, VectorType<Half, 4>]>;
     def : Builtin<name, [Void, ImageType<Image1dArray, aQual>, VectorType<Int, 2>, VectorType<Half, 4>]>;
     def : Builtin<name, [Void, ImageType<Image3d, aQual>, VectorType<Int, 4>, VectorType<Half, 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]>;
-    def get_max_sub_group_size : Builtin<"get_max_sub_group_size", [UInt]>;
-    def get_num_sub_groups : Builtin<"get_num_sub_groups", [UInt]>;
-  }
-}

clang/lib/Sema/SemaLookup.cpp

static void InsertOCLBuiltinDeclarationsFromTable(Sema &S,
   // 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;
 
+    // Ignore this BIF if the version is incorrect.
+    if (Context.getLangOpts().OpenCLVersion < OpenCLBuiltin.MinVersion)
+      continue;
+    if ((OpenCLBuiltin.MaxVersion != 0) &&
+        (Context.getLangOpts().OpenCLVersion >= OpenCLBuiltin.MaxVersion))
+      continue;
+
     std::vector<QualType> RetTypes;
     SmallVector<std::vector<QualType>, 5> ArgTypes;
 
     GetQualTypesForOpenCLBuiltin(Context, OpenCLBuiltin, GenTypeMaxCnt,
                                  RetTypes, ArgTypes);
 
     if (GenTypeMaxCnt > 1) {
       HasGenType = true;

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

+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -DNO_HEADER
+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -finclude-default-header
+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -DNO_HEADER
+// RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -finclude-default-header
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header
+
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 // expected-no-diagnostics
+#endif
 
 // Test the -fdeclare-opencl-builtins option.
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
+#if __OPENCL_C_VERSION__ < CL_VERSION_1_2
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+#endif
 
 // Provide typedefs when invoking clang without -finclude-default-header.
 #ifdef NO_HEADER
 typedef char char2 __attribute__((ext_vector_type(2)));
 typedef float float4 __attribute__((ext_vector_type(4)));
 typedef half half4 __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 char uchar;
 typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef unsigned short ushort;
 typedef __SIZE_TYPE__ size_t;
 #endif
 
 
 kernel void basic_atomic(volatile __global void* global_p) {
   int i;
   unsigned int ui;
 

 kernel void basic_image_readonly(read_only image2d_t image_read_only_image2d) {
   int2 i2;
   sampler_t sampler;
 
   read_imageh(image_read_only_image2d, i2);
   read_imageh(image_read_only_image2d, sampler, i2);
 }
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 kernel void basic_image_readwrite(read_write image3d_t image_read_write_image3d) {
   half4 h4;
   int4 i4;
 
   write_imageh(image_read_write_image3d, i4, h4);
 }
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 kernel void basic_image_writeonly(write_only image1d_buffer_t image_write_only_image1d_buffer) {
   half4 h4;
   int i;
 
   write_imageh(image_write_only_image1d_buffer, i, h4);
 }
 
-kernel void basic_subgroup(global uint *out) {
-  out[0] = get_sub_group_size();
+kernel void basic_vector_data() {
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+  generic void *generic_p;
+#endif
+  constant void *constant_p;
+  local void *local_p;
+  global void *global_p;
+  private void *private_p;
+  size_t s;
+
+  vload4(s, (const __constant ulong *) constant_p);
+  vload16(s, (const __constant short *) constant_p);
+
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+  vload3(s, (const __generic ushort *) generic_p);
+  vload16(s, (const __generic uchar *) generic_p);
+#endif
+
+  vload8(s, (const __global long *) global_p);
+  vload2(s, (const __local uint *) local_p);
+  vload16(s, (const __private float *) private_p);
+}
+
+kernel void basic_work_item() {
+  uint ui;
+
+  get_enqueued_local_size(ui);
+#if __OPENCL_C_VERSION__ < CL_VERSION_2_0
+// expected-error@-2{{implicit declaration of function 'get_enqueued_local_size' is invalid in OpenCL}}
+#endif
 }

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 //
 // static const unsigned SignatureTable[] = {
 //   15, 2, 15, // This is a signature
 //   ... // Other indexes of a struct OpenCLTypeStruct table, allowing to
 //       // build a signature.
 // };
 //
 // static const OpenCLBuiltinStruct BuiltinTable[] = {
-// // 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 },
+// // 891 convert_float2_rtn
+//   { 38, 2, 100, 0 }, // The "convert_float2_rtn" function has one signature
+//                      // at the index 891 of the SignatureTable, it uses the 2
+//                      // values after this index. The first value is the
+//                      // return type.
+//                      // This prototype is available from OpenCL C version 1.0
+//                      // to the last available version (0 meaning all).
+//   { 182, 2, 100, 0 },
+//   { 326, 2, 100, 0 },
 //   ...  // Other functions and signatures.
 // };
 //
 // static std::pair<unsigned, unsigned> isOpenCLBuiltin(llvm::StringRef name) {
 // // Find out whether a string matches an existing OpenCL builtin function
 // // name.
 // };
 //
private:
   // 15, 2, 15 can represent a function with the signature:
   // int func(float, int)
   // The "int" type being at the index 15 in the TypeTable.
   void EmitSignatureTable();
 
   // Emit the BuiltinTable table. This table contains all the overloads of
   // each function, and is a struct OpenCLBuiltinDecl.
   // E.g.:
-  // // convert_float2_rtn
-  //   { 58, 2 },
+  // // 891 convert_float2_rtn
+  //   { 38, 2, 100, 0 },
   // This means that the signature of this convert_float2_rtn overload has
   // 1 argument (+1 for the return type), stored at index 58 in
   // the OpenCLSignature table.
+  // Trailing values add information about the version.
   void EmitBuiltinTable();
 
   // Emit a StringMatcher function to check whether a function name is an
   // OpenCL builtin function name.
   void EmitStringMatcher();
 
   // Helper function for EmitQualTypeFinder.
   // This function emit the code adding qualifier attributes to QualTypes.

 // OpenCLBuiltinStruct table allows to have all the overloads.
 struct OpenCLBuiltinStruct {
   // Index of the signature in the OpenCLTypeStruct table.
   unsigned SigTableIndex;
   // Type between indexes SigTableIndex and (SigTableIndex + NumTypes - 1) in
   // the SignatureTable must be considered to build the signature.
   // The first type at index SigTableIndex is the return type.
   unsigned NumTypes;
+  // Version in which it was introduced (e.g.: CL20). MinVersion is inclusive.
+  unsigned MinVersion;
+  // Version in which it was introduced (e.g.: CL20). MaxVersion is exclusive.
+  unsigned MaxVersion;
 };
 
 )";
 }
 
 
 void BuiltinNameEmitter::GetOverloads() {
   // Populate the TypeMap.
void BuiltinNameEmitter::EmitBuiltinTable() {
   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()
+         << Overload.first->getValueAsListOfDefs("Signature").size() << ", "
+         << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("Name") << ", "
+         << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("Name")
          << " },\n";
          Index++;
     }
   }
   OS << "};\n\n";
 }