[OpenCL] Guard atomic_double with cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics

[haonanya]

Summary

It is necessary to guard atomic_double type according to https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_C.html#_footnotedef_54.
Platform that disables cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics will have compiling errors even if atomic_double is not used.

Compile the following OpenCL test with options clang++ -cc1 -emit-llvm -triple spir-unknown-unknown -finclude-default-header -cl-ext=+cl_khr_fp64,+opencl_c_fp64,-cl_khr_int64_base_atomics -cl-std=CL3.0 test.cl
kernel void test_kernel1() {}

error: use of type 'atomic_double' (aka '_Atomic(double)') requires cl_khr_int64_extended_atomics extension to be enabled

[Anastasia]

LGTM! Thanks

This might interfere with https://reviews.llvm.org/D119420

[svenvh]

In D119398#3310746, @Anastasia wrote:

This might interfere with https://reviews.llvm.org/D119420

Yes it will conflict.

Atomic doubles are not guarded properly for other builtins (outside of the cl_ext_float_atomics extensions) either, and I have a different solution in mind to solve it for all uses and extensions. So we could leave out the .td changes from this patch and only merge the opencl-c.h changes.

[haonanya]

Remove the .td changes.

[svenvh]

Thanks, LGTM! I'll try to followup with the .td changes soon.

[Anastasia]

Can this be committed now?

[haonanya]

Hi, @Anastasia. Please help to land it, thanks very much.

[Anastasia]

In D119398#3322547, @haonanya wrote:

Hi, @Anastasia. Please help to land it, thanks very much.

Sure, I will kindly ask @svenvh since he has some related patches to land too.

clang/lib/Headers/opencl-c.h

float __ovld atomic_fetch_min_explicit(volatile atomic_float *object,
                                        float operand, memory_order order,
                                        memory_scope scope);
 float __ovld atomic_fetch_max_explicit(volatile atomic_float *object,
                                        float operand, memory_order order,
                                        memory_scope scope);
 #endif // defined(__opencl_c_ext_fp32_global_atomic_min_max) &&                \
     defined(__opencl_c_ext_fp32_local_atomic_min_max)
 
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
 #if defined(__opencl_c_ext_fp64_global_atomic_min_max)
 double __ovld atomic_fetch_min(volatile __global atomic_double *object,
                                double operand);
 double __ovld atomic_fetch_max(volatile __global atomic_double *object,
                                double operand);
 double __ovld atomic_fetch_min_explicit(volatile __global atomic_double *object,
                                         double operand, memory_order order);
 double __ovld atomic_fetch_max_explicit(volatile __global atomic_double *object,

 double __ovld atomic_fetch_min_explicit(volatile atomic_double *object,
                                         double operand, memory_order order,
                                         memory_scope scope);
 double __ovld atomic_fetch_max_explicit(volatile atomic_double *object,
                                         double operand, memory_order order,
                                         memory_scope scope);
 #endif // defined(__opencl_c_ext_fp64_global_atomic_min_max) &&                \
     defined(__opencl_c_ext_fp64_local_atomic_min_max)
+#endif // defined(cl_khr_int64_base_atomics) &&                                \
+    defined(cl_khr_int64_extended_atomics)
 
 #if defined(__opencl_c_ext_fp16_global_atomic_add)
 half __ovld atomic_fetch_add(volatile __global atomic_half *object,
                              half operand);
 half __ovld atomic_fetch_sub(volatile __global atomic_half *object,
                              half operand);
 half __ovld atomic_fetch_add_explicit(volatile __global atomic_half *object,
                                       half operand, memory_order order);
float __ovld atomic_fetch_add_explicit(volatile atomic_float *object,
                                        float operand, memory_order order,
                                        memory_scope scope);
 float __ovld atomic_fetch_sub_explicit(volatile atomic_float *object,
                                        float operand, memory_order order,
                                        memory_scope scope);
 #endif // defined(__opencl_c_ext_fp32_global_atomic_add) &&                    \
     defined(__opencl_c_ext_fp32_local_atomic_add)
 
+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
 #if defined(__opencl_c_ext_fp64_global_atomic_add)
 double __ovld atomic_fetch_add(volatile __global atomic_double *object,
                                double operand);
 double __ovld atomic_fetch_sub(volatile __global atomic_double *object,
                                double operand);
 double __ovld atomic_fetch_add_explicit(volatile __global atomic_double *object,
                                         double operand, memory_order order);
 double __ovld atomic_fetch_sub_explicit(volatile __global atomic_double *object,

 double __ovld atomic_fetch_add_explicit(volatile atomic_double *object,
                                         double operand, memory_order order,
                                         memory_scope scope);
 double __ovld atomic_fetch_sub_explicit(volatile atomic_double *object,
                                         double operand, memory_order order,
                                         memory_scope scope);
 #endif // defined(__opencl_c_ext_fp64_global_atomic_add) &&                    \
     defined(__opencl_c_ext_fp64_local_atomic_add)
+#endif // defined(cl_khr_int64_base_atomics) &&                                \
+    defined(cl_khr_int64_extended_atomics)
 
 #endif // cl_ext_float_atomics
 
 // atomic_store()
 
 #if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device)
 #if defined(__opencl_c_generic_address_space)
 void __ovld atomic_store(volatile atomic_int *object, int desired);