[OpenCL] opencl-c.h: refactor named addrspace builtins

[svenvh]

Summary

The named address space overloads of builtins that take a pointer
argument are conditionalized on the __opencl_c_generic_address_space
feature macro (in a #else body). Introduce an internal feature
macro instead, such that their availability can be controlled in a
single place and independently of the generic address space feature
macro.

This commit does not change the available builtins.

[Anastasia]

LGTM, aside from the name that can be fixed on a final commit!

clang/lib/Headers/opencl-c-base.h

78

I think for consistency it's better to spell addrsp -> address_space as we don't gain much space anyway...

Or maybe we could use __opencl_c_builtins_with_named_address_spaces?

clang/lib/Headers/opencl-c-base.h

 #if (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
 // For the SPIR and SPIR-V target all features are supported.
 #if defined(__SPIR__) || defined(__SPIRV__)
 #define __opencl_c_atomic_scope_all_devices 1
 #define __opencl_c_read_write_images 1
 #endif // defined(__SPIR__)
 #endif // (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300)
 
+#if !defined(__opencl_c_generic_address_space)
+// Internal feature macro to provide named (global, local, private) address
+// space overloads for builtin functions that take a pointer argument.
+#define __opencl_c_named_address_space_builtins 1
+#endif // !defined(__opencl_c_generic_address_space)
+
 // built-in scalar data types:
 
 /**
  * An unsigned 8-bit integer.
  */
 typedef unsigned char uchar;
 
 /**

clang/lib/Headers/opencl-c.h

 #ifdef cl_khr_fp16
 half __ovld fract(half x, half *iptr);
 half2 __ovld fract(half2 x, half2 *iptr);
 half3 __ovld fract(half3 x, half3 *iptr);
 half4 __ovld fract(half4 x, half4 *iptr);
 half8 __ovld fract(half8 x, half8 *iptr);
 half16 __ovld fract(half16 x, half16 *iptr);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld fract(float x, __global float *iptr);
 float2 __ovld fract(float2 x, __global float2 *iptr);
 float3 __ovld fract(float3 x, __global float3 *iptr);
 float4 __ovld fract(float4 x, __global float4 *iptr);
 float8 __ovld fract(float8 x, __global float8 *iptr);
 float16 __ovld fract(float16 x, __global float16 *iptr);
 float __ovld fract(float x, __local float *iptr);
 float2 __ovld fract(float2 x, __local float2 *iptr);

 half16 __ovld fract(half16 x, __local half16 *iptr);
 half __ovld fract(half x, __private half *iptr);
 half2 __ovld fract(half2 x, __private half2 *iptr);
 half3 __ovld fract(half3 x, __private half3 *iptr);
 half4 __ovld fract(half4 x, __private half4 *iptr);
 half8 __ovld fract(half8 x, __private half8 *iptr);
 half16 __ovld fract(half16 x, __private half16 *iptr);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Extract mantissa and exponent from x. For each
  * component the mantissa returned is a float with
  * magnitude in the interval [1/2, 1) or 0. Each
  * component of x equals mantissa returned * 2^exp.
  */
 #if defined(__opencl_c_generic_address_space)

 #ifdef cl_khr_fp16
 half __ovld frexp(half x, int *exp);
 half2 __ovld frexp(half2 x, int2 *exp);
 half3 __ovld frexp(half3 x, int3 *exp);
 half4 __ovld frexp(half4 x, int4 *exp);
 half8 __ovld frexp(half8 x, int8 *exp);
 half16 __ovld frexp(half16 x, int16 *exp);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld frexp(float x, __global int *exp);
 float2 __ovld frexp(float2 x, __global int2 *exp);
 float3 __ovld frexp(float3 x, __global int3 *exp);
 float4 __ovld frexp(float4 x, __global int4 *exp);
 float8 __ovld frexp(float8 x, __global int8 *exp);
 float16 __ovld frexp(float16 x, __global int16 *exp);
 float __ovld frexp(float x, __local int *exp);
 float2 __ovld frexp(float2 x, __local int2 *exp);

 half16 __ovld frexp(half16 x, __local int16 *exp);
 half __ovld frexp(half x, __private int *exp);
 half2 __ovld frexp(half2 x, __private int2 *exp);
 half3 __ovld frexp(half3 x, __private int3 *exp);
 half4 __ovld frexp(half4 x, __private int4 *exp);
 half8 __ovld frexp(half8 x, __private int8 *exp);
 half16 __ovld frexp(half16 x, __private int16 *exp);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Compute the value of the square root of x^2 + y^2
  * without undue overflow or underflow.
  */
 float __ovld __cnfn hypot(float x, float y);
 float2 __ovld __cnfn hypot(float2 x, float2 y);
 float3 __ovld __cnfn hypot(float3 x, float3 y);

 #ifdef cl_khr_fp16
 half __ovld lgamma_r(half x, int *signp);
 half2 __ovld lgamma_r(half2 x, int2 *signp);
 half3 __ovld lgamma_r(half3 x, int3 *signp);
 half4 __ovld lgamma_r(half4 x, int4 *signp);
 half8 __ovld lgamma_r(half8 x, int8 *signp);
 half16 __ovld lgamma_r(half16 x, int16 *signp);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld lgamma_r(float x, __global int *signp);
 float2 __ovld lgamma_r(float2 x, __global int2 *signp);
 float3 __ovld lgamma_r(float3 x, __global int3 *signp);
 float4 __ovld lgamma_r(float4 x, __global int4 *signp);
 float8 __ovld lgamma_r(float8 x, __global int8 *signp);
 float16 __ovld lgamma_r(float16 x, __global int16 *signp);
 float __ovld lgamma_r(float x, __local int *signp);
 float2 __ovld lgamma_r(float2 x, __local int2 *signp);

 half16 __ovld lgamma_r(half16 x, __local int16 *signp);
 half __ovld lgamma_r(half x, __private int *signp);
 half2 __ovld lgamma_r(half2 x, __private int2 *signp);
 half3 __ovld lgamma_r(half3 x, __private int3 *signp);
 half4 __ovld lgamma_r(half4 x, __private int4 *signp);
 half8 __ovld lgamma_r(half8 x, __private int8 *signp);
 half16 __ovld lgamma_r(half16 x, __private int16 *signp);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Compute natural logarithm.
  */
 float __ovld __cnfn log(float);
 float2 __ovld __cnfn log(float2);
 float3 __ovld __cnfn log(float3);
 float4 __ovld __cnfn log(float4);

 #ifdef cl_khr_fp16
 half __ovld modf(half x, half *iptr);
 half2 __ovld modf(half2 x, half2 *iptr);
 half3 __ovld modf(half3 x, half3 *iptr);
 half4 __ovld modf(half4 x, half4 *iptr);
 half8 __ovld modf(half8 x, half8 *iptr);
 half16 __ovld modf(half16 x, half16 *iptr);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld modf(float x, __global float *iptr);
 float2 __ovld modf(float2 x, __global float2 *iptr);
 float3 __ovld modf(float3 x, __global float3 *iptr);
 float4 __ovld modf(float4 x, __global float4 *iptr);
 float8 __ovld modf(float8 x, __global float8 *iptr);
 float16 __ovld modf(float16 x, __global float16 *iptr);
 float __ovld modf(float x, __local float *iptr);
 float2 __ovld modf(float2 x, __local float2 *iptr);

 half16 __ovld modf(half16 x, __local half16 *iptr);
 half __ovld modf(half x, __private half *iptr);
 half2 __ovld modf(half2 x, __private half2 *iptr);
 half3 __ovld modf(half3 x, __private half3 *iptr);
 half4 __ovld modf(half4 x, __private half4 *iptr);
 half8 __ovld modf(half8 x, __private half8 *iptr);
 half16 __ovld modf(half16 x, __private half16 *iptr);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Returns a quiet NaN. The nancode may be placed
  * in the significand of the resulting NaN.
  */
 float __ovld __cnfn nan(uint nancode);
 float2 __ovld __cnfn nan(uint2 nancode);
 float3 __ovld __cnfn nan(uint3 nancode);

 #endif //cl_khr_fp64
 #ifdef cl_khr_fp16
 half __ovld remquo(half x, half y, int *quo);
 half2 __ovld remquo(half2 x, half2 y, int2 *quo);
 half3 __ovld remquo(half3 x, half3 y, int3 *quo);
 half4 __ovld remquo(half4 x, half4 y, int4 *quo);
 half8 __ovld remquo(half8 x, half8 y, int8 *quo);
 half16 __ovld remquo(half16 x, half16 y, int16 *quo);
-
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld remquo(float x, float y, __global int *quo);
 float2 __ovld remquo(float2 x, float2 y, __global int2 *quo);
 float3 __ovld remquo(float3 x, float3 y, __global int3 *quo);
 float4 __ovld remquo(float4 x, float4 y, __global int4 *quo);
 float8 __ovld remquo(float8 x, float8 y, __global int8 *quo);
 float16 __ovld remquo(float16 x, float16 y, __global int16 *quo);
 float __ovld remquo(float x, float y, __local int *quo);
 float2 __ovld remquo(float2 x, float2 y, __local int2 *quo);

 half16 __ovld remquo(half16 x, half16 y, __local int16 *quo);
 half __ovld remquo(half x, half y, __private int *quo);
 half2 __ovld remquo(half2 x, half2 y, __private int2 *quo);
 half3 __ovld remquo(half3 x, half3 y, __private int3 *quo);
 half4 __ovld remquo(half4 x, half4 y, __private int4 *quo);
 half8 __ovld remquo(half8 x, half8 y, __private int8 *quo);
 half16 __ovld remquo(half16 x, half16 y, __private int16 *quo);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 /**
  * Round to integral value (using round to nearest
  * even rounding mode) in floating-point format.
  * Refer to section 7.1 for description of rounding
  * modes.
  */
 float __ovld __cnfn rint(float);
 float2 __ovld __cnfn rint(float2);

 #ifdef cl_khr_fp16
 half __ovld sincos(half x, half *cosval);
 half2 __ovld sincos(half2 x, half2 *cosval);
 half3 __ovld sincos(half3 x, half3 *cosval);
 half4 __ovld sincos(half4 x, half4 *cosval);
 half8 __ovld sincos(half8 x, half8 *cosval);
 half16 __ovld sincos(half16 x, half16 *cosval);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld sincos(float x, __global float *cosval);
 float2 __ovld sincos(float2 x, __global float2 *cosval);
 float3 __ovld sincos(float3 x, __global float3 *cosval);
 float4 __ovld sincos(float4 x, __global float4 *cosval);
 float8 __ovld sincos(float8 x, __global float8 *cosval);
 float16 __ovld sincos(float16 x, __global float16 *cosval);
 float __ovld sincos(float x, __local float *cosval);
 float2 __ovld sincos(float2 x, __local float2 *cosval);

 half16 __ovld sincos(half16 x, __local half16 *cosval);
 half __ovld sincos(half x, __private half *cosval);
 half2 __ovld sincos(half2 x, __private half2 *cosval);
 half3 __ovld sincos(half3 x, __private half3 *cosval);
 half4 __ovld sincos(half4 x, __private half4 *cosval);
 half8 __ovld sincos(half8 x, __private half8 *cosval);
 half16 __ovld sincos(half16 x, __private half16 *cosval);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Compute hyperbolic sine.
  */
 float __ovld __cnfn sinh(float);
 float2 __ovld __cnfn sinh(float2);
 float3 __ovld __cnfn sinh(float3);
 float4 __ovld __cnfn sinh(float4);

 #ifdef cl_khr_fp16
 half __ovld __purefn vload(size_t offset, const half *p);
 half2 __ovld __purefn vload2(size_t offset, const half *p);
 half3 __ovld __purefn vload3(size_t offset, const half *p);
 half4 __ovld __purefn vload4(size_t offset, const half *p);
 half8 __ovld __purefn vload8(size_t offset, const half *p);
 half16 __ovld __purefn vload16(size_t offset, const half *p);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 char2 __ovld __purefn vload2(size_t offset, const __global char *p);
 uchar2 __ovld __purefn vload2(size_t offset, const __global uchar *p);
 short2 __ovld __purefn vload2(size_t offset, const __global short *p);
 ushort2 __ovld __purefn vload2(size_t offset, const __global ushort *p);
 int2 __ovld __purefn vload2(size_t offset, const __global int *p);
 uint2 __ovld __purefn vload2(size_t offset, const __global uint *p);
 long2 __ovld __purefn vload2(size_t offset, const __global long *p);
 ulong2 __ovld __purefn vload2(size_t offset, const __global ulong *p);

 half16 __ovld __purefn vload16(size_t offset, const __local half *p);
 half __ovld __purefn vload(size_t offset, const __private half *p);
 half2 __ovld __purefn vload2(size_t offset, const __private half *p);
 half3 __ovld __purefn vload3(size_t offset, const __private half *p);
 half4 __ovld __purefn vload4(size_t offset, const __private half *p);
 half8 __ovld __purefn vload8(size_t offset, const __private half *p);
 half16 __ovld __purefn vload16(size_t offset, const __private half *p);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 #if defined(__opencl_c_generic_address_space)
 void __ovld vstore2(char2 data, size_t offset, char *p);
 void __ovld vstore2(uchar2 data, size_t offset, uchar *p);
 void __ovld vstore2(short2 data, size_t offset, short *p);
 void __ovld vstore2(ushort2 data, size_t offset, ushort *p);
 void __ovld vstore2(int2 data, size_t offset, int *p);
 void __ovld vstore2(uint2 data, size_t offset, uint *p);

 #ifdef cl_khr_fp16
 void __ovld vstore(half data, size_t offset, half *p);
 void __ovld vstore2(half2 data, size_t offset, half *p);
 void __ovld vstore3(half3 data, size_t offset, half *p);
 void __ovld vstore4(half4 data, size_t offset, half *p);
 void __ovld vstore8(half8 data, size_t offset, half *p);
 void __ovld vstore16(half16 data, size_t offset, half *p);
 #endif //cl_khr_fp16
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 void __ovld vstore2(char2 data, size_t offset, __global char *p);
 void __ovld vstore2(uchar2 data, size_t offset, __global uchar *p);
 void __ovld vstore2(short2 data, size_t offset, __global short *p);
 void __ovld vstore2(ushort2 data, size_t offset, __global ushort *p);
 void __ovld vstore2(int2 data, size_t offset, __global int *p);
 void __ovld vstore2(uint2 data, size_t offset, __global uint *p);
 void __ovld vstore2(long2 data, size_t offset, __global long *p);
 void __ovld vstore2(ulong2 data, size_t offset, __global ulong *p);

 void __ovld vstore16(half16 data, size_t offset, __local half *p);
 void __ovld vstore(half data, size_t offset, __private half *p);
 void __ovld vstore2(half2 data, size_t offset, __private half *p);
 void __ovld vstore3(half3 data, size_t offset, __private half *p);
 void __ovld vstore4(half4 data, size_t offset, __private half *p);
 void __ovld vstore8(half8 data, size_t offset, __private half *p);
 void __ovld vstore16(half16 data, size_t offset, __private half *p);
 #endif //cl_khr_fp16
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Read sizeof (half) bytes of data from address
  * (p + offset). The data read is interpreted as a
  * half value. The half value is converted to a
  * float value and the float value is returned.
  * The read address computed as (p + offset)
  * must be 16-bit aligned.
  */
 float __ovld __purefn vload_half(size_t offset, const __constant half *p);
 #if defined(__opencl_c_generic_address_space)
 float __ovld __purefn vload_half(size_t offset, const half *p);
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float __ovld __purefn vload_half(size_t offset, const __global half *p);
 float __ovld __purefn vload_half(size_t offset, const __local half *p);
 float __ovld __purefn vload_half(size_t offset, const __private half *p);
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * Read sizeof (halfn) bytes of data from address
  * (p + (offset * n)). The data read is interpreted
  * as a halfn value. The halfn value read is
  * converted to a floatn value and the floatn
  * value is returned. The read address computed
  * as (p + (offset * n)) must be 16-bit aligned.
  */
 float2 __ovld __purefn vload_half2(size_t offset, const __constant half *p);
 float3 __ovld __purefn vload_half3(size_t offset, const __constant half *p);
 float4 __ovld __purefn vload_half4(size_t offset, const __constant half *p);
 float8 __ovld __purefn vload_half8(size_t offset, const __constant half *p);
 float16 __ovld __purefn vload_half16(size_t offset, const __constant half *p);
 #if defined(__opencl_c_generic_address_space)
 float2 __ovld __purefn vload_half2(size_t offset, const half *p);
 float3 __ovld __purefn vload_half3(size_t offset, const half *p);
 float4 __ovld __purefn vload_half4(size_t offset, const half *p);
 float8 __ovld __purefn vload_half8(size_t offset, const half *p);
 float16 __ovld __purefn vload_half16(size_t offset, const half *p);
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float2 __ovld __purefn vload_half2(size_t offset, const __global half *p);
 float3 __ovld __purefn vload_half3(size_t offset, const __global half *p);
 float4 __ovld __purefn vload_half4(size_t offset, const __global half *p);
 float8 __ovld __purefn vload_half8(size_t offset, const __global half *p);
 float16 __ovld __purefn vload_half16(size_t offset, const __global half *p);
 float2 __ovld __purefn vload_half2(size_t offset, const __local half *p);
 float3 __ovld __purefn vload_half3(size_t offset, const __local half *p);
 float4 __ovld __purefn vload_half4(size_t offset, const __local half *p);
 float8 __ovld __purefn vload_half8(size_t offset, const __local half *p);
 float16 __ovld __purefn vload_half16(size_t offset, const __local half *p);
 float2 __ovld __purefn vload_half2(size_t offset, const __private half *p);
 float3 __ovld __purefn vload_half3(size_t offset, const __private half *p);
 float4 __ovld __purefn vload_half4(size_t offset, const __private half *p);
 float8 __ovld __purefn vload_half8(size_t offset, const __private half *p);
 float16 __ovld __purefn vload_half16(size_t offset, const __private half *p);
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * The float value given by data is first
  * converted to a half value using the appropriate
  * rounding mode. The half value is then written
  * to address computed as (p + offset). The
  * address computed as (p + offset) must be 16-
  * bit aligned.

 void __ovld vstore_half_rtn(float data, size_t offset, half *p);
 #ifdef cl_khr_fp64
 void __ovld vstore_half(double data, size_t offset, half *p);
 void __ovld vstore_half_rte(double data, size_t offset, half *p);
 void __ovld vstore_half_rtz(double data, size_t offset, half *p);
 void __ovld vstore_half_rtp(double data, size_t offset, half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, half *p);
 #endif //cl_khr_fp64
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 void __ovld vstore_half(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rte(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rtz(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rtn(float data, size_t offset, __global half *p);
 void __ovld vstore_half(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rte(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rtz(float data, size_t offset, __local half *p);

 void __ovld vstore_half_rtp(double data, size_t offset, __local half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, __local half *p);
 void __ovld vstore_half(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rte(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rtz(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rtp(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
 #endif //cl_khr_fp64
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * The floatn value given by data is converted to
  * a halfn value using the appropriate rounding
  * mode. The halfn value is then written to
  * address computed as (p + (offset * n)). The
  * address computed as (p + (offset * n)) must be
  * 16-bit aligned.

 void __ovld vstore_half8_rtp(double8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtp(double16 data, size_t offset, half *p);
 void __ovld vstore_half2_rtn(double2 data, size_t offset, half *p);
 void __ovld vstore_half3_rtn(double3 data, size_t offset, half *p);
 void __ovld vstore_half4_rtn(double4 data, size_t offset, half *p);
 void __ovld vstore_half8_rtn(double8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtn(double16 data, size_t offset, half *p);
 #endif //cl_khr_fp64
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 void __ovld vstore_half2(float2 data, size_t offset, __global half *p);
 void __ovld vstore_half3(float3 data, size_t offset, __global half *p);
 void __ovld vstore_half4(float4 data, size_t offset, __global half *p);
 void __ovld vstore_half8(float8 data, size_t offset, __global half *p);
 void __ovld vstore_half16(float16 data, size_t offset, __global half *p);
 void __ovld vstore_half2_rte(float2 data, size_t offset, __global half *p);
 void __ovld vstore_half3_rte(float3 data, size_t offset, __global half *p);
 void __ovld vstore_half4_rte(float4 data, size_t offset, __global half *p);

 void __ovld vstore_half8_rtp(double8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtp(double16 data, size_t offset, __private half *p);
 void __ovld vstore_half2_rtn(double2 data, size_t offset, __private half *p);
 void __ovld vstore_half3_rtn(double3 data, size_t offset, __private half *p);
 void __ovld vstore_half4_rtn(double4 data, size_t offset, __private half *p);
 void __ovld vstore_half8_rtn(double8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtn(double16 data, size_t offset, __private half *p);
 #endif //cl_khr_fp64
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * For n = 1, 2, 4, 8 and 16 read sizeof (halfn)
  * bytes of data from address (p + (offset * n)).
  * The data read is interpreted as a halfn value.
  * The halfn value read is converted to a floatn
  * value and the floatn value is returned.
  * The address computed as (p + (offset * n))

 float8 __ovld __purefn vloada_half8(size_t offset, const __constant half *p);
 float16 __ovld __purefn vloada_half16(size_t offset, const __constant half *p);
 #if defined(__opencl_c_generic_address_space)
 float2 __ovld __purefn vloada_half2(size_t offset, const half *p);
 float3 __ovld __purefn vloada_half3(size_t offset, const half *p);
 float4 __ovld __purefn vloada_half4(size_t offset, const half *p);
 float8 __ovld __purefn vloada_half8(size_t offset, const half *p);
 float16 __ovld __purefn vloada_half16(size_t offset, const half *p);
-#else
+#endif //defined(__opencl_c_generic_address_space)
+
+#if defined(__opencl_c_named_address_space_builtins)
 float2 __ovld __purefn vloada_half2(size_t offset, const __global half *p);
 float3 __ovld __purefn vloada_half3(size_t offset, const __global half *p);
 float4 __ovld __purefn vloada_half4(size_t offset, const __global half *p);
 float8 __ovld __purefn vloada_half8(size_t offset, const __global half *p);
 float16 __ovld __purefn vloada_half16(size_t offset, const __global half *p);
 float2 __ovld __purefn vloada_half2(size_t offset, const __local half *p);
 float3 __ovld __purefn vloada_half3(size_t offset, const __local half *p);
 float4 __ovld __purefn vloada_half4(size_t offset, const __local half *p);
 float8 __ovld __purefn vloada_half8(size_t offset, const __local half *p);
 float16 __ovld __purefn vloada_half16(size_t offset, const __local half *p);
 float2 __ovld __purefn vloada_half2(size_t offset, const __private half *p);
 float3 __ovld __purefn vloada_half3(size_t offset, const __private half *p);
 float4 __ovld __purefn vloada_half4(size_t offset, const __private half *p);
 float8 __ovld __purefn vloada_half8(size_t offset, const __private half *p);
 float16 __ovld __purefn vloada_half16(size_t offset, const __private half *p);
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 /**
  * The floatn value given by data is converted to
  * a halfn value using the appropriate rounding
  * mode.
  * For n = 1, 2, 4, 8 and 16, the halfn value is
  * written to the address computed as (p + (offset
  * * n)). The address computed as (p + (offset *

 void __ovld vstorea_half16_rtp(double16 data, size_t offset, half *p);
 
 void __ovld vstorea_half2_rtn(double2 data, size_t offset, half *p);
 void __ovld vstorea_half3_rtn(double3 data, size_t offset, half *p);
 void __ovld vstorea_half4_rtn(double4 data, size_t offset, half *p);
 void __ovld vstorea_half8_rtn(double8 data, size_t offset, half *p);
 void __ovld vstorea_half16_rtn(double16 data, size_t offset, half *p);
 #endif //cl_khr_fp64
+#endif //defined(__opencl_c_generic_address_space)
 
-#else
+#if defined(__opencl_c_named_address_space_builtins)
 void __ovld vstorea_half2(float2 data, size_t offset, __global half *p);
 void __ovld vstorea_half3(float3 data, size_t offset, __global half *p);
 void __ovld vstorea_half4(float4 data, size_t offset, __global half *p);
 void __ovld vstorea_half8(float8 data, size_t offset, __global half *p);
 void __ovld vstorea_half16(float16 data, size_t offset, __global half *p);
 
 void __ovld vstorea_half2_rte(float2 data, size_t offset, __global half *p);
 void __ovld vstorea_half3_rte(float3 data, size_t offset, __global half *p);

 void __ovld vstorea_half16_rtp(double16 data, size_t offset, __private half *p);
 
 void __ovld vstorea_half2_rtn(double2 data,size_t offset, __private half *p);
 void __ovld vstorea_half3_rtn(double3 data,size_t offset, __private half *p);
 void __ovld vstorea_half4_rtn(double4 data,size_t offset, __private half *p);
 void __ovld vstorea_half8_rtn(double8 data,size_t offset, __private half *p);
 void __ovld vstorea_half16_rtn(double16 data,size_t offset, __private half *p);
 #endif //cl_khr_fp64
-#endif //defined(__opencl_c_generic_address_space)
+#endif //defined(__opencl_c_named_address_space_builtins)
 
 // OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
 
 /**
  * All work-items in a work-group executing the kernel
  * on a processor must execute this function before any
  * are allowed to continue execution beyond the barrier.
  * This function must be encountered by all work-items in

 #if defined(cl_arm_integer_dot_product_accumulate_saturate_int8)
 uint __ovld arm_dot_acc_sat(uchar4 a, uchar4 b, uint c);
 int __ovld arm_dot_acc_sat(char4 a, char4 b, int c);
 #endif // defined(cl_arm_integer_dot_product_accumulate_saturate_int8)
 
 // Disable any extensions we may have enabled previously.
 #pragma OPENCL EXTENSION all : disable
 
+#undef __opencl_c_named_address_space_builtins
+
 #undef __cnfn
 #undef __ovld
 #endif //_OPENCL_H_