[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?

139

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

301

0:default -> 0:none

517

Can you explain this better please.

531

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

[Pierre]

Corrections.

clang/lib/Sema/OpenCLBuiltins.td

139

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

137–142

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?

391

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

81

some testing of CL versions would be good.

[svenvh]

clang/lib/Sema/OpenCLBuiltins.td

137–142

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.

391

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

81

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

 def PrivateAS    : AddressSpace<"clang::LangAS::opencl_private">;
 def GlobalAS     : AddressSpace<"clang::LangAS::opencl_global">;
 def ConstantAS   : AddressSpace<"clang::LangAS::opencl_constant">;
 def LocalAS      : AddressSpace<"clang::LangAS::opencl_local">;
 def GenericAS    : AddressSpace<"clang::LangAS::opencl_generic">;
 
 
 // Qualified Type. Allow to retrieve an ASTContext QualType.
-class QualType<string _Name, int _IsAbstract=0> {
+class QualType<string _Name, bit _IsAbstract=0> {
   // Name of the field or function in a clang::ASTContext
   // E.g. Name="IntTy" for the int type, and "getIntPtrType()" for an intptr_t
   string Name = _Name;
   // Some QualType should not be used as such. This is a mean to identify them.
   bit IsAbstract = _IsAbstract;
 }
 
 
class Type<string _Name, QualType _QTName> {
   string AccessQualifier = "";
   // Address space associated.
   string AddrSpace = DefaultAS.Name;
 }
 
 // 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;
 }
 
 // OpenCL pointer types (e.g.: int*, float*, ...)
 class PointerType<Type _Ty, AddressSpace _AS = DefaultAS> :
                                       Type<_Ty.Name, _Ty.QTName> {
   let AddrSpace = _AS.Name;
   // Inherited fields
class VolatileType<Type _Ty> : Type<_Ty.Name, _Ty.QTName> {
   let IsVolatile = 1;
   // Inherited fields
   let VecWidth = _Ty.VecWidth;
   let IsPointer = _Ty.IsPointer;
   let IsConst = _Ty.IsConst;
   let AccessQualifier = _Ty.AccessQualifier;
   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_t)
+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.
 class TypeList<string _Name, list<Type> _Type> {
   string Name = _Name;
   list<Type> List = _Type;
 }
 

 def uintptr_t   : Type<"uintptr_t", QualType<"getUIntPtrType()">>;
 def void_t      : Type<"void", QualType<"VoidTy">>;
 
 // OpenCL v1.0/1.2/2.0/2.0 s6.1.2: Built-in Vector Data Types.
 // VectorTypes are dynamically defined. See the OpenCL 2.0 : 6.13.7 section of
 // this file as example.
 
 
-// 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 the OpenCL extension v2.2 s5.1.9 of this file as example.
+def image2d_t             : Type<"image2d_t", QualType<"OCLImage2d", 1>>;
+def image3d_t             : Type<"image3d_t", QualType<"OCLImage3d", 1>>;
+def image2d_array_t       : Type<"image2d_array_t", QualType<"OCLImage2dArray", 1>>;
+def image1d_t             : Type<"image1d_t", QualType<"OCLImage1d", 1>>;
+def image1d_buffer_t      : Type<"image1d_buffer_t", QualType<"OCLImage1dBuffer", 1>>;
+def image1d_array_t       : Type<"image1d_array_t", QualType<"OCLImage1dArray", 1>>;
+def image2d_depth_t       : Type<"image2d_depth_t", QualType<"OCLImage2dDepth", 1>>;
+def image2d_array_depth_t : Type<"image2d_array_depth_t", QualType<"OCLImage2dArrayDepth", 1>>;
+def image2d_msaa_t             : Type<"image2d_msaa_t", QualType<"OCLImage2dMSAA", 1>>;
+def image2d_array_msaa_t       : Type<"image2d_array_msaa_t", QualType<"OCLImage2dArrayMSAA", 1>>;
+def image2d_msaa_depth_t       : Type<"image2d_msaa_depth_t", QualType<"OCLImage2dMSAADepth", 1>>;
+def image2d_array_msaa_depth_t : Type<"image2d_array_msaa_depth_t", QualType<"OCLImage2dArrayMSAADepth", 1>>;
 def sampler_t         : Type<"sampler_t", QualType<"OCLSamplerTy">>;
 def event_t           : Type<"event_t", QualType<"OCLEventTy">>;
 
 // Generic types and lists of int.
 // Lists of int.
 def ListNNonZero : IntList<"ListNNonZero", [2, 3, 4, 8, 16]>;
 def ListN        : IntList<"ListN", [0, 2, 3, 4, 8, 16]>;
 // GenTypes lists.

 
 foreach name = ["fmax", "fmin"] in {
   def : Builtin<name, [FGenTypeN, FGenTypeN, FGenTypeN]>;
   def : Builtin<name, [genType_float_ListNNonZero, genType_float_ListNNonZero, float_t]>;
   def : Builtin<name, [genType_double_ListNNonZero, genType_double_ListNNonZero, double_t]>;
   def : Builtin<name, [genType_half_ListNNonZero, genType_half_ListNNonZero, half_t]>;
 }
 
-// OpenCL v1.2 s6.12.14: Built-in Image Read Functions
-def read_imagef : Builtin<"read_imagef",
-                          [VectorType<float_t, 4>, image2d_RO_t, VectorType<int_t, 2>]>;
-def write_imagef : Builtin<"write_imagef",
-                           [void_t,
-                            image2d_WO_t,
-                            VectorType<int_t, 2>,
-                            VectorType<float_t, 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_t, float_t] in {
+      foreach Type2 = [image2d_t, image1d_array_t] in {
+        def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type2, aQual>, sampler_t, VectorType<Type1, 2>]>;
+      }
+      foreach Type2 = [image3d_t, image2d_array_t] in {
+        def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type2, aQual>, sampler_t, VectorType<Type1, 4>]>;
+      }
+      foreach Type2 = [image1d_t] in {
+        def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type2, aQual>, sampler_t, Type1]>;
+      }
+    }
+  }
+}
+// OpenCL extension v2.2 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_t, image1d_array_t] in {
+      def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type1, aQual>, VectorType<int_t, 2>]>;
+    }
+    foreach Type1 = [image3d_t, image2d_array_t] in {
+      def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type1, aQual>, VectorType<int_t, 4>]>;
+    }
+    foreach Type1 = [image1d_t, image1d_buffer_t] in {
+      def : Builtin<name, [VectorType<half_t, 4>, ImageType<Type1, aQual>, int_t]>;
+    }
+  }
+}
+// OpenCL extension v2.2 s5.1.11 : Built-in Image Write Functions
+// --- Table 10 ---
+foreach aQual = ["WO", "RW"] in {
+  foreach name = ["write_imageh"] in {
+    def : Builtin<name, [void_t, ImageType<image2d_t, aQual>, VectorType<int_t, 2>, VectorType<half_t, 4>]>;
+    def : Builtin<name, [void_t, ImageType<image2d_array_t, aQual>, VectorType<int_t, 4>, VectorType<half_t, 4>]>;
+    def : Builtin<name, [void_t, ImageType<image1d_t, aQual>, int_t, VectorType<half_t, 4>]>;
+    def : Builtin<name, [void_t, ImageType<image1d_buffer_t, aQual>, int_t, VectorType<half_t, 4>]>;
+    def : Builtin<name, [void_t, ImageType<image1d_array_t, aQual>, VectorType<int_t, 2>, VectorType<half_t, 4>]>;
+    def : Builtin<name, [void_t, ImageType<image3d_t, aQual>, VectorType<int_t, 4>, VectorType<half_t, 4>]>;
+  }
+}
+
 
 
 // OpenCL v2.0 s9.17.3: Additions to section 6.13.1: Work-Item Functions
 let Version = CL20 in {
   let Extension = "cl_khr_subgroups" in {
     def get_sub_group_size : Builtin<"get_sub_group_size", [uint_t]>;
     def get_max_sub_group_size : Builtin<"get_max_sub_group_size", [uint_t]>;
     def get_num_sub_groups : Builtin<"get_num_sub_groups", [uint_t]>;
   }
 }

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

 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -DNO_HEADER
 // RUN: %clang_cc1 %s -triple spir -verify -pedantic -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header
 // expected-no-diagnostics
 
 // 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)));
 typedef unsigned int uint;
 typedef __SIZE_TYPE__ size_t;
 #endif
 
 
kernel void basic_conversion() {
   int4 i4;
 
   f = convert_float(d);
   d = convert_double_sat_rtp(f);
   l2 = convert_long2_rtz(c2);
   i4 = convert_int4_sat(f4);
 }
 
-kernel void basic_readonly_image_type(__read_only image2d_t img, int2 coord, global float4 *out) {
-  out[0] = read_imagef(img, coord);
+kernel void basic_readonly_image_type(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_writeonly_image_type(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_readwrite_image_type(read_write image3d_t image_read_write_image3d) {
+  half4 h4;
+  int4 i4;
+
+  write_imageh(image_read_write_image3d, i4, h4);
 }
 
 kernel void basic_subgroup(global uint *out) {
   out[0] = get_sub_group_size();
 }

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

struct OpenCLTypeStruct {
   // Size of the vector (if applicable, 0 otherwise and for generic types).
   unsigned VectorWidth;
   // 0 if the type is not a pointer.
   bool IsPointer;
   // 0 if the type is not const.
   bool IsConst;
   // 0 if the type is not volatile.
   bool IsVolatile;
+  // 0:none, 1:read_only, 2:write_only, 3:read_write
+  unsigned AccessQualifier;
   // Address space of the pointer (if applicable).
   LangAS AS;
 };
 
 // Store a type (i.e. int, float, int2, ...). The type is stored as an index of
 // a struct OpenCLType table. Multiple entries following each other form a
 // signature.
 struct OpenCLSignatureStruct {
if (it == SignaturesList.end()) {
       SignIndex = it->second;
     }
     FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
   }
 }
 
 
 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: // default
+        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";
 }
 
 
 void BuiltinNameEmitter::EmitSignatureTable() {
   std::vector<std::vector<Record *>> Signature;
for (const auto *VectList : Records.getAllDerivedDefinitions("IntList")) {
     }
     OS << "};\n";
   }
 
   // Start of switch statement over all possible types used in Builtin
   // 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.
   for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) {
     OS << "    case OCLT_" << GenType->getValueAsString("Name") << ":\n";
 
     for (uint I = 0;
          I < GenType->getValueAsDef("VectorList")->getValueAsListOfInts("List").size();
          I++) {
       for (const auto *T :
for (const auto *GenType : Records.getAllDerivedDefinitions("GenericType")) {
     OS << "      break;\n";
   }
 
   // Switch case for non generic, non image types (int, int4, float, ...).
   std::vector<Record *> Types = Records.getAllDerivedDefinitions("Type");
   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));
 
     // Check the Type does not have an "abstract" QualType
     auto QT = T->getValueAsDef("QTName");
     if (QT->getValueAsBit("IsAbstract") == 1)
       continue;