[C++4OpenCL] Add clang extension for non-portable kernel parameters

[olestrohm]

Summary

This feature allows using non-portable types as kernel parameters. This allows bypassing the portability guarantees from the restrictions specified
in C++ for OpenCL v1.0 s2.4.

Currently this only disables the restrictions related to layout, as a programmer using the same compiler for host and device should get the same representation.
This could be extended to other things (like size_t) if desired in the future, but I think it's unlikely that someone would want that.

Previous discussion about the extension in https://bugs.llvm.org/show_bug.cgi?id=50081

[Anastasia]

clang/docs/LanguageExtensions.rst

1816

How about __cl_clang_unsafe_kernel_parameters to match the other extension naming scheme? Or we could use __cl_clang_non_portable_kernel_parameters, __cl_clang_non_portable_kernel_parameter_types to be more specific regarding the kind of safety that we allow to break?

1819

1824

1825

1826

1835

Let's add declarations of such types along in the example.

clang/lib/Sema/SemaDecl.cpp

8652

I would rather add an assert for this because we should not ever reach this function for the dependent types?

[olestrohm]

clang/lib/Sema/SemaDecl.cpp

8652

The function is actually called on dependent types

[olestrohm]

Improved the description and example per the feedback.

The check for dependent type is needed. If it is not included the diagnostic will get triggered when the extension is disabled, but not when it's enabled.

[Anastasia]

clang/docs/LanguageExtensions.rst

1820

Let's add references to relevant OpenCL C and C++ for OpenCL sections with restrictions.

1830

1836

1836

Let's add . at the end of every sentance. :)

1837

1844

[olestrohm]

Added a link to the C++ for OpenCL specification and cleaned up the text according to the requests.

[olestrohm]

Fixed merge error

[Anastasia]

LGTM! Thanks!

[Anastasia]

Closed by https://reviews.llvm.org/rGe994e74bca49831eb649e7c67955e9de7a1784b6

clang/docs/LanguageExtensions.rst

 .. code-block:: c++
 
   #pragma OPENCL EXTENSION __cl_clang_variadic_functions : enable
   void foo(int a, ...); // compiled - no diagnostic generated
 
   #pragma OPENCL EXTENSION __cl_clang_variadic_functions : disable
   void bar(int a, ...); // error - variadic prototype is not allowed
 
+``__cl_clang_non_portable_kernel_parameters``
+---------------------------------------------
+
+With this extension it is possible to enable the use of some restricted types
+in kernel parameters specified in `C++ for OpenCL v1.0 s2.4
+<https://www.khronos.org/opencl/assets/CXX_for_OpenCL.html#kernel_function>`_.
+The restrictions can be relaxed using regular OpenCL extension pragma mechanism
+detailed in `the OpenCL Extension Specification, section 1.2
+<https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#extensions-overview>`_.
+
+This is not a conformant behavior and it can only be used when the
+kernel arguments are not accessed on the host side or the data layout/size
+between the host and device is known to be compatible.
+
+**Example of Use**:
+
+.. code-block:: c++
+
+  // Plain Old Data type.
+  struct Pod {
+    int a;
+    int b;
+  };
+
+  // Not POD type because of the constructor.
+  // Standard layout type because there is only one access control.
+  struct OnlySL {
+    int a;
+    int b;
+    NotPod() : a(0), b(0) {}
+  };
+
+  // Not standard layout type because of two different access controls.
+  struct NotSL {
+    int a;
+  private:
+    int b;
+  }
+
+  kernel void kernel_main(
+    Pod a,
+  #pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : enable
+    OnlySL b,
+    global NotSL *c,
+  #pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : disable
+    global OnlySL *d,
+  );
+
 Legacy 1.x atomics with generic address space
 ---------------------------------------------
 
 Clang allows use of atomic functions from the OpenCL 1.x standards
 with the generic address space pointer in C++ for OpenCL mode.
 
 This is a non-portable feature and might not be supported by all
 targets.

clang/include/clang/Basic/OpenCLExtensions.def

 OPENCL_EXTENSION(cl_khr_mipmap_image_writes, true, 200)
 OPENCL_EXTENSION(cl_khr_srgb_image_writes, true, 200)
 OPENCL_EXTENSION(cl_khr_subgroups, true, 200)
 
 // Clang Extensions.
 OPENCL_EXTENSION(cl_clang_storage_class_specifiers, true, 100)
 OPENCL_EXTENSION(__cl_clang_function_pointers, true, 100)
 OPENCL_EXTENSION(__cl_clang_variadic_functions, true, 100)
+OPENCL_EXTENSION(__cl_clang_non_portable_kernel_parameters, true, 100)
 
 // AMD OpenCL extensions
 OPENCL_EXTENSION(cl_amd_media_ops, true, 100)
 OPENCL_EXTENSION(cl_amd_media_ops2, true, 100)
 
 // ARM OpenCL extensions
 OPENCL_EXTENSION(cl_arm_integer_dot_product_int8, true, 120)
 OPENCL_EXTENSION(cl_arm_integer_dot_product_accumulate_int8, true, 120)

clang/lib/Basic/Targets/AMDGPU.h

bool setCPU(const std::string &Name) override {
     return GPUKind != llvm::AMDGPU::GK_NONE;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts["cl_clang_storage_class_specifiers"] = true;
     Opts["__cl_clang_variadic_functions"] = true;
     Opts["__cl_clang_function_pointers"] = true;
+    Opts["__cl_clang_non_portable_kernel_parameters"] = true;
 
     bool IsAMDGCN = isAMDGCN(getTriple());
 
     Opts["cl_khr_fp64"] = hasFP64();
 
     if (IsAMDGCN || GPUKind >= llvm::AMDGPU::GK_CEDAR) {
       Opts["cl_khr_byte_addressable_store"] = true;
       Opts["cl_khr_global_int32_base_atomics"] = true;

clang/lib/Basic/Targets/NVPTX.h

bool setCPU(const std::string &Name) override {
     return GPU != CudaArch::UNKNOWN;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts["cl_clang_storage_class_specifiers"] = true;
     Opts["__cl_clang_function_pointers"] = true;
     Opts["__cl_clang_variadic_functions"] = true;
+    Opts["__cl_clang_non_portable_kernel_parameters"] = true;
 
     Opts["cl_khr_fp64"] = true;
     Opts["cl_khr_byte_addressable_store"] = true;
     Opts["cl_khr_global_int32_base_atomics"] = true;
     Opts["cl_khr_global_int32_extended_atomics"] = true;
     Opts["cl_khr_local_int32_base_atomics"] = true;
     Opts["cl_khr_local_int32_extended_atomics"] = true;
   }

clang/lib/Sema/SemaDecl.cpp

do {
     Ty = DesugaredTy;
     DesugaredTy = Ty.getSingleStepDesugaredType(C);
   } while (DesugaredTy != Ty);
 
   return false;
 }
 
 static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT) {
+  if (PT->isDependentType())
+    return InvalidKernelParam;
+
   if (PT->isPointerType() || PT->isReferenceType()) {
     QualType PointeeType = PT->getPointeeType();
     if (PointeeType.getAddressSpace() == LangAS::opencl_generic ||
         PointeeType.getAddressSpace() == LangAS::opencl_private ||
         PointeeType.getAddressSpace() == LangAS::Default)
       return InvalidAddrSpacePtrKernelParam;
 
     if (PointeeType->isPointerType()) {
       // This is a pointer to pointer parameter.
       // Recursively check inner type.
       OpenCLParamType ParamKind = getOpenCLKernelParameterType(S, PointeeType);
       if (ParamKind == InvalidAddrSpacePtrKernelParam ||
           ParamKind == InvalidKernelParam)
         return ParamKind;
 
       return PtrPtrKernelParam;
     }
 
     // C++ for OpenCL v1.0 s2.4:
     // Moreover the types used in parameters of the kernel functions must be:
     // Standard layout types for pointer parameters. The same applies to
     // reference if an implementation supports them in kernel parameters.
-    if (S.getLangOpts().OpenCLCPlusPlus && !PointeeType->isAtomicType() &&
-        !PointeeType->isVoidType() && !PointeeType->isStandardLayoutType())
+    if (S.getLangOpts().OpenCLCPlusPlus &&
+        !S.getOpenCLOptions().isAvailableOption(
+            "__cl_clang_non_portable_kernel_parameters", S.getLangOpts()) &&
+        !PointeeType->isAtomicType() && !PointeeType->isVoidType() &&
+        !PointeeType->isStandardLayoutType())
       return InvalidKernelParam;
 
     return PtrKernelParam;
   }
 
   // OpenCL v1.2 s6.9.k:
   // Arguments to kernel functions in a program cannot be declared with the
   // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
if (PT->isArrayType()) {
     // array, this recursive call only happens once.
     return getOpenCLKernelParameterType(S, QualType(UnderlyingTy, 0));
   }
 
   // C++ for OpenCL v1.0 s2.4:
   // Moreover the types used in parameters of the kernel functions must be:
   // Trivial and standard-layout types C++17 [basic.types] (plain old data
   // types) for parameters passed by value;
-  if (S.getLangOpts().OpenCLCPlusPlus && !PT->isOpenCLSpecificType() &&
-      !PT.isPODType(S.Context))
+  if (S.getLangOpts().OpenCLCPlusPlus &&
+      !S.getOpenCLOptions().isAvailableOption(
+          "__cl_clang_non_portable_kernel_parameters", S.getLangOpts()) &&
+      !PT->isOpenCLSpecificType() && !PT.isPODType(S.Context))
     return InvalidKernelParam;
 
   if (PT->isRecordType())
     return RecordKernelParam;
 
   return ValidKernelParam;
 }
 

clang/test/Misc/amdgcn.languageOptsOpenCL.cl

 #endif
 #pragma OPENCL EXTENSION __cl_clang_function_pointers : enable
 
 #ifndef __cl_clang_variadic_functions
 #error "Missing __cl_clang_variadic_functions define"
 #endif
 #pragma OPENCL EXTENSION __cl_clang_variadic_functions : enable
 
+#ifndef __cl_clang_non_portable_kernel_parameters
+#error "Missing __cl_clang_non_portable_kernel_parameters define"
+#endif
+#pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : enable
+
 #ifndef cl_khr_fp16
 #error "Missing cl_khr_fp16 define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_fp16: enable
 
 #ifndef cl_khr_int64_base_atomics
 #error "Missing cl_khr_int64_base_atomics define"
 #endif

clang/test/Misc/nvptx.languageOptsOpenCL.cl

 #endif
 #pragma OPENCL EXTENSION __cl_clang_function_pointers : enable
 
 #ifndef __cl_clang_variadic_functions
 #error "Missing __cl_clang_variadic_functions define"
 #endif
 #pragma OPENCL EXTENSION __cl_clang_variadic_functions : enable
 
+#ifndef __cl_clang_non_portable_kernel_parameters
+#error "Missing __cl_clang_non_portable_kernel_parameters define"
+#endif
+#pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : enable
+
 #ifdef cl_khr_fp16
 #error "Incorrect cl_khr_fp16 define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_fp16: enable
 // expected-warning@-1{{unsupported OpenCL extension 'cl_khr_fp16' - ignoring}}
 
 #ifdef cl_khr_int64_base_atomics
 #error "Incorrect cl_khr_int64_base_atomics define"

clang/test/Misc/r600.languageOptsOpenCL.cl

 #endif
 #pragma OPENCL EXTENSION __cl_clang_function_pointers : enable
 
 #ifndef __cl_clang_variadic_functions
 #error "Missing __cl_clang_variadic_functions define"
 #endif
 #pragma OPENCL EXTENSION __cl_clang_variadic_functions : enable
 
+#ifndef __cl_clang_non_portable_kernel_parameters
+#error "Missing __cl_clang_non_portable_kernel_parameters define"
+#endif
+#pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : enable
+
 #ifdef cl_khr_fp16
 #error "Incorrect cl_khr_fp16 define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_fp16: enable
 // expected-warning@-1{{unsupported OpenCL extension 'cl_khr_fp16' - ignoring}}
 
 #ifdef cl_khr_int64_base_atomics
 #error "Incorrect cl_khr_int64_base_atomics define"

clang/test/SemaOpenCLCXX/invalid-kernel.clcpp

-// RUN: %clang_cc1 %s -pedantic -verify -fsyntax-only
+// RUN: %clang_cc1 %s -pedantic -verify -fsyntax-only -triple spir-unknown-unknown
+// RUN: %clang_cc1 %s -pedantic -verify -fsyntax-only -triple spir-unknown-unknown -DUNSAFEKERNELPARAMETER
+
+#ifdef UNSAFEKERNELPARAMETER
+#pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_parameters : enable
+#endif
 
 struct C {
   kernel void m(); //expected-error{{kernel functions cannot be class members}}
 };
 
 template <typename T>
 //expected-error@+1{{'T' cannot be used as the type of a kernel parameter}}
 kernel void templ(T par) { //expected-error{{kernel functions cannot be used in a template declaration, instantiation or specialization}}

 
 kernel void int_v(int in);
 kernel void int_p(__global int *in);
 kernel void int_r(__global int &in);
 kernel void int_p_p(__global int *__global *in);
 kernel void int_p_r(__global int *__global &in);
 kernel void int_p_p_r(__global int *__global *__global &in);
 
-// expected-error@+1{{'__private atomic_int' (aka '__private _Atomic(int)') cannot be used as the type of a kernel parameter}}
 kernel void k_atomic_v(atomic_int in);
+#ifndef UNSAFEKERNELPARAMETER
+// expected-error@-2{{'__private atomic_int' (aka '__private _Atomic(int)') cannot be used as the type of a kernel parameter}}
+#endif
 kernel void k_atomic_p(__global atomic_int *in);
 kernel void k_atomic_r(__global atomic_int &in);
 
 kernel void k_pipe(read_only pipe int in, write_only pipe int out);
 kernel void k_sampler(sampler_t in);
 kernel void k_void(__global void *in);
 
 typedef int int4 __attribute__((ext_vector_type(4)));

 kernel void pod_r(__global POD &in) {}
 
 struct StandardLayout {
   int a;
   int b;
   StandardLayout(int a, int b) : a(a), b(b) {}
 };
 
-kernel void standard_v(StandardLayout in) {} //expected-error{{'__private StandardLayout' cannot be used as the type of a kernel parameter}}
+kernel void standard_v(StandardLayout in) {}
+#ifndef UNSAFEKERNELPARAMETER
+//expected-error@-2{{'__private StandardLayout' cannot be used as the type of a kernel parameter}}
+#endif
 kernel void standard_p(__global StandardLayout *in) {}
 kernel void standard_p_p(__global StandardLayout *__global *in) {}
 kernel void standard_r(__global StandardLayout &in) {}
 
 struct Trivial {
   int a;
 private:
   int b;
 };
 
-kernel void trivial_v(Trivial in) {} //expected-error{{'__private Trivial' cannot be used as the type of a kernel parameter}}
-kernel void trivial_p(__global Trivial *in) {} //expected-error{{'__global Trivial *__private' cannot be used as the type of a kernel parameter}}
-kernel void trivial_p_p(__global Trivial *__global *in) {} //expected-error{{'__global Trivial *__global *__private' cannot be used as the type of a kernel parameter}}
-kernel void trivial_r(__global Trivial &in) {} //expected-error{{'__global Trivial &__private' cannot be used as the type of a kernel parameter}}
+kernel void trivial_v(Trivial in) {}
+#ifndef UNSAFEKERNELPARAMETER
+//expected-error@-2{{'__private Trivial' cannot be used as the type of a kernel parameter}}
+#endif
+kernel void trivial_p(__global Trivial *in) {}
+#ifndef UNSAFEKERNELPARAMETER
+//expected-error@-2{{'__global Trivial *__private' cannot be used as the type of a kernel parameter}}
+#endif
+kernel void trivial_p_p(__global Trivial *__global *in) {}
+#ifndef UNSAFEKERNELPARAMETER
+//expected-error@-2{{'__global Trivial *__global *__private' cannot be used as the type of a kernel parameter}}
+#endif
+kernel void trivial_r(__global Trivial &in) {}
+#ifndef UNSAFEKERNELPARAMETER
+//expected-error@-2{{'__global Trivial &__private' cannot be used as the type of a kernel parameter}}
+#endif