opencl-c.h: CL3.0 generic address space

[airlied]

Summary

This is one of the easier pieces of adding CL3.0 support.

[Anastasia]

clang/lib/Headers/opencl-c.h

7341

This one is not generic address space pointer though but I think this bit is part of an #else block? If you could just re-upload as a full diff, this will make it less confusing to review: https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface

[airlied]

updated to full diff.

[airlied]

clang/lib/Headers/opencl-c.h

7341

That's a good point, I was just adding the defined() bits to the endif to match the way other parts are done, however if there is an #else in the middle does this still make sense. I find having the defined comments is helpful for matching up wayward elses. The atomic changes are much more invasive so it would be good to know what we think is correct before I rework them all.

[airlied]

I've dropped the SPIR change in the base header until things are resolved for library SPIR users to disable extension defines.

[Anastasia]

In D105526#2863386, @airlied wrote:

I've dropped the SPIR change in the base header until things are resolved for library SPIR users to disable extension defines.

Makes sense! But this is not a full diff again. Would it be possible to reupload it?

[airlied]

full diff.

[Anastasia]

LGTM! Thanks!

PS this patch is straightforward and doesn't seem to affect functionality for older standards provided that we set __opencl_c_generic_address_space correctly which is not in the scope of this change.

clang/lib/Headers/opencl-c.h

 half8 __ovld __cnfn fmod(half8 x, half8 y);
 half16 __ovld __cnfn fmod(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns fmin(x - floor (x), 0x1.fffffep-1f ).
  * floor(x) is returned in iptr.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld fract(float x, float *iptr);
 float2 __ovld fract(float2 x, float2 *iptr);
 float3 __ovld fract(float3 x, float3 *iptr);
 float4 __ovld fract(float4 x, float4 *iptr);
 float8 __ovld fract(float8 x, float8 *iptr);
 float16 __ovld fract(float16 x, float16 *iptr);
 #ifdef cl_khr_fp64
 double __ovld fract(double x, double *iptr);

 half3 __ovld fract(half3 x, __local half3 *iptr);
 half4 __ovld fract(half4 x, __local half4 *iptr);
 half8 __ovld fract(half8 x, __local half8 *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld frexp(float x, int *exp);
 float2 __ovld frexp(float2 x, int2 *exp);
 float3 __ovld frexp(float3 x, int3 *exp);
 float4 __ovld frexp(float4 x, int4 *exp);
 float8 __ovld frexp(float8 x, int8 *exp);
 float16 __ovld frexp(float16 x, int16 *exp);
 #ifdef cl_khr_fp64
 double __ovld frexp(double x, int *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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);

 half __ovld __cnfn lgamma(half x);
 half2 __ovld __cnfn lgamma(half2 x);
 half3 __ovld __cnfn lgamma(half3 x);
 half4 __ovld __cnfn lgamma(half4 x);
 half8 __ovld __cnfn lgamma(half8 x);
 half16 __ovld __cnfn lgamma(half16 x);
 #endif //cl_khr_fp16
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld lgamma_r(float x, int *signp);
 float2 __ovld lgamma_r(float2 x, int2 *signp);
 float3 __ovld lgamma_r(float3 x, int3 *signp);
 float4 __ovld lgamma_r(float4 x, int4 *signp);
 float8 __ovld lgamma_r(float8 x, int8 *signp);
 float16 __ovld lgamma_r(float16 x, int16 *signp);
 #ifdef cl_khr_fp64
 double __ovld lgamma_r(double x, int *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * Compute natural logarithm.
  */
 float __ovld __cnfn log(float);
 float2 __ovld __cnfn log(float2);
 float3 __ovld __cnfn log(float3);
 float4 __ovld __cnfn log(float4);

 
 /**
  * Decompose a floating-point number. The modf
  * function breaks the argument x into integral and
  * fractional parts, each of which has the same sign as
  * the argument. It stores the integral part in the object
  * pointed to by iptr.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld modf(float x, float *iptr);
 float2 __ovld modf(float2 x, float2 *iptr);
 float3 __ovld modf(float3 x, float3 *iptr);
 float4 __ovld modf(float4 x, float4 *iptr);
 float8 __ovld modf(float8 x, float8 *iptr);
 float16 __ovld modf(float16 x, float16 *iptr);
 #ifdef cl_khr_fp64
 double __ovld modf(double x, double *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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);

  * to x/y, n shall be the even one. If r is zero, it is
  * given the same sign as x. This is the same value
  * that is returned by the remainder function.
  * remquo also calculates the lower seven bits of the
  * integral quotient x/y, and gives that value the same
  * sign as x/y. It stores this signed value in the object
  * pointed to by quo.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld remquo(float x, float y, int *quo);
 float2 __ovld remquo(float2 x, float2 y, int2 *quo);
 float3 __ovld remquo(float3 x, float3 y, int3 *quo);
 float4 __ovld remquo(float4 x, float4 y, int4 *quo);
 float8 __ovld remquo(float8 x, float8 y, int8 *quo);
 float16 __ovld remquo(float16 x, float16 y, int16 *quo);
 #ifdef cl_khr_fp64
 double __ovld remquo(double x, double y, int *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 /**
  * 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);

 half16 __ovld __cnfn sin(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute sine and cosine of x. The computed sine
  * is the return value and computed cosine is returned
  * in cosval.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld sincos(float x, float *cosval);
 float2 __ovld sincos(float2 x, float2 *cosval);
 float3 __ovld sincos(float3 x, float3 *cosval);
 float4 __ovld sincos(float4 x, float4 *cosval);
 float8 __ovld sincos(float8 x, float8 *cosval);
 float16 __ovld sincos(float16 x, float16 *cosval);
 #ifdef cl_khr_fp64
 double __ovld sincos(double x, double *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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * Compute hyperbolic sine.
  */
 float __ovld __cnfn sinh(float);
 float2 __ovld __cnfn sinh(float2);
 float3 __ovld __cnfn sinh(float3);
 float4 __ovld __cnfn sinh(float4);

 half __ovld vload(size_t offset, const __constant half *p);
 half2 __ovld vload2(size_t offset, const __constant half *p);
 half3 __ovld vload3(size_t offset, const __constant half *p);
 half4 __ovld vload4(size_t offset, const __constant half *p);
 half8 __ovld vload8(size_t offset, const __constant half *p);
 half16 __ovld vload16(size_t offset, const __constant half *p);
 #endif //cl_khr_fp16
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 char2 __ovld vload2(size_t offset, const char *p);
 uchar2 __ovld vload2(size_t offset, const uchar *p);
 short2 __ovld vload2(size_t offset, const short *p);
 ushort2 __ovld vload2(size_t offset, const ushort *p);
 int2 __ovld vload2(size_t offset, const int *p);
 uint2 __ovld vload2(size_t offset, const uint *p);
 long2 __ovld vload2(size_t offset, const long *p);
 ulong2 __ovld vload2(size_t offset, const ulong *p);

 half16 __ovld vload16(size_t offset, const __local half *p);
 half __ovld vload(size_t offset, const __private half *p);
 half2 __ovld vload2(size_t offset, const __private half *p);
 half3 __ovld vload3(size_t offset, const __private half *p);
 half4 __ovld vload4(size_t offset, const __private half *p);
 half8 __ovld vload8(size_t offset, const __private half *p);
 half16 __ovld vload16(size_t offset, const __private half *p);
 #endif //cl_khr_fp16
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#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);
 void __ovld vstore2(long2 data, size_t offset, long *p);
 void __ovld vstore2(ulong2 data, size_t offset, 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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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 vload_half(size_t offset, const __constant half *p);
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld vload_half(size_t offset, const half *p);
 #else
 float __ovld vload_half(size_t offset, const __global half *p);
 float __ovld vload_half(size_t offset, const __local half *p);
 float __ovld vload_half(size_t offset, const __private half *p);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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 vload_half2(size_t offset, const __constant half *p);
 float3 __ovld vload_half3(size_t offset, const __constant half *p);
 float4 __ovld vload_half4(size_t offset, const __constant half *p);
 float8 __ovld vload_half8(size_t offset, const __constant half *p);
 float16 __ovld vload_half16(size_t offset, const __constant half *p);
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float2 __ovld vload_half2(size_t offset, const half *p);
 float3 __ovld vload_half3(size_t offset, const half *p);
 float4 __ovld vload_half4(size_t offset, const half *p);
 float8 __ovld vload_half8(size_t offset, const half *p);
 float16 __ovld vload_half16(size_t offset, const half *p);
 #else
 float2 __ovld vload_half2(size_t offset, const __global half *p);
 float3 __ovld vload_half3(size_t offset, const __global half *p);
 float4 __ovld vload_half4(size_t offset, const __global half *p);
 float8 __ovld vload_half8(size_t offset, const __global half *p);
 float16 __ovld vload_half16(size_t offset, const __global half *p);
 float2 __ovld vload_half2(size_t offset, const __local half *p);
 float3 __ovld vload_half3(size_t offset, const __local half *p);
 float4 __ovld vload_half4(size_t offset, const __local half *p);
 float8 __ovld vload_half8(size_t offset, const __local half *p);
 float16 __ovld vload_half16(size_t offset, const __local half *p);
 float2 __ovld vload_half2(size_t offset, const __private half *p);
 float3 __ovld vload_half3(size_t offset, const __private half *p);
 float4 __ovld vload_half4(size_t offset, const __private half *p);
 float8 __ovld vload_half8(size_t offset, const __private half *p);
 float16 __ovld vload_half16(size_t offset, const __private half *p);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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.
  * vstore_half use the current rounding mode.
  * The default current rounding mode is round to
  * nearest even.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 void __ovld vstore_half(float data, size_t offset, half *p);
 void __ovld vstore_half_rte(float data, size_t offset, half *p);
 void __ovld vstore_half_rtz(float data, size_t offset, half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, half *p);
 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_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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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.
  * vstore_halfn uses the current rounding mode.
  * The default current rounding mode is round to
  * nearest even.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 void __ovld vstore_half2(float2 data, size_t offset, half *p);
 void __ovld vstore_half3(float3 data, size_t offset, half *p);
 void __ovld vstore_half4(float4 data, size_t offset, half *p);
 void __ovld vstore_half8(float8 data, size_t offset, half *p);
 void __ovld vstore_half16(float16 data, size_t offset, half *p);
 void __ovld vstore_half2_rte(float2 data, size_t offset, half *p);
 void __ovld vstore_half3_rte(float3 data, size_t offset, half *p);
 void __ovld vstore_half4_rte(float4 data, size_t offset, 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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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))
  * must be aligned to sizeof (halfn) bytes.
  * For n = 3, vloada_half3 reads a half3 from
  * address (p + (offset * 4)) and returns a float3.
  * The address computed as (p + (offset * 4))
  * must be aligned to sizeof (half) * 4 bytes.
  */
 float __ovld vloada_half(size_t offset, const __constant half *p);
 float2 __ovld vloada_half2(size_t offset, const __constant half *p);
 float3 __ovld vloada_half3(size_t offset, const __constant half *p);
 float4 __ovld vloada_half4(size_t offset, const __constant half *p);
 float8 __ovld vloada_half8(size_t offset, const __constant half *p);
 float16 __ovld vloada_half16(size_t offset, const __constant half *p);
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 float __ovld vloada_half(size_t offset, const half *p);
 float2 __ovld vloada_half2(size_t offset, const half *p);
 float3 __ovld vloada_half3(size_t offset, const half *p);
 float4 __ovld vloada_half4(size_t offset, const half *p);
 float8 __ovld vloada_half8(size_t offset, const half *p);
 float16 __ovld vloada_half16(size_t offset, const half *p);
 #else
 float __ovld vloada_half(size_t offset, const __global half *p);

 float8 __ovld vloada_half8(size_t offset, const __local half *p);
 float16 __ovld vloada_half16(size_t offset, const __local half *p);
 float __ovld vloada_half(size_t offset, const __private half *p);
 float2 __ovld vloada_half2(size_t offset, const __private half *p);
 float3 __ovld vloada_half3(size_t offset, const __private half *p);
 float4 __ovld vloada_half4(size_t offset, const __private half *p);
 float8 __ovld vloada_half8(size_t offset, const __private half *p);
 float16 __ovld vloada_half16(size_t offset, const __private half *p);
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 /**
  * 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 *
  * n)) must be aligned to sizeof (halfn) bytes.
  * For n = 3, the half3 value is written to the
  * address computed as (p + (offset * 4)). The
  * address computed as (p + (offset * 4)) must be
  * aligned to sizeof (half) * 4 bytes.
  * vstorea_halfn uses the current rounding
  * mode. The default current rounding mode is
  * round to nearest even.
  */
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 void __ovld vstorea_half(float data, size_t offset, half *p);
 void __ovld vstorea_half2(float2 data, size_t offset, half *p);
 void __ovld vstorea_half3(float3 data, size_t offset, half *p);
 void __ovld vstorea_half4(float4 data, size_t offset, half *p);
 void __ovld vstorea_half8(float8 data, size_t offset, half *p);
 void __ovld vstorea_half16(float16 data, size_t offset, half *p);
 
 void __ovld vstorea_half_rte(float data, size_t offset, half *p);

 
 void __ovld vstorea_half_rtn(double 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_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 // 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

  * values:
  * CLK_LOCAL_MEM_FENCE
  * CLK_GLOBAL_MEM_FENCE.
  */
 void __ovld write_mem_fence(cl_mem_fence_flags flags);
 
 // OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__opencl_c_generic_address_space)
 cl_mem_fence_flags __ovld get_fence(const void *ptr);
 cl_mem_fence_flags __ovld get_fence(void *ptr);
 
 /**
  * Builtin functions to_global, to_local, and to_private need to be declared as Clang builtin functions
  * and checked in Sema since they should be declared as
  *   addr gentype* to_addr (gentype*);
  * where gentype is builtin type or user defined type.
  */
 
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif //defined(__opencl_c_generic_address_space)
 
 // OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
 
 /**
  * event_t async_work_group_copy (
  * __global gentype *dst,
  * const __local gentype *src,
  * size_t num_elements,