[SYCL][libclc] Add generic addrspace overloads of math builtins (#13015)

The generic implementations of the math builtins which take pointer
arguments were using unqualified address spaces. This could either
resolve to the generic address space or the private address space,
depending on whether the target supports the generic address space or
not.

The newer unified OpenCL C specification is clearer in mandating that
all targets must provide overloads on the explicitly qualified 'private'
address space, as well as optionally defining ones on the (unqualified)
generic address space. This meant that most of these math builtins were
lacking one overload: either the private or generic one, depending on
which target was compiling the builtins.

One notable exception here is NVIDIA, which maps the private and generic
address spaces to the same target address space. Thus declaring builtins
overloaded on these two address spaces results in a mangling clash,
which we can't have. Therefore we now say that NVIDIA targets don't
support the generic address space for the purposes of these builtins. In
reality, the builtins with the private address space are functionally
equivalent to the generic ones, so users won't notice.

For the sake of code clarity, although the 'generic' keyword is
technically reserved, we know that clang defines it to be the
corresponding unqualified generic address space, so we use that to be
explicit. We always compile with clang so it shouldn't be a problem with
portability.

With this we can also enable a LIT test for HIP, which was previously
failing as it couldn't find the generic address space overloads of the
fract and lgamma_r builtins.

There are other builtins that this treatment (may) need applied to, such
as the vload and vstore variants. Those will be handled in a subsequent
patch.

Author: frasercrmck

libclc/CMakeLists.txt

@@ -400,6 +400,7 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
     endif()
     message( "    DEVICE: ${d} ( ${${d}_aliases} )" )
 
+    set ( supports_generic_addrspace TRUE )
     if ( ${ARCH} STREQUAL "spirv" OR ${ARCH} STREQUAL "spirv64" )
       if( ${ARCH} STREQUAL "spirv" )
         set( t "spir--" )
@@ -416,6 +417,14 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
     elseif( ${ARCH} STREQUAL "nvptx" OR ${ARCH} STREQUAL "nvptx64" )
       set( build_flags )
       set( opt_flags -O3 "--nvvm-reflect-enable=false" )
+      # Note: when declaring builtins, we don't consider NVIDIA as supporting
+      # the generic address space. This is because it maps to the same target
+      # address space as the private address space, resulting in a mangling
+      # clash.
+      # Since we can't declare builtins overloaded on both address spaces
+      # simultaneously, we choose declare the builtins using the private space,
+      # which will also work for the generic address space.
+      set( supports_generic_addrspace FALSE )
     elseif( ${ARCH} STREQUAL "clspv64" )
       set( t "spir64--" )
       set( build_flags "-Wno-unknown-assumption")
@@ -437,8 +446,10 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
       "+cl_khr_fp16,"
       "+__opencl_c_3d_image_writes,"
       "+__opencl_c_images,"
-      "+cl_khr_3d_image_writes,"
-      "+__opencl_c_generic_address_space")
+      "+cl_khr_3d_image_writes")
+    if(supports_generic_addrspace)
+      string( APPEND CL_3_0_EXTENSIONS ",+__opencl_c_generic_address_space" )
+    endif()
     list( APPEND flags ${CL_3_0_EXTENSIONS})
 
     # Add platform specific flags

libclc/generic/include/clc/math/fract.inc

@@ -23,3 +23,8 @@
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE fract(__CLC_GENTYPE x, global __CLC_GENTYPE *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE fract(__CLC_GENTYPE x, local __CLC_GENTYPE *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE fract(__CLC_GENTYPE x, private __CLC_GENTYPE *iptr);
+#if __OPENCL_C_VERSION__ == CL_VERSION_2_0 ||                                  \
+    (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
+     defined(__opencl_c_generic_address_space))
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE fract(__CLC_GENTYPE x, generic __CLC_GENTYPE *iptr);
+#endif

libclc/generic/include/clc/math/frexp.inc

@@ -1,3 +1,8 @@
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE frexp(__CLC_GENTYPE x, global __CLC_INTN *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE frexp(__CLC_GENTYPE x, local __CLC_INTN *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE frexp(__CLC_GENTYPE x, private __CLC_INTN *iptr);
+#if __OPENCL_C_VERSION__ == CL_VERSION_2_0 ||                                  \
+    (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
+     defined(__opencl_c_generic_address_space))
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE frexp(__CLC_GENTYPE x, generic __CLC_INTN *iptr);
+#endif

libclc/generic/include/clc/math/modf.inc

@@ -23,3 +23,8 @@
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE modf(__CLC_GENTYPE x, global __CLC_GENTYPE *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE modf(__CLC_GENTYPE x, local __CLC_GENTYPE *iptr);
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE modf(__CLC_GENTYPE x, private __CLC_GENTYPE *iptr);
+#if __OPENCL_C_VERSION__ == CL_VERSION_2_0 ||                                  \
+    (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
+     defined(__opencl_c_generic_address_space))
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE modf(__CLC_GENTYPE x, generic __CLC_GENTYPE *iptr);
+#endif

libclc/generic/include/clc/math/remquo.h

@@ -15,4 +15,13 @@
 #include <clc/math/gentype.inc>
 #undef __CLC_ADDRESS_SPACE
 
+#if __OPENCL_C_VERSION__ == CL_VERSION_2_0 ||                                  \
+    (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
+     defined(__opencl_c_generic_address_space))
+#define __CLC_BODY <clc/math/remquo.inc>
+#define __CLC_ADDRESS_SPACE generic
+#include <clc/math/gentype.inc>
+#undef __CLC_ADDRESS_SPACE
+#endif
+
 #undef __CLC_FUNCTION

libclc/generic/include/clc/math/sincos.inc

@@ -1,3 +1,8 @@
  _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE sincos (__CLC_GENTYPE x, global __CLC_GENTYPE * cosval);
  _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE sincos (__CLC_GENTYPE x, local __CLC_GENTYPE * cosval);
  _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE sincos (__CLC_GENTYPE x, private __CLC_GENTYPE * cosval);
+#if __OPENCL_C_VERSION__ == CL_VERSION_2_0 ||                                  \
+    (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
+     defined(__opencl_c_generic_address_space))
+ _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE sincos (__CLC_GENTYPE x, generic __CLC_GENTYPE * cosval);
+#endif