[libclc] Separate out generic AS support macros (intel#13792)

The previous model where we declare/define builtins based on whether
target supports the generic address space was not able to capture the
full complexity of what we need.

We could see this in the fact that the two targets which we marked as
not supporting the generic AS do in fact support it. The problem is
rather that the target AS they map the generic AS to is the same target
AS mapped to by the private AS.

This problem hasn't properly been made apparent because all builtins we
want to support with the generic AS also have overloads on the private
AS. However, as can be seen in PRs like intel#13428, some targets want to
support generic AS overloads of atomic builtins which don't also have
private AS overloads. It's here that the simple dichotomy breaks down.

This patch splits up the support of the generic AS into:

1. The target doesn't support the generic AS
2. The target supports the generic AS as a distinct target AS
3. The target supports the generic AS mapped identically as the private
the AS

All of our previous uses of case 1 have been migrated to case 3. These
targets can make use of case 2 in the future to support generic AS
builtins where no private AS builtins are supported.

Note how we hardcode the assumption that the clash is on the private
address space. This is unfortunate but for simplicity as it's the case
for the two targets we care about. It was already being made, but in a
less obvious way. There are ways of loosening this assumption if we ever
needed to but it would currently complicate the code for untested
scenarios.

libclc/CMakeLists.txt

@@ -346,27 +346,32 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
 
     message( STATUS "  device: ${d} ( ${${d}_aliases} )" )
 
+    # Note: when declaring builtins, we must consider that even if a target
+    # formally/nominally supports the generic address space, in practice that
+    # target may map it to the same target address space as another address
+    # space (often the private one). In such cases we must be careful not to
+    # multiply-define a builtin in a single target address space, as it would
+    # result in a mangling clash.
+    # For this reason we must consider the target support of the generic
+    # address space separately from the *implementation* decision about whether
+    # to declare certain builtins in that address space.
     set ( supports_generic_addrspace TRUE )
+    # Note: we assume that if there is no distinct generic address space, it
+    # maps to the private address space.
+    set ( has_distinct_generic_addrspace TRUE )
     if ( ARCH STREQUAL spirv OR ARCH STREQUAL spirv64 )
       set( opt_flags -O3 )
       set( spvflags --spirv-max-version=1.1 )
     elseif( ARCH STREQUAL clspv OR ARCH STREQUAL clspv64 )
       set( opt_flags -O3 )
     elseif( ARCH STREQUAL nvptx OR ARCH STREQUAL nvptx64 )
       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 )
+      set( has_distinct_generic_addrspace FALSE )
     elseif( ARCH STREQUAL amdgcn )
       set( opt_flags -O3 --amdgpu-oclc-reflect-enable=false )
     elseif( ARCH STREQUAL x86_64)
       set( opt_flags )
-      set( supports_generic_addrspace FALSE )
+      set( has_distinct_generic_addrspace FALSE )
     else()
       set( opt_flags -O3 )
     endif()
@@ -379,16 +384,18 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
     file( MAKE_DIRECTORY ${LIBCLC_ARCH_OBJFILE_DIR} )
 
     # OpenCL 3.0 extensions
-    list( APPEND flags -cl-std=CL3.0 "-Xclang" )
     string(CONCAT CL_3_0_EXTENSIONS
       "-cl-ext="
       "+cl_khr_fp64,"
       "+cl_khr_fp16,"
       "+__opencl_c_3d_image_writes,"
       "+__opencl_c_images,"
       "+cl_khr_3d_image_writes")
-    if(supports_generic_addrspace)
+    if( supports_generic_addrspace )
       string( APPEND CL_3_0_EXTENSIONS ",+__opencl_c_generic_address_space" )
+      if( has_distinct_generic_addrspace )
+        list( APPEND flags -D__CLC_DISTINCT_GENERIC_ADDRSPACE__ )
+      endif()
     else()
       # Explictly disable opencl_c_generic_address_space (it may be enabled
       # by default on some targets). We also disable opencl_c_pipes and
@@ -397,7 +404,7 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} )
       string( APPEND CL_3_0_EXTENSIONS ",-__opencl_c_pipes" )
       string( APPEND CL_3_0_EXTENSIONS ",-__opencl_c_device_enqueue" )
     endif()
-    list( APPEND flags ${CL_3_0_EXTENSIONS})
+    list( APPEND flags -cl-std=CL3.0 "-Xclang" ${CL_3_0_EXTENSIONS} )
 
     # Add platform specific flags
     if(WIN32)

libclc/generic/include/clc/clc.h

@@ -18,8 +18,16 @@
     (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
      defined(__opencl_c_generic_address_space))
 #define _CLC_GENERIC_AS_SUPPORTED 1
+// Note that we hard-code the assumption that a non-distinct address space means
+// that the target maps the generic address space to the private address space.
+#ifdef __CLC_DISTINCT_GENERIC_ADDRSPACE__
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 1
+#else
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 0
+#endif
 #else
 #define _CLC_GENERIC_AS_SUPPORTED 0
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 0
 #endif
 
 /* Function Attributes */

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

@@ -23,6 +23,6 @@
 _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 _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE fract(__CLC_GENTYPE x, generic __CLC_GENTYPE *iptr);
 #endif

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

@@ -1,6 +1,6 @@
 _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 _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE frexp(__CLC_GENTYPE x, generic __CLC_INTN *iptr);
 #endif

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

@@ -23,6 +23,6 @@
 _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 _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE modf(__CLC_GENTYPE x, generic __CLC_GENTYPE *iptr);
 #endif

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

@@ -15,7 +15,7 @@
 #include <clc/math/gentype.inc>
 #undef __CLC_ADDRESS_SPACE
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define __CLC_BODY <clc/math/remquo.inc>
 #define __CLC_ADDRESS_SPACE generic
 #include <clc/math/gentype.inc>

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

@@ -1,6 +1,6 @@
  _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 _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
  _CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE sincos (__CLC_GENTYPE x, generic __CLC_GENTYPE * cosval);
 #endif

libclc/generic/include/clc/shared/vload.h

@@ -9,7 +9,7 @@
   _CLC_VLOAD_DECL(SUFFIX, MEM_TYPE, PRIM_TYPE##8, 8, ADDR_SPACE)               \
   _CLC_VLOAD_DECL(SUFFIX, MEM_TYPE, PRIM_TYPE##16, 16, ADDR_SPACE)
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define _CLC_VECTOR_VLOAD_GENERIC_DECL _CLC_VECTOR_VLOAD_DECL
 #else
 // The generic address space isn't available, so make the macro do nothing
@@ -61,7 +61,7 @@ _CLC_VLOAD_DECL(a_half, half, float, , __global)
 _CLC_VLOAD_DECL(a_half, half, float, , __local)
 _CLC_VLOAD_DECL(a_half, half, float, , __private)
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_VLOAD_DECL(_half, half, float, , __generic)
 _CLC_VLOAD_DECL(a_half, half, float, , __generic)
 #endif

libclc/generic/include/clc/shared/vstore.h

@@ -9,7 +9,7 @@
   _CLC_VSTORE_DECL(SUFFIX, MEM_TYPE, PRIM_TYPE##8, 8, ADDR_SPACE, RND)         \
   _CLC_VSTORE_DECL(SUFFIX, MEM_TYPE, PRIM_TYPE##16, 16, ADDR_SPACE, RND)
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define _CLC_VSTORE_GENERIC_DECL _CLC_VSTORE_DECL
 #define _CLC_VECTOR_VSTORE_GENERIC_DECL _CLC_VECTOR_VSTORE_DECL
 #else

libclc/generic/include/spirv/spirv.h

@@ -24,8 +24,16 @@
     (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 &&                                 \
      defined(__opencl_c_generic_address_space))
 #define _CLC_GENERIC_AS_SUPPORTED 1
+// Note that we hard-code the assumption that a non-distinct address space means
+// that the target maps the generic address space to the private address space.
+#if __CLC_DISTINCT_GENERIC_ADDRSPACE__
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 1
+#else
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 0
+#endif
 #else
 #define _CLC_GENERIC_AS_SUPPORTED 0
+#define _CLC_DISTINCT_GENERIC_AS_SUPPORTED 0
 #endif
 
 /* Function Attributes */

libclc/generic/include/spirv/spirv_builtins.h

@@ -14476,7 +14476,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t
 __spirv_ocl_fract(__clc_vec16_fp16_t, __clc_vec16_fp16_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t
 __spirv_ocl_fract(__clc_fp32_t, __clc_fp32_t __generic *);
 
@@ -14637,7 +14637,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t
 __spirv_ocl_frexp(__clc_vec16_fp16_t, __clc_vec16_int32_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t
 __spirv_ocl_frexp(__clc_fp32_t, __clc_int32_t __generic *);
 _CLC_OVERLOAD _CLC_DECL __clc_vec2_fp32_t
@@ -15218,7 +15218,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t
 __spirv_ocl_lgamma_r(__clc_vec16_fp16_t, __clc_vec16_int32_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t
 __spirv_ocl_lgamma_r(__clc_fp32_t, __clc_int32_t __generic *);
 _CLC_OVERLOAD _CLC_DECL __clc_vec2_fp32_t
@@ -15767,7 +15767,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t
 __spirv_ocl_modf(__clc_vec16_fp16_t, __clc_vec16_fp16_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t __spirv_ocl_modf(__clc_fp32_t,
                                                       __clc_fp32_t __generic *);
 _CLC_OVERLOAD _CLC_DECL __clc_vec2_fp32_t
@@ -16752,7 +16752,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t __spirv_ocl_remquo(
     __clc_vec16_fp16_t, __clc_vec16_fp16_t, __clc_vec16_int32_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t
 __spirv_ocl_remquo(__clc_fp32_t, __clc_fp32_t, __clc_int32_t __generic *);
 _CLC_OVERLOAD _CLC_DECL __clc_vec2_fp32_t __spirv_ocl_remquo(
@@ -19016,7 +19016,7 @@ _CLC_OVERLOAD _CLC_DECL __clc_vec16_fp16_t
 __spirv_ocl_sincos(__clc_vec16_fp16_t, __clc_vec16_fp16_t __global *);
 #endif
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 _CLC_OVERLOAD _CLC_DECL __clc_fp32_t
 __spirv_ocl_sincos(__clc_fp32_t, __clc_fp32_t __generic *);
 _CLC_OVERLOAD _CLC_DECL __clc_vec2_fp32_t

libclc/generic/lib/math/fract.inc

@@ -39,7 +39,7 @@
 FRACT_DEF(private);
 FRACT_DEF(local);
 FRACT_DEF(global);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 FRACT_DEF(generic);
 #endif
 

libclc/generic/lib/math/frexp.cl

@@ -16,7 +16,7 @@
 #include <clc/math/gentype.inc>
 #undef __CLC_ADDRESS_SPACE
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define __CLC_BODY <frexp.inc>
 #define __CLC_ADDRESS_SPACE generic
 #include <clc/math/gentype.inc>

libclc/generic/lib/math/modf.inc

@@ -43,7 +43,7 @@ _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE modf(__CLC_GENTYPE x, private __CLC_GENTYPE
 
 MODF_DEF(local);
 MODF_DEF(global);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 MODF_DEF(generic);
 #endif
 

libclc/generic/lib/math/remquo.cl

@@ -16,7 +16,7 @@
 #include <clc/math/gentype.inc>
 #undef __CLC_ADDRESS_SPACE
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define __CLC_BODY <remquo.inc>
 #define __CLC_ADDRESS_SPACE generic
 #include <clc/math/gentype.inc>

libclc/generic/lib/math/sincos.inc

@@ -8,7 +8,7 @@
 __CLC_DECLARE_SINCOS(global, __CLC_GENTYPE)
 __CLC_DECLARE_SINCOS(local, __CLC_GENTYPE)
 __CLC_DECLARE_SINCOS(private, __CLC_GENTYPE)
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 __CLC_DECLARE_SINCOS(generic, __CLC_GENTYPE)
 #endif
 

libclc/generic/lib/shared/vload.cl

@@ -27,7 +27,7 @@
     return *((const ADDR_SPACE less_aligned_##ADDR_SPACE##PRIM_TYPE##16*) (&x[16*offset])); \
   }
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define VLOAD_VECTORIZE_GENERIC VLOAD_VECTORIZE
 #else
 // The generic address space isn't available, so make the macro do nothing
@@ -70,7 +70,7 @@ float __clc_vload_half_float_helper__constant(const __constant half *);
 float __clc_vload_half_float_helper__global(const __global half *);
 float __clc_vload_half_float_helper__local(const __local half *);
 float __clc_vload_half_float_helper__private(const __private half *);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 float __clc_vload_half_float_helper__generic(const __generic half *);
 #endif
 

libclc/generic/lib/shared/vload_half.inc

@@ -12,7 +12,7 @@
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __local);
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __global);
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __constant);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __generic);
 #endif
 
@@ -22,7 +22,7 @@
   FUNC(, 1, 1, __CLC_GENTYPE, __local);
   FUNC(, 1, 1, __CLC_GENTYPE, __global);
   FUNC(, 1, 1, __CLC_GENTYPE, __constant);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
   FUNC(, 1, 1, __CLC_GENTYPE, __generic);
 #endif
 #endif

libclc/generic/lib/shared/vstore.cl

@@ -28,7 +28,7 @@
     *((ADDR_SPACE less_aligned_##ADDR_SPACE##PRIM_TYPE##16*) (&mem[16*offset])) = vec; \
   }
 
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 #define VSTORE_VECTORIZE_GENERIC VSTORE_VECTORIZE
 #else
 // The generic address space isn't available, so make the macro do nothing
@@ -75,15 +75,15 @@ _CLC_DEF void __clc_vstore_half_##STYPE##_helper##AS(STYPE s, AS half *d) \
 DECLARE_HELPER(float, __private, __builtin_store_halff);
 DECLARE_HELPER(float, __global, __builtin_store_halff);
 DECLARE_HELPER(float, __local, __builtin_store_halff);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 DECLARE_HELPER(float, __generic, __builtin_store_halff);
 #endif
 
 #ifdef cl_khr_fp64
 DECLARE_HELPER(double, __private, __builtin_store_half);
 DECLARE_HELPER(double, __global, __builtin_store_half);
 DECLARE_HELPER(double, __local, __builtin_store_half);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
 DECLARE_HELPER(double, __generic, __builtin_store_half);
 #endif
 #endif

libclc/generic/lib/shared/vstore_half.inc

@@ -11,7 +11,7 @@
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __private);
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __local);
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __global);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
   FUNC(__CLC_VECSIZE, __CLC_VECSIZE, __CLC_OFFSET, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __generic);
 #endif
 
@@ -20,7 +20,7 @@
   FUNC(, 1, 1, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __private);
   FUNC(, 1, 1, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __local);
   FUNC(, 1, 1, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __global);
-#if _CLC_GENERIC_AS_SUPPORTED
+#if _CLC_DISTINCT_GENERIC_AS_SUPPORTED
   FUNC(, 1, 1, __CLC_GENTYPE, __CLC_SCALAR_GENTYPE, __generic);
 #endif
 #endif