[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

183

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?

308

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

183

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.

308

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

356

I wish TableGen had templates :)

459–460

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

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

104–105

Is 891 relevant here?

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

459–460

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

104–105

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 CLNull  : 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.
+  // CLNull abstracts a version beyond all existing version.
+  Version MaxVersion = CLNull;
 }
 
 //===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL C types
 //===----------------------------------------------------------------------===//
 
 // OpenCL v1.0/1.2/2.0/2.2 s6.1.1: Built-in Scalar Data Types
 def bool_t      : Type<"bool", QualType<"BoolTy">>;
foreach sat = ["", "_sat"] in {
                           VectorType<IType,
                           v>]>;
         }
       }
     }
   }
 }
 
+//--------------------------------------------------------------------
+// OpenCL v1.1 s6.11.1, v1.2 s6.12.1, v2.0/2.2 s6.13.1 - Work-item Functions
+// --- Table 7 ---
+def : 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]>;
+}
+
+let MinVersion = CL20 in {
+  def : Builtin<"get_enqueued_local_size", [size_t, uint_t]>;
+  foreach name = ["get_global_linear_id", "get_local_linear_id"] in {
+    def : Builtin<name, [size_t]>;
+  }
+}
+
+//--------------------------------------------------------------------
+// OpenCL v1.1 s6.11.7, v1.2 s6.12.7, v2.0/2.2 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_t, VSize>, size_t, PointerType<ConstType<char_t>, AS>]>;
+        def : Builtin<name, [VectorType<uchar_t, VSize>, size_t, PointerType<ConstType<uchar_t>, AS>]>;
+        def : Builtin<name, [VectorType<short_t, VSize>, size_t, PointerType<ConstType<short_t>, AS>]>;
+        def : Builtin<name, [VectorType<ushort_t, VSize>, size_t, PointerType<ConstType<ushort_t>, AS>]>;
+        def : Builtin<name, [VectorType<int_t, VSize>, size_t, PointerType<ConstType<int_t>, AS>]>;
+        def : Builtin<name, [VectorType<uint_t, VSize>, size_t, PointerType<ConstType<uint_t>, AS>]>;
+        def : Builtin<name, [VectorType<long_t, VSize>, size_t, PointerType<ConstType<long_t>, AS>]>;
+        def : Builtin<name, [VectorType<ulong_t, VSize>, size_t, PointerType<ConstType<ulong_t>, AS>]>;
+        def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<float_t>, AS>]>;
+        def : Builtin<name, [VectorType<double_t, VSize>, size_t, PointerType<ConstType<double_t>, AS>]>;
+        def : Builtin<name, [VectorType<half_t, VSize>, size_t, PointerType<ConstType<half_t>, AS>]>;
+      }
+      foreach name = ["vstore"#VSize] in {
+        def : Builtin<name, [void_t, VectorType<char_t, VSize>, size_t, PointerType<ConstType<char_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<uchar_t, VSize>, size_t, PointerType<ConstType<uchar_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<short_t, VSize>, size_t, PointerType<ConstType<short_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<ushort_t, VSize>, size_t, PointerType<ConstType<ushort_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<int_t, VSize>, size_t, PointerType<ConstType<int_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<uint_t, VSize>, size_t, PointerType<ConstType<uint_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<long_t, VSize>, size_t, PointerType<ConstType<long_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<ulong_t, VSize>, size_t, PointerType<ConstType<ulong_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<float_t, VSize>, size_t, PointerType<ConstType<float_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<double_t, VSize>, size_t, PointerType<ConstType<double_t>, AS>]>;
+        def : Builtin<name, [void_t, VectorType<half_t, VSize>, size_t, PointerType<ConstType<half_t>, AS>]>;
+      }
+      foreach name = ["vloada_half"#VSize] in {
+        def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<half_t>, AS>]>;
+      }
+      foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+        foreach name = ["vstorea_half"#VSize#rnd] in {
+          def : Builtin<name, [void_t, VectorType<float_t, VSize>, size_t, PointerType<half_t, AS>]>;
+          def : Builtin<name, [void_t, VectorType<double_t, VSize>, size_t, PointerType<half_t, 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_t, VSize>, size_t, PointerType<ConstType<char_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<uchar_t, VSize>, size_t, PointerType<ConstType<uchar_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<short_t, VSize>, size_t, PointerType<ConstType<short_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<ushort_t, VSize>, size_t, PointerType<ConstType<ushort_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<int_t, VSize>, size_t, PointerType<ConstType<int_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<uint_t, VSize>, size_t, PointerType<ConstType<uint_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<long_t, VSize>, size_t, PointerType<ConstType<long_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<ulong_t, VSize>, size_t, PointerType<ConstType<ulong_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<float_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<double_t, VSize>, size_t, PointerType<ConstType<double_t>, GenericAS>]>;
+      def : Builtin<name, [VectorType<half_t, VSize>, size_t, PointerType<ConstType<half_t>, GenericAS>]>;
+    }
+    foreach name = ["vstore"#VSize] in {
+      def : Builtin<name, [void_t, VectorType<char_t, VSize>, size_t, PointerType<ConstType<char_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<uchar_t, VSize>, size_t, PointerType<ConstType<uchar_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<short_t, VSize>, size_t, PointerType<ConstType<short_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<ushort_t, VSize>, size_t, PointerType<ConstType<ushort_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<int_t, VSize>, size_t, PointerType<ConstType<int_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<uint_t, VSize>, size_t, PointerType<ConstType<uint_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<long_t, VSize>, size_t, PointerType<ConstType<long_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<ulong_t, VSize>, size_t, PointerType<ConstType<ulong_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<float_t, VSize>, size_t, PointerType<ConstType<float_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<double_t, VSize>, size_t, PointerType<ConstType<double_t>, GenericAS>]>;
+      def : Builtin<name, [void_t, VectorType<half_t, VSize>, size_t, PointerType<ConstType<half_t>, GenericAS>]>;
+    }
+    foreach name = ["vloada_half"#VSize] in {
+      def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<half_t>, GenericAS>]>;
+    }
+    foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+      foreach name = ["vstorea_half"#VSize#rnd] in {
+        def : Builtin<name, [void_t, VectorType<float_t, VSize>, size_t, PointerType<half_t, GenericAS>]>;
+        def : Builtin<name, [void_t, VectorType<double_t, VSize>, size_t, PointerType<half_t, 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_t, VSize>, size_t, PointerType<ConstType<char_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<uchar_t, VSize>, size_t, PointerType<ConstType<uchar_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<short_t, VSize>, size_t, PointerType<ConstType<short_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<ushort_t, VSize>, size_t, PointerType<ConstType<ushort_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<int_t, VSize>, size_t, PointerType<ConstType<int_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<uint_t, VSize>, size_t, PointerType<ConstType<uint_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<long_t, VSize>, size_t, PointerType<ConstType<long_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<ulong_t, VSize>, size_t, PointerType<ConstType<ulong_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<float_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<double_t, VSize>, size_t, PointerType<ConstType<double_t>, ConstantAS>]>;
+    def : Builtin<name, [VectorType<half_t, VSize>, size_t, PointerType<ConstType<half_t>, ConstantAS>]>;
+  }
+  foreach name = ["vloada_half"#VSize] in {
+    def : Builtin<name, [VectorType<float_t, VSize>, size_t, PointerType<ConstType<half_t>, ConstantAS>]>;
+  }
+  foreach rnd = ["", "_rte", "_rtz", "_rtp", "_rtn"] in {
+    foreach name = ["vstorea_half"#VSize#rnd] in {
+      def : Builtin<name, [void_t, VectorType<float_t, VSize>, size_t, PointerType<half_t, ConstantAS>]>;
+      def : Builtin<name, [void_t, VectorType<double_t, VSize>, size_t, PointerType<half_t, ConstantAS>]>;
+    }
+  }
+}
 
 
 //--------------------------------------------------------------------
 // OpenCL v2.0/2.2 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_t, uint_t] in {
   foreach name = ["atom_add", "atom_sub", "atom_xchg"] in {
     def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type]>;
   }
   foreach name = ["atom_inc", "atom_dec"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>]>;
   }
   foreach name = ["atom_cmpxchg"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, GlobalAS>, Type, Type]>;
   }
 }
 
 
-
-// OpenCL v1.2 s6.12.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 {
   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, [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 extension v2.2 s5.1.9 : Built-in Image Read Functions
 // --- Table 8 ---
 foreach aQual = ["RO"] in {
   foreach name = ["read_imageh"] in {
     foreach Type1 = [int_t, float_t] in {
       foreach Type2 = [image2d_t, image1d_array_t] in {
         def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type2, aQual>, sampler_t, VectorType<Type1, 2>]>;
       }
       foreach Type2 = [image3d_t, image2d_array_t] in {
foreach name = ["write_imageh"] in {
     def : Builtin<name, [void_t, ImageType<image2d_t, aQual>, VectorType<int_t, 2>, VectorType<half_t, 4>]>;
     def : Builtin<name, [void_t, ImageType<image2d_array_t, aQual>, VectorType<int_t, 4>, VectorType<half_t, 4>]>;
     def : Builtin<name, [void_t, ImageType<image1d_t, aQual>, int_t, VectorType<half_t, 4>]>;
     def : Builtin<name, [void_t, ImageType<image1d_buffer_t, aQual>, int_t, VectorType<half_t, 4>]>;
     def : Builtin<name, [void_t, ImageType<image1d_array_t, aQual>, VectorType<int_t, 2>, VectorType<half_t, 4>]>;
     def : Builtin<name, [void_t, ImageType<image3d_t, aQual>, VectorType<int_t, 4>, VectorType<half_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

static void InsertOCLBuiltinDeclarations(Sema &S,
   unsigned GenTypeMaxCnt;
   // The function has been declared using generic types
   bool HasGenType = false;
 
   for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
     const OpenCLBuiltinStruct &Decl = BuiltinTable[FctIndex + SignatureIndex];
     ASTContext &Context = S.Context;
 
+    // Ignore this BIF if the version is incorrect.
+    if (Context.getLangOpts().OpenCLVersion < Decl.MinVersion)
+      continue;
+    if ((Decl.MaxVersion != 0) &&
+        (Context.getLangOpts().OpenCLVersion >= Decl.MaxVersion))
+      continue;
+
     std::vector<QualType> RetTypes;
     SmallVector<std::vector<QualType>, 5> ArgTypes;
 
     GetQualTypes(Context, Decl, 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;
 
   atom_add((volatile __global int *) global_p, i);
   atom_cmpxchg((volatile __global unsigned int *) global_p, ui, ui);
 }
 
-
-
 kernel void basic_conversion() {
   double d;
   float f;
   char2 c2;
   long2 l2;
   float4 f4;
   int4 i4;
 

 
 kernel void basic_writeonly_image_type(write_only image1d_buffer_t image_write_only_image1d_buffer) {
   half4 h4;
   int i;
 
   write_imageh(image_write_only_image1d_buffer, i, h4);
 }
 
+
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 kernel void basic_readwrite_image_type(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_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
+
+#if __OPENCL_C_VERSION__ < CL_VERSION_2_0
+  vload8(s, (const __global long *) global_p);
+  vload2(s, (const __local uint *) local_p);
+  vload16(s, (const __private float *) private_p);
+#endif
+}
+
+kernel void basic_work_item() {
+  uint ui;
 
-kernel void basic_subgroup(global uint *out) {
-  out[0] = get_sub_group_size();
+  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

private:
   // E.g.:
   // 12, 15, 12 can reference 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 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();

 // 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;
+  // 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() {
   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->getValueAsDef("MinVersion")->getValueAsInt("Name") << ", "
+         << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("Name")
          << " },\n";
          Index++;
     }
   }
   OS << "};\n\n";
 }
 
 
for (auto &i : FctOverloadMap) {
     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);