[OpenCL] Add image type handling for builtin functions

[svenvh]

Summary

Image types were previously available, but not working. This patch
adds handling for OpenCL builtin functions.

Rename the image type definitions in the .td file to make them
consistent with other type names. Use abstract types to represent the
unqualified types. Instantiate access-qualified image types at the
point of use using e.g. ImageType<Image2d, "RO">.

Add/update some TableGen definitions that use image types.

[Pierre]

Add context lines

[Anastasia]

This patch adds handling for OpenCL builtin functions.

I think this is a copy-paste from other reviews. :)

clang/lib/Sema/OpenCLBuiltins.td

44

Btw _IsAbstract can be bit type?

136

Btw do we always need to set all the inherited fields in each subclass in the same way?

For example VecWidth should be set to 0 in image types?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

247

0:default -> 0:none

449

Can you explain this better please.

463

Also can you explain perhaps with an example what you are trying to emit...

[Pierre]

Corrections.

clang/lib/Sema/OpenCLBuiltins.td

136

This was meant to take the values from _Ty when default values from the Type class could have been wrong.
This might not be necessary for every field of every subclass of the Type class, but this is safer.

For example VecWidth should be set to 0 in image types?

Indeed, the two incompatible fields that I see are the VecWidth of the ImageType class, and the AccessQualifier of the VectorType.

[Pierre]

Rebase on previous patches.

[svenvh]

• Use StringSwitch in some places
• Improve comments
• clang-format
• Use an enum instead of an unsigned to represent qualifiers.

[Anastasia]

clang/lib/Sema/OpenCLBuiltins.td

136

Probably doesn't belong to this patch I was just wondering whether it would make sense to factor our uncommon fields like AccessQualifier from common Type?

449

I think 3D image writes are only available in CL2.0 and the same for all read_write images. Are we guarding that?

clang/test/SemaOpenCL/fdeclare-opencl-builtins.cl

65

some testing of CL versions would be good.

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

136

It might be possible, but in the end we need to set the AccessQualifier field somewhere as Type represents the entries in the final table.

449

Not yet, that will have to be guarded by a future patch as there is no handling of versions and extension on Clang master yet. Something to add to https://reviews.llvm.org/D63504 I suppose.

clang/test/SemaOpenCL/fdeclare-opencl-builtins.cl

65

There is no handling of OpenCL versions / extensions yet.

[svenvh]

Rebase, add other image read and write builtins, add some tests.

[Anastasia]

LGTM! Thanks!

clang/lib/Sema/OpenCLBuiltins.td

 // OpenCL vector types (e.g.: int2, int3, int16, float8, ...).
 class VectorType<Type _Ty, int _VecWidth> : Type<_Ty.Name, _Ty.QTName> {
   let VecWidth = _VecWidth;
+  let AccessQualifier = "";
   // Inherited fields
   let IsPointer = _Ty.IsPointer;
   let IsConst = _Ty.IsConst;
   let IsVolatile = _Ty.IsVolatile;
-  let AccessQualifier = _Ty.AccessQualifier;
   let AddrSpace = _Ty.AddrSpace;
 }
 

   let AddrSpace = _Ty.AddrSpace;
 }
 
-// OpenCL image types (e.g. image2d_t, ...)
-class ImageType<Type _Ty, QualType _QTName, string _AccessQualifier> :
-                                              Type<_Ty.Name, _QTName> {
+// OpenCL image types (e.g.: image2d)
+class ImageType<Type _Ty, string _AccessQualifier> :
+          Type<_Ty.Name, QualType<_Ty.QTName.Name#_AccessQualifier#"Ty", 0>> {
+  let VecWidth = 0;
   let AccessQualifier = _AccessQualifier;
+  // Inherited fields
+  let IsPointer = _Ty.IsPointer;
+  let IsConst = _Ty.IsConst;
+  let IsVolatile = _Ty.IsVolatile;
+  let AddrSpace = _Ty.AddrSpace;
 }
 
 // Store a list of Types.

 // using VectorTypes.
 
 
-// OpenCL v1.2 s6.1.3: Other Built-in Data Types
-// These definitions with a "null" name are "abstract". They should not
-// be used in definitions of Builtin functions.
-def image2d_t         : Type<"image2d_t", QualType<"null", 1>>;
-def image3d_t         : Type<"image3d_t", QualType<"null", 1>>;
-def image2d_array_t   : Type<"image2d_array_t", QualType<"null", 1>>;
-def image1d_t         : Type<"image1d_t", QualType<"null", 1>>;
-def image1d_buffer_t  : Type<"image1d_buffer_t", QualType<"null", 1>>;
-def image1d_array_t   : Type<"image1d_array_t", QualType<"null", 1>>;
-// Unlike the few functions above, the following definitions can be used
-// in definitions of Builtin functions (they have a QualType with a name).
-foreach v = ["RO", "WO", "RW"] in {
-  def image2d_#v#_t       : ImageType<image2d_t,
-                                      QualType<"OCLImage2d"#v#"Ty">,
-                                      v>;
-  def image3d_#v#_t       : ImageType<image3d_t,
-                                      QualType<"OCLImage3d"#v#"Ty">,
-                                      v>;
-  def image2d_array#v#_t  : ImageType<image2d_array_t,
-                                      QualType<"OCLImage2dArray"#v#"Ty">,
-                                      v>;
-  def image1d_#v#_t       : ImageType<image1d_t,
-                                      QualType<"OCLImage1d"#v#"Ty">,
-                                      v>;
-  def image1d_buffer#v#_t : ImageType<image1d_buffer_t,
-                                      QualType<"OCLImage1dBuffer"#v#"Ty">,
-                                      v>;
-  def image1d_array#v#_t  : ImageType<image1d_array_t,
-                                      QualType<"OCLImage1dArray"#v#"Ty">,
-                                      v>;
-}
+// OpenCL v1.0/1.2/2.0 : 6.1.3 : Other Built-in Data Types
+// These definitions are "abstract". They should not be used as such.
+// They need an access qualifier specified (RO/WO/RW).
+// See where image types are used as example.
+def Image2d               : Type<"image2d_t", QualType<"OCLImage2d", 1>>;
+def Image3d               : Type<"image3d_t", QualType<"OCLImage3d", 1>>;
+def Image2dArray          : Type<"image2d_array_t", QualType<"OCLImage2dArray", 1>>;
+def Image1d               : Type<"image1d_t", QualType<"OCLImage1d", 1>>;
+def Image1dBuffer         : Type<"image1d_buffer_t", QualType<"OCLImage1dBuffer", 1>>;
+def Image1dArray          : Type<"image1d_array_t", QualType<"OCLImage1dArray", 1>>;
+def Image2dDepth          : Type<"image2d_depth_t", QualType<"OCLImage2dDepth", 1>>;
+def Image2dArrayDepth     : Type<"image2d_array_depth_t", QualType<"OCLImage2dArrayDepth", 1>>;
+def Image2dMsaa           : Type<"image2d_msaa_t", QualType<"OCLImage2dMSAA", 1>>;
+def Image2dArrayMsaa      : Type<"image2d_array_msaa_t", QualType<"OCLImage2dArrayMSAA", 1>>;
+def Image2dMsaaDepth      : Type<"image2d_msaa_depth_t", QualType<"OCLImage2dMSAADepth", 1>>;
+def Image2dArrayMsaaDepth : Type<"image2d_array_msaa_depth_t", QualType<"OCLImage2dArrayMSAADepth", 1>>;
 
 def Sampler           : Type<"Sampler", QualType<"OCLSamplerTy">>;
 def Event             : Type<"Event", QualType<"OCLEventTy">>;

   def : Builtin<name, [GenTypeHalfListNNoScalar, GenTypeHalfListNNoScalar, Half]>;
 }
 
-// OpenCL v1.2 s6.12.14: Built-in Image Read Functions
-def read_imagef : Builtin<"read_imagef",
-                          [VectorType<Float, 4>, image2d_RO_t, VectorType<Int, 2>]>;
-def write_imagef : Builtin<"write_imagef",
-                           [Void,
-                            image2d_WO_t,
-                            VectorType<Int, 2>,
-                            VectorType<Float, 4>]>;
+
+// OpenCL extension v2.0 s5.1.9 : Built-in Image Read Functions
+// --- Table 8 ---
+foreach aQual = ["RO"] in {
+  foreach name = ["read_imageh"] in {
+    foreach Type1 = [Int, Float] in {
+      foreach Type2 = [Image2d, Image1dArray] in {
+        def : Builtin<name, [VectorType<Half, 4>, ImageType<Type2, aQual>, Sampler, VectorType<Type1, 2>]>;
+      }
+      foreach Type2 = [Image3d, Image2dArray] in {
+        def : Builtin<name, [VectorType<Half, 4>, ImageType<Type2, aQual>, Sampler, VectorType<Type1, 4>]>;
+      }
+      foreach Type2 = [Image1d] in {
+        def : Builtin<name, [VectorType<Half, 4>, ImageType<Type2, aQual>, Sampler, Type1]>;
+      }
+    }
+  }
+}
+// OpenCL extension v2.0 s5.1.10 : Built-in Image Sampler-less Read Functions
+// --- Table 9 ---
+foreach aQual = ["RO", "RW"] in {
+  foreach name = ["read_imageh"] in {
+    foreach Type1 = [Image2d, Image1dArray] in {
+      def : Builtin<name, [VectorType<Half, 4>, ImageType<Type1, aQual>, VectorType<Int, 2>]>;
+    }
+    foreach Type1 = [Image3d, Image2dArray] in {
+      def : Builtin<name, [VectorType<Half, 4>, ImageType<Type1, aQual>, VectorType<Int, 4>]>;
+    }
+    foreach Type1 = [Image1d, Image1dBuffer] in {
+      def : Builtin<name, [VectorType<Half, 4>, ImageType<Type1, aQual>, Int]>;
+    }
+  }
+}
+// OpenCL extension v2.0 s5.1.11 : Built-in Image Write Functions
+// --- Table 10 ---
+foreach aQual = ["WO", "RW"] in {
+  foreach name = ["write_imageh"] in {
+    def : Builtin<name, [Void, ImageType<Image2d, aQual>, VectorType<Int, 2>, VectorType<Half, 4>]>;
+    def : Builtin<name, [Void, ImageType<Image2dArray, aQual>, VectorType<Int, 4>, VectorType<Half, 4>]>;
+    def : Builtin<name, [Void, ImageType<Image1d, aQual>, Int, VectorType<Half, 4>]>;
+    def : Builtin<name, [Void, ImageType<Image1dBuffer, aQual>, Int, VectorType<Half, 4>]>;
+    def : Builtin<name, [Void, ImageType<Image1dArray, aQual>, VectorType<Int, 2>, VectorType<Half, 4>]>;
+    def : Builtin<name, [Void, ImageType<Image3d, aQual>, VectorType<Int, 4>, VectorType<Half, 4>]>;
+  }
+}
+
 
 
 // OpenCL v2.0 s9.17.3: Additions to section 6.13.1: Work-Item Functions

clang/test/SemaOpenCL/fdeclare-opencl-builtins.cl

 
 // Test the -fdeclare-opencl-builtins option.
 
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
 // Provide typedefs when invoking clang without -finclude-default-header.
 #ifdef NO_HEADER
 typedef char char2 __attribute__((ext_vector_type(2)));
 typedef float float4 __attribute__((ext_vector_type(4)));
+typedef half half4 __attribute__((ext_vector_type(4)));
 typedef int int2 __attribute__((ext_vector_type(2)));
 typedef int int4 __attribute__((ext_vector_type(4)));
 typedef long long2 __attribute__((ext_vector_type(2)));

   i4 = convert_int4_sat(f4);
 }
 
+kernel void basic_image_readonly(read_only image2d_t image_read_only_image2d) {
+  int2 i2;
+  sampler_t sampler;
+
+  read_imageh(image_read_only_image2d, i2);
+  read_imageh(image_read_only_image2d, sampler, i2);
+}
+
+kernel void basic_image_readwrite(read_write image3d_t image_read_write_image3d) {
+  half4 h4;
+  int4 i4;
+
+  write_imageh(image_read_write_image3d, i4, h4);
+}
+
+kernel void basic_image_writeonly(write_only image1d_buffer_t image_write_only_image1d_buffer) {
+  half4 h4;
+  int i;
+
+  write_imageh(image_write_only_image1d_buffer, i, h4);
+}
+
 kernel void basic_subgroup(global uint *out) {
   out[0] = get_sub_group_size();
 }

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

 // };
 //
 // static const OpenCLTypeStruct TypeTable[] = {
-//   { OCLT_double, 2, 0, 0, 0, clang::LangAS::Default},
+//   { OCLT_double, 2, 0, 0, 0, 0, clang::LangAS::Default},
 //   // This represents the double type, with a vector width of 2,
-//   // which is not a pointer (0), not a const (0), not a volatile (0).
+//   // which is not a pointer (0), not a const (0), not a volatile (0),
+//   // and no access specifier (0).
 //   // The address space is not relevant since this is not a pointer.
 //   ... // Other types with their vector size.
 // };

   // have several attributes (e.g. the size of the vector (if applicable),
   // if this is a pointer type, a const type, ...).
   // E.g.:
-  // { OCLT_Double, 2, 0, 0, 0, clang::LangAS::Default},
+  // { OCLT_Double, 2, 0, 0, 0, 0, clang::LangAS::Default},
   // is describing the type "Double", being a vector of 2 elements. See the
   // struct OpenCLTypeStruct for more information.
   void EmitTypeTable();

   const bool IsConst;
   // 0 if the type is not volatile.
   const bool IsVolatile;
+  // 0:none, 1:read_only, 2:write_only, 3:read_write
+  const unsigned AccessQualifier;
   // Address space of the pointer (if applicable).
   const LangAS AS;
 };

 
 
 void BuiltinNameEmitter::EmitTypeTable() {
+  // Access Qualifier
+  unsigned AQ;
+  std::string AQName;
+
   OS << "static const OpenCLTypeStruct TypeTable[] = {\n";
   for (const auto &T : TypeMap) {
+    AQ = 0;
+    AQName = T.first->getValueAsString("AccessQualifier");
+    switch (AQName[0]) {
+      case 'R':
+        switch (AQName[1]) {
+          case 'O': // RO
+            AQ = 1;
+            break;
+          case 'W': // RW
+            AQ = 3;
+            break;
+        }
+        break;
+      case 'W': // WO
+        AQ = 2;
+        break;
+      default: // none
+        AQ = 0;
+        break;
+    }
+
     OS << "  // " << T.second << "\n";
     OS << "  { OCLT_" << T.first->getValueAsString("Name") << ", "
        << T.first->getValueAsInt("VecWidth") << ", "
        << T.first->getValueAsBit("IsPointer") << ", "
        << T.first->getValueAsBit("IsConst") << ", "
        << T.first->getValueAsBit("IsVolatile") << ", "
+       << AQ << ", " // AccessQualifier
        << T.first->getValueAsString("AddrSpace") << "},\n";
   }
   OS << "};\n\n";

   // functions.
   OS << "\n\n  switch (Ty.ID) {\n";
 
+  // Switch cases for image types (Image2d, Image3d, ...)
+  std::vector<Record *> ImageTypes =
+      Records.getAllDerivedDefinitions("ImageType");
+
+  // ImageTypesMap maps the name of an image type to its 3 instances
+  // (RO, WO, RW).
+  // ImageTypesMap("Image2d") = <<Record* <name="Image2d", AQ="RO">
+  //                             <Record* <name="Image2d", AQ="WO">
+  //                             <Record* <name="Image2d", AQ="RW">>
+  std::map<StringRef, SmallVector<Record *, 3>> ImageTypesMap;
+
+  // Populate ImageTypesMap.
+  for (auto *IT : ImageTypes) {
+    std::map<StringRef, SmallVector<Record *, 3>>::iterator Entry =
+        ImageTypesMap.find(IT->getValueAsString("Name"));
+    if (Entry == ImageTypesMap.end()) {
+      SmallVector<Record *, 3> ImageList;
+      ImageList.push_back(IT);
+      ImageTypesMap.insert(std::make_pair(IT->getValueAsString("Name"),
+                                          ImageList));
+    } else {
+      Entry->second.push_back(IT);
+    }
+  }
+
+  // Emit the cases for the image types.
+  // For an image type name, there are 3 QualType associated ("RO", "WO", "RW").
+  // The "AccessQualifier" field allows to find which one is needed.
+  // The code emitted for the "Image2d" type is as below:
+  // case OCLT_image2d_t:
+  //   switch (Ty.AccessQualifier) {
+  //     case 1: // RO
+  //       QT.push_back(Context.OCLImage2dROTy);
+  //       break;
+  //     case 3: // RW
+  //       QT.push_back(Context.OCLImage2dRWTy);
+  //       break;
+  //     case 2: // WO
+  //       QT.push_back(Context.OCLImage2dWOTy);
+  //       break;
+  //   }
+  //   break;
+  for (const auto &ITE : ImageTypesMap) {
+    OS << "    case OCLT_" << ITE.first.str() << ":\n";
+    OS << "      switch (Ty.AccessQualifier) {\n";
+    for (const auto &Image : ITE.second) {
+      switch (Image->getValueAsString("AccessQualifier").str()[0]) {
+        case 'R':
+          switch (Image->getValueAsString("AccessQualifier").str()[1]) {
+            case 'O':
+              OS << "        case 1: // RO\n";
+              break;
+            case 'W':
+              OS << "        case 3: // RW\n";
+              break;
+          }
+          break;
+        case 'W':
+          OS << "        case 2: // WO\n";
+          break;
+      }
+      OS << "          QT.push_back(Context."
+         << Image->getValueAsDef("QTName")->getValueAsString("Name") << ");\n"
+         << "          break;\n";
+    }
+    OS << "      }\n";
+    OS << "      break;\n";
+  }
+
   // Switch case for generic types.
   // The genererated code for the FGenTypeN generic type is:
   // case OCLT_FGenTypeN:

   StringMap<bool> TypesSeen;
 
   for (const auto *T : Types) {
-    // Check we have not seen this Type
+    // Check this isn't an image type
+    if (ImageTypesMap.find(T->getValueAsString("Name")) != ImageTypesMap.end())
+      continue;
+    // Check we haven't seen this Type
     if (TypesSeen.find(T->getValueAsString("Name")) != TypesSeen.end())
       continue;
     TypesSeen.insert(std::make_pair(T->getValueAsString("Name"), true));