[DebugInfo] Fill DW_TAG_label attributes.

[HsiangKai]

Summary

Go through the list of DbgLabels in DwarfDebug to fill the DW_TAG_label
DIE information.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
   /// \brief Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
   void finishVariableDefinition(const DbgVariable &Var);
+  void finishLabelDefinition(const DbgLabel &Label);
 
   /// Find abstract variable associated with Var.
   using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
   DbgVariable *getExistingAbstractVariable(InlinedVariable IV,
                                            const DILocalVariable *&Cleansed);
   DbgVariable *getExistingAbstractVariable(InlinedVariable IV);
   void createAbstractVariable(const DILocalVariable *DV, LexicalScope *Scope);
 

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::finishVariableDefinition(const DbgVariable &Var) {
   auto *VariableDie = Var.getDIE();
   if (AbsVar && AbsVar->getDIE()) {
     addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
                       *AbsVar->getDIE());
   } else
     applyVariableAttributes(Var, *VariableDie);
 }
 
+void DwarfCompileUnit::finishLabelDefinition(const DbgLabel &Label) {
+  auto *LabelDie = Label.getDIE();
+  StringRef Name = Label.getName();
+  if (!Name.empty())
+    addString(*LabelDie, dwarf::DW_AT_name, Name);
+  const auto *DILabel = Label.getLabel();
+  addSourceLine(*LabelDie, DILabel);
+  const MCSymbol *Sym = Label.getSymbol();
+  addLabelAddress(*LabelDie, dwarf::DW_AT_low_pc, Sym);
+}
+
 DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(InlinedVariable IV) {
   const DILocalVariable *Cleansed;
   return getExistingAbstractVariable(IV, Cleansed);
 }
 
 // Find abstract variable, if any, associated with Var.
 DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(
     InlinedVariable IV, const DILocalVariable *&Cleansed) {

lib/CodeGen/AsmPrinter/DwarfDebug.h

DbgLabel *createGotoLabel(DwarfCompileUnit &TheCU,
                             LexicalScope &Scope,
                             InlinedLabel IL);
 
   /// Construct a DIE for this abstract scope.
   void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
 
   void finishVariableDefinitions();
 
+  void finishLabelDefinitions();
+
   void finishSubprogramDefinitions();
 
   /// Finish off debug information after all functions have been
   /// processed.
   void finalizeModuleInfo();
 
   /// Emit the debug info section.
   void emitDebugInfo();

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const auto &Var : ConcreteVariables) {
     // in the ConcreteVariables list, rather than looking it up again here.
     // DIE::getUnit isn't simple - it walks parent pointers, etc.
     DwarfCompileUnit *Unit = CUDieMap.lookup(VariableDie->getUnitDie());
     assert(Unit);
     Unit->finishVariableDefinition(*Var);
   }
 }
 
+void DwarfDebug::finishLabelDefinitions() {
+  for (const auto &Label : GotoLabels) {
+    DIE *LabelDie = Label->getDIE();
+    assert(LabelDie);
+    DwarfCompileUnit *Unit = CUDieMap.lookup(LabelDie->getUnitDie());
+    assert(Unit);
+    Unit->finishLabelDefinition(*Label);
+  }
+}
+
 void DwarfDebug::finishSubprogramDefinitions() {
   for (const DISubprogram *SP : ProcessedSPNodes) {
     assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
     forBothCUs(
         getOrCreateDwarfCompileUnit(SP->getUnit()),
         [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
   }
 }
 
 void DwarfDebug::finalizeModuleInfo() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
   finishSubprogramDefinitions();
 
   finishVariableDefinitions();
 
+  finishLabelDefinitions();
+
   // Include the DWO file name in the hash if there's more than one CU.
   // This handles ThinLTO's situation where imported CUs may very easily be
   // duplicate with the same CU partially imported into another ThinLTO unit.
   StringRef DWOName;
   if (CUMap.size() > 1)
     DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
 
   // Handle anything that needs to be done on a per-unit basis after

lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   /// Add block data.
   void addBlock(DIE &Die, dwarf::Attribute Attribute, DIEBlock *Block);
 
   /// Add location information to specified debug information entry.
   void addSourceLine(DIE &Die, unsigned Line, const DIFile *File);
   void addSourceLine(DIE &Die, const DILocalVariable *V);
   void addSourceLine(DIE &Die, const DIGlobalVariable *G);
   void addSourceLine(DIE &Die, const DISubprogram *SP);
+  void addSourceLine(DIE &Die, const DILabel *L);
   void addSourceLine(DIE &Die, const DIType *Ty);
   void addSourceLine(DIE &Die, const DIObjCProperty *Ty);
 
   /// Add constant value entry in variable DIE.
   void addConstantValue(DIE &Die, const MachineOperand &MO, const DIType *Ty);
   void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty);
   void addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty);
   void addConstantValue(DIE &Die, const APInt &Val, bool Unsigned);

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
   assert(SP);
 
   addSourceLine(Die, SP->getLine(), SP->getFile());
 }
 
+void DwarfUnit::addSourceLine(DIE &Die, const DILabel *L) {
+  assert(L);
+
+  addSourceLine(Die, L->getLine(), L->getFile());
+}
+
 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
   assert(Ty);
 
   addSourceLine(Die, Ty->getLine(), Ty->getFile());
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
   assert(Ty);