Skip llvm.global.annotations when applying referenced-indirectly attribute

When IGC is checking if function can be accessed indirecty it iterates
over all function users looking for user that is not a function call.

But when pointer to given function is in @llvm.global.annotations it
will also be found and function will be marked as "referenced-indirectly",
despite @llvm.global.annotations being used only for metadata and removed
couple passes later in Dead Global Elimination Pass.

Author: MiloszSkobejko

IGC/AdaptorCommon/ProcessFuncAttributes.cpp

@@ -411,6 +411,30 @@ static void addAlwaysInlineForImageBuiltinUserFunctions(Module &M) {
   }
 }
 
+static void collectGlobalAnnotationsPointers(const Module &M, DenseSet<const Value *> &GlobalAnnotations) {
+  auto *GA = M.getGlobalVariable("llvm.global.annotations");
+  if (!GA)
+    return;
+
+  auto *CA = dyn_cast<ConstantArray>(GA->getInitializer());
+  if (!CA)
+    return;
+
+  for (Value *Op : CA->operands()) {
+    auto *Annot = dyn_cast<ConstantStruct>(Op);
+    if (!Annot)
+      continue;
+
+    // In case of opaque pointers add whole struct, since it
+    // will be visible as function user, otherwise add bitcast
+    if (Annot->getOperand(0)->getType()->isOpaquePointerTy()) {
+      GlobalAnnotations.insert(Annot);
+    } else {
+      GlobalAnnotations.insert(Annot->getOperand(0));
+    }
+  }
+}
+
 bool ProcessFuncAttributes::runOnModule(Module &M) {
   MetaDataUtilsWrapper &mduw = getAnalysis<MetaDataUtilsWrapper>();
   MetaDataUtils *pMdUtils = mduw.getMetaDataUtils();
@@ -436,6 +460,9 @@ bool ProcessFuncAttributes::runOnModule(Module &M) {
     }
   }
 
+  DenseSet<const Value *> GlobalAnnotationsPtr;
+  collectGlobalAnnotationsPointers(M, GlobalAnnotationsPtr);
+
   auto SetNoInline = [](Function *F) {
     F->addFnAttr(llvm::Attribute::NoInline);
     F->removeFnAttr(llvm::Attribute::AlwaysInline);
@@ -599,6 +626,11 @@ bool ProcessFuncAttributes::runOnModule(Module &M) {
         // Set the indirect flag if the function's address is taken by a non-call instruction.
         for (auto u = F->user_begin(), e = F->user_end(); u != e; u++) {
           CallInst *call = dyn_cast<CallInst>(*u);
+
+          // If user is function bitcast or function ptr in @llvm.global.annotations we should skip it.
+          if (GlobalAnnotationsPtr.find(*u) != GlobalAnnotationsPtr.end())
+            continue;
+
           if (!call || IGCLLVM::getCalledValue(call) != F) {
             isIndirect = true;
             break;

IGC/Compiler/tests/ProcessFuncAttributes/skip-global-annotations-indirect.ll

@@ -0,0 +1,33 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+;
+; RUN: igc_opt --igc-process-func-attributes -S < %s 2>&1 | FileCheck %s
+; ------------------------------------------------
+
+; When pointer to function is in @llvm.global.annotations we should not
+; consider this user when applying "referenced-indirectly" attribute.
+
+@0 = private unnamed_addr constant [9 x i8] zeroinitializer, section "llvm.metadata"
+@llvm.global.annotations = appending global [1 x { i8*, i8*, i8*, i32 }] [{ i8*, i8*, i8*, i32 } { i8* bitcast (void ()* @func to i8*), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @0, i32 0, i32 0), i8* undef, i32 undef }], section "llvm.metadata"
+
+define internal spir_func void @func() #0 {
+  ret void
+}
+
+define spir_kernel void @kernel() {
+  call void @func()
+  ret void
+}
+
+; CHECK-NOT: "referenced-indirectly"
+attributes #0 = { nounwind }
+
+!igc.functions = !{!1}
+!1 = !{void ()* @kernel, !2}
+!2 = !{!3}
+!3 = !{!"function_type", i32 0}