Add has_printf_calls to zeinfo

KanclerzPiotr · igcbot · commit 0b5f9e11eb10 · 2025-08-20T10:30:06.000+02:00
zeinfo now contains information if kernel/function has printf calls
and function pointer calls. This allows neo to create printf_buffer when
it is really used.
diff --git a/IGC/AdaptorOCL/OCL/KernelAnnotations.hpp b/IGC/AdaptorOCL/OCL/KernelAnnotations.hpp
@@ -90,6 +90,8 @@ struct ExecutionEnvironment {
   DWORD StatelessWritesCount = 0;
   DWORD IndirectStatelessCount = 0;
   DWORD numThreads = 0;
+  bool HasPrintfCalls = false;
+  bool HasIndirectCalls = false;
   bool HasStackCalls = false;
   bool RequireDisableEUFusion = false;
   DWORD PerThreadSpillMemoryUsage = 0;
diff --git a/IGC/AdaptorOCL/OCL/sp/zebin_builder.cpp b/IGC/AdaptorOCL/OCL/sp/zebin_builder.cpp
@@ -471,11 +471,12 @@ void ZEBinaryBuilder::addKernelExecEnv(const SOpenCLKernelInfo &annotations, zeI
       CPlatform(mPlatform).hasScratchSurface() && IGC_IS_FLAG_ENABLED(SeparateSpillPvtScratchSpace);
   env.has_no_stateless_write = (annotations.m_executionEnvironment.StatelessWritesCount == 0);
   env.has_stack_calls = annotations.m_executionEnvironment.HasStackCalls;
+  // env.has_printf_calls = annotations.m_executionEnvironment.HasPrintfCalls;
+  // env.has_indirect_calls = annotations.m_executionEnvironment.HasIndirectCalls;
   env.require_disable_eufusion = annotations.m_executionEnvironment.RequireDisableEUFusion;
   env.indirect_stateless_count = annotations.m_executionEnvironment.IndirectStatelessCount;
   env.inline_data_payload_size = annotations.m_threadPayload.PassInlineDataSize;
   env.offset_to_skip_per_thread_data_load = annotations.m_threadPayload.OffsetToSkipPerThreadDataLoad;
-  ;
   env.offset_to_skip_set_ffid_gp = annotations.m_threadPayload.OffsetToSkipSetFFIDGP;
   env.generate_local_id = annotations.m_threadPayload.generateLocalID;
   env.has_lsc_stores_with_non_default_l1_cache_controls =
@@ -515,6 +516,8 @@ void ZEBinaryBuilder::addFunctionExecEnv(const SOpenCLKernelInfo &annotations,
   env.simd_size = annotations.m_executionEnvironment.CompiledSIMDSize;
   env.barrier_count = zeFuncAttr.f_BarrierCount;
   env.has_rtcalls = zeFuncAttr.f_hasRTCalls;
+  // env.has_printf_calls = zeFuncAttr.f_hasPrintfCalls;
+  // env.has_indirect_calls = zeFuncAttr.f_hasIndirectCalls;
 }
 
 void ZEBinaryBuilder::addLocalIds(uint32_t simdSize, uint32_t grfSize, bool has_local_id_x, bool has_local_id_y,
diff --git a/IGC/Compiler/CISACodeGen/CISABuilder.cpp b/IGC/Compiler/CISACodeGen/CISABuilder.cpp
@@ -5138,9 +5138,11 @@ void CEncoder::CreateFuncAttributeTable(VISAKernel *pMainKernel, GenXFunctionGro
     uint32_t spillMemPerThread =
         getSpillMemSizeWithFG(*F, jitInfo->stats.spillMemUsed, pFga, jitInfo->numBytesScratchGtpin);
     uint8_t hasRTCalls = (uint8_t)modMD->FuncMD[F].hasSyncRTCalls;
+    uint8_t hasPrintfCalls = (uint8_t)modMD->FuncMD[F].hasPrintfCalls;
+    uint8_t hasIndirectCalls = (uint8_t)modMD->FuncMD[F].hasIndirectCalls;
 
     attrs.emplace_back((uint8_t)isKernel, isExternal, barrierCount, privateMemPerThread, spillMemPerThread,
-                       F->getName().str(), hasRTCalls);
+                       F->getName().str(), hasRTCalls, hasPrintfCalls, hasIndirectCalls);
   }
 }
 
diff --git a/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp b/IGC/Compiler/CISACodeGen/OpenCLKernelCodeGen.cpp
@@ -1739,6 +1739,8 @@ void COpenCLKernel::FillKernel(SIMDMode simdMode) {
     m_kernelInfo.m_executionEnvironment.CompiledSubGroupsNumber = funcMD.CompiledSubGroupsNumber;
 
     m_kernelInfo.m_executionEnvironment.HasRTCalls = funcMD.hasSyncRTCalls;
+    m_kernelInfo.m_executionEnvironment.HasPrintfCalls = funcMD.hasPrintfCalls;
+    m_kernelInfo.m_executionEnvironment.HasIndirectCalls = funcMD.hasIndirectCalls;
   }
 
   m_kernelInfo.m_executionEnvironment.HasGlobalAtomics = GetHasGlobalAtomics();
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.cpp
@@ -65,6 +65,11 @@ bool OpenCLPrintfAnalysis::runOnModule(Module &M) {
       if (!func.isDeclaration() && m_hasPrintfs.find(&func) != m_hasPrintfs.end()) {
         addPrintfBufferArgs(func);
         changed = true;
+
+        if (m_modMD == nullptr) {
+          m_modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
+        }
+        m_modMD->FuncMD[&func].hasPrintfCalls = true;
       }
     }
   }
@@ -76,9 +81,16 @@ bool OpenCLPrintfAnalysis::runOnModule(Module &M) {
   return m_hasPrintfs.size();
 }
 
-void OpenCLPrintfAnalysis::visitCallInst(llvm::CallInst &callInst) {
+void OpenCLPrintfAnalysis::visitCallInst(CallInst &callInst) {
   Function *pF = callInst.getParent()->getParent();
   if (!callInst.getCalledFunction() || m_hasPrintfs.find(pF) != m_hasPrintfs.end()) {
+
+    if( callInst.isIndirectCall()) {
+      if (m_modMD == nullptr) {
+        m_modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
+      }
+      m_modMD->FuncMD[pF].hasIndirectCalls = true;
+    }
     return;
   }
 
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.hpp b/IGC/Compiler/Optimizer/OpenCLPasses/OpenCLPrintf/OpenCLPrintfAnalysis.hpp
@@ -33,7 +33,9 @@ class OpenCLPrintfAnalysis : public llvm::ModulePass, public llvm::InstVisitor<O
   /// @brief  Provides name of pass
   virtual llvm::StringRef getPassName() const override { return "OpenCLPrintfAnalysis"; }
 
-  void getAnalysisUsage(llvm::AnalysisUsage &AU) const override { AU.addRequired<MetaDataUtilsWrapper>(); }
+  void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
+    AU.addRequired<MetaDataUtilsWrapper>();
+  }
 
   /// @brief  Main entry point.
   /// @param  M The destination module.
@@ -62,6 +64,7 @@ class OpenCLPrintfAnalysis : public llvm::ModulePass, public llvm::InstVisitor<O
 
   std::unordered_set<llvm::Function *> m_hasPrintfs;
 
+  ModuleMetaData *m_modMD = nullptr;
   /// @brief  MetaData utils used to generate LLVM metadata
   IGCMD::MetaDataUtils *m_pMDUtils = nullptr;
 };
diff --git a/IGC/ZEBinWriter/zebin/source/autogen/ZEInfo.hpp b/IGC/ZEBinWriter/zebin/source/autogen/ZEInfo.hpp
@@ -47,7 +47,7 @@ struct zeInfoExecutionEnv
 {
     bool operator==(const zeInfoExecutionEnv& other) const
     {
-        return barrier_count == other.barrier_count && disable_mid_thread_preemption == other.disable_mid_thread_preemption && grf_count == other.grf_count && has_4gb_buffers == other.has_4gb_buffers && has_device_enqueue == other.has_device_enqueue && has_dpas == other.has_dpas && has_fence_for_image_access == other.has_fence_for_image_access && has_global_atomics == other.has_global_atomics && has_multi_scratch_spaces == other.has_multi_scratch_spaces && has_no_stateless_write == other.has_no_stateless_write && has_stack_calls == other.has_stack_calls && require_disable_eufusion == other.require_disable_eufusion && indirect_stateless_count == other.indirect_stateless_count && inline_data_payload_size == other.inline_data_payload_size && offset_to_skip_per_thread_data_load == other.offset_to_skip_per_thread_data_load && offset_to_skip_set_ffid_gp == other.offset_to_skip_set_ffid_gp && required_sub_group_size == other.required_sub_group_size && required_work_group_size == other.required_work_group_size && simd_size == other.simd_size && slm_size == other.slm_size && private_size == other.private_size && spill_size == other.spill_size && subgroup_independent_forward_progress == other.subgroup_independent_forward_progress && thread_scheduling_mode == other.thread_scheduling_mode && work_group_walk_order_dimensions == other.work_group_walk_order_dimensions && eu_thread_count == other.eu_thread_count && has_sample == other.has_sample && has_rtcalls == other.has_rtcalls && generate_local_id == other.generate_local_id && has_lsc_stores_with_non_default_l1_cache_controls == other.has_lsc_stores_with_non_default_l1_cache_controls && require_iab == other.require_iab;
+        return barrier_count == other.barrier_count && disable_mid_thread_preemption == other.disable_mid_thread_preemption && grf_count == other.grf_count && has_4gb_buffers == other.has_4gb_buffers && has_device_enqueue == other.has_device_enqueue && has_dpas == other.has_dpas && has_fence_for_image_access == other.has_fence_for_image_access && has_global_atomics == other.has_global_atomics && has_multi_scratch_spaces == other.has_multi_scratch_spaces && has_no_stateless_write == other.has_no_stateless_write && has_stack_calls == other.has_stack_calls && has_printf_calls == other.has_printf_calls && has_indirect_calls == other.has_indirect_calls && require_disable_eufusion == other.require_disable_eufusion && indirect_stateless_count == other.indirect_stateless_count && inline_data_payload_size == other.inline_data_payload_size && offset_to_skip_per_thread_data_load == other.offset_to_skip_per_thread_data_load && offset_to_skip_set_ffid_gp == other.offset_to_skip_set_ffid_gp && required_sub_group_size == other.required_sub_group_size && required_work_group_size == other.required_work_group_size && simd_size == other.simd_size && slm_size == other.slm_size && private_size == other.private_size && spill_size == other.spill_size && subgroup_independent_forward_progress == other.subgroup_independent_forward_progress && thread_scheduling_mode == other.thread_scheduling_mode && work_group_walk_order_dimensions == other.work_group_walk_order_dimensions && eu_thread_count == other.eu_thread_count && has_sample == other.has_sample && has_rtcalls == other.has_rtcalls && generate_local_id == other.generate_local_id && has_lsc_stores_with_non_default_l1_cache_controls == other.has_lsc_stores_with_non_default_l1_cache_controls && require_iab == other.require_iab;
     }
     zeinfo_int32_t barrier_count = 0;
     zeinfo_bool_t disable_mid_thread_preemption = false;
@@ -60,6 +60,8 @@ struct zeInfoExecutionEnv
     zeinfo_bool_t has_multi_scratch_spaces = false;
     zeinfo_bool_t has_no_stateless_write = false;
     zeinfo_bool_t has_stack_calls = false;
+    zeinfo_bool_t has_printf_calls = false;
+    zeinfo_bool_t has_indirect_calls = false;
     zeinfo_bool_t require_disable_eufusion = false;
     zeinfo_int32_t indirect_stateless_count = 0;
     zeinfo_int32_t inline_data_payload_size = 0;
@@ -293,7 +295,7 @@ struct zeInfoContainer
     KernelsCostInfoTy kernels_cost_info;
 };
 struct PreDefinedAttrGetter{
-    static zeinfo_str_t getVersionNumber() { return "1.58"; }
+    static zeinfo_str_t getVersionNumber() { return "1.59"; }
 
     enum class ArgThreadSchedulingMode {
         age_based,
diff --git a/IGC/ZEBinWriter/zebin/source/autogen/ZEInfoYAML.cpp b/IGC/ZEBinWriter/zebin/source/autogen/ZEInfoYAML.cpp
@@ -69,6 +69,8 @@ void MappingTraits<zeInfoExecutionEnv>::mapping(IO& io, zeInfoExecutionEnv& info
     io.mapOptional("has_multi_scratch_spaces", info.has_multi_scratch_spaces, false);
     io.mapOptional("has_no_stateless_write", info.has_no_stateless_write, false);
     io.mapOptional("has_stack_calls", info.has_stack_calls, false);
+    io.mapOptional("has_printf_calls", info.has_printf_calls, false);
+    io.mapOptional("has_indirect_calls", info.has_indirect_calls, false);
     io.mapOptional("require_disable_eufusion", info.require_disable_eufusion, false);
     io.mapOptional("indirect_stateless_count", info.indirect_stateless_count, 0);
     io.mapOptional("inline_data_payload_size", info.inline_data_payload_size, 0);
diff --git a/IGC/ZEBinWriter/zebin/spec/version.md b/IGC/ZEBinWriter/zebin/spec/version.md
@@ -7,7 +7,7 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ==========================-->
 
 # ZEBIN Version
-Version 1.58
+Version 1.59
 =======
 
 ## Versioning
@@ -16,6 +16,7 @@ Format: \<_Major number_\>.\<_Minor number_\>
 - Minor number: Increase when backward-compatible features are added. For example, add new attributes.
 
 ## Change Note
+- **Version 1.59**: Add execution env has_printf_calls and has_indirect_calls.
 - **Version 1.58**: Add new enum value NT_INTELGT_INDIRECT_ACCESS_BUFFER_VERSION
 - **Version 1.57**: Internal feature.
 - **Version 1.56**: Internal feature.
diff --git a/IGC/ZEBinWriter/zebin/spec/zeinfo.md b/IGC/ZEBinWriter/zebin/spec/zeinfo.md
@@ -127,6 +127,8 @@ If an attribute is **Required**, it must be present in execution_env. If it's **
 | has_multi_scratch_spaces | bool | Optional | false | |
 | has_no_stateless_write | bool | Optional | false | |
 | has_stack_calls | bool | Optional | false | When this value is true, it indicates that program uses stack calls. The implicit_arg_buffer is allocated accordingly.  |
+| has_printf_calls | bool | Optional | false | When this value is true, it indicates that the kernel itself uses printf calls in its body. |
+| has_indirect_calls | bool | Optional | false | When this value is true, it indicates that the kernel itself uses indirect calls in its body. |
 | require_disable_eufusion | bool | Optional | false | When this value is true, it indicates that program requires EU fusion disable |
 | indirect_stateless_count | int32 | Optional | 0 | |
 | inline_data_payload_size | int32 | Optional | 0 | Size of inline data in cross-thread-payload in byte. The value is 0 when inline data is disabled (default). |
diff --git a/IGC/common/MDFrameWork.h b/IGC/common/MDFrameWork.h
@@ -361,6 +361,8 @@ enum class ShaderTypeMD
         bool globalIDPresent = false;
         // This is true if the function has any sync raytracing functionality
         bool hasSyncRTCalls = false;
+        bool hasPrintfCalls = false;
+        bool hasIndirectCalls = false;
 
         // Analysis result of if there are non-kernel-argument ld/st in the kernel
         bool hasNonKernelArgLoad = false;
diff --git a/visa/include/RelocationInfo.h b/visa/include/RelocationInfo.h
@@ -17,6 +17,7 @@ SPDX-License-Identifier: MIT
 #ifndef RELOCATION_INFO_H
 #define RELOCATION_INFO_H
 
+#include <cstdint>
 #include <string>
 
 namespace vISA {
@@ -121,14 +122,19 @@ struct ZEFuncAttribEntry {
                                   // for this function
   std::string f_name;             // The function's name
   uint8_t f_hasRTCalls;
+  uint8_t f_hasPrintfCalls;
+  uint8_t f_hasIndirectCalls;
 
   ZEFuncAttribEntry(uint8_t isKernel, uint8_t isExternal, uint32_t barrierCount,
                     uint32_t privateMemPerThread, uint32_t spillMemPerThread,
-                    std::string funcName, uint8_t hasRTCalls)
+                    std::string funcName, uint8_t hasRTCalls,
+                    uint8_t hasPrintfCalls, uint8_t hasIndirectCalls)
       : f_isKernel(isKernel), f_isExternal(isExternal),
         f_BarrierCount(barrierCount),
         f_privateMemPerThread(privateMemPerThread),
-        f_spillMemPerThread(spillMemPerThread), f_name(std::move(funcName)), f_hasRTCalls(hasRTCalls) {}
+        f_spillMemPerThread(spillMemPerThread), f_name(std::move(funcName)),
+        f_hasRTCalls(hasRTCalls), f_hasPrintfCalls(hasPrintfCalls),
+        f_hasIndirectCalls(hasIndirectCalls) {}
 };
 
 /// ZEHostAccessEntry - A host access entry that will later be transformed to ZE

Original file line number	Diff line number	Diff line change
`@@ -5138,9 +5138,11 @@ void CEncoder::CreateFuncAttributeTable(VISAKernel *pMainKernel, GenXFunctionGro`
`5138`	`5138`	`uint32_t spillMemPerThread =`
`5139`	`5139`	`getSpillMemSizeWithFG(*F, jitInfo->stats.spillMemUsed, pFga, jitInfo->numBytesScratchGtpin);`
`5140`	`5140`	`uint8_t hasRTCalls = (uint8_t)modMD->FuncMD[F].hasSyncRTCalls;`
	`5141`	`+ uint8_t hasPrintfCalls = (uint8_t)modMD->FuncMD[F].hasPrintfCalls;`
	`5142`	`+ uint8_t hasIndirectCalls = (uint8_t)modMD->FuncMD[F].hasIndirectCalls;`
`5141`	`5143`
`5142`	`5144`	`attrs.emplace_back((uint8_t)isKernel, isExternal, barrierCount, privateMemPerThread, spillMemPerThread,`
`5143`		`- F->getName().str(), hasRTCalls);`
	`5145`	`+ F->getName().str(), hasRTCalls, hasPrintfCalls, hasIndirectCalls);`
`5144`	`5146`	`}`
`5145`	`5147`	`}`
`5146`	`5148`
Original file line number	Diff line number	Diff line change
`@@ -1739,6 +1739,8 @@ void COpenCLKernel::FillKernel(SIMDMode simdMode) {`
`1739`	`1739`	`m_kernelInfo.m_executionEnvironment.CompiledSubGroupsNumber = funcMD.CompiledSubGroupsNumber;`
`1740`	`1740`
`1741`	`1741`	`m_kernelInfo.m_executionEnvironment.HasRTCalls = funcMD.hasSyncRTCalls;`
	`1742`	`+ m_kernelInfo.m_executionEnvironment.HasPrintfCalls = funcMD.hasPrintfCalls;`
	`1743`	`+ m_kernelInfo.m_executionEnvironment.HasIndirectCalls = funcMD.hasIndirectCalls;`
`1742`	`1744`	`}`
`1743`	`1745`
`1744`	`1746`	`m_kernelInfo.m_executionEnvironment.HasGlobalAtomics = GetHasGlobalAtomics();`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,11 @@ bool OpenCLPrintfAnalysis::runOnModule(Module &M) {`
`65`	`65`	`if (!func.isDeclaration() && m_hasPrintfs.find(&func) != m_hasPrintfs.end()) {`
`66`	`66`	`addPrintfBufferArgs(func);`
`67`	`67`	`changed = true;`
	`68`	`+`
	`69`	`+ if (m_modMD == nullptr) {`
	`70`	`+ m_modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();`
	`71`	`+ }`
	`72`	`+ m_modMD->FuncMD[&func].hasPrintfCalls = true;`
`68`	`73`	`}`
`69`	`74`	`}`
`70`	`75`	`}`
`@@ -76,9 +81,16 @@ bool OpenCLPrintfAnalysis::runOnModule(Module &M) {`
`76`	`81`	`return m_hasPrintfs.size();`
`77`	`82`	`}`
`78`	`83`
`79`		`-void OpenCLPrintfAnalysis::visitCallInst(llvm::CallInst &callInst) {`
	`84`	`+void OpenCLPrintfAnalysis::visitCallInst(CallInst &callInst) {`
`80`	`85`	`Function *pF = callInst.getParent()->getParent();`
`81`	`86`	`if (!callInst.getCalledFunction() \|\| m_hasPrintfs.find(pF) != m_hasPrintfs.end()) {`
	`87`	`+`
	`88`	`+ if( callInst.isIndirectCall()) {`
	`89`	`+ if (m_modMD == nullptr) {`
	`90`	`+ m_modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();`
	`91`	`+ }`
	`92`	`+ m_modMD->FuncMD[pF].hasIndirectCalls = true;`
	`93`	`+ }`
`82`	`94`	`return;`
`83`	`95`	`}`
`84`	`96`