@cpp-linter/clang-tidy-win32-x64 21.1.0 → 23.1.3

package/lib/clang/{21 → 23}/include/opencl-c.h

@@ -13736,8 +13736,8 @@ half __ovld atomic_fetch_min_explicit(volatile atomic_half *,
                                       half, memory_order, memory_scope);
 half __ovld atomic_fetch_max_explicit(volatile atomic_half *,
                                       half, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp16_global_atomic_min_max) &&                \
-    defined(__opencl_c_ext_fp16_local_atomic_min_max)
+#endif // defined(__opencl_c_ext_fp16_global_atomic_min_max) &&
+       // defined(__opencl_c_ext_fp16_local_atomic_min_max)
 
 #if defined(__opencl_c_ext_fp32_global_atomic_min_max)
 float __ovld atomic_fetch_min(volatile __global atomic_float *, float);
@@ -13777,8 +13777,8 @@ float __ovld atomic_fetch_min_explicit(volatile atomic_float *,
                                        float, memory_order, memory_scope);
 float __ovld atomic_fetch_max_explicit(volatile atomic_float *,
                                        float, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp32_global_atomic_min_max) &&                \
-    defined(__opencl_c_ext_fp32_local_atomic_min_max)
+#endif // defined(__opencl_c_ext_fp32_global_atomic_min_max) &&
+       // defined(__opencl_c_ext_fp32_local_atomic_min_max)
 
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
 #if defined(__opencl_c_ext_fp64_global_atomic_min_max)
@@ -13819,10 +13819,10 @@ double __ovld atomic_fetch_min_explicit(volatile atomic_double *,
                                         double, memory_order, memory_scope);
 double __ovld atomic_fetch_max_explicit(volatile atomic_double *,
                                         double, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp64_global_atomic_min_max) &&                \
-    defined(__opencl_c_ext_fp64_local_atomic_min_max)
-#endif // defined(cl_khr_int64_base_atomics) &&                                \
-    defined(cl_khr_int64_extended_atomics)
+#endif // defined(__opencl_c_ext_fp64_global_atomic_min_max) &&
+       // defined(__opencl_c_ext_fp64_local_atomic_min_max)
+#endif // defined(cl_khr_int64_base_atomics) &&
+       // defined(cl_khr_int64_extended_atomics)
 
 #if defined(__opencl_c_ext_fp16_global_atomic_add)
 half __ovld atomic_fetch_add(volatile __global atomic_half *, half);
@@ -13862,8 +13862,8 @@ half __ovld atomic_fetch_add_explicit(volatile atomic_half *,
                                       half, memory_order, memory_scope);
 half __ovld atomic_fetch_sub_explicit(volatile atomic_half *,
                                       half, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp16_global_atomic_add) &&                    \
-    defined(__opencl_c_ext_fp16_local_atomic_add)
+#endif // defined(__opencl_c_ext_fp16_global_atomic_add) &&
+       // defined(__opencl_c_ext_fp16_local_atomic_add)
 
 #if defined(__opencl_c_ext_fp32_global_atomic_add)
 float __ovld atomic_fetch_add(volatile __global atomic_float *, float);
@@ -13903,8 +13903,8 @@ float __ovld atomic_fetch_add_explicit(volatile atomic_float *,
                                        float, memory_order, memory_scope);
 float __ovld atomic_fetch_sub_explicit(volatile atomic_float *,
                                        float, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp32_global_atomic_add) &&                    \
-    defined(__opencl_c_ext_fp32_local_atomic_add)
+#endif // defined(__opencl_c_ext_fp32_global_atomic_add) &&
+       // defined(__opencl_c_ext_fp32_local_atomic_add)
 
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
 #if defined(__opencl_c_ext_fp64_global_atomic_add)
@@ -13945,10 +13945,10 @@ double __ovld atomic_fetch_add_explicit(volatile atomic_double *,
                                         double, memory_order, memory_scope);
 double __ovld atomic_fetch_sub_explicit(volatile atomic_double *,
                                         double, memory_order, memory_scope);
-#endif // defined(__opencl_c_ext_fp64_global_atomic_add) &&                    \
-    defined(__opencl_c_ext_fp64_local_atomic_add)
-#endif // defined(cl_khr_int64_base_atomics) &&                                \
-    defined(cl_khr_int64_extended_atomics)
+#endif // defined(__opencl_c_ext_fp64_global_atomic_add) &&
+       // defined(__opencl_c_ext_fp64_local_atomic_add)
+#endif // defined(cl_khr_int64_base_atomics) &&
+       // defined(cl_khr_int64_extended_atomics)
 
 #endif // cl_ext_float_atomics
 
@@ -15199,8 +15199,8 @@ float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4)
 int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, int4);
 int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4);
 uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, int4);
-uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4);
-#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t,
+                                   float4);
 
 float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, int);
 float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float);
@@ -15210,7 +15210,6 @@ int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float);
 uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, int);
 uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float);
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, int2);
 float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2);
 
@@ -15220,13 +15219,13 @@ uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, int2);
 uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2);
 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2);
 float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, int2);
 
 float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4);
 float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, int4);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 #if defined(cl_khr_gl_msaa_sharing)
 float4 __ovld __purefn read_imagef(read_only image2d_msaa_t, int2, int);
@@ -15243,9 +15242,10 @@ float __ovld __purefn read_imagef(read_only image2d_array_msaa_depth_t, int4, in
 #endif //cl_khr_gl_msaa_sharing
 
 // OpenCL Extension v2.0 s9.18 - Mipmaps
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#if defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 #ifdef cl_khr_mipmap_image
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float);
 int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float);
 uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float);
@@ -15253,27 +15253,31 @@ uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float)
 float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float);
 int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float);
 uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 
 float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float);
 int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float);
 uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float);
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float);
 int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float);
 uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float);
 int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float);
 uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float);
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float, float);
 int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float, float);
 uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float, float);
@@ -15281,31 +15285,34 @@ uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float,
 float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float, float);
 int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float, float);
 uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float, float);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 
 float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float2, float2);
 int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float2, float2);
 uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float2, float2);
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float2, float2);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float2, float2);
 int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float2, float2);
 uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float2, float2);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float2, float2);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float4, float4);
 int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float4, float4);
 uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float4, float4);
 
 #endif //cl_khr_mipmap_image
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif // defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+#if defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 
 /**
 * Sampler-less Image Access
@@ -15331,36 +15338,39 @@ float4 __ovld __purefn read_imagef(read_only image2d_array_t, int4);
 int4 __ovld __purefn read_imagei(read_only image2d_array_t, int4);
 uint4 __ovld __purefn read_imageui(read_only image2d_array_t, int4);
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_only image2d_depth_t, int2);
 float __ovld __purefn read_imagef(read_only image2d_array_depth_t, int4);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 float4 __ovld __purefn read_imagef(read_only image3d_t, int4);
 int4 __ovld __purefn read_imagei(read_only image3d_t, int4);
 uint4 __ovld __purefn read_imageui(read_only image3d_t, int4);
 
-#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+#endif // defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 
 // Image read functions returning half4 type
 #ifdef cl_khr_fp16
-half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, int);
-half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, float);
 half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, int2);
 half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, float2);
 half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, int4);
 half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, float4);
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, int);
+half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, float);
 half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, int2);
 half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, float2);
 half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, int4);
 half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, float4);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
 /**
  * Sampler-less Image Access
  */
-half4 __ovld __purefn read_imageh(read_only image1d_t, int);
 half4 __ovld __purefn read_imageh(read_only image2d_t, int2);
 half4 __ovld __purefn read_imageh(read_only image3d_t, int4);
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
+half4 __ovld __purefn read_imageh(read_only image1d_t, int);
 half4 __ovld __purefn read_imageh(read_only image1d_array_t, int2);
 half4 __ovld __purefn read_imageh(read_only image2d_array_t, int4);
 half4 __ovld __purefn read_imageh(read_only image1d_buffer_t, int);
@@ -15395,10 +15405,10 @@ int4 __ovld __purefn read_imagei(read_write image3d_t, int4);
 uint4 __ovld __purefn read_imageui(read_write image3d_t, int4);
 #endif // cl_khr_3d_image_writes
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_write image2d_depth_t, int2);
 float __ovld __purefn read_imagef(read_write image2d_array_depth_t, int4);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 #if cl_khr_gl_msaa_sharing
 float4 __ovld __purefn read_imagef(read_write image2d_msaa_t, int2, int);
@@ -15414,6 +15424,7 @@ float __ovld __purefn read_imagef(read_write image2d_array_msaa_depth_t, int4, i
 #endif //cl_khr_gl_msaa_sharing
 
 #ifdef cl_khr_mipmap_image
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float);
 int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float);
 uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float);
@@ -15421,18 +15432,27 @@ uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float
 float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float);
 int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float);
 uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
 
 float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float);
 int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float);
 uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float);
 
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float);
+#endif // defined(__opencl_depth_image_builtins)
 
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float);
 int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float);
 uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
 
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float);
+#endif // defined(__opencl_depth_image_builtins)
 
 #ifdef cl_khr_3d_image_writes
 float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float);
@@ -15440,6 +15460,7 @@ int4 __ovld __purefn read_imagei(read_write image3d_t, sampler_t, float4, float)
 uint4 __ovld __purefn read_imageui(read_write image3d_t, sampler_t, float4, float);
 #endif // cl_khr_3d_image_writes
 
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float, float);
 int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float, float);
 uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float, float);
@@ -15447,18 +15468,27 @@ uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float
 float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float, float);
 int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float, float);
 uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float, float);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
 
 float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float2, float2);
 int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float2, float2);
 uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float2, float2);
 
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float2, float2);
+#endif // defined(__opencl_depth_image_builtins)
 
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float2, float2);
 int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float2, float2);
 uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float2, float2);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
 
+#if defined(__opencl_depth_image_builtins)
 float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float2, float2);
+#endif // defined(__opencl_depth_image_builtins)
 
 #ifdef cl_khr_3d_image_writes
 float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float4, float4);
@@ -15574,14 +15604,14 @@ void __ovld write_imagei(write_only image3d_t, int4, int4);
 void __ovld write_imageui(write_only image3d_t, int4, uint4);
 #endif
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 void __ovld write_imagef(write_only image2d_depth_t, int2, float);
 void __ovld write_imagef(write_only image2d_array_depth_t, int4, float);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 // OpenCL Extension v2.0 s9.18 - Mipmaps
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 #if defined(cl_khr_mipmap_image_writes)
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 void __ovld write_imagef(write_only image1d_t, int, int, float4);
 void __ovld write_imagei(write_only image1d_t, int, int, int4);
 void __ovld write_imageui(write_only image1d_t, int, int, uint4);
@@ -15590,16 +15620,20 @@ void __ovld write_imagef(write_only image1d_array_t, int2, int, float4);
 void __ovld write_imagei(write_only image1d_array_t, int2, int, int4);
 void __ovld write_imageui(write_only image1d_array_t, int2, int, uint4);
 
-void __ovld write_imagef(write_only image2d_t, int2, int, float4);
-void __ovld write_imagei(write_only image2d_t, int2, int, int4);
-void __ovld write_imageui(write_only image2d_t, int2, int, uint4);
-
 void __ovld write_imagef(write_only image2d_array_t, int4, int, float4);
 void __ovld write_imagei(write_only image2d_array_t, int4, int, int4);
 void __ovld write_imageui(write_only image2d_array_t, int4, int, uint4);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
+
+void __ovld write_imagef(write_only image2d_t, int2, int, float4);
+void __ovld write_imagei(write_only image2d_t, int2, int, int4);
+void __ovld write_imageui(write_only image2d_t, int2, int, uint4);
 
+#if defined(__opencl_depth_image_builtins)
 void __ovld write_imagef(write_only image2d_depth_t, int2, int, float);
 void __ovld write_imagef(write_only image2d_array_depth_t, int4, int, float);
+#endif // defined(__opencl_depth_image_builtins)
 
 #ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(write_only image3d_t, int4, int, float4);
@@ -15607,8 +15641,7 @@ void __ovld write_imagei(write_only image3d_t, int4, int, int4);
 void __ovld write_imageui(write_only image3d_t, int4, int, uint4);
 #endif //cl_khr_3d_image_writes
 
-#endif //defined(cl_khr_mipmap_image_writes)
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif // defined(cl_khr_mipmap_image_writes)
 
 // Image write functions for half4 type
 #ifdef cl_khr_fp16
@@ -15650,12 +15683,13 @@ void __ovld write_imagei(read_write image3d_t, int4, int4);
 void __ovld write_imageui(read_write image3d_t, int4, uint4);
 #endif
 
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 void __ovld write_imagef(read_write image2d_depth_t, int2, float);
 void __ovld write_imagef(read_write image2d_array_depth_t, int4, float);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 #if defined(cl_khr_mipmap_image_writes)
+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)
 void __ovld write_imagef(read_write image1d_t, int, int, float4);
 void __ovld write_imagei(read_write image1d_t, int, int, int4);
 void __ovld write_imageui(read_write image1d_t, int, int, uint4);
@@ -15664,16 +15698,20 @@ void __ovld write_imagef(read_write image1d_array_t, int2, int, float4);
 void __ovld write_imagei(read_write image1d_array_t, int2, int, int4);
 void __ovld write_imageui(read_write image1d_array_t, int2, int, uint4);
 
-void __ovld write_imagef(read_write image2d_t, int2, int, float4);
-void __ovld write_imagei(read_write image2d_t, int2, int, int4);
-void __ovld write_imageui(read_write image2d_t, int2, int, uint4);
-
 void __ovld write_imagef(read_write image2d_array_t, int4, int, float4);
 void __ovld write_imagei(read_write image2d_array_t, int4, int, int4);
 void __ovld write_imageui(read_write image2d_array_t, int4, int, uint4);
+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >=
+       // CL_VERSION_1_2)
+
+void __ovld write_imagef(read_write image2d_t, int2, int, float4);
+void __ovld write_imagei(read_write image2d_t, int2, int, int4);
+void __ovld write_imageui(read_write image2d_t, int2, int, uint4);
 
+#if defined(__opencl_depth_image_builtins)
 void __ovld write_imagef(read_write image2d_depth_t, int2, int, float);
 void __ovld write_imagef(read_write image2d_array_depth_t, int4, int, float);
+#endif // defined(__opencl_depth_image_builtins)
 
 #ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(read_write image3d_t, int4, int, float4);
@@ -15710,10 +15748,10 @@ int __ovld __cnfn get_image_width(read_only image2d_t);
 int __ovld __cnfn get_image_width(read_only image3d_t);
 int __ovld __cnfn get_image_width(read_only image1d_array_t);
 int __ovld __cnfn get_image_width(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_width(read_only image2d_depth_t);
 int __ovld __cnfn get_image_width(read_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_width(read_only image2d_msaa_t);
 int __ovld __cnfn get_image_width(read_only image2d_msaa_depth_t);
@@ -15729,10 +15767,10 @@ int __ovld __cnfn get_image_width(write_only image3d_t);
 #endif
 int __ovld __cnfn get_image_width(write_only image1d_array_t);
 int __ovld __cnfn get_image_width(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_width(write_only image2d_depth_t);
 int __ovld __cnfn get_image_width(write_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_width(write_only image2d_msaa_t);
 int __ovld __cnfn get_image_width(write_only image2d_msaa_depth_t);
@@ -15749,10 +15787,10 @@ int __ovld __cnfn get_image_width(read_write image3d_t);
 #endif // cl_khr_3d_image_writes
 int __ovld __cnfn get_image_width(read_write image1d_array_t);
 int __ovld __cnfn get_image_width(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_width(read_write image2d_depth_t);
 int __ovld __cnfn get_image_width(read_write image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_width(read_write image2d_msaa_t);
 int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t);
@@ -15767,10 +15805,10 @@ int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t);
 int __ovld __cnfn get_image_height(read_only image2d_t);
 int __ovld __cnfn get_image_height(read_only image3d_t);
 int __ovld __cnfn get_image_height(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_height(read_only image2d_depth_t);
 int __ovld __cnfn get_image_height(read_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_height(read_only image2d_msaa_t);
 int __ovld __cnfn get_image_height(read_only image2d_msaa_depth_t);
@@ -15783,10 +15821,10 @@ int __ovld __cnfn get_image_height(write_only image2d_t);
 int __ovld __cnfn get_image_height(write_only image3d_t);
 #endif
 int __ovld __cnfn get_image_height(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_height(write_only image2d_depth_t);
 int __ovld __cnfn get_image_height(write_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_height(write_only image2d_msaa_t);
 int __ovld __cnfn get_image_height(write_only image2d_msaa_depth_t);
@@ -15800,10 +15838,10 @@ int __ovld __cnfn get_image_height(read_write image2d_t);
 int __ovld __cnfn get_image_height(read_write image3d_t);
 #endif // cl_khr_3d_image_writes
 int __ovld __cnfn get_image_height(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_height(read_write image2d_depth_t);
 int __ovld __cnfn get_image_height(read_write image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_height(read_write image2d_msaa_t);
 int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t);
@@ -15825,18 +15863,22 @@ int __ovld __cnfn get_image_depth(read_write image3d_t);
 #endif //defined(__opencl_c_read_write_images)
 #endif // cl_khr_3d_image_writes
 
-// OpenCL Extension v2.0 s9.18 - Mipmaps
-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+// OpenCL Extension - Mipmaps
+#if defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 #ifdef cl_khr_mipmap_image
 /**
  * Return the image miplevels.
  */
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(read_only image1d_t);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(read_only image2d_t);
 int __ovld get_image_num_mip_levels(read_only image3d_t);
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(write_only image1d_t);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(write_only image2d_t);
 #ifdef cl_khr_3d_image_writes
 int __ovld get_image_num_mip_levels(write_only image3d_t);
@@ -15850,31 +15892,37 @@ int __ovld get_image_num_mip_levels(read_write image3d_t);
 #endif // cl_khr_3d_image_writes
 #endif //defined(__opencl_c_read_write_images)
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(read_only image1d_array_t);
 int __ovld get_image_num_mip_levels(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
+#if defined(__opencl_depth_image_builtins)
 int __ovld get_image_num_mip_levels(read_only image2d_array_depth_t);
 int __ovld get_image_num_mip_levels(read_only image2d_depth_t);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(write_only image1d_array_t);
 int __ovld get_image_num_mip_levels(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
+#if defined(__opencl_depth_image_builtins)
 int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t);
 int __ovld get_image_num_mip_levels(write_only image2d_depth_t);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 
 #if defined(__opencl_c_read_write_images)
+#if __OPENCL_C_VERSION__ >= CL_VERSION_1_2
 int __ovld get_image_num_mip_levels(read_write image1d_array_t);
 int __ovld get_image_num_mip_levels(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_1_2
+#if defined(__opencl_depth_image_builtins)
 int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t);
 int __ovld get_image_num_mip_levels(read_write image2d_depth_t);
-#endif // cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #endif //defined(__opencl_c_read_write_images)
 
-#endif //cl_khr_mipmap_image
-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
+#endif // cl_khr_mipmap_image
+#endif // defined(__OPENCL_CPP_VERSION__) || defined(__OPENCL_C_VERSION__)
 
 /**
  * Return the channel data type. Valid values are:
@@ -15901,10 +15949,10 @@ int __ovld __cnfn get_image_channel_data_type(read_only image2d_t);
 int __ovld __cnfn get_image_channel_data_type(read_only image3d_t);
 int __ovld __cnfn get_image_channel_data_type(read_only image1d_array_t);
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_depth_t);
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_t);
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_depth_t);
@@ -15920,10 +15968,10 @@ int __ovld __cnfn get_image_channel_data_type(write_only image3d_t);
 #endif
 int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_depth_t);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_t);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_depth_t);
@@ -15940,10 +15988,10 @@ int __ovld __cnfn get_image_channel_data_type(read_write image3d_t);
 #endif // cl_khr_3d_image_writes
 int __ovld __cnfn get_image_channel_data_type(read_write image1d_array_t);
 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_data_type(read_write image2d_depth_t);
 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_t);
 int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t);
@@ -15975,10 +16023,10 @@ int __ovld __cnfn get_image_channel_order(read_only image2d_t);
 int __ovld __cnfn get_image_channel_order(read_only image3d_t);
 int __ovld __cnfn get_image_channel_order(read_only image1d_array_t);
 int __ovld __cnfn get_image_channel_order(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_order(read_only image2d_depth_t);
 int __ovld __cnfn get_image_channel_order(read_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_t);
 int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_depth_t);
@@ -15994,10 +16042,10 @@ int __ovld __cnfn get_image_channel_order(write_only image3d_t);
 #endif
 int __ovld __cnfn get_image_channel_order(write_only image1d_array_t);
 int __ovld __cnfn get_image_channel_order(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_order(write_only image2d_depth_t);
 int __ovld __cnfn get_image_channel_order(write_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_t);
 int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_depth_t);
@@ -16014,10 +16062,10 @@ int __ovld __cnfn get_image_channel_order(read_write image3d_t);
 #endif // cl_khr_3d_image_writes
 int __ovld __cnfn get_image_channel_order(read_write image1d_array_t);
 int __ovld __cnfn get_image_channel_order(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int __ovld __cnfn get_image_channel_order(read_write image2d_depth_t);
 int __ovld __cnfn get_image_channel_order(read_write image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_t);
 int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t);
@@ -16033,10 +16081,10 @@ int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t)
  */
 int2 __ovld __cnfn get_image_dim(read_only image2d_t);
 int2 __ovld __cnfn get_image_dim(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int2 __ovld __cnfn get_image_dim(read_only image2d_array_depth_t);
 int2 __ovld __cnfn get_image_dim(read_only image2d_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_t);
 int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_depth_t);
@@ -16046,10 +16094,10 @@ int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_depth_t);
 
 int2 __ovld __cnfn get_image_dim(write_only image2d_t);
 int2 __ovld __cnfn get_image_dim(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int2 __ovld __cnfn get_image_dim(write_only image2d_array_depth_t);
 int2 __ovld __cnfn get_image_dim(write_only image2d_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_t);
 int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_depth_t);
@@ -16060,10 +16108,10 @@ int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t);
 #if defined(__opencl_c_read_write_images)
 int2 __ovld __cnfn get_image_dim(read_write image2d_t);
 int2 __ovld __cnfn get_image_dim(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 int2 __ovld __cnfn get_image_dim(read_write image2d_array_depth_t);
 int2 __ovld __cnfn get_image_dim(read_write image2d_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_t);
 int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t);
@@ -16092,9 +16140,9 @@ int4 __ovld __cnfn get_image_dim(read_write image3d_t);
 
 size_t __ovld __cnfn get_image_array_size(read_only image1d_array_t);
 size_t __ovld __cnfn get_image_array_size(read_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 size_t __ovld __cnfn get_image_array_size(read_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_t);
 size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_depth_t);
@@ -16102,9 +16150,9 @@ size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_depth_t);
 
 size_t __ovld __cnfn get_image_array_size(write_only image1d_array_t);
 size_t __ovld __cnfn get_image_array_size(write_only image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 size_t __ovld __cnfn get_image_array_size(write_only image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_t);
 size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t);
@@ -16113,9 +16161,9 @@ size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t)
 #if defined(__opencl_c_read_write_images)
 size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t);
 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t);
-#ifdef cl_khr_depth_images
+#if defined(__opencl_depth_image_builtins)
 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t);
-#endif //cl_khr_depth_images
+#endif // defined(__opencl_depth_image_builtins)
 #if defined(cl_khr_gl_msaa_sharing)
 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t);
 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t);
@@ -17505,10 +17553,14 @@ uint4      __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p
 uint8      __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p );
 
 #if defined(__opencl_c_images)
-void       __ovld __conv intel_sub_group_block_write_ui(read_only image2d_t, int2, uint);
-void       __ovld __conv intel_sub_group_block_write_ui2(read_only image2d_t, int2, uint2);
-void       __ovld __conv intel_sub_group_block_write_ui4(read_only image2d_t, int2, uint4);
-void       __ovld __conv intel_sub_group_block_write_ui8(read_only image2d_t, int2, uint8);
+void __ovld __conv intel_sub_group_block_write_ui(write_only image2d_t, int2,
+                                                  uint);
+void __ovld __conv intel_sub_group_block_write_ui2(write_only image2d_t, int2,
+                                                   uint2);
+void __ovld __conv intel_sub_group_block_write_ui4(write_only image2d_t, int2,
+                                                   uint4);
+void __ovld __conv intel_sub_group_block_write_ui8(write_only image2d_t, int2,
+                                                   uint8);
 #endif // defined(__opencl_c_images)
 
 #if defined(__opencl_c_read_write_images)
@@ -17525,6 +17577,13 @@ void       __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint
 
 #endif // defined(cl_intel_subgroups_char) || defined(cl_intel_subgroups_short) ||
        // defined(cl_intel_subgroups_long)
+
+#if defined(cl_intel_subgroup_buffer_prefetch)
+void       __ovld __conv intel_sub_group_block_prefetch_ui(const __global uint *p);
+void       __ovld __conv intel_sub_group_block_prefetch_ui2(const __global uint *p);
+void       __ovld __conv intel_sub_group_block_prefetch_ui4(const __global uint *p);
+void       __ovld __conv intel_sub_group_block_prefetch_ui8(const __global uint *p);
+#endif // defined(cl_intel_subgroup_buffer_prefetch)
 #endif // cl_intel_subgroups
 
 #if defined(cl_intel_subgroups_short)
@@ -17660,6 +17719,14 @@ void        __ovld __conv intel_sub_group_block_write_us2( __global ushort* p, u
 void        __ovld __conv intel_sub_group_block_write_us4( __global ushort* p, ushort4 data );
 void        __ovld __conv intel_sub_group_block_write_us8( __global ushort* p, ushort8 data );
 void        __ovld __conv intel_sub_group_block_write_us16( __global ushort* p, ushort16 data );
+
+#if defined(cl_intel_subgroup_buffer_prefetch)
+void        __ovld __conv intel_sub_group_block_prefetch_us(const __global ushort *p);
+void        __ovld __conv intel_sub_group_block_prefetch_us2(const __global ushort *p);
+void        __ovld __conv intel_sub_group_block_prefetch_us4(const __global ushort *p);
+void        __ovld __conv intel_sub_group_block_prefetch_us8(const __global ushort *p);
+void        __ovld __conv intel_sub_group_block_prefetch_us16(const __global ushort *p);
+#endif // defined(cl_intel_subgroup_buffer_prefetch)
 #endif // cl_intel_subgroups_short
 
 #if defined(cl_intel_subgroups_char)
@@ -17795,6 +17862,14 @@ void        __ovld __conv intel_sub_group_block_write_uc2( __global uchar* p, uc
 void        __ovld __conv intel_sub_group_block_write_uc4( __global uchar* p, uchar4 data );
 void        __ovld __conv intel_sub_group_block_write_uc8( __global uchar* p, uchar8 data );
 void        __ovld __conv intel_sub_group_block_write_uc16( __global uchar* p, uchar16 data );
+
+#if defined(cl_intel_subgroup_buffer_prefetch)
+void        __ovld __conv intel_sub_group_block_prefetch_uc(const __global uchar *p);
+void        __ovld __conv intel_sub_group_block_prefetch_uc2(const __global uchar *p);
+void        __ovld __conv intel_sub_group_block_prefetch_uc4(const __global uchar *p);
+void        __ovld __conv intel_sub_group_block_prefetch_uc8(const __global uchar *p);
+void        __ovld __conv intel_sub_group_block_prefetch_uc16(const __global uchar *p);
+#endif // defined(cl_intel_subgroup_buffer_prefetch)
 #endif // cl_intel_subgroups_char
 
 #if defined(cl_intel_subgroups_long)
@@ -17839,6 +17914,13 @@ void        __ovld __conv intel_sub_group_block_write_ul(  __global ulong* p, ul
 void        __ovld __conv intel_sub_group_block_write_ul2( __global ulong* p, ulong2 data );
 void        __ovld __conv intel_sub_group_block_write_ul4( __global ulong* p, ulong4 data );
 void        __ovld __conv intel_sub_group_block_write_ul8( __global ulong* p, ulong8 data);
+
+#if defined(cl_intel_subgroup_buffer_prefetch)
+void        __ovld __conv intel_sub_group_block_prefetch_ul(const __global ulong *p);
+void        __ovld __conv intel_sub_group_block_prefetch_ul2(const __global ulong *p);
+void        __ovld __conv intel_sub_group_block_prefetch_ul4(const __global ulong *p);
+void        __ovld __conv intel_sub_group_block_prefetch_ul8(const __global ulong *p);
+#endif // defined(cl_intel_subgroup_buffer_prefetch)
 #endif // cl_intel_subgroups_long
 
 #if defined(cl_intel_subgroup_local_block_io)
@@ -17852,19 +17934,15 @@ void    __ovld __conv intel_sub_group_block_write2( __local uint* p, uint2 data
 void    __ovld __conv intel_sub_group_block_write4( __local uint* p, uint4 data );
 void    __ovld __conv intel_sub_group_block_write8( __local uint* p, uint8 data );
 
-#if defined(cl_intel_subgroups_char) || defined(cl_intel_subgroups_short) ||   \
-    defined(cl_intel_subgroups_long)
-uint       __ovld __conv intel_sub_group_block_read_ui( const __local uint* p );
-uint2      __ovld __conv intel_sub_group_block_read_ui2( const __local uint* p );
-uint4      __ovld __conv intel_sub_group_block_read_ui4( const __local uint* p );
-uint8      __ovld __conv intel_sub_group_block_read_ui8( const __local uint* p );
-
-void       __ovld __conv intel_sub_group_block_write_ui( __local uint* p, uint data );
-void       __ovld __conv intel_sub_group_block_write_ui2( __local uint* p, uint2 data );
-void       __ovld __conv intel_sub_group_block_write_ui4( __local uint* p, uint4 data );
-void       __ovld __conv intel_sub_group_block_write_ui8( __local uint* p, uint8 data );
-#endif // defined(cl_intel_subgroups_char) || defined(cl_intel_subgroups_short) ||
-       // defined(cl_intel_subgroups_long)
+uint __ovld __conv intel_sub_group_block_read_ui(const __local uint *p);
+uint2 __ovld __conv intel_sub_group_block_read_ui2(const __local uint *p);
+uint4 __ovld __conv intel_sub_group_block_read_ui4(const __local uint *p);
+uint8 __ovld __conv intel_sub_group_block_read_ui8(const __local uint *p);
+
+void __ovld __conv intel_sub_group_block_write_ui(__local uint *p, uint data);
+void __ovld __conv intel_sub_group_block_write_ui2(__local uint *p, uint2 data);
+void __ovld __conv intel_sub_group_block_write_ui4(__local uint *p, uint4 data);
+void __ovld __conv intel_sub_group_block_write_ui8(__local uint *p, uint8 data);
 
 #if defined(cl_intel_subgroups_char)
 uchar      __ovld __conv intel_sub_group_block_read_uc(   const __local uchar* p );
@@ -17907,6 +17985,18 @@ void        __ovld __conv intel_sub_group_block_write_ul8( __local ulong* p, ulo
 #endif // defined(cl_intel_subgroups_long)
 #endif // cl_intel_subgroup_local_block_io
 
+#ifdef cl_intel_split_work_group_barrier
+void __ovld __conv intel_work_group_barrier_arrive(cl_mem_fence_flags flags);
+void __ovld __conv intel_work_group_barrier_wait(cl_mem_fence_flags flags);
+
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+void __ovld __conv intel_work_group_barrier_arrive(cl_mem_fence_flags flags,
+                                                   memory_scope scope);
+void __ovld __conv intel_work_group_barrier_wait(cl_mem_fence_flags flags,
+                                                 memory_scope scope);
+#endif // __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+#endif // cl_intel_split_work_group_barrier
+
 #ifdef cl_intel_device_side_avc_motion_estimation
 #pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : begin
 
@@ -18410,6 +18500,22 @@ intel_sub_group_avc_mce_convert_to_sic_result(
 #pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : end
 #endif // cl_intel_device_side_avc_motion_estimation
 
+#if defined(cl_intel_bfloat16_conversions)
+ushort __ovld intel_convert_bfloat16_as_ushort(float source);
+ushort2 __ovld intel_convert_bfloat162_as_ushort2(float2 source);
+ushort3 __ovld intel_convert_bfloat163_as_ushort3(float3 source);
+ushort4 __ovld intel_convert_bfloat164_as_ushort4(float4 source);
+ushort8 __ovld intel_convert_bfloat168_as_ushort8(float8 source);
+ushort16 __ovld intel_convert_bfloat1616_as_ushort16(float16 source);
+
+float __ovld intel_convert_as_bfloat16_float(ushort source);
+float2 __ovld intel_convert_as_bfloat162_float2(ushort2 source);
+float3 __ovld intel_convert_as_bfloat163_float3(ushort3 source);
+float4 __ovld intel_convert_as_bfloat164_float4(ushort4 source);
+float8 __ovld intel_convert_as_bfloat168_float8(ushort8 source);
+float16 __ovld intel_convert_as_bfloat1616_float16(ushort16 source);
+#endif // cl_intel_bfloat16_conversions
+
 #ifdef cl_amd_media_ops
 uint __ovld amd_bitalign(uint, uint, uint);
 uint2 __ovld amd_bitalign(uint2, uint2, uint2);
@@ -18627,4 +18733,5 @@ int __ovld arm_dot_acc_sat(char4, char4, int);
 
 #undef __cnfn
 #undef __ovld
+
 #endif //_OPENCL_H_