Debug info implementation to support subroutines

Changes to .debug_frames section to support subroutine debug info.

Changes include:
1. Fixing subroutine name emitted by VISA debug info so it matches
   subroutine name in IGC.
2. Passing flag to indicate if a function is a subroutine.
3. Emitting CIE and FDE for subroutines.

Author: pratikashar

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -1060,8 +1060,9 @@ bool EmitPass::runOnFunction(llvm::Function& F)
         m_currShader->GetDebugInfoData().m_pDebugEmitter = m_pDebugEmitter;
 
         const bool IsPrimary = isFuncGroupHead;
-        m_pDebugEmitter->resetModule(
-            IGC::ScalarVisaModule::BuildNew(m_currShader, &F, IsPrimary));
+        bool GroupHasStackCall = m_FGA && m_FGA->getGroup(&F)->hasStackCall();
+        m_pDebugEmitter->resetModule(IGC::ScalarVisaModule::BuildNew(
+            m_currShader, &F, IsPrimary, GroupHasStackCall));
     }
 
     // We only invoke EndEncodingMark() to update last VISA id.

IGC/Compiler/DebugInfo/ScalarVISAModule.cpp

@@ -88,18 +88,18 @@ namespace IGC {
     return (fullDebugInfo | lineNumbersOnly);
 }
 
-ScalarVisaModule::ScalarVisaModule(CShader* TheShader,
-                                   llvm::Function *TheFunction,
-                                   bool IsPrimary)
-  : m_pShader(TheShader), VISAModule(TheFunction, IsPrimary) {
-  UpdateVisaId();
+ScalarVisaModule::ScalarVisaModule(CShader *TheShader,
+                                   llvm::Function *TheFunction, bool IsPrimary,
+                                   bool IsStackCallContext)
+    : m_pShader(TheShader),
+      VISAModule(TheFunction, IsPrimary, IsStackCallContext) {
+    UpdateVisaId();
 }
 
-std::unique_ptr<IGC::VISAModule> ScalarVisaModule::BuildNew(CShader* S,
-                                                            llvm::Function *F,
-                                                            bool IsPrimary)
-{
-    auto* n = new ScalarVisaModule(S, F, IsPrimary);
+std::unique_ptr<IGC::VISAModule>
+ScalarVisaModule::BuildNew(CShader *S, llvm::Function *F, bool IsPrimary,
+                           bool IsStackCallContext) {
+    auto *n = new ScalarVisaModule(S, F, IsPrimary, IsStackCallContext);
     return std::unique_ptr<IGC::VISAModule>(n);
 }
 

IGC/Compiler/DebugInfo/ScalarVISAModule.h

@@ -33,7 +33,8 @@ class ScalarVisaModule final : public IGC::VISAModule {
 public:
 
     static std::unique_ptr<IGC::VISAModule>
-        BuildNew(CShader* S, llvm::Function *F, bool IsPrimary = false);
+  BuildNew(CShader *S, llvm::Function *F, bool IsPrimary = false,
+           bool IsCallerStackCall = false);
 
     unsigned int getUnpaddedProgramSize() const override {
         return m_pShader->ProgramOutput()->m_unpaddedProgramSize;
@@ -125,8 +126,11 @@ class ScalarVisaModule final : public IGC::VISAModule {
     /// used to emit vISA code.
     /// @param IsPrimary indicates if the currently processed function
     /// is a "primary entry point" to the corresponding Shader object.
+    /// @param IsStackCallContext is set to true if current instance
+    /// is a subroutine and caller context is stack call.
     /// See Source/IGC/DebugInfo/VISAModule.hpp for more details
-    ScalarVisaModule(CShader* TheShader, llvm::Function *TheFunction, bool IsPrimary);
+    ScalarVisaModule(CShader *TheShader, llvm::Function *TheFunction,
+                     bool IsPrimary, bool IsStackCallContext);
     /// @brief Trace given value to its origin value, searching for LLVM Argument.
     /// @param pVal value to process.
     /// @param isAddress indecates if the value represents an address.

IGC/DebugInfo/DwarfDebug.cpp

@@ -496,6 +496,13 @@ DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram *SP) {
     }
   }
 
+  if (m_pModule && m_pModule->getFunction() &&
+      m_pModule->getFunction()->getSubprogram() == SP &&
+      m_pModule->GetType() == VISAModule::ObjectType::SUBROUTINE) {
+    SPCU->addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
+                  dwarf::DW_CC_nocall);
+  }
+
   if (EmitSettings.EnableRelocation) {
     auto Id = m_pModule->GetFuncId();
     SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
@@ -1131,15 +1138,11 @@ void DwarfDebug::beginModule() {
   SectionMap[Asm->GetTextSection()];
 
   Asm->SwitchSection(Asm->GetDwarfFrameSection());
-  if (m_pModule->getSubroutines(*VisaDbgInfo)->empty()) {
-    // First stack call CIE is written out,
-    // next subroutine CIE if required.
-    offsetCIEStackCall = 0;
-    offsetCIESubroutine = writeStackcallCIE();
-  } else {
-    // TODO: .debug_frame for subrotuines is currently unsupported.
-    // writeSubroutineCIE();
-  }
+  offsetCIEStackCall = 0;
+  offsetCIESubroutine = writeStackcallCIE();
+  // First stack call CIE is written out,
+  // next subroutine CIE.
+  writeSubroutineCIE();
 }
 
 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
@@ -2312,13 +2315,13 @@ void DwarfDebug::endFunction(const Function *MF) {
   }
 
   Asm->SwitchSection(Asm->GetDwarfFrameSection());
-  if (m_pModule->getSubroutines(*VisaDbgInfo)->empty()) {
-    LLVM_DEBUG(dbgs() << "[DwarfDebug] writing FDEStackCall start ---\n");
-    writeFDEStackCall(m_pModule);
-    LLVM_DEBUG(dbgs() << "[DwarfDebug] writing FDEStackCall end  ***\n");
+
+  if (m_pModule->GetType() == VISAModule::ObjectType::SUBROUTINE) {
+    LLVM_DEBUG(dbgs() << "[DwarfDebug] writing FDESubproutine ***\n");
+    writeFDESubroutine(m_pModule);
   } else {
-    LLVM_DEBUG(dbgs() << "[DwarfDebug] FDESubproutine skipped  ***\n");
-    // writeFDESubroutine(m_pModule);
+    LLVM_DEBUG(dbgs() << "[DwarfDebug] writing FDEStackCall ***\n");
+    writeFDEStackCall(m_pModule);
   }
 
   ScopeVariables.clear();
@@ -2808,6 +2811,11 @@ uint32_t DwarfDebug::writeSubroutineCIE() {
   std::vector<uint8_t> data;
   auto numGRFs = GetVISAModule()->getNumGRFs();
 
+  auto writeSameValue = [](std::vector<uint8_t> &data, uint32_t srcReg) {
+    write(data, (uint8_t)llvm::dwarf::DW_CFA_same_value);
+    writeULEB128(data, srcReg);
+  };
+
   // Emit CIE
   auto ptrSize = Asm->GetPointerSize();
   // The size of the length field plus the value of length must be an integral
@@ -2818,7 +2826,7 @@ uint32_t DwarfDebug::writeSubroutineCIE() {
 
   // Write CIE_id
   write(data,
-        ptrSize == 4 ? (uint32_t)0xfffffffe : (uint64_t)0xfffffffffffffffe);
+        ptrSize == 4 ? (uint32_t)0xffffffff : (uint64_t)0xffffffffffffffff);
 
   // version - ubyte
   write(data, (uint8_t)4);
@@ -2841,13 +2849,13 @@ uint32_t DwarfDebug::writeSubroutineCIE() {
   // return address register - uleb128
   // set machine return register to one which is physically
   // absent. later CFA instructions map this to a valid GRF.
-  writeULEB128(data, numGRFs);
+  writeULEB128(data, RegisterNumbering::IP);
 
   // initial instructions (array of ubyte)
-  // DW_CFA_def_cfa -> fpreg+0
-  write(data, (uint8_t)llvm::dwarf::DW_CFA_def_cfa);
-  writeULEB128(data, 0);
-  writeULEB128(data, 0);
+  // same value rule for all GRFs
+  for (unsigned int grf = 0; grf != numGRFs; ++grf) {
+    writeSameValue(data, GetEncodedRegNum<RegisterNumbering::GRFBase>(grf));
+  }
 
   while ((lenSize + data.size()) % ptrSize != 0)
     // Insert DW_CFA_nop
@@ -3028,7 +3036,8 @@ uint32_t DwarfDebug::writeStackcallCIE() {
 }
 
 void DwarfDebug::writeFDESubroutine(VISAModule *m) {
-  std::vector<uint8_t> data;
+  std::vector<uint8_t> data, data1;
+  uint64_t LabelOffset = std::numeric_limits<uint64_t>::max();
 
   auto firstInst = (m->GetInstInfoMap()->begin())->first;
   // TODO: fixup to a proper name getter
@@ -3045,8 +3054,6 @@ void DwarfDebug::writeFDESubroutine(VISAModule *m) {
   if (!sub)
     return;
 
-  auto numGRFs = GetVISAModule()->getNumGRFs();
-
   // Emit CIE
   auto ptrSize = Asm->GetPointerSize();
   uint8_t lenSize = 4;
@@ -3081,27 +3088,68 @@ void DwarfDebug::writeFDESubroutine(VISAModule *m) {
 
   // assume ret var is live throughout sub-routine and it is contained
   // in same GRF.
-  uint32_t linearAddr =
-      (retvarLR.front().var.mapping.r.regNum * m_pModule->getGRFSizeInBytes()) +
-      retvarLR.front().var.mapping.r.subRegNum;
+  uint16_t retRegNum = retvarLR.front().var.mapping.r.regNum;
+  uint16_t retSubRegNum = retvarLR.front().var.mapping.r.subRegNum;
 
   // initial location
-  write(data, ptrSize == 4 ? (uint32_t)genOffStart : genOffStart);
+  // LabelOffset holds offset where start %ip is written to buffer.
+  // Code later uses this to insert label for relocation.
+  LabelOffset = data.size();
+  if (EmitSettings.EnableRelocation) {
+    write(data,
+          ptrSize == 4 ? (uint32_t)0xfefefefe : (uint64_t)0xfefefefefefefefe);
+  } else {
+    write(data, ptrSize == 4 ? (uint32_t)genOffStart : (uint64_t)genOffStart);
+  }
 
   // address range
   write(data, ptrSize == 4 ? (uint32_t)(genOffEnd - genOffStart)
-                           : (genOffEnd - genOffStart));
+                           : (uint64_t)(genOffEnd - genOffStart));
 
   // instruction - ubyte
-  write(data, (uint8_t)llvm::dwarf::DW_CFA_register);
+  write(data, (uint8_t)llvm::dwarf::DW_CFA_val_expression);
 
   // return reg operand
-  writeULEB128(data, numGRFs);
+  writeULEB128(data, RegisterNumbering ::IP);
 
   // actual reg holding retval
-  writeULEB128(data, linearAddr);
+  data1.clear();
+  write(data1, (uint8_t)llvm::dwarf::DW_OP_const2u);
+  write(data1,
+        (uint16_t)GetEncodedRegNum<RegisterNumbering::GRFBase>(retRegNum));
+  write(data1, (uint8_t)llvm::dwarf::DW_OP_const2u);
+  write(data1, (uint16_t)(retSubRegNum * 8));
+  write(data1, (uint8_t)DW_OP_INTEL_regval_bits);
+  write(data1, (uint8_t)32);
+
+  writeULEB128(data, data1.size());
+  for (auto item : data1)
+    write(data, (uint8_t)item);
 
   // initial instructions (array of ubyte)
+  // DW_CFA_def_cfa_expression = DW_OP_lit0
+  write(data, (uint8_t)llvm::dwarf::DW_CFA_def_cfa_expression);
+  data1.clear();
+  if (m->StackCallContext()) {
+    // CFA is BE_SP location
+    write(data1, (uint8_t)llvm::dwarf::DW_OP_const2u);
+    write(data1, (uint16_t)GetEncodedRegNum<RegisterNumbering::GRFBase>(
+                     GetSpecialGRF()));
+    write(data1, (uint8_t)llvm::dwarf::DW_OP_const1u);
+    if (GetABIVersion() == 3)
+      write(data1, (uint8_t)(BESPSubReg_3 * 32));
+    else
+      write(data1, (uint8_t)(BESPSubReg_1_2 * 32));
+    write(data1, (uint8_t)DW_OP_INTEL_regval_bits);
+    write(data1, (uint8_t)32);
+    encodeScratchAddrSpace(data1);
+  } else {
+    write(data1, (uint8_t)llvm::dwarf::DW_OP_lit0);
+  }
+  writeULEB128(data, data1.size());
+  for (auto item : data1)
+    write(data, (uint8_t)item);
+
   while ((lenSize + data.size()) % ptrSize != 0)
     // Insert DW_CFA_nop
     write(data, (uint8_t)llvm::dwarf::DW_CFA_nop);
@@ -3111,8 +3159,24 @@ void DwarfDebug::writeFDESubroutine(VISAModule *m) {
     Asm->EmitInt32(0xffffffff);
   Asm->EmitIntValue(data.size(), ptrSize);
 
-  for (auto &byte : data)
-    Asm->EmitInt8(byte);
+  if (EmitSettings.EnableRelocation) {
+    uint32_t ByteOffset = 0;
+
+    for (auto it = data.begin(); it != data.end(); ++it) {
+      auto byte = *it;
+      if (ByteOffset++ == (uint32_t)LabelOffset) {
+        auto Label = GetLabelBeforeIp(genOffStart);
+        Asm->EmitLabelReference(Label, ptrSize, false);
+        // Now skip ptrSize number of bytes from data
+        std::advance(it, ptrSize);
+        byte = *it;
+      }
+      Asm->EmitInt8(byte);
+    }
+  } else {
+    for (auto &byte : data)
+      Asm->EmitInt8(byte);
+  }
 }
 
 void DwarfDebug::writeFDEStackCall(VISAModule *m) {
@@ -3316,7 +3380,7 @@ void DwarfDebug::writeFDEStackCall(VISAModule *m) {
         write(data1, (uint8_t)llvm::dwarf::DW_OP_const4u);
         write(data1, (uint32_t)(DWRegEncoded));
         write(data1, (uint8_t)llvm::dwarf::DW_OP_const2u);
-        write(data1, (uint16_t)(getRetIPSubReg() * 4));
+        write(data1, (uint16_t)(getRetIPSubReg() * 4 * 8));
         write(data1, (uint8_t)DW_OP_INTEL_regval_bits);
         write(data1, (uint8_t)32);
         writeULEB128(cfaOps[item.end + MovGenInstSizeInBytes], data1.size());

IGC/DebugInfo/VISAModule.hpp

@@ -412,6 +412,8 @@ class VISAModule {
 
   std::unique_ptr<VarInfoCache> VICache = std::make_unique<VarInfoCache>();
 
+  bool IsStackCallContext = false;
+
 public:
   /// @brief Constructor.
   /// @param AssociatedFunc holds llvm IR function associated with
@@ -421,8 +423,14 @@ class VISAModule {
   /// "Primary entry point" is a function that spawns a separate
   /// gen object (compiled gen isa code). Currently, such functions
   /// correspond to kernel functions or indirectly called functions.
-  VISAModule(llvm::Function *AssociatedFunc, bool IsPrimary)
-      : m_Func(AssociatedFunc), IsPrimaryFunc(IsPrimary) {}
+  /// @param StackCallContext is true for subroutines when caller is
+  /// a stack call function. For non-subroutines this field contains
+  /// no useful meaning.
+  VISAModule(llvm::Function *AssociatedFunc, bool IsPrimary,
+             bool StackCallContext = false)
+      : m_Func(AssociatedFunc), IsPrimaryFunc(IsPrimary) {
+    IsStackCallContext = StackCallContext;
+  }
 
   virtual ~VISAModule() {}
 
@@ -581,6 +589,8 @@ class VISAModule {
   llvm::Function *getFunction() const { return m_Func; }
   uint64_t GetFuncId() const { return (uint64_t)m_Func; }
 
+  bool StackCallContext() const { return IsStackCallContext; }
+
   void dump() const { print(llvm::dbgs()); }
   void print(llvm::raw_ostream &OS) const;
 };

IGC/VectorCompiler/test/DebugInfo/NoDISP/subroutine.ll

@@ -12,22 +12,24 @@
 ; RUN: -vc-dbginfo-dumps-name-override=%basename_t \
 ; RUN: -finalizer-opts='-generateDebugInfo' -o /dev/null
 
-; RUN: llvm-dwarfdump -a dbginfo_%basename_t_test_kernel_dwarf.elf | FileCheck %s
+; REQUIRES: oneapi-readelf
+; RUN: oneapi-readelf --debug-dump dbginfo_%basename_t_test_kernel_dwarf.elf | FileCheck %s
 
-; CHECK: .debug_abbrev contents:
-; CHECK: .debug_info contents:
+; CHECK: Contents of the .debug_info section:
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK: DW_AT_name ("kernel_genx.cpp")
+; CHECK: DW_AT_name : kernel_genx.cpp
 
 ; CHECK: DW_TAG_subprogram
-; CHECK: DW_AT_name ("test_kernel")
+; CHECK: DW_AT_name : test_kernel
 
-; CHECK: .debug_line contents:
-; CHECK: total_length: 0x[[#]]
-; CHECK: version: 4
-; CHECK: file_names{{\[}} [[#]]{{]}}:
-; CHECK: Address Line Column File ISA Discriminator Flags
+; CHECK: Contents of the .debug_abbrev section:
+
+; CHECK: Raw dump of debug contents of section .debug_line:
+; CHECK: Length: [[#]]
+; CHECK: DWARF Version: 4
+; CHECK: The Directory Table
+; CHECK: The File Name Table
 
 ; ModuleID = 'Deserialized SPIRV Module'
 target datalayout = "e-p:64:64-i64:64-n8:16:32"

visa/DebugInfo.cpp

@@ -1046,7 +1046,25 @@ template <class T> void emitDataSubroutines(VISAKernelImpl *visaKernel, T &t) {
           }
         }
         vISA_ASSERT(retval && subLabel, "All of the basic blocks are empty.");
-        emitDataName(subLabel->getLabelName(), t);
+        auto sanitizeSubLabel = [&](const char *lbl) {
+          // VISA appends L_f#_ prefix to subroutines contained
+          // in stack call functions. This causes a mismatch
+          // with function name in llvm IR. When emitting VISA
+          // VISA debug info, we remove this prefix.
+          std::string newName = lbl;
+          if (visaKernel->getIsFunction()) {
+            // Sanity check for first char of prefix
+            if (newName.find("L_f") != 0)
+              return newName;
+            // Eliminate L_f
+            newName = newName.substr(3);
+            auto delim = newName.find('_');
+            newName = newName.substr(delim + 1);
+            return newName;
+          }
+          return newName;
+        };
+        emitDataName(sanitizeSubLabel(subLabel->getLabelName()), t);
         emitDataUInt32(start, t);
         emitDataUInt32(end, t);