clover/llvm: Clean up codestyle of get_kernel_args().

Reviewed-by: Serge Martin <[email protected]>
Tested-by: Jan Vesely <[email protected]>

1 files changed, 103 insertions, 120 deletions

diff --git a/src/gallium/state_trackers/clover/llvm/invocation.cpp b/src/gallium/state_trackers/clover/llvm/invocation.cpp
index 754e477bd29..0fc6190280f 100644
--- a/src/gallium/state_trackers/clover/llvm/invocation.cpp
+++ b/src/gallium/state_trackers/clover/llvm/invocation.cpp
@@ -77,7 +77,10 @@
 using namespace clover;
 using namespace clover::llvm;
 
+using ::llvm::cast;
+using ::llvm::dyn_cast;
 using ::llvm::Function;
+using ::llvm::isa;
 using ::llvm::LLVMContext;
 using ::llvm::Module;
 using ::llvm::raw_string_ostream;
@@ -362,147 +365,127 @@ namespace {
    }
 #endif
 
+   enum module::argument::type
+   get_image_type(const std::string &type,
+                  const std::string &qual) {
+      if (type == "image2d_t" && qual == "read_only")
+         return module::argument::image2d_rd;
+      else if (type == "image2d_t" && qual == "write_only")
+         return module::argument::image2d_wr;
+      else if (type == "image3d_t" && qual == "read_only")
+         return module::argument::image3d_rd;
+      else if (type == "image3d_t" && qual == "write_only")
+         return module::argument::image3d_wr;
+      else
+         unreachable("Unknown image type");
+   }
+
    std::vector<module::argument>
-   get_kernel_args(const llvm::Module *mod, const std::string &kernel_name,
-                   const clang::CompilerInstance &c) {
+   make_kernel_args(const Module &mod, const std::string &kernel_name,
+                    const clang::CompilerInstance &c) {
       std::vector<module::argument> args;
       const auto address_spaces = c.getTarget().getAddressSpaceMap();
-      llvm::Function *kernel_func = mod->getFunction(kernel_name);
-      assert(kernel_func && "Kernel name not found in module.");
-      auto arg_md = get_kernel_arg_md(kernel_func);
-
-      llvm::DataLayout TD(mod);
-      llvm::Type *size_type =
-         TD.getSmallestLegalIntType(mod->getContext(), sizeof(cl_uint) * 8);
-
-      for (const auto &arg: kernel_func->args()) {
+      const Function &f = *mod.getFunction(kernel_name);
+      const auto arg_md = get_kernel_arg_md(&f);
+      ::llvm::DataLayout dl(&mod);
+      const auto size_type =
+         dl.getSmallestLegalIntType(mod.getContext(), sizeof(cl_uint) * 8);
 
-         llvm::Type *arg_type = arg.getType();
-         const unsigned arg_store_size = TD.getTypeStoreSize(arg_type);
+      for (const auto &arg : f.args()) {
+         const auto arg_type = arg.getType();
 
          // OpenCL 1.2 specification, Ch. 6.1.5: "A built-in data
          // type that is not a power of two bytes in size must be
          // aligned to the next larger power of two".  We need this
          // alignment for three element vectors, which have
          // non-power-of-2 store size.
+         const unsigned arg_store_size = dl.getTypeStoreSize(arg_type);
          const unsigned arg_api_size = util_next_power_of_two(arg_store_size);
 
-         llvm::Type *target_type = arg_type->isIntegerTy() ?
-               TD.getSmallestLegalIntType(mod->getContext(), arg_store_size * 8)
-               : arg_type;
-         unsigned target_size = TD.getTypeStoreSize(target_type);
-         unsigned target_align = TD.getABITypeAlignment(target_type);
-
-         llvm::StringRef type_name = arg_md[arg.getArgNo()].type_name;
-         llvm::StringRef access_qual = arg_md[arg.getArgNo()].access_qual;
-
-         // Image
-         const bool is_image2d = type_name == "image2d_t";
-         const bool is_image3d = type_name == "image3d_t";
-         if (is_image2d || is_image3d) {
-            const bool is_write_only = access_qual == "write_only";
-            const bool is_read_only = access_qual == "read_only";
-
-            enum module::argument::type marg_type;
-            if (is_image2d && is_read_only) {
-               marg_type = module::argument::image2d_rd;
-            } else if (is_image2d && is_write_only) {
-               marg_type = module::argument::image2d_wr;
-            } else if (is_image3d && is_read_only) {
-               marg_type = module::argument::image3d_rd;
-            } else if (is_image3d && is_write_only) {
-               marg_type = module::argument::image3d_wr;
-            } else {
-               assert(0 && "Wrong image access qualifier");
-            }
-
-            args.push_back(module::argument(marg_type,
-                                            arg_store_size, target_size,
-                                            target_align,
-                                            module::argument::zero_ext));
-            continue;
-         }
-
-         // Image size implicit argument
-         if (type_name == "__llvm_image_size") {
-            args.push_back(module::argument(module::argument::scalar,
-                                            sizeof(cl_uint),
-                                            TD.getTypeStoreSize(size_type),
-                                            TD.getABITypeAlignment(size_type),
-                                            module::argument::zero_ext,
-                                            module::argument::image_size));
-            continue;
-         }
-
-         // Image format implicit argument
-         if (type_name == "__llvm_image_format") {
-            args.push_back(module::argument(module::argument::scalar,
-                                            sizeof(cl_uint),
-                                            TD.getTypeStoreSize(size_type),
-                                            TD.getABITypeAlignment(size_type),
-                                            module::argument::zero_ext,
-                                            module::argument::image_format));
-            continue;
-         }
+         const auto target_type = !arg_type->isIntegerTy() ? arg_type :
+            dl.getSmallestLegalIntType(mod.getContext(), arg_store_size * 8);
+         const unsigned target_size = dl.getTypeStoreSize(target_type);
+         const unsigned target_align = dl.getABITypeAlignment(target_type);
+
+         const auto type_name = arg_md[arg.getArgNo()].type_name;
+
+         if (type_name == "image2d_t" || type_name == "image3d_t") {
+            // Image.
+            const auto access_qual = arg_md[arg.getArgNo()].access_qual;
+            args.emplace_back(get_image_type(type_name, access_qual),
+                              arg_store_size, target_size,
+                              target_align, module::argument::zero_ext);
+
+         } else if (type_name == "__llvm_image_size") {
+            // Image size implicit argument.
+            args.emplace_back(module::argument::scalar, sizeof(cl_uint),
+                              dl.getTypeStoreSize(size_type),
+                              dl.getABITypeAlignment(size_type),
+                              module::argument::zero_ext,
+                              module::argument::image_size);
+
+         } else if (type_name == "__llvm_image_format") {
+            // Image format implicit argument.
+            args.emplace_back(module::argument::scalar, sizeof(cl_uint),
+                              dl.getTypeStoreSize(size_type),
+                              dl.getABITypeAlignment(size_type),
+                              module::argument::zero_ext,
+                              module::argument::image_format);
 
-         // Other types
-         if (llvm::isa<llvm::PointerType>(arg_type) && arg.hasByValAttr()) {
-            arg_type =
-                  llvm::dyn_cast<llvm::PointerType>(arg_type)->getElementType();
-         }
+         } else {
+            // Other types.
+            const auto actual_type =
+               isa<::llvm::PointerType>(arg_type) && arg.hasByValAttr() ?
+               cast<::llvm::PointerType>(arg_type)->getElementType() : arg_type;
+
+            if (actual_type->isPointerTy()) {
+               const unsigned address_space =
+                  cast<::llvm::PointerType>(actual_type)->getAddressSpace();
+
+               if (address_space == address_spaces[clang::LangAS::opencl_local
+                                                   - clang::LangAS::Offset]) {
+                  args.emplace_back(module::argument::local, arg_api_size,
+                                    target_size, target_align,
+                                    module::argument::zero_ext);
+               } else {
+                  // XXX: Correctly handle constant address space.  There is no
+                  // way for r600g to pass a handle for constant buffers back
+                  // to clover like it can for global buffers, so
+                  // creating constant arguments will break r600g.  For now,
+                  // continue treating constant buffers as global buffers
+                  // until we can come up with a way to create handles for
+                  // constant buffers.
+                  args.emplace_back(module::argument::global, arg_api_size,
+                                    target_size, target_align,
+                                    module::argument::zero_ext);
+               }
 
-         if (arg_type->isPointerTy()) {
-            unsigned address_space = llvm::cast<llvm::PointerType>(arg_type)->getAddressSpace();
-            if (address_space == address_spaces[clang::LangAS::opencl_local
-                                                     - clang::LangAS::Offset]) {
-               args.push_back(module::argument(module::argument::local,
-                                               arg_api_size, target_size,
-                                               target_align,
-                                               module::argument::zero_ext));
             } else {
-               // XXX: Correctly handle constant address space.  There is no
-               // way for r600g to pass a handle for constant buffers back
-               // to clover like it can for global buffers, so
-               // creating constant arguments will break r600g.  For now,
-               // continue treating constant buffers as global buffers
-               // until we can come up with a way to create handles for
-               // constant buffers.
-               args.push_back(module::argument(module::argument::global,
-                                               arg_api_size, target_size,
-                                               target_align,
-                                               module::argument::zero_ext));
-           }
+               const bool needs_sign_ext = f.getAttributes().hasAttribute(
+                  arg.getArgNo() + 1, ::llvm::Attribute::SExt);
 
-         } else {
-            llvm::AttributeSet attrs = kernel_func->getAttributes();
-            enum module::argument::ext_type ext_type =
-                  (attrs.hasAttribute(arg.getArgNo() + 1,
-                                     llvm::Attribute::SExt) ?
-                   module::argument::sign_ext :
-                   module::argument::zero_ext);
-
-            args.push_back(
-               module::argument(module::argument::scalar, arg_api_size,
-                                target_size, target_align, ext_type));
+               args.emplace_back(module::argument::scalar, arg_api_size,
+                                 target_size, target_align,
+                                 (needs_sign_ext ? module::argument::sign_ext :
+                                  module::argument::zero_ext));
+            }
          }
       }
 
       // Append implicit arguments.  XXX - The types, ordering and
       // vector size of the implicit arguments should depend on the
       // target according to the selected calling convention.
-      args.push_back(
-         module::argument(module::argument::scalar, sizeof(cl_uint),
-                          TD.getTypeStoreSize(size_type),
-                          TD.getABITypeAlignment(size_type),
-                          module::argument::zero_ext,
-                          module::argument::grid_dimension));
-
-      args.push_back(
-         module::argument(module::argument::scalar, sizeof(cl_uint),
-                          TD.getTypeStoreSize(size_type),
-                          TD.getABITypeAlignment(size_type),
-                          module::argument::zero_ext,
-                          module::argument::grid_offset));
+      args.emplace_back(module::argument::scalar, sizeof(cl_uint),
+                        dl.getTypeStoreSize(size_type),
+                        dl.getABITypeAlignment(size_type),
+                        module::argument::zero_ext,
+                        module::argument::grid_dimension);
+
+      args.emplace_back(module::argument::scalar, sizeof(cl_uint),
+                        dl.getTypeStoreSize(size_type),
+                        dl.getABITypeAlignment(size_type),
+                        module::argument::zero_ext,
+                        module::argument::grid_offset);
 
       return args;
    }
@@ -531,7 +514,7 @@ namespace {
                                   find_kernels(const_cast<Module *>(&mod)))) {
          if (offsets.count(name))
             m.syms.emplace_back(name, 0, offsets.at(name),
-                                get_kernel_args(&mod, name, c));
+                                make_kernel_args(mod, name, c));
       }
 
       m.secs.push_back(make_text_section(code));