Put indirectly called functions to separate section

skachkov-intel · igcbot · commit 278c9b53d115 · 2021-11-30T11:02:46.000+01:00
diff --git a/IGC/VectorCompiler/igcdeps/src/ShaderOverride.cpp b/IGC/VectorCompiler/igcdeps/src/ShaderOverride.cpp
@@ -38,8 +38,8 @@ class VC_IGCShaderOverrider final : public vc::ShaderOverrider {
   VC_IGCShaderOverrider(ShaderHash const &Hash, PLATFORM const &Platform);
 
   // Overrides .asm or .dat files
-  bool override(void *&GenXBin, int &GenXBinSize, llvm::StringRef KernelName,
-                llvm::StringRef FunctionName, Extensions Ext) const override;
+  bool override(void *&GenXBin, int &GenXBinSize, llvm::StringRef FunctionName,
+                Extensions Ext) const override;
 };
 
 } // namespace
@@ -60,17 +60,9 @@ static std::string legalizeName(std::string Name) {
 }
 
 bool VC_IGCShaderOverrider::override(void *&GenXBin, int &GenXBinSize,
-                                     llvm::StringRef KernelName,
                                      llvm::StringRef FunctionName,
                                      Extensions Ext) const {
-  // It is possible to override indirect function which has name
-  // "VC_hash_kernelName_functionName.ext". There is a name check to determine
-  // whether a function or kernel is overriding.
-  std::string const FullName =
-      KernelName.str() +
-      (KernelName.equals(FunctionName) ? "" : '_' + FunctionName.str());
-
-  std::string const LegalizedShaderName = legalizeName(FullName);
+  std::string const LegalizedShaderName = legalizeName(FunctionName.str());
   std::string const FullPath = path(LegalizedShaderName, Ext);
   bool Status = false;
 
diff --git a/IGC/VectorCompiler/igcdeps/src/cmc.cpp b/IGC/VectorCompiler/igcdeps/src/cmc.cpp
@@ -751,10 +751,10 @@ static void setGtpinInfo(const FINALIZER_INFO &JitterInfo,
   Kernel.m_kernelInfo.m_executionEnivronment.PerThreadScratchSpace +=
       JitterInfo.numBytesScratchGtpin;
 
-  if (!GtpinInfo.getGTPinBuffer().empty()) {
-    const size_t BufSize = GtpinInfo.getGTPinBuffer().size();
+  if (!GtpinInfo.empty()) {
+    const size_t BufSize = GtpinInfo.size();
     void *GtpinBuffer = IGC::aligned_malloc(BufSize, 16);
-    memcpy_s(GtpinBuffer, BufSize, GtpinInfo.getGTPinBuffer().data(), BufSize);
+    memcpy_s(GtpinBuffer, BufSize, GtpinInfo.data(), BufSize);
     Kernel.getProgramOutput().m_gtpinBufferSize = BufSize;
     Kernel.getProgramOutput().m_gtpinBuffer = GtpinBuffer;
   }
diff --git a/IGC/VectorCompiler/include/vc/GenXCodeGen/GenXOCLRuntimeInfo.h b/IGC/VectorCompiler/include/vc/GenXCodeGen/GenXOCLRuntimeInfo.h
@@ -178,7 +178,7 @@ class GenXOCLRuntimeInfo : public ModulePass {
 
     unsigned SLMSize = 0;
     unsigned ThreadPrivateMemSize = 0;
-    unsigned StatelessPrivateMemSize;
+    unsigned StatelessPrivateMemSize = 0;
 
     unsigned GRFSizeInBytes;
 
@@ -204,6 +204,8 @@ class GenXOCLRuntimeInfo : public ModulePass {
     using arg_size_type = ArgInfoStorageTy::size_type;
 
   public:
+    // Creates kernel info for empty kernel.
+    KernelInfo(const GenXSubtarget &ST);
     // Creates kernel info for given function group.
     KernelInfo(const FunctionGroup &FG, const GenXSubtarget &ST,
                const GenXBackendConfig &BC);
@@ -251,13 +253,7 @@ class GenXOCLRuntimeInfo : public ModulePass {
     const PrintStringStorageTy &getPrintStrings() const { return PrintStrings; }
   };
 
-  class GTPinInfo {
-    std::vector<char> gtpinBuffer;
-  public:
-    GTPinInfo(std::vector<char>&& buf): gtpinBuffer(std::move(buf)) {}
-    unsigned getGTPinBufferSize() const { return gtpinBuffer.size(); }
-    const std::vector<char> &getGTPinBuffer() const { return gtpinBuffer; }
-  };
+  using GTPinInfo = std::vector<char>;
 
   class CompiledKernel {
     KernelInfo CompilerInfo;
@@ -267,8 +263,7 @@ class GenXOCLRuntimeInfo : public ModulePass {
 
   public:
     CompiledKernel(KernelInfo &&KI, const FINALIZER_INFO &JI,
-                   const GTPinInfo &GI,
-                   std::vector<char> DebugInfo);
+                   const GTPinInfo &GI, std::vector<char> DebugInfo);
 
     const KernelInfo &getKernelInfo() const { return CompilerInfo; }
     const FINALIZER_INFO &getJitterInfo() const { return JitterInfo; }
diff --git a/IGC/VectorCompiler/include/vc/Support/ShaderOverride.h b/IGC/VectorCompiler/include/vc/Support/ShaderOverride.h
@@ -22,7 +22,6 @@ class ShaderOverrider {
   enum class Extensions { VISAASM, ASM, DAT, LL };
 
   virtual bool override(void *&GenXBin, int &GenXBinSize,
-                        llvm::StringRef KernelName,
                         llvm::StringRef FunctionName, Extensions Ext) const = 0;
 
   virtual ~ShaderOverrider() = default;
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXOCLRuntimeInfo.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXOCLRuntimeInfo.cpp
@@ -339,6 +339,10 @@ void GenXOCLRuntimeInfo::KernelInfo::setPrintStrings(
                  });
 }
 
+GenXOCLRuntimeInfo::KernelInfo::KernelInfo(const GenXSubtarget &ST)
+    : Name{"Intel_Symbol_Table_Void_Program"}, GRFSizeInBytes{
+                                                   ST.getGRFByteSize()} {}
+
 GenXOCLRuntimeInfo::KernelInfo::KernelInfo(const FunctionGroup &FG,
                                            const GenXSubtarget &ST,
                                            const GenXBackendConfig &BC) {
@@ -413,18 +417,20 @@ void constructSymbols(InputIter First, InputIter Last, OutputIter Out) {
 }
 
 static GenXOCLRuntimeInfo::SymbolSeq constructFunctionSymbols(
-    genx::BinaryDataAccumulator<const Function *> &GenBinary) {
+    genx::BinaryDataAccumulator<const Function *> &GenBinary, bool HasKernel) {
   GenXOCLRuntimeInfo::SymbolSeq Symbols;
   Symbols.reserve(GenBinary.getNumSections());
-  auto &KernelSection = GenBinary.front();
-  Symbols.emplace_back(vISA::GenSymType::S_KERNEL, KernelSection.Info.Offset,
-                       KernelSection.Info.getSize(),
-                       KernelSection.Key->getName().str());
+  if (HasKernel) {
+    auto &KernelSection = GenBinary.front();
+    Symbols.emplace_back(vISA::GenSymType::S_KERNEL, KernelSection.Info.Offset,
+                         KernelSection.Info.getSize(),
+                         KernelSection.Key->getName().str());
+  }
 
-  // Skipping first section with the kernel.
-  constructSymbols<vISA::GenSymType::S_FUNC>(std::next(GenBinary.begin()),
-                                             GenBinary.end(),
-                                             std::back_inserter(Symbols));
+  // Skipping first section if binary has a kernel.
+  constructSymbols<vISA::GenSymType::S_FUNC>(
+      HasKernel ? std::next(GenBinary.begin()) : GenBinary.begin(),
+      GenBinary.end(), std::back_inserter(Symbols));
 
   return Symbols;
 }
@@ -452,13 +458,12 @@ appendFuncBinary(genx::BinaryDataAccumulator<const Function *> &GenBinary,
 // Returns the success status of the loading.
 static bool
 loadGenBinaryFromFile(genx::BinaryDataAccumulator<const Function *> &GenBinary,
-                      const Function &Kernel, const Function &F,
-                      vc::ShaderOverrider const &Loader,
+                      const Function &F, vc::ShaderOverrider const &Loader,
                       vc::ShaderOverrider::Extensions Ext) {
   void *GenBin = nullptr;
   int GenBinSize = 0;
 
-  if (!Loader.override(GenBin, GenBinSize, Kernel.getName(), F.getName(), Ext))
+  if (!Loader.override(GenBin, GenBinSize, F.getName(), Ext))
     return false;
 
   if (!GenBin || !GenBinSize) {
@@ -477,29 +482,24 @@ loadGenBinaryFromFile(genx::BinaryDataAccumulator<const Function *> &GenBinary,
 // Returns the success status of the overriding.
 static bool
 tryOverrideBinary(genx::BinaryDataAccumulator<const Function *> &GenBinary,
-                  const Function &Kernel, const Function &F,
-                  vc::ShaderOverrider const &Loader) {
+                  const Function &F, vc::ShaderOverrider const &Loader) {
   using Extensions = vc::ShaderOverrider::Extensions;
 
   // Attempts to override .asm
-  if (loadGenBinaryFromFile(GenBinary, Kernel, F, Loader, Extensions::ASM))
+  if (loadGenBinaryFromFile(GenBinary, F, Loader, Extensions::ASM))
     return true;
 
   // If it has failed then attempts to override .dat file
-  return loadGenBinaryFromFile(GenBinary, Kernel, F, Loader, Extensions::DAT);
+  return loadGenBinaryFromFile(GenBinary, F, Loader, Extensions::DAT);
 }
 
-// Either loads binaries from VISABuilder or overrides from files.
-// \p Kernel should always be kernel function, meanwhile if \p F is actually a
-// kernel means we are loading kernel, and if \p F is a function means we are
-// loading function.
-static void
-loadBinaries(genx::BinaryDataAccumulator<const Function *> &GenBinary,
-             VISABuilder &VB, const Function &Kernel, const Function &F,
-             GenXBackendConfig const &BC) {
+// Either loads binary from VISABuilder or overrides from file.
+static void loadBinary(genx::BinaryDataAccumulator<const Function *> &GenBinary,
+                       VISABuilder &VB, const Function &F,
+                       GenXBackendConfig const &BC) {
   // Attempt to override
   if (BC.hasShaderOverrider() &&
-      tryOverrideBinary(GenBinary, Kernel, F, BC.getShaderOverrider()))
+      tryOverrideBinary(GenBinary, F, BC.getShaderOverrider()))
     return;
 
   // If there is no overriding or attemp fails, then gets binary from compilation
@@ -537,23 +537,11 @@ std::vector<const Function *> collectCalledFunctions(const FunctionGroup &FG,
 // Constructs gen binary for provided function group \p FG.
 static genx::BinaryDataAccumulator<const Function *>
 getGenBinary(const FunctionGroup &FG, VISABuilder &VB,
-             GenXBackendConfig const &BC,
-             std::set<const Function *> &ProcessedCalls) {
+             GenXBackendConfig const &BC) {
   Function const *Kernel = FG.getHead();
   genx::BinaryDataAccumulator<const Function *> GenBinary;
   // load kernel
-  loadBinaries(GenBinary, VB, *Kernel, *Kernel, BC);
-
-  const auto IndirectFunctions = collectCalledFunctions(
-      FG, [](const Function *F) { return genx::isReferencedIndirectly(F); });
-  for (const Function *F : IndirectFunctions) {
-    if (ProcessedCalls.count(F) != 0)
-      continue;
-    ProcessedCalls.insert(F);
-    // load functions
-    loadBinaries(GenBinary, VB, *Kernel, *F, BC);
-  }
-
+  loadBinary(GenBinary, VB, *Kernel, BC);
   return std::move(GenBinary);
 }
 
@@ -656,7 +644,6 @@ class RuntimeInfoCollector final {
   const GenXSubtarget &ST;
   const Module &M;
   const GenXDebugInfo &DBG;
-  std::set<const llvm::Function *> ProcessedCalls;
 
 public:
   using KernelStorageTy = GenXOCLRuntimeInfo::KernelStorageTy;
@@ -673,7 +660,9 @@ class RuntimeInfoCollector final {
   CompiledModuleT run();
 
 private:
-  CompiledKernel collectFunctionGroupInfo(const FunctionGroup &FG);
+  CompiledKernel collectFunctionGroupInfo(const FunctionGroup &FG) const;
+  CompiledKernel collectFunctionSubgroupsInfo(
+      const std::vector<FunctionGroup *> &Subgroups) const;
 };
 
 } // namespace
@@ -684,12 +673,20 @@ RuntimeInfoCollector::CompiledModuleT RuntimeInfoCollector::run() {
                  [this](const FunctionGroup *FG) {
                    return collectFunctionGroupInfo(*FG);
                  });
+  std::vector<FunctionGroup *> IndirectlyReferencedFuncs;
+  std::copy_if(FGA.subgroup_begin(), FGA.subgroup_end(),
+               std::back_inserter(IndirectlyReferencedFuncs),
+               [](const FunctionGroup *FG) {
+                 return genx::isReferencedIndirectly(FG->getHead());
+               });
+  if (!IndirectlyReferencedFuncs.empty())
+    Kernels.push_back(collectFunctionSubgroupsInfo(IndirectlyReferencedFuncs));
   return {getModuleInfo(M), std::move(Kernels),
           M.getDataLayout().getPointerSize()};
 }
 
 RuntimeInfoCollector::CompiledKernel
-RuntimeInfoCollector::collectFunctionGroupInfo(const FunctionGroup &FG) {
+RuntimeInfoCollector::collectFunctionGroupInfo(const FunctionGroup &FG) const {
   using KernelInfo = GenXOCLRuntimeInfo::KernelInfo;
   using GTPinInfo = GenXOCLRuntimeInfo::GTPinInfo;
   using CompiledKernel = GenXOCLRuntimeInfo::CompiledKernel;
@@ -722,7 +719,7 @@ RuntimeInfoCollector::collectFunctionGroupInfo(const FunctionGroup &FG) {
   }
 
   genx::BinaryDataAccumulator<const Function *> GenBinary =
-      getGenBinary(FG, VB, BC, ProcessedCalls);
+      getGenBinary(FG, VB, BC);
 
   const auto& Dbg = DBG.getModuleDebug();
   auto DbgIt = Dbg.find(KernelFunction);
@@ -737,20 +734,42 @@ RuntimeInfoCollector::collectFunctionGroupInfo(const FunctionGroup &FG) {
   CISA_CALL(VK->GetGenRelocEntryBuffer(Info.LegacyFuncRelocations.Buffer,
                                        Info.LegacyFuncRelocations.Size,
                                        Info.LegacyFuncRelocations.Entries));
-  Info.Func.Symbols = constructFunctionSymbols(GenBinary);
+  Info.Func.Symbols = constructFunctionSymbols(GenBinary, /*HasKernel=*/true);
 
   void *GTPinBuffer = nullptr;
   unsigned GTPinBufferSize = 0;
   CISA_CALL(VK->GetGTPinBuffer(GTPinBuffer, GTPinBufferSize));
 
   auto *GTPinBytes = static_cast<char *>(GTPinBuffer);
-  GTPinInfo gtpin{{GTPinBytes, GTPinBytes + GTPinBufferSize}};
+  GTPinInfo gtpin{GTPinBytes, GTPinBytes + GTPinBufferSize};
 
   Info.Func.Data.Buffer = std::move(GenBinary).emitConsolidatedData();
   return CompiledKernel{std::move(Info), *JitInfo, std::move(gtpin),
                         std::move(DebugData)};
 }
 
+RuntimeInfoCollector::CompiledKernel
+RuntimeInfoCollector::collectFunctionSubgroupsInfo(
+    const std::vector<FunctionGroup *> &Subgroups) const {
+  using KernelInfo = GenXOCLRuntimeInfo::KernelInfo;
+  using CompiledKernel = GenXOCLRuntimeInfo::CompiledKernel;
+
+  IGC_ASSERT(!Subgroups.empty());
+  KernelInfo Info{ST};
+
+  genx::BinaryDataAccumulator<const Function *> GenBinary;
+  for (auto *FG : Subgroups) {
+    auto *Func = FG->getHead();
+    IGC_ASSERT(genx::fg::isSubGroupHead(*Func));
+    loadBinary(GenBinary, VB, *Func, BC);
+  }
+  Info.Func.Symbols = constructFunctionSymbols(GenBinary, /*HasKernel*/false);
+  Info.Func.Data.Buffer = GenBinary.emitConsolidatedData();
+
+  return CompiledKernel{std::move(Info), FINALIZER_INFO{}, /*GtpinInfo*/ {},
+                        /*DebugInfo*/ {}};
+}
+
 void GenXOCLRuntimeInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<FunctionGroupAnalysis>();
   AU.addRequired<GenXBackendConfig>();
