[C++4OpenCL] Introduces __remove_address_space utility

[Topotuna]

Summary

This change provides a way to conveniently declare types that have
address space qualifiers removed.

Since OpenCL adds address spaces implicitly even when they are not
specified in source, it is useful to allow deriving address space
unqualified types.

Fixes llvm.org/PR45326

[Topotuna]

Change to LanguageExtensions.rst assumes there is a section about the utility on official C++ for OpenCL documentation. However, it is not yet documented

[Anastasia]

clang/docs/LanguageExtensions.rst

1970

I think we should migrate this description into here for now and make this a clang-only feature in C++ for OpenCL v1.0. Mainly because new functionality changes can only be added with the version increase. Otherwise, developers would have to know which clang supports it and which doesn't.

But I suggest keeping your draft PR https://github.com/KhronosGroup/OpenCL-Docs/pull/647 open so we don't forget to add it into the next language version doc.

[Anastasia]

I would like @svenvh to take a look from the clang header's design point.

[Topotuna]

Reference to C++ for OpenCL 1.0 specification removed. More elaborate code example added.

[svenvh]

In D106785#2904619, @Anastasia wrote:

I would like @svenvh to take a look from the clang header's design point.

Looks okay to me.

clang/docs/LanguageExtensions.rst

1980

clang/test/CodeGenOpenCLCXX/remove-address-space.clcpp

15

It's maybe worth testing is_same with static_assert(!is_same<float, int>::value); too, or at least testing some negative case.

A case without any address space qualifiers is currently missing (i.e., for the first trait).

[Topotuna]

Additional tests added for is_same

[Anastasia]

clang/docs/LanguageExtensions.rst

1964

Maybe we could title it something like:

Address space removal utility
or
Address space removal trait
?

1968

[Anastasia]

clang/docs/LanguageExtensions.rst

1964

Although we could also be more specific and name it
Remove address space builtin function?

[Topotuna]

Documentation rewording

clang/docs/LanguageExtensions.rst

1964

Builtin address space removal utility?

I would prefer not to leave wording "Remove address space" in description because it is already what utility name says and so it adds no extra information.

1968

I would rather use word "affects" instead of "removes" here. There is already excessive amount of "remove" in this paragraph

[Topotuna]

Test case added that checks if __remove_address_space modifies types without address space

[Anastasia]

The patch looks good but I would like to check with @rjmccall whether it would make sense to add this functionality generically for C/C++ too just like __remove_const and other builtins proposed in https://reviews.llvm.org/D67052?

[Anastasia]

clang/docs/LanguageExtensions.rst

1964

Well the section name is to identify the content and not to provide extra information so the closer you are to the actual content the better. I find Remove address space builtin function much more specific to the content to be honest.

[Topotuna]

Documentation section title reworded

[Anastasia]

LGTM! Thanks

clang/docs/LanguageExtensions.rst

kernel void kernel_main(
     Pod a,
   #pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_param_types : enable
     OnlySL b,
     global NotSL *c,
   #pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_param_types : disable
     global OnlySL *d,
   );
 
+Remove address space builtin function
+-------------------------------------
+
+``__remove_address_space`` allows to derive types in C++ for OpenCL
+that have address space qualifiers removed. This utility only affects
+address space qualifiers, therefore, other type qualifiers such as
+``const`` or ``volatile`` remain unchanged.
+
+**Example of Use**:
+
+.. code-block:: c++
+
+  template<typename T>
+  void foo(T *par){
+    T var1; // error - local function variable with global address space
+    __private T var2; // error - conflicting address space qualifiers
+    __private __remove_address_space<T> var3; // var3 is __private int
+  }
+
+  void bar(){
+    __global int* ptr;
+    foo(ptr);
+  }
+
 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/lib/Headers/opencl-c-base.h

 #define as_half16(x) __builtin_astype((x), half16)
 #endif // cl_khr_fp16
 
 #define as_size_t(x) __builtin_astype((x), size_t)
 #define as_ptrdiff_t(x) __builtin_astype((x), ptrdiff_t)
 #define as_intptr_t(x) __builtin_astype((x), intptr_t)
 #define as_uintptr_t(x) __builtin_astype((x), uintptr_t)
 
+// C++ for OpenCL - __remove_address_space
+#if defined(__OPENCL_CPP_VERSION__)
+template <typename _Tp> struct __remove_address_space { using type = _Tp; };
+template <typename _Tp> struct __remove_address_space<__generic _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__global _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__private _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__local _Tp> {
+  using type = _Tp;
+};
+template <typename _Tp> struct __remove_address_space<__constant _Tp> {
+  using type = _Tp;
+};
+#endif
+
 // OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers
 
 #define __kernel_exec(X, typen) __kernel \
   __attribute__((work_group_size_hint(X, 1, 1))) \
   __attribute__((vec_type_hint(typen)))
 
 #define kernel_exec(X, typen) __kernel \
   __attribute__((work_group_size_hint(X, 1, 1))) \

clang/test/CodeGenOpenCLCXX/remove-address-space.clcpp

+// RUN: %clang_cc1 %s -cl-std=clc++ -fdeclare-opencl-builtins -finclude-default-header
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+void test_is_same() {
+  static_assert(is_same<int, int>::value);
+  static_assert(!is_same<int, float>::value);
+  static_assert(!is_same<__private int, int>::value);
+}
+
+void test_remove_address_space() {
+  static_assert(is_same<__remove_address_space<int>::type, int>::value,
+                "type without an address space unexpectedly modified by __remove_address_space");
+  static_assert(is_same<__remove_address_space<__generic int>::type, int>::value,
+                "__generic address space not removed by __remove_address_space");
+  static_assert(is_same<__remove_address_space<__global char>::type, char>::value,
+                "__global address space not removed by __remove_address_space");
+  static_assert(is_same<__remove_address_space<__private ulong>::type, ulong>::value,
+                "__private address space not removed by __remove_address_space");
+  static_assert(is_same<__remove_address_space<__local short>::type, short>::value,
+                "__local address space not removed by __remove_address_space");
+  static_assert(is_same<__remove_address_space<__constant int3>::type, int3>::value,
+                "__constant address space not removed by __remove_address_space");
+  static_assert(is_same<__remove_address_space<const volatile __global int>::type, const volatile int>::value,
+                "non-address-space qualifiers inappropriately removed by __remove_address_space");
+}