Recognize string as printf string, when any of uses is printf (#23337)

Currently constnt string literals used only by printf are recognized
as printf strings and are stored in constant buffer. But when there is
reference to that string, even unused it's no longer recognized as printf
string and it's content is stored in .global buffer. This can lead to
segfault in runtime, as when trying to use printf it will recieve GPU
pointer.

Co-authored-by: Skobejko, Milosz <[email protected]>

Author: igcbot

IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.cpp

@@ -95,7 +95,7 @@ void OpenCLPrintfAnalysis::addPrintfBufferArgs(Function &F) {
   ImplicitArgs::addImplicitArgs(F, implicitArgs, m_pMDUtils);
 }
 
-bool isPrintfOnlyStringConstantImpl(const llvm::Value *v, std::set<const llvm::User *> &visited) {
+bool isPrintfStringConstantImpl(const llvm::Value *v, std::set<const llvm::User *> &visited) {
   // Recursively check the users of the value until reaching the top level
   // user or a call.
 
@@ -114,7 +114,6 @@ bool isPrintfOnlyStringConstantImpl(const llvm::Value *v, std::set<const llvm::U
       continue;
     visited.insert(user);
 
-    bool res = false;
     if (const llvm::CallInst *call = llvm::dyn_cast<llvm::CallInst>(user)) {
       // Stop when reaching a call and check if it is an opencl/oneapi
       // printf call.
@@ -124,30 +123,25 @@ bool isPrintfOnlyStringConstantImpl(const llvm::Value *v, std::set<const llvm::U
                              OpenCLPrintfAnalysis::isBuiltinPrintf(target);
 
       if (isStringLiteral) {
-        res = true;
+        return true;
       } else {
         unsigned int opIndex = call->getDataOperandNo(&use);
-        res = isPrintfOnlyStringConstantImpl(target->arg_begin() + opIndex, visited);
+        return isPrintfStringConstantImpl(target->arg_begin() + opIndex, visited);
       }
     } else if (llvm::dyn_cast<llvm::CastInst>(user) || llvm::dyn_cast<llvm::SelectInst>(user) ||
                llvm::dyn_cast<llvm::PHINode>(user)) {
-      res = isPrintfOnlyStringConstantImpl(user, visited);
+      return isPrintfStringConstantImpl(user, visited);
     } else if (const llvm::GetElementPtrInst *gep = llvm::dyn_cast<llvm::GetElementPtrInst>(user)) {
       if (gep->hasAllZeroIndices())
-        res = isPrintfOnlyStringConstantImpl(user, visited);
+        return isPrintfStringConstantImpl(user, visited);
     }
-
-    if (!res)
-      return false;
   }
-
-  // Return true as every top level user is a printf call.
-  return true;
+  return false;
 }
 
-// Check paths from a string literal to printf calls and return true if every
+// Check paths from a string literal to printf calls and return true if any
 // path lead to a printf call.
-bool OpenCLPrintfAnalysis::isPrintfOnlyStringConstant(const llvm::GlobalVariable *GV) {
+bool OpenCLPrintfAnalysis::isPrintfStringConstant(const llvm::GlobalVariable *GV) {
   const llvm::Constant *Initializer = GV->getInitializer();
   if (!Initializer) {
     return false;
@@ -166,7 +160,7 @@ bool OpenCLPrintfAnalysis::isPrintfOnlyStringConstant(const llvm::GlobalVariable
 
   if (IsNullTerminatedString || IsZeroInitCharArray) {
     std::set<const llvm::User *> Visited;
-    return isPrintfOnlyStringConstantImpl(GV, Visited);
+    return isPrintfStringConstantImpl(GV, Visited);
   }
 
   return false;

IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.hpp

@@ -52,7 +52,7 @@ class OpenCLPrintfAnalysis : public llvm::ModulePass, public llvm::InstVisitor<O
   // Return true if every top level user of a string literal is a printf
   // call. Note that the function is expected to work only before printf
   // expansion.
-  static bool isPrintfOnlyStringConstant(const llvm::GlobalVariable *GV);
+  static bool isPrintfStringConstant(const llvm::GlobalVariable *GV);
 
 private:
   /// @brief  Adds an implicit argument for address of printf output buffer

IGC/Compiler/Optimizer/OpenCLPasses/ProgramScopeConstants/ProgramScopeConstantAnalysis.cpp

@@ -118,8 +118,8 @@ bool ProgramScopeConstantAnalysis::runOnModule(Module &M) {
     InlineProgramScopeBufferType inlineProgramScopeBufferType = {};
 
     // Constant variables that are string literals
-    // used only by printf will be stored in the second constant buffer.
-    bool isZebinPrintfStringConst = OpenCLPrintfAnalysis::isPrintfOnlyStringConstant(globalVar);
+    // used by printf will be stored in the second constant buffer.
+    bool isZebinPrintfStringConst = OpenCLPrintfAnalysis::isPrintfStringConstant(globalVar);
     // Here we follow SPV_EXT_relaxed_printf_string_address_space to relax
     // the address space requirement of printf strings and accept
     // non-constant address space printf strings. However, we expect it is

IGC/Compiler/tests/ProgramScopeConstantAnalysis/printf-string-reference.ll

@@ -0,0 +1,31 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+; REQUIRES: regkeys
+; RUN: igc_opt --typed-pointers -igc-programscope-constant-analysis -igc-serialize-metadata \
+; RUN:   -S < %s | FileCheck %s
+; ------------------------------------------------
+; ProgramScopeConstantAnalysis
+; ------------------------------------------------
+
+; Test checks that metadata is updated with printf string, while there is reference to this
+; string in another global.
+
+; CHECK:     !{!"stringConstants",
+; CHECK-DAG: !{!"stringConstantsSet{{[[][0-9][]]}}", [3 x i8] addrspace(2)* @str}
+
+@str = internal unnamed_addr addrspace(2) constant [3 x i8] c"A\0A\00", align 1
+@ref = addrspace(2) constant [1 x i64] [i64 ptrtoint ([3 x i8] addrspace(2)* @str to i64)]
+; decl of opencl printf
+declare spir_func i32 @printf(i8 addrspace(2)*, ...)
+
+; Function Attrs: convergent noinline nounwind optnone
+define spir_func void @foo() {
+  %1 = getelementptr inbounds [3 x i8], [3 x i8] addrspace(2)* @str, i64 0, i64 0
+  %2 = call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* %1)
+  ret void
+}