Use ZEBinary symbol tables instead of legacy types

Changed usages of legacy symbol table structures (m_funcSymbolTable) to ZEBinary structures (m_symbols).
Removed VC/LegacyInfoGeneration source files, as they're not needed after deprecating legacy relocations and symbols.

Author: michalkr52

IGC/Compiler/CISACodeGen/CISABuilder.cpp

@@ -4953,16 +4953,14 @@ void CEncoder::CreateSymbolTable(ValueToSymbolList &symbolTableList) {
         auto Iter = stackFuncMap.find(VFDef);
         IGC_ASSERT_MESSAGE(Iter != stackFuncMap.end(), "vISA function not found");
 
-        vISA::GenSymEntry fEntry;
-        IGC_ASSERT(F.getName().size() <= vISA::MAX_SYMBOL_NAME_LENGTH);
-        strcpy_s(fEntry.s_name, vISA::MAX_SYMBOL_NAME_LENGTH, F.getName().str().c_str());
-        fEntry.s_name[vISA::MAX_SYMBOL_NAME_LENGTH - 1] = 0; // ensure null termination when buffer is too small
+        vISA::ZESymEntry fEntry;
+        fEntry.s_name = F.getName().str();
 
         // Query vISA for the function's byte offset within the compiled module
         // The actual binary offset data should point to the function definition
         VISAFunction *visaFunc = Iter->second;
         fEntry.s_type = vISA::GenSymType::S_FUNC;
-        fEntry.s_offset = (uint32_t)visaFunc->getGenOffset();
+        fEntry.s_offset = (size_t)visaFunc->getGenOffset();
         fEntry.s_size = (uint32_t)visaFunc->getGenSize();
 
         symbolTableList.push_back(std::make_pair(&F, fEntry));
@@ -4980,10 +4978,8 @@ void CEncoder::CreateSymbolTable(ValueToSymbolList &symbolTableList) {
         }
       }
 
-      vISA::GenSymEntry fEntry;
-      IGC_ASSERT(F.getName().size() <= vISA::MAX_SYMBOL_NAME_LENGTH);
-      strcpy_s(fEntry.s_name, vISA::MAX_SYMBOL_NAME_LENGTH, F.getName().str().c_str());
-      fEntry.s_name[vISA::MAX_SYMBOL_NAME_LENGTH - 1] = 0; // ensure null termination when buffer is too small
+      vISA::ZESymEntry fEntry;
+      fEntry.s_name = F.getName().str();
 
       if (F.isDeclaration()) {
         // If the function is only declared, set as undefined type
@@ -4997,7 +4993,7 @@ void CEncoder::CreateSymbolTable(ValueToSymbolList &symbolTableList) {
         // Query vISA for the function's byte offset within the compiled module
         VISAFunction *visaFunc = Iter->second;
         fEntry.s_type = vISA::GenSymType::S_FUNC;
-        fEntry.s_offset = (uint32_t)visaFunc->getGenOffset();
+        fEntry.s_offset = (size_t)visaFunc->getGenOffset();
         fEntry.s_size = (uint32_t)visaFunc->getGenSize();
       }
       symbolTableList.push_back(std::make_pair(&F, fEntry));
@@ -5026,20 +5022,20 @@ void CEncoder::CreateSymbolTable(ValueToSymbolList &symbolTableList) {
       unsigned addrSpace = pGlobal->getType()->getAddressSpace();
       IGC_ASSERT(name.size() <= vISA::MAX_SYMBOL_NAME_LENGTH);
 
-      vISA::GenSymEntry sEntry;
-      strcpy_s(sEntry.s_name, vISA::MAX_SYMBOL_NAME_LENGTH, name.str().c_str());
+      vISA::ZESymEntry sEntry;
+      sEntry.s_name = name.str();
+
       MDNode *md = pGlobal->getMetadata("ConstSampler");
       if (md) {
         // Constant Sampler: s_offset contains the sampler ID
         sEntry.s_type = vISA::GenSymType::S_CONST_SAMPLER;
         sEntry.s_size = 0;
         sEntry.s_offset = static_cast<size_t>(global.second);
       } else {
-        uint32_t type = vISA::GenSymType::S_GLOBAL_VAR_CONST;
+        vISA::GenSymType type = vISA::GenSymType::S_GLOBAL_VAR_CONST;
         // For Zebin always use constant type for string constants
         // because of the relaxed address space requirement of
         // printf strings.
-        IGC_ASSERT(modMD->stringConstants.empty() || m_program->GetContext()->enableZEBinary());
         if (addrSpace == ADDRESS_SPACE_GLOBAL && !modMD->stringConstants.count(pGlobal))
           type = vISA::GenSymType::S_GLOBAL_VAR;
         if (!pGlobal->hasInitializer())
@@ -5054,68 +5050,48 @@ void CEncoder::CreateSymbolTable(ValueToSymbolList &symbolTableList) {
   }
 }
 
-void CEncoder::CreateSymbolTable(void *&buffer, unsigned &bufferSize, unsigned &tableEntries) {
-  buffer = nullptr;
-  bufferSize = 0;
-  tableEntries = 0;
-
-  ValueToSymbolList symbolTableList;
-  CreateSymbolTable(symbolTableList);
-
-  // Get the data for patch token
-  if (!symbolTableList.empty()) {
-    std::vector<vISA::GenSymEntry> tempBufferData;
-    // Collect the data just for the symbol table entries
-    for (const auto &I : symbolTableList) {
-      auto symbolEntry = I.second;
-      tempBufferData.push_back(symbolEntry);
-    }
-
-    tableEntries = tempBufferData.size();
-    bufferSize = tableEntries * sizeof(vISA::GenSymEntry);
-    buffer = malloc(bufferSize);
-    IGC_ASSERT_MESSAGE(nullptr != buffer, "Symbol table cannot be allocated");
-    memcpy_s(buffer, bufferSize, tempBufferData.data(), bufferSize);
-  }
-}
-
-void CEncoder::CreateSymbolTable(SProgramOutput::ZEBinFuncSymbolTable &funcSyms,
-                                 SOpenCLProgramInfo::ZEBinProgramSymbolTable &programSyms) {
-  ValueToSymbolList symbolTableList;
-  CreateSymbolTable(symbolTableList);
-  ModuleMetaData *modMD = m_program->GetContext()->getModuleMetaData();
-
-  // Get the data for zebin
+void CEncoder::CreateFunctionSymbolTable(ValueToSymbolList &symbolTableList,
+                                         SProgramOutput::ZEBinFuncSymbolTable &funcSyms) {
   for (const auto &I : symbolTableList) {
     Value *symbolValue = I.first;
     auto symbolEntry = I.second;
 
     if (Function *F = dyn_cast<Function>(symbolValue)) {
       funcSyms.function.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset, symbolEntry.s_size,
-                                     F->getName().str());
+                                      F->getName().str());
     } else if (GlobalVariable *G = dyn_cast<GlobalVariable>(symbolValue)) {
-      // const sampler
+      // Const sampler
       if (symbolEntry.s_type == vISA::GenSymType::S_CONST_SAMPLER) {
         funcSyms.sampler.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset, symbolEntry.s_size,
                                       G->getName().str());
       }
-      // global variables, including external variables (S_UNDEF)
-      else if (symbolEntry.s_type == vISA::GenSymType::S_GLOBAL_VAR ||
-               symbolEntry.s_type == vISA::GenSymType::S_UNDEF) {
+    }
+  }
+}
+
+void CEncoder::CreateProgramSymbolTable(ValueToSymbolList &symbolTableList,
+                                        SOpenCLProgramInfo::ZEBinProgramSymbolTable &programSyms) {
+  ModuleMetaData *modMD = m_program->GetContext()->getModuleMetaData();
+
+  for (const auto &I : symbolTableList) {
+    Value *symbolValue = I.first;
+    auto symbolEntry = I.second;
+
+    if (GlobalVariable* G = dyn_cast<GlobalVariable>(symbolValue)) {
+      // Global variables, including external variables (S_UNDEF)
+      if (symbolEntry.s_type == vISA::GenSymType::S_GLOBAL_VAR || symbolEntry.s_type == vISA::GenSymType::S_UNDEF) {
         programSyms.global.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset, symbolEntry.s_size,
-                                        G->getName().str());
+                                         G->getName().str());
       }
-      // global constants and string literals
+      // Global constants and string literals
       else {
         if (modMD->stringConstants.count(G)) {
           programSyms.globalStringConst.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset,
-                                                     symbolEntry.s_size, G->getName().str());
+                                                      symbolEntry.s_size, G->getName().str());
         } else
           programSyms.globalConst.emplace_back((vISA::GenSymType)symbolEntry.s_type, symbolEntry.s_offset,
-                                               symbolEntry.s_size, G->getName().str());
+                                                symbolEntry.s_size, G->getName().str());
       }
-    } else {
-      IGC_ASSERT(0);
     }
   }
 }
@@ -5168,23 +5144,6 @@ void CEncoder::CreateFuncAttributeTable(VISAKernel *pMainKernel, GenXFunctionGro
   }
 }
 
-void CEncoder::CreateGlobalHostAccessTable(void *&buffer, unsigned &bufferSize, unsigned &tableEntries) {
-  buffer = nullptr;
-  bufferSize = 0;
-  tableEntries = 0;
-
-  HostAccessList hostAccessList;
-  CreateGlobalHostAccessTable(hostAccessList);
-
-  if (!hostAccessList.empty()) {
-    tableEntries = hostAccessList.size();
-    bufferSize = tableEntries * sizeof(vISA::HostAccessEntry);
-    buffer = malloc(bufferSize);
-    IGC_ASSERT_MESSAGE(nullptr != buffer, "Host access table cannot be allocated");
-    memcpy_s(buffer, bufferSize, hostAccessList.data(), bufferSize);
-  }
-}
-
 void CEncoder::CreateGlobalHostAccessTable(HostAccessList &hostAccessList) {
   ModuleMetaData *modMD = m_program->GetContext()->getModuleMetaData();
 
@@ -5787,68 +5746,67 @@ void CEncoder::createSymbolAndGlobalHostAccessTables(bool hasSymbolTable, VISAKe
                                                      unsigned int scratchOffset) {
   CodeGenContext *context = m_program->GetContext();
   SProgramOutput *pOutput = m_program->ProgramOutput();
-  bool ZEBinEnabled = context->enableZEBinary();
   vISA::FINALIZER_INFO *jitInfo = nullptr;
   pMainKernel.GetJitInfo(jitInfo);
   if (hasSymbolTable) {
-    if (ZEBinEnabled) {
-      // we can only support zebin symbols for OPENCL_SHADER for now
-      IGC_ASSERT(context->type == ShaderType::OPENCL_SHADER);
-      auto cl_context = static_cast<OpenCLProgramContext *>(context);
-      CreateSymbolTable(pOutput->m_symbols, cl_context->m_programInfo.m_zebinSymbolTable);
-      // Set up per-function GTPIN information for indirect functions.
-      for (auto &sym : pOutput->m_symbols.function) {
-        void *buffer = nullptr;
-        unsigned size = 0;
-        if (sym.s_type != vISA::GenSymType::S_UNDEF) {
-          IGC_ASSERT(vbuilder->GetVISAKernel(sym.s_name) != nullptr);
-          vbuilder->GetVISAKernel(sym.s_name)->GetGTPinBuffer(buffer, size, scratchOffset);
-          pOutput->m_FuncGTPinInfoList.push_back({sym.s_name, buffer, size});
-        }
-      }
-      CreateGlobalHostAccessTable(cl_context->m_programInfo.m_zebinGlobalHostAccessTable);
-    } else {
-      CreateSymbolTable(pOutput->m_funcSymbolTable, pOutput->m_funcSymbolTableSize, pOutput->m_funcSymbolTableEntries);
+    ValueToSymbolList symbolTableList;
+    CreateSymbolTable(symbolTableList);
+    CreateFunctionSymbolTable(symbolTableList, pOutput->m_symbols);
 
-      CreateGlobalHostAccessTable(pOutput->m_globalHostAccessTable, pOutput->m_globalHostAccessTableSize,
-                                  pOutput->m_globalHostAccessTableEntries);
+    if (context->type == ShaderType::OPENCL_SHADER) {
+      auto cl_context = static_cast<OpenCLProgramContext *>(context);
+      CreateProgramSymbolTable(symbolTableList, cl_context->m_programInfo.m_zebinSymbolTable);
     }
-  }
 
-  if (ZEBinEnabled) {
-    // create symbols for kernel.
-    // The kernel Symbol has the same name as the kernel, and offset
-    // pointed to 0.
-    CreateLocalSymbol(m_program->entry->getName().str(), vISA::GenSymType::S_KERNEL, 0,
-                      (unsigned)pMainKernel.getGenSize(), pOutput->m_symbols);
-
-    // Emit symbol "_entry' as the actual kernel start. Maybe we can
-    // consider to use the value of the _main label in this case. Now
-    // set the symbol value as the max offset next to the per-thread
-    // prolog, the cross-thread prolog, or the compute-FFID prolog.
-    unsigned actual_kernel_start_off =
-        std::max(std::max(jitInfo->offsetToSkipPerThreadDataLoad, jitInfo->offsetToSkipCrossThreadDataLoad),
-                 jitInfo->offsetToSkipSetFFIDGP1);
-    CreateLocalSymbol("_entry", vISA::GenSymType::S_NOTYPE, actual_kernel_start_off, 0, pOutput->m_symbols);
-
-    // Create local function symbols for direct stackcall functions.
-    for (auto &stackFunc : stackFuncMap) {
-      Function *func = stackFunc.first;
-      if (func->hasFnAttribute("referenced-indirectly"))
-        continue;
-
-      const std::string funcName = func->getName().str();
-      VISAFunction *visaFunc = stackFunc.second;
-      CreateLocalSymbol(funcName, vISA::GenSymType::S_FUNC, (uint32_t)visaFunc->getGenOffset(),
-                        (uint32_t)visaFunc->getGenSize(), pOutput->m_symbols);
-      // Set up per-function GTPIN information for direct stackcall
-      // functions as well.
+    // Set up per-function GTPIN information for indirect functions.
+    for (auto &sym : pOutput->m_symbols.function) {
       void *buffer = nullptr;
       unsigned size = 0;
-      visaFunc->GetGTPinBuffer(buffer, size, 0);
-      pOutput->m_FuncGTPinInfoList.push_back({funcName, buffer, size});
+      if (sym.s_type != vISA::GenSymType::S_UNDEF) {
+        IGC_ASSERT(vbuilder->GetVISAKernel(sym.s_name) != nullptr);
+        vbuilder->GetVISAKernel(sym.s_name)->GetGTPinBuffer(buffer, size, scratchOffset);
+        pOutput->m_FuncGTPinInfoList.push_back({sym.s_name, buffer, size});
+      }
+    }
+
+    if (context->type == ShaderType::OPENCL_SHADER) {
+      auto cl_context = static_cast<OpenCLProgramContext *>(context);
+      CreateGlobalHostAccessTable(cl_context->m_programInfo.m_zebinGlobalHostAccessTable);
     }
   }
+
+  // create symbols for kernel.
+  // The kernel Symbol has the same name as the kernel, and offset
+  // pointed to 0.
+  CreateLocalSymbol(m_program->entry->getName().str(), vISA::GenSymType::S_KERNEL, 0,
+                    (unsigned)pMainKernel.getGenSize(), pOutput->m_symbols);
+
+  // Emit symbol "_entry' as the actual kernel start. Maybe we can
+  // consider to use the value of the _main label in this case. Now
+  // set the symbol value as the max offset next to the per-thread
+  // prolog, the cross-thread prolog, or the compute-FFID prolog.
+  unsigned actual_kernel_start_off =
+      std::max(std::max(jitInfo->offsetToSkipPerThreadDataLoad, jitInfo->offsetToSkipCrossThreadDataLoad),
+                jitInfo->offsetToSkipSetFFIDGP1);
+  CreateLocalSymbol("_entry", vISA::GenSymType::S_NOTYPE, actual_kernel_start_off, 0, pOutput->m_symbols);
+
+  // Create local function symbols for direct stackcall functions.
+  for (auto &stackFunc : stackFuncMap) {
+    Function *func = stackFunc.first;
+    if (func->hasFnAttribute("referenced-indirectly"))
+      continue;
+
+    const std::string funcName = func->getName().str();
+    VISAFunction *visaFunc = stackFunc.second;
+    CreateLocalSymbol(funcName, vISA::GenSymType::S_FUNC, (uint32_t)visaFunc->getGenOffset(),
+                      (uint32_t)visaFunc->getGenSize(), pOutput->m_symbols);
+    // Set up per-function GTPIN information for direct stackcall
+    // functions as well.
+    void *buffer = nullptr;
+    unsigned size = 0;
+    visaFunc->GetGTPinBuffer(buffer, size, 0);
+    pOutput->m_FuncGTPinInfoList.push_back({funcName, buffer, size});
+  }
 }
 
 void CEncoder::SetKernelRetryState(CodeGenContext *context, vISA::FINALIZER_INFO *jitInfo,

IGC/Compiler/CISACodeGen/CISABuilder.hpp

@@ -522,38 +522,31 @@ class CEncoder {
   // save compile time by avoiding retry if the amount of spill is (very) small
   bool AvoidRetryOnSmallSpill() const;
 
-  // CreateSymbolTable will create symbols in two formats. One in given buffer that will be
-  // later parsed as patch token based format, another as struct type that will be parsed
-  // as ZE binary format
-
   // CreateSymbolTable
   // Note that this function should be called only once even if there are
   // multiple kernels in a program. Current IGC flow will create all symbols in
   // the first kernel and all the other kernels won't contain symbols
-  typedef std::vector<std::pair<llvm::Value *, vISA::GenSymEntry>> ValueToSymbolList;
+  typedef std::vector<std::pair<llvm::Value *, vISA::ZESymEntry>> ValueToSymbolList;
   void CreateSymbolTable(ValueToSymbolList &symbolTableList);
-  // input/output: buffer, bufferSize, tableEntries: for patch-token-based
-  // format.
-  void CreateSymbolTable(void *&buffer, unsigned &bufferSize, unsigned &tableEntries);
-  // input/output: symbols: for ZEBinary foramt
-  void CreateSymbolTable(SProgramOutput::ZEBinFuncSymbolTable &funcSyms,
-                         SOpenCLProgramInfo::ZEBinProgramSymbolTable &programSyms);
-  // Create local symbols for kernels. This is ZEBinary format only.
+  // Create function symbols
+  void CreateFunctionSymbolTable(ValueToSymbolList &symbolTableList, SProgramOutput::ZEBinFuncSymbolTable &funcSyms);
+  // Create program symbols
+  void CreateProgramSymbolTable(ValueToSymbolList &symbolTableList,
+                                SOpenCLProgramInfo::ZEBinProgramSymbolTable &programSyms);
+  // Create local symbols for kernels
   void CreateLocalSymbol(const std::string &kernelName, vISA::GenSymType type, unsigned offset, unsigned size,
                          SProgramOutput::ZEBinFuncSymbolTable &symbols);
 
-  // input/output: relocations: for ZEBinary foramt
+  // input/output: relocations
   void CreateRelocationTable(VISAKernel *pMainKernel, SProgramOutput::RelocListTy &relocations);
 
   // CreateFuncAttributeTable
   void CreateFuncAttributeTable(VISAKernel *pMainKernel, GenXFunctionGroupAnalysis *pFga);
 
   // CreateGlobalHostAccessTable
   typedef std::vector<vISA::HostAccessEntry> HostAccessList;
-  void CreateGlobalHostAccessTable(void *&buffer, unsigned &bufferSize, unsigned &tableEntries);
-  // input/output: hostAccessMap: for patch-token-based format.
   void CreateGlobalHostAccessTable(HostAccessList &hostAccessMap);
-  // input/output: global host access names: for ZEBinary format
+  // input/output: global host access names
   void CreateGlobalHostAccessTable(SOpenCLProgramInfo::ZEBinGlobalHostAccessTable &globalHostAccessTable);
 
   uint32_t getGRFSize() const;
@@ -622,11 +615,10 @@ class CEncoder {
   // setup m_retryManager according to jitinfo and other factors
   void SetKernelRetryState(CodeGenContext *context, vISA::FINALIZER_INFO *jitInfo, GenXFunctionGroupAnalysis *&pFGA);
 
-  /// create symbol tables and GlobalHostAccessTable according to if it's zebin
-  /// or patch-token formats
+  /// create symbol tables and GlobalHostAccessTable
   void createSymbolAndGlobalHostAccessTables(bool hasSymbolTable, VISAKernel &pMainKernel, unsigned int scratchOffset);
 
-  /// create relocation according to if it's zebin or patch-token formats
+  /// create relocation tables according
   void createRelocationTables(VISAKernel &pMainKernel);
 
   /// Estimate vISA stack size according to FunctionGroup information.

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -475,10 +475,7 @@ bool EmitPass::isSymbolTableRequired(llvm::Function *F) {
         pGlobal->removeDeadConstantUsers();
 
         // Check if relocation is required by checking uses
-
-        // FIXME: Ideally we should emit symtab for the global if
-        // there's an user in both ZEBIN and PT.
-        if (m_pCtx->enableZEBinary() && !pGlobal->user_empty())
+        if (!pGlobal->user_empty())
           return true;
 
         for (auto user : pGlobal->users()) {