[OpenCL] Diagnose write_only image3d when extension is disabled

[svenvh]

Summary

Diagnose write_only image3d when extension is disabled

Prior to OpenCL 2.0, image3d_t can only be used with the write_only
access qualifier when the cl_khr_3d_image_writes extension is enabled,
see e.g. OpenCL 1.1 s6.8b.

Require the extension for write_only image3d_t types and guard uses of
write_only image3d_t in the OpenCL header.

[yaxunl]

The tests should be added to SemaOpenCL/extension-version.cl

lib/Sema/SemaType.cpp

6683

should modify OpenCLImageTypes.def for image types associated with an extension. The diagnostics will be emitted automatically.

[svenvh]

Removed the custom sema check and added the extension to the image type in OpenCLImageTypes.def.

[svenvh]

In D28860#653662, @yaxunl wrote:

The tests should be added to SemaOpenCL/extension-version.cl

SemaOpenCL/extension-version.cl already has a test for the cl_khr_3d_image_writes extension.

lib/Sema/SemaType.cpp

6683

That's neat, thanks for pointing it out!

[yaxunl]

LGTM. Thanks!

[Anastasia]

Committed in r293050!

lib/Headers/opencl-c.h

 #define _OPENCL_H_
 
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 #ifndef cl_khr_depth_images
 #define cl_khr_depth_images
 #endif //cl_khr_depth_images
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
+#if __OPENCL_C_VERSION__ < CL_VERSION_2_0
+#ifdef cl_khr_3d_image_writes
+#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
+#endif //cl_khr_3d_image_writes
+#endif //__OPENCL_C_VERSION__ < CL_VERSION_2_0
+
 #define __ovld __attribute__((overloadable))
 #define __conv __attribute__((convergent))
 
 // Optimizations
 #define __purefn __attribute__((pure))
 #define __cnfn __attribute__((const))
 
 // built-in scalar data types:

 void __ovld write_imagef(write_only image1d_buffer_t image, int coord, float4 color);
 void __ovld write_imagei(write_only image1d_buffer_t image, int coord, int4 color);
 void __ovld write_imageui(write_only image1d_buffer_t image, int coord, uint4 color);
 
 void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, float4 color);
 void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);
 void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);
 
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);
 void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);
 void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);
+#endif
 
 #ifdef cl_khr_depth_images
 void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, float color);
 void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, float color);
 #endif //cl_khr_depth_images
 
 // OpenCL Extension v2.0 s9.18 - Mipmaps
 #ifdef cl_khr_mipmap_image

 
 void __ovld write_imagef(write_only image2d_array_t image_array, int4 coord, int lod, float4 color);
 void __ovld write_imagei(write_only image2d_array_t image_array, int4 coord, int lod, int4 color);
 void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, int lod, uint4 color);
 
 void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float color);
 void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float color);
 
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);
 void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);
 void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);
+#endif
 #endif //cl_khr_mipmap_image
 
 // Image write functions for half4 type
 #ifdef cl_khr_fp16
 void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);
 void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);
+#endif
 void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);
 void __ovld write_imageh(write_only image2d_array_t image, int4 coord, half4 color);
 void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 color);
 #endif //cl_khr_fp16
 
 // Image write functions for read_write images
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 void __ovld write_imagef(read_write image2d_t image, int2 coord, float4 color);

 void __ovld write_imagef(read_write image1d_buffer_t image, int coord, float4 color);
 void __ovld write_imagei(read_write image1d_buffer_t image, int coord, int4 color);
 void __ovld write_imageui(read_write image1d_buffer_t image, int coord, uint4 color);
 
 void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, float4 color);
 void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);
 void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);
 
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);
 void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);
 void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);
+#endif
 
 #ifdef cl_khr_depth_images
 void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, float color);
 void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, float color);
 #endif //cl_khr_depth_images
 
 #ifdef cl_khr_mipmap_image
 void __ovld write_imagef(read_write image1d_t image, int coord, int lod, float4 color);

 
 void __ovld write_imagef(read_write image2d_array_t image_array, int4 coord, int lod, float4 color);
 void __ovld write_imagei(read_write image2d_array_t image_array, int4 coord, int lod, int4 color);
 void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, int lod, uint4 color);
 
 void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);
 void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);
 
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);
 void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);
 void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);
+#endif
 #endif //cl_khr_mipmap_image
 
 // Image write functions for half4 type
 #ifdef cl_khr_fp16
 void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);
 void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);
+#ifdef cl_khr_3d_image_writes
 void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);
+#endif
 void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);
 void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);
 void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);
 #endif //cl_khr_fp16
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 // Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have
 // access qualifier, which by default assume read_only access qualifier. Image query builtin
 // functions with write_only image argument should also be declared.
 
 /**
  * Return the image width in pixels.
  *
   */
 int __ovld __cnfn get_image_width(read_only image1d_t image);
 int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);
 int __ovld __cnfn get_image_width(read_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_width(read_only image3d_t image);
+#endif
 int __ovld __cnfn get_image_width(read_only image1d_array_t image);
 int __ovld __cnfn get_image_width(read_only image2d_array_t image);
 #ifdef cl_khr_depth_images
 int __ovld __cnfn get_image_width(read_only image2d_depth_t image);
 int __ovld __cnfn get_image_width(read_only image2d_array_depth_t image);
 #endif //cl_khr_depth_images
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_width(read_only image2d_msaa_t image);
 int __ovld __cnfn get_image_width(read_only image2d_msaa_depth_t image);
 int __ovld __cnfn get_image_width(read_only image2d_array_msaa_t image);
 int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);
 #endif //cl_khr_gl_msaa_sharing
 
 int __ovld __cnfn get_image_width(write_only image1d_t image);
 int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);
 int __ovld __cnfn get_image_width(write_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_width(write_only image3d_t image);
+#endif
 int __ovld __cnfn get_image_width(write_only image1d_array_t image);
 int __ovld __cnfn get_image_width(write_only image2d_array_t image);
 #ifdef cl_khr_depth_images
 int __ovld __cnfn get_image_width(write_only image2d_depth_t image);
 int __ovld __cnfn get_image_width(write_only image2d_array_depth_t image);
 #endif //cl_khr_depth_images
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_width(write_only image2d_msaa_t image);

 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_height(read_only image2d_msaa_t image);
 int __ovld __cnfn get_image_height(read_only image2d_msaa_depth_t image);
 int __ovld __cnfn get_image_height(read_only image2d_array_msaa_t image);
 int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);
 #endif //cl_khr_gl_msaa_sharing
 
 int __ovld __cnfn get_image_height(write_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_height(write_only image3d_t image);
+#endif
 int __ovld __cnfn get_image_height(write_only image2d_array_t image);
 #ifdef cl_khr_depth_images
 int __ovld __cnfn get_image_height(write_only image2d_depth_t image);
 int __ovld __cnfn get_image_height(write_only image2d_array_depth_t image);
 #endif //cl_khr_depth_images
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_height(write_only image2d_msaa_t image);
 int __ovld __cnfn get_image_height(write_only image2d_msaa_depth_t image);

 #endif //cl_khr_gl_msaa_sharing
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 /**
  * Return the image depth in pixels.
  */
 int __ovld __cnfn get_image_depth(read_only image3d_t image);
 
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_depth(write_only image3d_t image);
+#endif
 
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 int __ovld __cnfn get_image_depth(read_write image3d_t image);
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 // OpenCL Extension v2.0 s9.18 - Mipmaps
 #ifdef cl_khr_mipmap_image
 /**
  * Return the image miplevels.
  */
 
 int __ovld get_image_num_mip_levels(read_only image1d_t image);
 int __ovld get_image_num_mip_levels(read_only image2d_t image);
 int __ovld get_image_num_mip_levels(read_only image3d_t image);
 
 int __ovld get_image_num_mip_levels(write_only image1d_t image);
 int __ovld get_image_num_mip_levels(write_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld get_image_num_mip_levels(write_only image3d_t image);
+#endif
 
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 int __ovld get_image_num_mip_levels(read_write image1d_t image);
 int __ovld get_image_num_mip_levels(read_write image2d_t image);
 int __ovld get_image_num_mip_levels(read_write image3d_t image);
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 int __ovld get_image_num_mip_levels(read_only image1d_array_t image);

 int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_depth_t image);
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_t image);
 int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth_t image);
 #endif //cl_khr_gl_msaa_sharing
 
 int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);
 int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);
+#endif
 int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t image);
 #ifdef cl_khr_depth_images
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_depth_t image);
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_depth_t image);
 #endif //cl_khr_depth_images
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_t image);

 int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_depth_t image);
 int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_t image);
 int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t image);
 #endif //cl_khr_gl_msaa_sharing
 
 int __ovld __cnfn get_image_channel_order(write_only image1d_t image);
 int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);
 int __ovld __cnfn get_image_channel_order(write_only image2d_t image);
+#ifdef cl_khr_3d_image_writes
 int __ovld __cnfn get_image_channel_order(write_only image3d_t image);
+#endif
 int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);
 int __ovld __cnfn get_image_channel_order(write_only image2d_array_t image);
 #ifdef cl_khr_depth_images
 int __ovld __cnfn get_image_channel_order(write_only image2d_depth_t image);
 int __ovld __cnfn get_image_channel_order(write_only image2d_array_depth_t image);
 #endif //cl_khr_depth_images
 #if defined(cl_khr_gl_msaa_sharing)
 int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_t image);

 
 /**
  * Return the 3D image width, height, and depth as an
  * int4 type. The width is returned in the x
  * component, height in the y component, depth in the z
  * component and the w component is 0.
  */
 int4 __ovld __cnfn get_image_dim(read_only image3d_t image);
+#ifdef cl_khr_3d_image_writes
 int4 __ovld __cnfn get_image_dim(write_only image3d_t image);
+#endif
 #if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
 int4 __ovld __cnfn get_image_dim(read_write image3d_t image);
 #endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
 
 /**
  * Return the image array size.
  */
 

lib/Sema/SemaType.cpp

static void HandleOpenCLAccessAttr(QualType &CurType, const AttributeList &Attr,
                                    Sema &S) {
   // OpenCL v2.0 s6.6 - Access qualifier can be used only for image and pipe type.
   if (!(CurType->isImageType() || CurType->isPipeType())) {
     S.Diag(Attr.getLoc(), diag::err_opencl_invalid_access_qualifier);
     Attr.setInvalid();
     return;
   }
 
+  // OpenCL v1.1 s6.8b - The image3d_t type cannot be used with the __write_only
+  // access qualifier unless the cl_khr_3d_image_writes extension is enabled.
+  if (CurType->isOCLImage3dWOType() &&
+      !S.getOpenCLOptions().isEnabled("cl_khr_3d_image_writes")) {
+    S.Diag(Attr.getLoc(), diag::err_opencl_requires_extension)
+        << 0 /* select type */ << CurType << "cl_khr_3d_image_writes";
+    Attr.setInvalid();
+    return;
+  }
+
   if (const TypedefType* TypedefTy = CurType->getAs<TypedefType>()) {
     QualType PointeeTy = TypedefTy->desugar();
     S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers);
 
     std::string PrevAccessQual;
     switch (cast<BuiltinType>(PointeeTy.getTypePtr())->getKind()) {
       #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
     case BuiltinType::Id:                                          \

test/Headers/opencl-c-header.cl

 // RUN: %clang_cc1 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s | FileCheck %s
 // RUN: %clang_cc1 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -cl-std=CL1.1| FileCheck %s
 
-// CHECK: _Z16convert_char_rtec
-// CHECK-NOT: _Z3ctzc
-// CHECK20: _Z3ctzc
-// CHECK20-NOT: _Z16convert_char_rtec
-// CHECK-MOD: Reading modules
-
 // Test including the default header as a module.
 // The module should be compiled only once and loaded from cache afterwards.
 // Change the directory mode to read only to make sure no new modules are created.
 // Check time report to make sure module is used.
+// Check that some builtins occur in the generated IR when called.
 
 // ===
 // Clear current directory.
 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 
 // ===
 // Compile for OpenCL 1.0 for the first time. A module should be generated.

 // RUN: mkdir -p %t
 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
 // RUN: %clang_cc1 -triple amdgcn--amdhsa -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
 // RUN: chmod u-w %t 
 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
 // RUN: %clang_cc1 -triple amdgcn--amdhsa -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
 // RUN: chmod u+w %t
 
+// Verify that called builtins occur in the generated IR.
+
+// CHECK: _Z16convert_char_rtec
+// CHECK-NOT: _Z3ctzc
+// CHECK20: _Z3ctzc
+// CHECK20-NOT: _Z16convert_char_rtec
 char f(char x) {
 #if __OPENCL_C_VERSION__ != CL_VERSION_2_0
   return convert_char_rte(x);
 #ifdef NO_HEADER
   //expected-warning@-2{{implicit declaration of function 'convert_char_rte' is invalid in C99}}
 #endif //NO_HEADER
 
 #else //__OPENCL_C_VERSION__
   return ctz(x);
 #endif //__OPENCL_C_VERSION__
 }
+
+// Verify that a builtin using a write_only image3d_t type is available
+// from OpenCL 2.0 onwards.
+
+// CHECK20: _Z12write_imagef14ocl_image3d_wo
+#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
+void test_image3dwo(write_only image3d_t img) {
+  write_imagef(img, (0), (0.0f));
+}
+#endif //__OPENCL_C_VERSION__
+
+// CHECK-MOD: Reading modules

test/SemaOpenCL/access-qualifier.cl

 #endif
 
 #if __OPENCL_C_VERSION__ >= 200
 void myPipeWrite(write_only pipe int); // expected-note {{passing argument to parameter here}}
 kernel void k14(read_only pipe int p) {
   myPipeWrite(p); // expected-error {{passing 'read_only pipe int' to parameter of incompatible type 'write_only pipe int'}}
 }
 #endif
+
+#if __OPENCL_C_VERSION__ < 200
+kernel void test_image3d_wo(write_only image3d_t img) {} // expected-error {{use of type '__write_only image3d_t' requires cl_khr_3d_image_writes extension to be enabled}}
+#endif