Fix inlining of non-kernel funcs with SPIR-V image args

Before the migration to opaque pointers, the inlining logic in
ProcessFuncAttributes decided to inline functions based on the actual
type of an argument. With typed pointers, SPIR-V/OpenCL images were
represented using pointers to opaque structs (allowing to recognize the
image type by parsing the struct name). With opauqe pointers, such types
are represented using TargetExtTy. However, TargetExtTy are missing at
this point during compilation due to earlier retyping (to opaque
pointers) in PreprocessSPVIR. Hence, this change allows recognition of
such types based on metadata hints. Analogous metadata are already
emitted for kernel functions by SPIR-V Reader.

Author: michalpaszkowski

IGC/AdaptorCommon/ProcessFuncAttributes.cpp

@@ -267,6 +267,30 @@ ModulePass *createProcessFuncAttributesPass() { return new ProcessFuncAttributes
 
 extern bool isSupportedAggregateArgument(Argument *arg);
 
+static bool hasImageTypesInMetadataTypeHints(Function *F, ModuleMetaData *ModMD) {
+  auto It = ModMD->FuncMD.find(F);
+  if (It != ModMD->FuncMD.end()) {
+    const FunctionMetaData &FuncMD = It->second;
+    IGC_ASSERT_MESSAGE(FuncMD.m_OpenCLArgBaseTypes.size() == F->arg_size(),
+                       "m_OpenCLArgBaseTypes and function argument size mismatch!");
+
+    for (const auto &BaseTy : FuncMD.m_OpenCLArgBaseTypes) {
+      if (BaseTy.find("image") != std::string::npos)
+        return true;
+    }
+  }
+
+  MDNode *Hints = F->getMetadata("non_kernel_arg_type_hints");
+  if (Hints) {
+    for (auto &Operand : Hints->operands())
+      if (MDString *MDStr = dyn_cast<MDString>(Operand))
+        if (MDStr->getString().contains_insensitive("image"))
+          return true;
+  }
+
+  return false;
+}
+
 // Only pointer, struct and array types are considered. E.g. vector type
 // cannot contain opaque subtypes, function type may contain but ignored.
 static void getBuiltinType(Type *T, SmallPtrSetImpl<Type *> &BuiltinTypes) {
@@ -688,12 +712,18 @@ bool ProcessFuncAttributes::runOnModule(Module &M) {
       // Curently, ExtensionArgAnalysis assumes that all functions with image arguments
       // to be inlined. We add always inline for such cases.
       for (auto &arg : F->args()) {
+        // TODO: Remove following the migration to opaque pointers. The following method won't be able to recognize
+        // builtin types. TargetExtTy information is lost at this point (following the retyping in PreprocessSPVIR) and
+        // type hints in the metadata should be used instead, see hasImageTypesInMetadataTypeHints below.
         if (containsImageType(arg.getType())) {
           mustAlwaysInline = true;
           break;
         }
       }
 
+      if (hasImageTypesInMetadataTypeHints(F, modMD))
+        mustAlwaysInline = true;
+
       if (pCtx->m_hasDPEmu && !mustAlwaysInline && !isKernel) {
         // Prefer stackcall if a func has double operations
         bool isSet = false;

IGC/AdaptorOCL/preprocess_spvir/PreprocessSPVIR.cpp

@@ -159,6 +159,30 @@ void PreprocessSPVIR::visitCallInst(CallInst &CI) {
   }
 }
 
+#if LLVM_VERSION_MAJOR >= 16
+static void addNonKernelFuncsArgTypeHints(Module &M) {
+  for (Function &F : M) {
+    if (F.isDeclaration() || F.getCallingConv() != CallingConv::SPIR_FUNC)
+      continue;
+
+    SmallVector<Metadata *, 8> Hints;
+    for (Argument &Arg : F.args()) {
+      Type *ArgTy = Arg.getType();
+
+      // Hints are needed only for SPIR-V builtin types.
+      std::string HintValue = "";
+      if (TargetExtType *TET = dyn_cast<TargetExtType>(ArgTy))
+        HintValue = TET->getTargetExtName();
+
+      Hints.push_back(MDString::get(M.getContext(), HintValue));
+    }
+
+    MDNode *Node = MDNode::get(M.getContext(), Hints);
+    F.setMetadata("non_kernel_arg_type_hints", Node);
+  }
+}
+#endif
+
 static void fixKernelArgBaseTypes(Module &M) {
   LLVMContext &Ctx = M.getContext();
 
@@ -232,6 +256,14 @@ bool PreprocessSPVIR::runOnModule(Module &M) {
   // incorrect and inconsistent with the prior behavior.
   fixKernelArgBaseTypes(M);
 
+#if LLVM_VERSION_MAJOR >= 16
+  // Add SPIR-V builtin type hints as metadata to non-kernel functions. Kernel functions already have metadata type
+  // hints added by the SPIR-V Reader. Type hints for non-kernel functions are not strictly required, but allow us to
+  // apply certain optimizations (e.g. inlining) without doing costly type deduction. Adding type hints is easier before
+  // retyping since we can rely on TargetExtTy information.
+  addNonKernelFuncsArgTypeHints(M);
+#endif
+
   // Retype function arguments of OpenCL types represented as TargetExtTy to
   // use opaque pointers instead. This is necessary to match function
   // signatures generated by Clang, given that it only has partial TargetExtTy

IGC/Compiler/tests/PreprocessSPVIR/add-type-hints-to-non-kernel-funcs.ll

@@ -0,0 +1,19 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; REQUIRES: llvm-16-plus
+; RUN: igc_opt --opaque-pointers -igc-preprocess-spvir -S < %s | FileCheck %s --check-prefixes=CHECK-A
+; RUN: igc_opt --opaque-pointers -igc-preprocess-spvir -igc-process-func-attributes  -S < %s | FileCheck %s --check-prefixes=CHECK-B
+
+; CHECK-A: !non_kernel_arg_type_hints ![[#NODE:]]
+; CHECK-A: ![[#NODE:]] = !{!"spirv.Image", !"spirv.SampledImage"}
+; CHECK-B: alwaysinline
+
+define spir_func void @testNonKernel(target("spirv.Image", void, 0, 0, 0, 0, 0, 0, 2) %img, target("spirv.SampledImage", void, 1, 1, 0, 0, 0, 0, 0) %sampledImg) {
+  ret void
+}