[DebugInfo] Construct DWARF-specific data for labels in DwarfDebug.

[HsiangKai]

Summary

Construct class DbgLabel to record DWARF-specific data for labels in
DwarfDebug. It contains DILabel metadata, MCSymbol before DBG_LABEL MI,
and a pointer to DIE data structure. MCSymbol is used to query the
address of the label to generate DW_AT_low_pc attribute of DW_TAG_label.

DwarfDebug::collectLabelInfo() will convert the mappings of DILabel to
(DILocation, MachineInstr) in DebugHandlerBase to mappings of scope to
DbgLabels.

lib/CodeGen/AsmPrinter/DwarfDebug.h

public:
   const DIType *getType() const;
 
 private:
   template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
     return Ref.resolve();
   }
 };
 
+//===----------------------------------------------------------------------===//
+/// This class is used to track label information.
+///
+/// Labels can be created from \c DBG_LABEL instructions.
+class DbgLabel {
+  const DILabel *Label;                 /// Label Descriptor.
+  const MCSymbol *Sym;                  /// Symbol before DBG_LABEL instruction.
+  DIE *TheDIE = nullptr;                /// Label DIE.
+
+public:
+  // We need MCSymbol information to generate DW_AT_low_pc.
+  DbgLabel(const DILabel *V, const MCSymbol *Sym)
+      : Label(V), Sym(Sym) {}
+
+  // Accessors.
+  const DILabel *getLabel() const { return Label; }
+  const MCSymbol *getSymbol() const { return Sym; }
+  void setDIE(DIE &D) { TheDIE = &D; }
+  DIE *getDIE() const { return TheDIE; }
+  StringRef getName() const { return Label->getName(); }
+
+  // Translate tag to proper Dwarf tag.
+  dwarf::Tag getTag() const {
+    return dwarf::DW_TAG_label;
+  }
+
+private:
+  template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
+    return Ref.resolve();
+  }
+};
+
 /// Helper used to pair up a symbol and its DWARF compile unit.
 struct SymbolCU {
   SymbolCU(DwarfCompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
 
   const MCSymbol *Sym;
   DwarfCompileUnit *CU;
 };
 
class DwarfDebug : public DebugHandlerBase {
   std::vector<SymbolCU> ArangeLabels;
 
   /// Size of each symbol emitted (for those symbols that have a specific size).
   DenseMap<const MCSymbol *, uint64_t> SymSize;
 
   /// Collection of abstract variables.
   SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
 
+  /// Collection of abstract labels.
+  SmallVector<std::unique_ptr<DbgLabel>, 64> GotoLabels;
+
   /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
   /// can refer to them in spite of insertions into this list.
   DebugLocStream DebugLocs;
 
   /// This is a collection of subprogram MDNodes that are processed to
   /// create DIEs.
   SetVector<const DISubprogram *, SmallVector<const DISubprogram *, 16>,
             SmallPtrSet<const DISubprogram *, 16>>
class DwarfDebug : public DebugHandlerBase {
   void ensureAbstractVariableIsCreated(DwarfCompileUnit &CU, InlinedVariable Var,
                                        const MDNode *Scope);
   void ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU, InlinedVariable Var,
                                                const MDNode *Scope);
 
   DbgVariable *createConcreteVariable(DwarfCompileUnit &TheCU,
                                       LexicalScope &Scope, InlinedVariable IV);
 
+  /// Convert InlinedLabel to DWARF-related DbgLabel.
+  DbgLabel *createGotoLabel(DwarfCompileUnit &TheCU,
+                            LexicalScope &Scope,
+                            InlinedLabel IL);
+
   /// Construct a DIE for this abstract scope.
   void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
 
   void finishVariableDefinitions();
 
   void finishSubprogramDefinitions();
 
   /// Finish off debug information after all functions have been
class DwarfDebug : public DebugHandlerBase {
   /// source line list.
   void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
                         unsigned Flags);
 
   /// Populate LexicalScope entries with variables' info.
   void collectVariableInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
                            DenseSet<InlinedVariable> &ProcessedVars);
 
+  /// Populate LexicalScope entries with labels' info.
+  void collectLabelInfo(DwarfCompileUnit &TheCU);
+
   /// Build the location list for all DBG_VALUEs in the
   /// function that describe the same variable.
   void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
                          const DbgValueHistoryMap::InstrRanges &Ranges);
 
   /// Collect variable information from the side table maintained by MF.
   void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU,
                                       DenseSet<InlinedVariable> &P);

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DbgVariable *DwarfDebug::createConcreteVariable(DwarfCompileUnit &TheCU,
                                                 InlinedVariable IV) {
   ensureAbstractVariableIsCreatedIfScoped(TheCU, IV, Scope.getScopeNode());
   ConcreteVariables.push_back(
       llvm::make_unique<DbgVariable>(IV.first, IV.second));
   InfoHolder.addScopeVariable(&Scope, ConcreteVariables.back().get());
   return ConcreteVariables.back().get();
 }
 
+DbgLabel *DwarfDebug::createGotoLabel(DwarfCompileUnit &TheCU,
+                                      LexicalScope &Scope,
+                                      InlinedLabel IL) {
+  LabelInfo LInfo = IL.second;
+  MCSymbol *Sym = getLabelBeforeInsn(LInfo.second);
+  GotoLabels.push_back(make_unique<DbgLabel>(IL.first, Sym));
+  InfoHolder.addScopeLabel(&Scope, GotoLabels.back().get());
+  return GotoLabels.back().get();
+}
+
 /// Determine whether a *singular* DBG_VALUE is valid for the entirety of its
 /// enclosing lexical scope. The check ensures there are no other instructions
 /// in the same lexical scope preceding the DBG_VALUE and that its range is
 /// either open or otherwise rolls off the end of the scope.
 static bool validThroughout(LexicalScopes &LScopes,
                             const MachineInstr *DbgValue,
                             const MachineInstr *RangeEnd) {
   assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location");
void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
   // Collect info for variables that were optimized out.
   for (const DILocalVariable *DV : SP->getVariables()) {
     if (Processed.insert(InlinedVariable(DV, nullptr)).second)
       if (LexicalScope *Scope = LScopes.findLexicalScope(DV->getScope()))
         createConcreteVariable(TheCU, *Scope, InlinedVariable(DV, nullptr));
   }
 }
 
+// Find labels for each lexical scope.
+void DwarfDebug::collectLabelInfo(DwarfCompileUnit &TheCU) {
+  // For each InlinedLabel collected from MI instructions, convert to
+  // DWARF-related DbgLabel.
+  for (const auto &I : DbgLabels) {
+    LexicalScope *Scope = nullptr;
+    LabelInfo LInfo = I.second;
+    if (const DILocation *IA = LInfo.first)
+      Scope = LScopes.findInlinedScope(I.first->getScope(), IA);
+    else
+      Scope = LScopes.findLexicalScope(I.first->getScope());
+    // If label scope is not found then skip this label.
+    if (!Scope)
+      continue;
+
+    createGotoLabel(TheCU, *Scope, I);
+  }
+}
+
 // Process beginning of an instruction.
 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   DebugHandlerBase::beginInstruction(MI);
   assert(CurMI);
 
   const auto *SP = MI->getMF()->getFunction().getSubprogram();
   if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
     return;
void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
 
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
   assert(!FnScope || SP == FnScope->getScopeNode());
   DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
 
   DenseSet<InlinedVariable> ProcessedVars;
   collectVariableInfo(TheCU, SP, ProcessedVars);
 
+  collectLabelInfo(TheCU);
+
   // Add the range of this function to the list of ranges for the CU.
   TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
 
   // Under -gmlt, skip building the subprogram if there are no inlined
   // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
   // is still needed as we need its source location.
   if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
       TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
if (!LScopes.getAbstractScopesList().empty() &&
         TheCU.getCUNode()->getSplitDebugInlining())
       SkelCU->constructSubprogramScopeDIE(SP, FnScope);
 
   // Clear debug info
   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
   // DbgVariables except those that are also in AbstractVariables (since they
   // can be used cross-function)
   InfoHolder.getScopeVariables().clear();
+  InfoHolder.getScopeLabels().clear();
   PrevLabel = nullptr;
   CurFn = nullptr;
 }
 
 // Register a source line with debug info. Returns the  unique label that was
 // emitted and which provides correspondence to the source line list.
 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
                                   unsigned Flags) {

lib/CodeGen/AsmPrinter/DwarfFile.h

 #include <map>
 #include <memory>
 #include <utility>
 
 namespace llvm {
 
 class AsmPrinter;
 class DbgVariable;
+class DbgLabel;
 class DwarfCompileUnit;
 class DwarfUnit;
 class LexicalScope;
 class MCSection;
 
 class DwarfFile {
   // Target of Dwarf emission, used for sizing of abbreviations.
   AsmPrinter *Asm;
struct ScopeVars {
     /// We need to sort Args by ArgNo and check for duplicates. This could also
     /// be implemented as a list or vector + std::lower_bound().
     std::map<unsigned, DbgVariable *> Args;
     SmallVector<DbgVariable *, 8> Locals;
   };
   /// Collection of DbgVariables of each lexical scope.
   DenseMap<LexicalScope *, ScopeVars> ScopeVariables;
 
+  // Collection of dbg labels of a scope.
+  DenseMap<LexicalScope *, SmallVector<DbgLabel *, 8>> ScopeLabels;
+
   // Collection of abstract subprogram DIEs.
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
 
   /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
   /// be shared across CUs, that is why we keep the map here instead
   /// of in DwarfCompileUnit.
   DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
public:
 
   MCSymbol *getStringOffsetsStartSym() const { return StringOffsetsStartSym; }
 
   void setStringOffsetsStartSym(MCSymbol *Sym) { StringOffsetsStartSym = Sym; }
 
   /// \returns false if the variable was merged with a previous one.
   bool addScopeVariable(LexicalScope *LS, DbgVariable *Var);
 
+  void addScopeLabel(LexicalScope *LS, DbgLabel *Label);
+
   DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
     return ScopeVariables;
   }
 
+  DenseMap<LexicalScope *, SmallVector<DbgLabel *, 8>> &getScopeLabels() {
+    return ScopeLabels;
+  }
+
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     return AbstractSPDies;
   }
 
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> &getAbstractVariables() {
     return AbstractVariables;
   }
 

lib/CodeGen/AsmPrinter/DwarfFile.cpp

else {
       Cached->second->addMMIEntry(*Var);
       return false;
     }
   } else {
     ScopeVars.Locals.push_back(Var);
   }    
   return true;
 }
+
+void DwarfFile::addScopeLabel(LexicalScope *LS, DbgLabel *Label) {
+  SmallVectorImpl<DbgLabel *> &Labels = ScopeLabels[LS];
+  Labels.push_back(Label);
+}