[OpenCL] Add declarations with enum/typedef args

[svenvh]

Summary

Add the remaining missing builtin function declarations that have enum
or typedef argument or return types.

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

932

Btw, I am guessing you are matching the behavior of opencl-c.h, but however it doesn't seem entirely conformant.

cl_mem_fence_flags get_fence(gentype *ptr)

So I guess we should have implemented these as other functions from Table 22. Built-in Address Space Qualifier Functions in clang? But since the void pointer is only used as a parameter and not return value I doubt this is customer visible. Should we add a comment or something?

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

185

Should work_group_barrier and fences also be added to the testing?

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

932

Yes, I'm matching opencl-c.h here, as the "gentype argument to indicate any of the built-in data types supported by OpenCL C or a user defined type. Since this cannot be captured" can't be expressed literally. I can add the following comment if that makes sense?

// The OpenCL 3.0 specification defines these with a "gentype" argument indicating any builtin
// type or user-defined type, which cannot be represented currently.  Hence we slightly diverge
// from this by providing only the following two overloads with a void pointer.

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

185

MemFenceFlags are already tested using barrier() on line 23, so not strictly needed. I added this test to verify the combination of MemFenceFlags and extensions. Do you think we're missing any tablegen functionality coverage that would require adding more builtins to the test (also taking into account the comment on lines 10-13)?

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

932

Yes, I think a comment is good enough. We could even create a spec bug because it is literally not possible to implement without a magic and just using void* is so easy and straight forward.

1103

I think this should be renamed now, but we can do as a separate change.

I would suggest using something like OverloadTypes instead...

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

185

Taking into account the definition it's not easy to tell. I was trying to apply the strategy of any new group of declarations is to be tested but it might not be the original intention. I still think we do need to come up with some sort of unambiguous strategy but perhaps it is not in the scope of this patch.

[svenvh]

Add comment about get_fence.

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

932

Added the comment.

1103

Agreed that renaming belongs to a separate patch, we can probably bikeshed over the actual name. TypeTuple would already be better than TypePair for this case. I find OverloadTypes a bit ambiguous (I guess with "Overload" you intend to refer to a particular instance of the overloaded function, but not sure if it's common to use "overload" as a noun). ReturnTypeAndArgumentTypes or OverloadedFunctionTypes seem more accurate but a bit unwieldy...

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

185

any new group of declarations is to be tested but it might not be the original intention.

That has not been the convention for this test indeed. It's a bit hard to give an exact definition when the purpose of the test is to do a quick sweep across the main functional aspects of the -fdeclare-opencl-builtins machinery. As mentioned in various other reviews, a full test for all OpenCL builtins is desirable to have, but outside the scope of this test (which is probably more like a best-effort test).

[Anastasia]

LGTM! Thanks!

clang/lib/Sema/OpenCLBuiltins.td

933

I would suggest changing this slightly to:

which cannot be represented currently -> which cannot be represented in C based languages

otherwise, it feels like there would be a way to represent it later. I just want to make sure it is clear that this is not a limitation of Tablegen or anything else in the implementation but rather conceptual issue.

1103

Yes, we can use more domain-specific names I would prefer those to TypeTuple.

clang/lib/Sema/OpenCLBuiltins.td

 def Image2dArrayMsaaDepth : Type<"image2d_array_msaa_depth_t", QualType<"Context.OCLImage2dArrayMSAADepth", 1>>;
 
 def Sampler               : Type<"sampler_t", QualType<"Context.OCLSamplerTy">>;
 def ClkEvent              : Type<"clk_event_t", QualType<"Context.OCLClkEventTy">>;
 def Event                 : Type<"event_t", QualType<"Context.OCLEventTy">>;
 def Queue                 : Type<"queue_t", QualType<"Context.OCLQueueTy">>;
 def ReserveId             : Type<"reserve_id_t", QualType<"Context.OCLReserveIDTy">>;
 def MemFenceFlags         : TypedefType<"cl_mem_fence_flags">;
+def ClkProfilingInfo      : TypedefType<"clk_profiling_info">;
 
 // OpenCL v2.0 s6.13.11: Atomic integer and floating-point types.
 def AtomicInt             : Type<"atomic_int", QualType<"Context.getAtomicType(Context.IntTy)">>;
 def AtomicUInt            : Type<"atomic_uint", QualType<"Context.getAtomicType(Context.UnsignedIntTy)">>;
 def AtomicLong            : Type<"atomic_long", QualType<"Context.getAtomicType(Context.LongTy)">>;
 def AtomicULong           : Type<"atomic_ulong", QualType<"Context.getAtomicType(Context.UnsignedLongTy)">>;
 def AtomicFloat           : Type<"atomic_float", QualType<"Context.getAtomicType(Context.FloatTy)">>;
 def AtomicDouble          : Type<"atomic_double", QualType<"Context.getAtomicType(Context.DoubleTy)">>;
 def AtomicIntPtr          : Type<"atomic_intptr_t", QualType<"Context.getAtomicType(Context.getIntPtrType())">>;
 def AtomicUIntPtr         : Type<"atomic_uintptr_t", QualType<"Context.getAtomicType(Context.getUIntPtrType())">>;
 def AtomicSize            : Type<"atomic_size_t", QualType<"Context.getAtomicType(Context.getSizeType())">>;
 def AtomicPtrDiff         : Type<"atomic_ptrdiff_t", QualType<"Context.getAtomicType(Context.getPointerDiffType())">>;
 
+def AtomicFlag            : TypedefType<"atomic_flag">;
 def MemoryOrder           : EnumType<"memory_order">;
 def MemoryScope           : EnumType<"memory_scope">;
 
 //===----------------------------------------------------------------------===//
 //                 Definitions of OpenCL gentype variants
 //===----------------------------------------------------------------------===//
 // The OpenCL specification often uses "gentype" in builtin function
 // declarations to indicate that a builtin function is available with various
foreach VSize = [2, 3, 4, 8, 16] in {
     foreach name = ["vload_half" # VSize] in {
       def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Half>, AS>]>;
     }
   }
 }
 
 // OpenCL v3.0 s6.15.8 - Synchronization Functions.
 def : Builtin<"barrier", [Void, MemFenceFlags], Attr.Convergent>;
+let MinVersion = CL20 in {
+  def : Builtin<"work_group_barrier", [Void, MemFenceFlags], Attr.Convergent>;
+  def : Builtin<"work_group_barrier", [Void, MemFenceFlags, MemoryScope], Attr.Convergent>;
+}
+
+// OpenCL v3.0 s6.15.9 - Legacy Explicit Memory Fence Functions.
+def : Builtin<"mem_fence", [Void, MemFenceFlags]>;
+def : Builtin<"read_mem_fence", [Void, MemFenceFlags]>;
+def : Builtin<"write_mem_fence", [Void, MemFenceFlags]>;
+
+// OpenCL v3.0 s6.15.10 - Address Space Qualifier Functions.
+// to_global, to_local, to_private are declared in Builtins.def.
+
+let MinVersion = CL20 in {
+  def : Builtin<"get_fence", [MemFenceFlags, PointerType<Void, GenericAS>]>;
+  def : Builtin<"get_fence", [MemFenceFlags, PointerType<ConstType<Void>, GenericAS>]>;
+}
 
 //--------------------------------------------------------------------
 // OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10: Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
 // OpenCL Extension v2.0 s5.1.7 and s6.1.7: Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
 // --- Table 18 ---
 foreach name = ["async_work_group_copy"] in {
   def : Builtin<name, [Event, PointerType<AGenTypeN, LocalAS>, PointerType<ConstType<AGenTypeN>, GlobalAS>, Size, Event]>;
   def : Builtin<name, [Event, PointerType<AGenTypeN, GlobalAS>, PointerType<ConstType<AGenTypeN>, LocalAS>, Size, Event]>;
foreach Type = [Int, UInt] in {
     }
     foreach name = ["atomic_cmpxchg"] in {
       def : Builtin<name, [Type, PointerType<VolatileType<Type>, AS>, Type, Type]>;
     }
   }
 }
 // OpenCL v2.0 s6.13.11 - Atomic Functions.
 let MinVersion = CL20 in {
+  def : Builtin<"atomic_work_item_fence", [Void, MemFenceFlags, MemoryOrder, MemoryScope]>;
+
   foreach TypePair = [[AtomicInt, Int], [AtomicUInt, UInt],
                       [AtomicLong, Long], [AtomicULong, ULong],
                       [AtomicFloat, Float], [AtomicDouble, Double]] in {
     def : Builtin<"atomic_init",
         [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
     def : Builtin<"atomic_store",
         [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
+    def : Builtin<"atomic_store_explicit",
+        [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1], MemoryOrder]>;
+    def : Builtin<"atomic_store_explicit",
+        [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1], MemoryOrder, MemoryScope]>;
     def : Builtin<"atomic_load",
         [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>]>;
+    def : Builtin<"atomic_load_explicit",
+        [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, MemoryOrder]>;
+    def : Builtin<"atomic_load_explicit",
+        [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, MemoryOrder, MemoryScope]>;
     def : Builtin<"atomic_exchange",
         [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
+    def : Builtin<"atomic_exchange_explicit",
+        [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1], MemoryOrder]>;
+    def : Builtin<"atomic_exchange_explicit",
+        [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1], MemoryOrder, MemoryScope]>;
     foreach Variant = ["weak", "strong"] in {
       def : Builtin<"atomic_compare_exchange_" # Variant,
           [Bool, PointerType<VolatileType<TypePair[0]>, GenericAS>,
            PointerType<TypePair[1], GenericAS>, TypePair[1]]>;
       def : Builtin<"atomic_compare_exchange_" # Variant # "_explicit",
           [Bool, PointerType<VolatileType<TypePair[0]>, GenericAS>,
            PointerType<TypePair[1], GenericAS>, TypePair[1], MemoryOrder, MemoryOrder]>;
       def : Builtin<"atomic_compare_exchange_" # Variant # "_explicit",
           [Bool, PointerType<VolatileType<TypePair[0]>, GenericAS>,
            PointerType<TypePair[1], GenericAS>, TypePair[1], MemoryOrder, MemoryOrder, MemoryScope]>;
     }
   }
 
   foreach TypePair = [[AtomicInt, Int, Int], [AtomicUInt, UInt, UInt],
                       [AtomicLong, Long, Long], [AtomicULong, ULong, ULong],
                       [AtomicIntPtr, IntPtr, PtrDiff],
                       [AtomicUIntPtr, UIntPtr, PtrDiff]] in {
     foreach ModOp = ["add", "sub"] in {
       def : Builtin<"atomic_fetch_" # ModOp,
           [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2]]>;
+      def : Builtin<"atomic_fetch_" # ModOp # "_explicit",
+          [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2], MemoryOrder]>;
+      def : Builtin<"atomic_fetch_" # ModOp # "_explicit",
+          [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2], MemoryOrder, MemoryScope]>;
     }
   }
   foreach TypePair = [[AtomicInt, Int, Int], [AtomicUInt, UInt, UInt],
                       [AtomicLong, Long, Long], [AtomicULong, ULong, ULong],
                       [AtomicIntPtr, IntPtr, IntPtr],
                       [AtomicUIntPtr, UIntPtr, UIntPtr]] in {
     foreach ModOp = ["or", "xor", "and", "min", "max"] in {
       def : Builtin<"atomic_fetch_" # ModOp,
           [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2]]>;
+      def : Builtin<"atomic_fetch_" # ModOp # "_explicit",
+          [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2], MemoryOrder]>;
+      def : Builtin<"atomic_fetch_" # ModOp # "_explicit",
+          [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2], MemoryOrder, MemoryScope]>;
     }
   }
+
+  def : Builtin<"atomic_flag_clear",
+      [Void, PointerType<VolatileType<AtomicFlag>, GenericAS>]>;
+  def : Builtin<"atomic_flag_clear_explicit",
+      [Void, PointerType<VolatileType<AtomicFlag>, GenericAS>, MemoryOrder]>;
+  def : Builtin<"atomic_flag_clear_explicit",
+      [Void, PointerType<VolatileType<AtomicFlag>, GenericAS>, MemoryOrder, MemoryScope]>;
+
+  def : Builtin<"atomic_flag_test_and_set",
+      [Bool, PointerType<VolatileType<AtomicFlag>, GenericAS>]>;
+  def : Builtin<"atomic_flag_test_and_set_explicit",
+      [Bool, PointerType<VolatileType<AtomicFlag>, GenericAS>, MemoryOrder]>;
+  def : Builtin<"atomic_flag_test_and_set_explicit",
+      [Bool, PointerType<VolatileType<AtomicFlag>, GenericAS>, MemoryOrder, MemoryScope]>;
 }
 
 //--------------------------------------------------------------------
 // OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions
 // --- Table 19 ---
 foreach VSize1 = [Vec2, Vec4, Vec8, Vec16] in {
   foreach VSize2 = [Vec2, Vec4, Vec8, Vec16] in {
     def : Builtin<"shuffle", [GenericType<"TLAll" # VSize1.Name, TLAll, VSize1>,
def : Builtin<"enqueue_marker",
     [Int, Queue, UInt, PointerType<ConstType<ClkEvent>, GenericAS>, PointerType<ClkEvent, GenericAS>]>;
 
 // --- Table 34 ---
 def : Builtin<"retain_event", [Void, ClkEvent]>;
 def : Builtin<"release_event", [Void, ClkEvent]>;
 def : Builtin<"create_user_event", [ClkEvent]>;
 def : Builtin<"is_valid_event", [Bool, ClkEvent]>;
 def : Builtin<"set_user_event_status", [Void, ClkEvent, Int]>;
-// TODO: capture_event_profiling_info
+def : Builtin<"capture_event_profiling_info",
+    [Void, ClkEvent, ClkProfilingInfo, PointerType<Void, GlobalAS>]>;
 
 // --- Table 35 ---
 def : Builtin<"get_default_queue", [Queue]>;
 // TODO: ndrange functions
 
 
 //--------------------------------------------------------------------
 // End of the builtin functions defined in the OpenCL C specification.
let Extension = FuncExtKhrSubgroups in {
   let MinVersion = CL20 in {
     foreach name = ["get_enqueued_num_sub_groups"] in {
       def : Builtin<name, [UInt]>;
     }
   }
 }
 
 // --- Table 28.2.2 ---
-// TODO: sub_group_barrier
+let Extension = FuncExtKhrSubgroups in {
+  def : Builtin<"sub_group_barrier", [Void, MemFenceFlags], Attr.Convergent>;
+  def : Builtin<"sub_group_barrier", [Void, MemFenceFlags, MemoryScope], Attr.Convergent>;
+}
 
 // --- Table 28.2.4 ---
 let Extension = FuncExtKhrSubgroups in {
   foreach name = ["sub_group_all", "sub_group_any"] in {
     def : Builtin<name, [Int, Int], Attr.Convergent>;
   }
   foreach name = ["sub_group_broadcast"] in {
     def : Builtin<name, [IntLongFloatGenType1, IntLongFloatGenType1, UInt], Attr.Convergent>;

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

 typedef uchar uchar4 __attribute__((ext_vector_type(4)));
 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 uint uint4 __attribute__((ext_vector_type(4)));
 typedef long long2 __attribute__((ext_vector_type(2)));
 
+typedef int clk_profiling_info;
+#define CLK_PROFILING_COMMAND_EXEC_TIME 0x1
+
 typedef uint cl_mem_fence_flags;
 #define CLK_GLOBAL_MEM_FENCE 0x02
 
 // Enable extensions that are enabled in opencl-c-base.h.
 #if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
 #define cl_khr_subgroup_extended_types 1
 #define cl_khr_subgroup_ballot 1
 #define cl_khr_subgroup_non_uniform_arithmetic 1
kernel void test_enum_args(volatile global atomic_int *global_p, global int *expected) {
   int desired;
   atomic_compare_exchange_strong_explicit(global_p, expected, desired,
                                           memory_order_acq_rel,
                                           memory_order_relaxed,
                                           memory_scope_work_group);
 }
 #endif
 
+#if defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200
+void test_typedef_args(clk_event_t evt, volatile atomic_flag *flg, global unsigned long long *values) {
+  capture_event_profiling_info(evt, CLK_PROFILING_COMMAND_EXEC_TIME, values);
+
+  atomic_flag_clear(flg);
+  bool result = atomic_flag_test_and_set(flg);
+}
+#endif
+
 kernel void basic_conversion() {
   double d;
   float f;
   char2 c2;
   long2 l2;
   float4 f4;
   int4 i4;
 

 }
 
 kernel void basic_subgroup(global uint *out) {
   out[0] = get_sub_group_size();
 #if __OPENCL_C_VERSION__ <= CL_VERSION_1_2 && !defined(__OPENCL_CPP_VERSION__)
   // expected-error@-2{{implicit declaration of function 'get_sub_group_size' is invalid in OpenCL}}
   // expected-error@-3{{implicit conversion changes signedness}}
 #endif
+
+// Only test when the base header is included, because we need the enum declarations.
+#if !defined(NO_HEADER) && (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
+  sub_group_barrier(CLK_GLOBAL_MEM_FENCE, memory_scope_device);
+#endif
 }
 
 kernel void extended_subgroup(global uint4 *out, global int *scalar, global char2 *c2) {
   out[0] = get_sub_group_eq_mask();
   scalar[0] = sub_group_non_uniform_scan_inclusive_or(3);
   scalar[1] = sub_group_clustered_reduce_logical_xor(2, 4);
   *c2 = sub_group_broadcast(*c2, 2);
 #if __OPENCL_C_VERSION__ < CL_VERSION_2_0 && !defined(__OPENCL_CPP_VERSION__)