[DebugInfo] Do not generate duplicated label debug info if it has been processed.

[HsiangKai]

Summary

In DwarfDebug::collectEntityInfo(), if the label entity is processed in DbgLabels list, it means the label is not optimized out. There is no need to generate debug info for it with null position.

The bug is reported by vext01 in https://reviews.llvm.org/D45045#1190748

[vext01]

Hi HsiangKai,

Thanks for looking into this.

I've applied this diff to my LLVM clone (again, just before you DILabel codegen stuff was reverted) and rebuilt, but I can still see 0x0 low_pcs in the resulting label.

$ ls -al `which clang`
lrwxrwxrwx 1 vext01 vext01 7 Aug  1 16:16 /home/vext01/research/llvm/inst.debug/bin/clang -> clang-7
$ ls -al `which clang-7`
-rwxr-xr-x 1 vext01 vext01 2102557136 Aug  9 10:54 /home/vext01/research/llvm/inst.debug/bin/clan
$ clang -O0 -g example.ll -o example.o
warning: overriding the module target triple with x86_64-unknown-linux-gnu [-Woverride-module]
1 warning generated.
$ dwarfdump example.o
...
< 2><0x00000041>      DW_TAG_label
                        DW_AT_name                  XXXYYYZZZ
                        DW_AT_decl_file             0x00000001 ./main.xxx
                        DW_AT_decl_line             0x00000001
                        DW_AT_low_pc                0x00000000
...

Do you have this change in a svn or git branch somewhere? There was some fuzz applying the diff, which might be the cause.

[aprantl]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1051

If this processes only variables, why return a set of InlinedEntities instead of InlinedVariables?

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1505

this is equivalent to

else {
  auto *DL = cast<DILabel>(DN); // llvm::cast asserts automatically.
  Scope = DL->getScope();
}

[HsiangKai]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1051

DILocalVariable and DILabel are both DINode. So, I combined InlinedVariable and InlinedLabel into InlinedEntity.
In this way, I have no need to allocate two separate ‘Processed’ sets for them. It is cleaner to check them processed or not.

So, there is no InlinedVariable any more in this patch.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1505

I keep the symmetric form of these if condition. It is cleaner to express the intension that there are two kinds of debug entity to process. If there is another debug entity to process in the future, it could add another if condition for it.

[HsiangKai]

In D50495#1193599, @vext01 wrote:

Hi HsiangKai,

Thanks for looking into this.

I've applied this diff to my LLVM clone (again, just before you DILabel codegen stuff was reverted) and rebuilt, but I can still see 0x0 low_pcs in the resulting label.

$ ls -al `which clang`
lrwxrwxrwx 1 vext01 vext01 7 Aug  1 16:16 /home/vext01/research/llvm/inst.debug/bin/clang -> clang-7
$ ls -al `which clang-7`
-rwxr-xr-x 1 vext01 vext01 2102557136 Aug  9 10:54 /home/vext01/research/llvm/inst.debug/bin/clan
$ clang -O0 -g example.ll -o example.o
warning: overriding the module target triple with x86_64-unknown-linux-gnu [-Woverride-module]
1 warning generated.
$ dwarfdump example.o
...
< 2><0x00000041>      DW_TAG_label
                        DW_AT_name                  XXXYYYZZZ
                        DW_AT_decl_file             0x00000001 ./main.xxx
                        DW_AT_decl_line             0x00000001
                        DW_AT_low_pc                0x00000000
...

Do you have this change in a svn or git branch somewhere? There was some fuzz applying the diff, which might be the cause.

After syncing with vext01 by private messages, the difference is caused by FastISel. By default, X86 uses FastISel under -O0. I prepared a patch for FastISel in D50622.

[HsiangKai]

Any comments?

[HsiangKai]

@aprantl, do you agree my comments?

[aprantl]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1051

Okay.

[HsiangKai]

Is there anything I should address?

Without this patch, it will generate two DW_TAG_label for the same label if retainedNodes also contains the label.
This patch will record processed labels in 'Processed' DenseSet to avoid generating duplicated DW_TAG_label for them.

[sammccall]

I have a bitcode example that crashes with llc badfile -split-dwarf-file some.dwo.
Reverting, will upload the file once it's done minimizing.

[sammccall]

Hmm, so thinking about it, since this is a clang change and the crash reproduces with llc, this is just generating code that triggers an existing LLVM bug.

I think we still need to revert it for now as it triggers a clang crash :-(

bugpoint-reduced-named-md.bc19 KBDownload

llc: /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:176: llvm::MCSymbolRefExpr::MCSymbolRefExpr(const llvm::MCSymbol *, llvm::MCSymbolRefExpr::VariantKind, const llvm::MCAsmInfo *, llvm::SMLoc): Assertion `Symbol' failed.
Stack dump:
0.	Program arguments: bin/llc bugpoint-reduced-named-md.bc -split-dwarf-file out.dwo 
#0 0x0000000003659b19 llvm::sys::PrintStackTrace(llvm::raw_ostream&) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:490:11
#1 0x0000000003659cc9 PrintStackTraceSignalHandler(void*) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:554:1
#2 0x0000000003657f26 llvm::sys::RunSignalHandlers() /usr/local/google/home/sammccall/src/llvm/lib/Support/Signals.cpp:66:5
#3 0x000000000365a2e7 SignalHandler(int) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:353:1
#4 0x00007f8f521d20c0 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x110c0)
#5 0x00007f8f50d63fcf gsignal (/lib/x86_64-linux-gnu/libc.so.6+0x32fcf)
#6 0x00007f8f50d653fa abort (/lib/x86_64-linux-gnu/libc.so.6+0x343fa)
#7 0x00007f8f50d5ce37 (/lib/x86_64-linux-gnu/libc.so.6+0x2be37)
#8 0x00007f8f50d5cee2 (/lib/x86_64-linux-gnu/libc.so.6+0x2bee2)
#9 0x0000000002e36e0f llvm::MCSymbolRefExpr::MCSymbolRefExpr(llvm::MCSymbol const*, llvm::MCSymbolRefExpr::VariantKind, llvm::MCAsmInfo const*, llvm::SMLoc) /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:177:1
#10 0x0000000002e36eb6 llvm::MCSymbolRefExpr::create(llvm::MCSymbol const*, llvm::MCSymbolRefExpr::VariantKind, llvm::MCContext&, llvm::SMLoc) /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:182:10
#11 0x0000000000c12368 llvm::MCSymbolRefExpr::create(llvm::MCSymbol const*, llvm::MCContext&) /usr/local/google/home/sammccall/src/llvm/include/llvm/MC/MCExpr.h:323:5
#12 0x00000000025e4262 llvm::AddressPool::emit(llvm::AsmPrinter&, llvm::MCSection*) /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp:60:15
#13 0x000000000250dfa9 llvm::DwarfDebug::emitDebugAddr() /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp:2380:1
#14 0x000000000250be72 llvm::DwarfDebug::endModule() /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp:896:11
#15 0x00000000024dd8ee llvm::AsmPrinter::doFinalization(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp:1450:12
#16 0x0000000002cf8bf4 llvm::FPPassManager::doFinalization(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1596:16
#17 0x0000000002cf95e3 (anonymous namespace)::MPPassManager::runOnModule(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1670:16
#18 0x0000000002cf8d9e llvm::legacy::PassManagerImpl::run(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1754:16
#19 0x0000000002cf9891 llvm::legacy::PassManager::run(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1785:3
#20 0x0000000000bd8a5c compileModule(char**, llvm::LLVMContext&) /usr/local/google/home/sammccall/src/llvm/tools/llc/llc.cpp:600:41
#21 0x0000000000bd695d main /usr/local/google/home/sammccall/src/llvm/tools/llc/llc.cpp:351:13
#22 0x00007f8f50d512b1 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x202b1)
#23 0x0000000000bd603a _start (bin/llc+0xbd603a)

[HsiangKai]

In D50495#1225927, @sammccall wrote:

Hmm, so thinking about it, since this is a clang change and the crash reproduces with llc, this is just generating code that triggers an existing LLVM bug.

I think we still need to revert it for now as it triggers a clang crash :-(

bugpoint-reduced-named-md.bc19 KBDownload

llc: /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:176: llvm::MCSymbolRefExpr::MCSymbolRefExpr(const llvm::MCSymbol *, llvm::MCSymbolRefExpr::VariantKind, const llvm::MCAsmInfo *, llvm::SMLoc): Assertion `Symbol' failed.
Stack dump:
0.	Program arguments: bin/llc bugpoint-reduced-named-md.bc -split-dwarf-file out.dwo 
#0 0x0000000003659b19 llvm::sys::PrintStackTrace(llvm::raw_ostream&) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:490:11
#1 0x0000000003659cc9 PrintStackTraceSignalHandler(void*) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:554:1
#2 0x0000000003657f26 llvm::sys::RunSignalHandlers() /usr/local/google/home/sammccall/src/llvm/lib/Support/Signals.cpp:66:5
#3 0x000000000365a2e7 SignalHandler(int) /usr/local/google/home/sammccall/src/llvm/lib/Support/Unix/Signals.inc:353:1
#4 0x00007f8f521d20c0 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x110c0)
#5 0x00007f8f50d63fcf gsignal (/lib/x86_64-linux-gnu/libc.so.6+0x32fcf)
#6 0x00007f8f50d653fa abort (/lib/x86_64-linux-gnu/libc.so.6+0x343fa)
#7 0x00007f8f50d5ce37 (/lib/x86_64-linux-gnu/libc.so.6+0x2be37)
#8 0x00007f8f50d5cee2 (/lib/x86_64-linux-gnu/libc.so.6+0x2bee2)
#9 0x0000000002e36e0f llvm::MCSymbolRefExpr::MCSymbolRefExpr(llvm::MCSymbol const*, llvm::MCSymbolRefExpr::VariantKind, llvm::MCAsmInfo const*, llvm::SMLoc) /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:177:1
#10 0x0000000002e36eb6 llvm::MCSymbolRefExpr::create(llvm::MCSymbol const*, llvm::MCSymbolRefExpr::VariantKind, llvm::MCContext&, llvm::SMLoc) /usr/local/google/home/sammccall/src/llvm/lib/MC/MCExpr.cpp:182:10
#11 0x0000000000c12368 llvm::MCSymbolRefExpr::create(llvm::MCSymbol const*, llvm::MCContext&) /usr/local/google/home/sammccall/src/llvm/include/llvm/MC/MCExpr.h:323:5
#12 0x00000000025e4262 llvm::AddressPool::emit(llvm::AsmPrinter&, llvm::MCSection*) /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp:60:15
#13 0x000000000250dfa9 llvm::DwarfDebug::emitDebugAddr() /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp:2380:1
#14 0x000000000250be72 llvm::DwarfDebug::endModule() /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp:896:11
#15 0x00000000024dd8ee llvm::AsmPrinter::doFinalization(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp:1450:12
#16 0x0000000002cf8bf4 llvm::FPPassManager::doFinalization(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1596:16
#17 0x0000000002cf95e3 (anonymous namespace)::MPPassManager::runOnModule(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1670:16
#18 0x0000000002cf8d9e llvm::legacy::PassManagerImpl::run(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1754:16
#19 0x0000000002cf9891 llvm::legacy::PassManager::run(llvm::Module&) /usr/local/google/home/sammccall/src/llvm/lib/IR/LegacyPassManager.cpp:1785:3
#20 0x0000000000bd8a5c compileModule(char**, llvm::LLVMContext&) /usr/local/google/home/sammccall/src/llvm/tools/llc/llc.cpp:600:41
#21 0x0000000000bd695d main /usr/local/google/home/sammccall/src/llvm/tools/llc/llc.cpp:351:13
#22 0x00007f8f50d512b1 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x202b1)
#23 0x0000000000bd603a _start (bin/llc+0xbd603a)

The bug is fixed in https://reviews.llvm.org/D51908.
Thanks for your test case.

[HsiangKai]

This revision is committed to master branch.
I forgot to add "Differential Revision" in commit message. So, this revision is not closed automatically.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// finished.
   MCSymbol *beginCVSubsection(codeview::DebugSubsectionKind Kind);
 
   void endCVSubsection(MCSymbol *EndLabel);
 
   void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
                            const InlineSite &Site);
 
-  using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
+  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
 
   void collectVariableInfo(const DISubprogram *SP);
 
-  void collectVariableInfoFromMFTable(DenseSet<InlinedVariable> &Processed);
+  void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
 
   // Construct the lexical block tree for a routine, pruning emptpy lexical
   // scopes, and populate it with local variables.
   void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
                                SmallVectorImpl<LexicalBlock *> &Blocks,
                                SmallVectorImpl<LocalVariable> &Locals);
   void collectLexicalBlockInfo(LexicalScope &Scope,
                                SmallVectorImpl<LexicalBlock *> &ParentBlocks,

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

CodeViewDebug::createDefRangeGeneral(uint16_t CVRegister, bool InMemory,
   DR.DataOffset = Offset;
   DR.IsSubfield = IsSubfield;
   DR.StructOffset = StructOffset;
   DR.CVRegister = CVRegister;
   return DR;
 }
 
 void CodeViewDebug::collectVariableInfoFromMFTable(
-    DenseSet<InlinedVariable> &Processed) {
+    DenseSet<InlinedEntity> &Processed) {
   const MachineFunction &MF = *Asm->MF;
   const TargetSubtargetInfo &TSI = MF.getSubtarget();
   const TargetFrameLowering *TFI = TSI.getFrameLowering();
   const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
 
   for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
     if (!VI.Var)
       continue;
     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
            "Expected inlined-at fields to agree");
 
-    Processed.insert(InlinedVariable(VI.Var, VI.Loc->getInlinedAt()));
+    Processed.insert(InlinedEntity(VI.Var, VI.Loc->getInlinedAt()));
     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 
     // If variable scope is not found then skip this variable.
     if (!Scope)
       continue;
 
     // If the variable has an attached offset expression, extract it.
     // FIXME: Try to handle DW_OP_deref as well.
for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
     else
       R.emplace_back(Begin, End);
 
     // FIXME: Do more range combining.
   }
 }
 
 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
-  DenseSet<InlinedVariable> Processed;
+  DenseSet<InlinedEntity> Processed;
   // Grab the variable info that was squirreled away in the MMI side-table.
   collectVariableInfoFromMFTable(Processed);
 
   for (const auto &I : DbgValues) {
-    InlinedVariable IV = I.first;
+    InlinedEntity IV = I.first;
     if (Processed.count(IV))
       continue;
-    const DILocalVariable *DIVar = IV.first;
+    const DILocalVariable *DIVar = dyn_cast<DILocalVariable>(IV.first);
     const DILocation *InlinedAt = IV.second;
 
     // Instruction ranges, specifying where IV is accessible.
     const auto &Ranges = I.second;
 
     LexicalScope *Scope = nullptr;
     if (InlinedAt)
       Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.h

class DbgValueHistoryMap {
   // Each instruction range starts with a DBG_VALUE instruction, specifying the
   // location of a variable, which is assumed to be valid until the end of the
   // range. If end is not specified, location is valid until the start
   // instruction of the next instruction range, or until the end of the
   // function.
 public:
   using InstrRange = std::pair<const MachineInstr *, const MachineInstr *>;
   using InstrRanges = SmallVector<InstrRange, 4>;
-  using InlinedVariable =
-      std::pair<const DILocalVariable *, const DILocation *>;
-  using InstrRangesMap = MapVector<InlinedVariable, InstrRanges>;
+  using InlinedEntity = std::pair<const DINode *, const DILocation *>;
+  using InstrRangesMap = MapVector<InlinedEntity, InstrRanges>;
 
 private:
   InstrRangesMap VarInstrRanges;
 
 public:
-  void startInstrRange(InlinedVariable Var, const MachineInstr &MI);
-  void endInstrRange(InlinedVariable Var, const MachineInstr &MI);
+  void startInstrRange(InlinedEntity Var, const MachineInstr &MI);
+  void endInstrRange(InlinedEntity Var, const MachineInstr &MI);
 
   // Returns register currently describing @Var. If @Var is currently
   // unaccessible or is not described by a register, returns 0.
-  unsigned getRegisterForVar(InlinedVariable Var) const;
+  unsigned getRegisterForVar(InlinedEntity Var) const;
 
   bool empty() const { return VarInstrRanges.empty(); }
   void clear() { VarInstrRanges.clear(); }
   InstrRangesMap::const_iterator begin() const { return VarInstrRanges.begin(); }
   InstrRangesMap::const_iterator end() const { return VarInstrRanges.end(); }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const;
 #endif
 };
 
 /// For each inlined instance of a source-level label, keep the corresponding
 /// DBG_LABEL instruction. The DBG_LABEL instruction could be used to generate
 /// a temporary (assembler) label before it.
 class DbgLabelInstrMap {
 public:
-  using InlinedLabel = std::pair<const DILabel *, const DILocation *>;
-  using InstrMap = MapVector<InlinedLabel, const MachineInstr *>;
+  using InlinedEntity = std::pair<const DINode *, const DILocation *>;
+  using InstrMap = MapVector<InlinedEntity, const MachineInstr *>;
 
 private:
   InstrMap LabelInstr;
 
 public:
-  void  addInstr(InlinedLabel Label, const MachineInstr &MI);
+  void  addInstr(InlinedEntity Label, const MachineInstr &MI);
 
   bool empty() const { return LabelInstr.empty(); }
   void clear() { LabelInstr.clear(); }
   InstrMap::const_iterator begin() const { return LabelInstr.begin(); }
   InstrMap::const_iterator end() const { return LabelInstr.end(); }
 };
 
 void calculateDbgEntityHistory(const MachineFunction *MF,
                                const TargetRegisterInfo *TRI,
                                DbgValueHistoryMap &DbgValues,
                                DbgLabelInstrMap &DbgLabels);
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DBGVALUEHISTORYCALCULATOR_H

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

 static unsigned isDescribedByReg(const MachineInstr &MI) {
   assert(MI.isDebugValue());
   assert(MI.getNumOperands() == 4);
   // If location of variable is described using a register (directly or
   // indirectly), this register is always a first operand.
   return MI.getOperand(0).isReg() ? MI.getOperand(0).getReg() : 0;
 }
 
-void DbgValueHistoryMap::startInstrRange(InlinedVariable Var,
+void DbgValueHistoryMap::startInstrRange(InlinedEntity Var,
                                          const MachineInstr &MI) {
   // Instruction range should start with a DBG_VALUE instruction for the
   // variable.
   assert(MI.isDebugValue() && "not a DBG_VALUE");
   auto &Ranges = VarInstrRanges[Var];
   if (!Ranges.empty() && Ranges.back().second == nullptr &&
       Ranges.back().first->isIdenticalTo(MI)) {
     LLVM_DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
                       << "\t" << Ranges.back().first << "\t" << MI << "\n");
     return;
   }
   Ranges.push_back(std::make_pair(&MI, nullptr));
 }
 
-void DbgValueHistoryMap::endInstrRange(InlinedVariable Var,
+void DbgValueHistoryMap::endInstrRange(InlinedEntity Var,
                                        const MachineInstr &MI) {
   auto &Ranges = VarInstrRanges[Var];
   // Verify that the current instruction range is not yet closed.
   assert(!Ranges.empty() && Ranges.back().second == nullptr);
   // For now, instruction ranges are not allowed to cross basic block
   // boundaries.
   assert(Ranges.back().first->getParent() == MI.getParent());
   Ranges.back().second = &MI;
 }
 
-unsigned DbgValueHistoryMap::getRegisterForVar(InlinedVariable Var) const {
+unsigned DbgValueHistoryMap::getRegisterForVar(InlinedEntity Var) const {
   const auto &I = VarInstrRanges.find(Var);
   if (I == VarInstrRanges.end())
     return 0;
   const auto &Ranges = I->second;
   if (Ranges.empty() || Ranges.back().second != nullptr)
     return 0;
   return isDescribedByReg(*Ranges.back().first);
 }
 
-void DbgLabelInstrMap::addInstr(InlinedLabel Label, const MachineInstr &MI) {
+void DbgLabelInstrMap::addInstr(InlinedEntity Label, const MachineInstr &MI) {
   assert(MI.isDebugLabel() && "not a DBG_LABEL");
   LabelInstr[Label] = &MI;
 }
 
 namespace {
 
 // Maps physreg numbers to the variables they describe.
-using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
-using RegDescribedVarsMap = std::map<unsigned, SmallVector<InlinedVariable, 1>>;
-using InlinedLabel = DbgLabelInstrMap::InlinedLabel;
+using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
+using RegDescribedVarsMap = std::map<unsigned, SmallVector<InlinedEntity, 1>>;
 
 } // end anonymous namespace
 
 // Claim that @Var is not described by @RegNo anymore.
 static void dropRegDescribedVar(RegDescribedVarsMap &RegVars, unsigned RegNo,
-                                InlinedVariable Var) {
+                                InlinedEntity Var) {
   const auto &I = RegVars.find(RegNo);
   assert(RegNo != 0U && I != RegVars.end());
   auto &VarSet = I->second;
   const auto &VarPos = llvm::find(VarSet, Var);
   assert(VarPos != VarSet.end());
   VarSet.erase(VarPos);
   // Don't keep empty sets in a map to keep it as small as possible.
   if (VarSet.empty())
     RegVars.erase(I);
 }
 
 // Claim that @Var is now described by @RegNo.
 static void addRegDescribedVar(RegDescribedVarsMap &RegVars, unsigned RegNo,
-                               InlinedVariable Var) {
+                               InlinedEntity Var) {
   assert(RegNo != 0U);
   auto &VarSet = RegVars[RegNo];
   assert(!is_contained(VarSet, Var));
   VarSet.push_back(Var);
 }
 
 // Terminate the location range for variables described by register at
 // @I by inserting @ClobberingInstr to their history.
for (const auto &MI : MBB) {
       if (MI.isDebugValue()) {
         assert(MI.getNumOperands() > 1 && "Invalid DBG_VALUE instruction!");
         // Use the base variable (without any DW_OP_piece expressions)
         // as index into History. The full variables including the
         // piece expressions are attached to the MI.
         const DILocalVariable *RawVar = MI.getDebugVariable();
         assert(RawVar->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
                "Expected inlined-at fields to agree");
-        InlinedVariable Var(RawVar, MI.getDebugLoc()->getInlinedAt());
+        InlinedEntity Var(RawVar, MI.getDebugLoc()->getInlinedAt());
 
         if (unsigned PrevReg = DbgValues.getRegisterForVar(Var))
           dropRegDescribedVar(RegVars, PrevReg, Var);
 
         DbgValues.startInstrRange(Var, MI);
 
         if (unsigned NewReg = isDescribedByReg(MI))
           addRegDescribedVar(RegVars, NewReg, Var);
       } else if (MI.isDebugLabel()) {
         assert(MI.getNumOperands() == 1 && "Invalid DBG_LABEL instruction!");
         const DILabel *RawLabel = MI.getDebugLabel();
         assert(RawLabel->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
             "Expected inlined-at fields to agree");
         // When collecting debug information for labels, there is no MCSymbol
         // generated for it. So, we keep MachineInstr in DbgLabels in order
         // to query MCSymbol afterward.
-        InlinedLabel L(RawLabel, MI.getDebugLoc()->getInlinedAt());
+        InlinedEntity L(RawLabel, MI.getDebugLoc()->getInlinedAt());
         DbgLabels.addInstr(L, MI);
       }
     }
 
     // Make sure locations for register-described variables are valid only
     // until the end of the basic block (unless it's the last basic block, in
     // which case let their liveness run off to the end of the function).
     if (!MBB.empty() && &MBB != &MF->back()) {
       for (auto I = RegVars.begin(), E = RegVars.end(); I != E;) {
         auto CurElem = I++; // CurElem can be erased below.
         if (TRI->isVirtualRegister(CurElem->first) ||
             ChangingRegs.test(CurElem->first))
           clobberRegisterUses(RegVars, CurElem, DbgValues, MBB.back());
       }
     }
   }
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void DbgValueHistoryMap::dump() const {
   dbgs() << "DbgValueHistoryMap:\n";
   for (const auto &VarRangePair : *this) {
-    const InlinedVariable &Var = VarRangePair.first;
+    const InlinedEntity &Var = VarRangePair.first;
     const InstrRanges &Ranges = VarRangePair.second;
 
-    const DILocalVariable *LocalVar = Var.first;
+    const DILocalVariable *LocalVar = dyn_cast<DILocalVariable>(Var.first);
     const DILocation *Location = Var.second;
 
     dbgs() << " - " << LocalVar->getName() << " at ";
 
     if (Location)
       dbgs() << Location->getFilename() << ":" << Location->getLine() << ":"
              << Location->getColumn();
     else

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
 
   /// Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
   void finishEntityDefinition(const DbgEntity *Entity);
 
   /// Find abstract variable associated with Var.
-  using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
+  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
   DbgEntity *getExistingAbstractEntity(const DINode *Node);
   void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
 
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
 
   unsigned getHeaderSize() const override {
     // DWARF v5 added the DWO ID to the header for split/skeleton units.

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   DebuggerKind DebuggerTuning = DebuggerKind::Default;
 
   MCDwarfDwoLineTable *getDwoLineTable(const DwarfCompileUnit &);
 
   const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
     return InfoHolder.getUnits();
   }
 
-  using InlinedVariable = DbgValueHistoryMap::InlinedVariable;
-  using InlinedLabel = DbgLabelInstrMap::InlinedLabel;
+  using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
 
   void ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
                                      const DINode *Node,
                                      const MDNode *Scope);
   void ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
                                              const DINode *Node,
                                              const MDNode *Scope);
 
class DwarfDebug : public DebugHandlerBase {
   /// Register a source line with debug info. Returns the unique
   /// label that was emitted and which provides correspondence to the
   /// source line list.
   void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
                         unsigned Flags);
 
   /// Populate LexicalScope entries with variables' info.
   void collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
-                         DenseSet<InlinedVariable> &ProcessedVars);
+                         DenseSet<InlinedEntity> &ProcessedVars);
 
   /// 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);
+                                      DenseSet<InlinedEntity> &P);
 
   /// Emit the reference to the section.
   void emitSectionReference(const DwarfCompileUnit &CU);
 
 protected:
   /// Gather pre-function debug information.
   void beginFunctionImpl(const MachineFunction *MF) override;
 

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
 
   if (LexicalScope *Scope =
           LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
     CU.createAbstractEntity(Node, Scope);
 }
 
 // Collect variable information from side table maintained by MF.
 void DwarfDebug::collectVariableInfoFromMFTable(
-    DwarfCompileUnit &TheCU, DenseSet<InlinedVariable> &Processed) {
-  SmallDenseMap<InlinedVariable, DbgVariable *> MFVars;
+    DwarfCompileUnit &TheCU, DenseSet<InlinedEntity> &Processed) {
+  SmallDenseMap<InlinedEntity, DbgVariable *> MFVars;
   for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
     if (!VI.Var)
       continue;
     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
            "Expected inlined-at fields to agree");
 
-    InlinedVariable Var(VI.Var, VI.Loc->getInlinedAt());
+    InlinedEntity Var(VI.Var, VI.Loc->getInlinedAt());
     Processed.insert(Var);
     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 
     // If variable scope is not found then skip this variable.
     if (!Scope)
       continue;
 
     ensureAbstractEntityIsCreatedIfScoped(TheCU, Var.first, Scope->getScopeNode());
-    auto RegVar = llvm::make_unique<DbgVariable>(Var.first, Var.second);
+    auto RegVar = llvm::make_unique<DbgVariable>(
+  dyn_cast<DILocalVariable>(Var.first), Var.second);
     RegVar->initializeMMI(VI.Expr, VI.Slot);
     if (DbgVariable *DbgVar = MFVars.lookup(Var))
       DbgVar->addMMIEntry(*RegVar);
     else if (InfoHolder.addScopeVariable(Scope, RegVar.get())) {
       MFVars.insert({Var, RegVar.get()});
       ConcreteEntities.push_back(std::move(RegVar));
     }
   }
if (DbgValue->getOperand(0).isImm() && MBB->pred_empty())
     return true;
 
   return false;
 }
 
 // Find variables for each lexical scope.
 void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
                                    const DISubprogram *SP,
-                                   DenseSet<InlinedVariable> &Processed) {
+                                   DenseSet<InlinedEntity> &Processed) {
   // Grab the variable info that was squirreled away in the MMI side-table.
   collectVariableInfoFromMFTable(TheCU, Processed);
 
   for (const auto &I : DbgValues) {
-    InlinedVariable IV = I.first;
+    InlinedEntity IV = I.first;
     if (Processed.count(IV))
       continue;
 
     // Instruction ranges, specifying where IV is accessible.
     const auto &Ranges = I.second;
     if (Ranges.empty())
       continue;
 
     LexicalScope *Scope = nullptr;
+    const DILocalVariable *LocalVar = dyn_cast<DILocalVariable>(IV.first);
     if (const DILocation *IA = IV.second)
-      Scope = LScopes.findInlinedScope(IV.first->getScope(), IA);
+      Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA);
     else
-      Scope = LScopes.findLexicalScope(IV.first->getScope());
+      Scope = LScopes.findLexicalScope(LocalVar->getScope());
     // If variable scope is not found then skip this variable.
     if (!Scope)
       continue;
 
     Processed.insert(IV);
     DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
-                                            *Scope, IV.first, IV.second));
+                                            *Scope, LocalVar, IV.second));
 
     const MachineInstr *MInsn = Ranges.front().first;
     assert(MInsn->isDebugValue() && "History must begin with debug value");
 
     // Check if there is a single DBG_VALUE, valid throughout the var's scope.
     if (Ranges.size() == 1 &&
         validThroughout(LScopes, MInsn, Ranges.front().second)) {
       RegVar->initializeDbgValue(MInsn);
for (const auto &I : DbgValues) {
     // Build the location list for this variable.
     SmallVector<DebugLocEntry, 8> Entries;
     buildLocationList(Entries, Ranges);
 
     // If the variable has a DIBasicType, extract it.  Basic types cannot have
     // unique identifiers, so don't bother resolving the type with the
     // identifier map.
     const DIBasicType *BT = dyn_cast<DIBasicType>(
-        static_cast<const Metadata *>(IV.first->getType()));
+        static_cast<const Metadata *>(LocalVar->getType()));
 
     // Finalize the entry by lowering it into a DWARF bytestream.
     for (auto &Entry : Entries)
       Entry.finalize(*Asm, List, BT);
   }
 
-  // For each InlinedLabel collected from DBG_LABEL instructions, convert to
+  // For each InlinedEntity collected from DBG_LABEL instructions, convert to
   // DWARF-related DbgLabel.
   for (const auto &I : DbgLabels) {
-    InlinedLabel IL = I.first;
+    InlinedEntity IL = I.first;
     const MachineInstr *MI = I.second;
     if (MI == nullptr)
       continue;
 
     LexicalScope *Scope = nullptr;
+    const DILabel *Label = dyn_cast<DILabel>(IL.first);
     // Get inlined DILocation if it is inlined label.
     if (const DILocation *IA = IL.second)
-      Scope = LScopes.findInlinedScope(IL.first->getScope(), IA);
+      Scope = LScopes.findInlinedScope(Label->getScope(), IA);
     else
-      Scope = LScopes.findLexicalScope(IL.first->getScope());
+      Scope = LScopes.findLexicalScope(Label->getScope());
     // If label scope is not found then skip this label.
     if (!Scope)
       continue;
 
+    Processed.insert(IL);
     /// At this point, the temporary label is created.
     /// Save the temporary label to DbgLabel entity to get the
     /// actually address when generating Dwarf DIE.
     MCSymbol *Sym = getLabelBeforeInsn(MI);
-    createConcreteEntity(TheCU, *Scope, IL.first, IL.second, Sym);
+    createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
   }
 
   // Collect info for variables/labels that were optimized out.
   for (const DINode *DN : SP->getRetainedNodes()) {
+    if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
+      continue;
     LexicalScope *Scope = nullptr;
     if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
-      if (!Processed.insert(InlinedVariable(DV, nullptr)).second)
-        continue;
       Scope = LScopes.findLexicalScope(DV->getScope());
     } else if (auto *DL = dyn_cast<DILabel>(DN)) {
       Scope = LScopes.findLexicalScope(DL->getScope());
     }
 
     if (Scope)
       createConcreteEntity(TheCU, *Scope, DN, nullptr);
   }
void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
   assert(!FnScope || SP == FnScope->getScopeNode());
   DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
   if (TheCU.getCUNode()->isDebugDirectivesOnly()) {
     PrevLabel = nullptr;
     CurFn = nullptr;
     return;
   }
 
-  DenseSet<InlinedVariable> ProcessedVars;
-  collectEntityInfo(TheCU, SP, ProcessedVars);
+  DenseSet<InlinedEntity> Processed;
+  collectEntityInfo(TheCU, SP, Processed);
 
   // 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 &&
       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
     assert(InfoHolder.getScopeVariables().empty());
     PrevLabel = nullptr;
     CurFn = nullptr;
     return;
   }
 
 #ifndef NDEBUG
   size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
 #endif
   // Construct abstract scopes.
   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
     auto *SP = cast<DISubprogram>(AScope->getScopeNode());
     for (const DINode *DN : SP->getRetainedNodes()) {
-      if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
-        // Collect info for variables that were optimized out.
-        if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
-          continue;
-        ensureAbstractEntityIsCreated(TheCU, DV, DV->getScope());
-        assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
-               && "ensureAbstractEntityIsCreated inserted abstract scopes");
-      } else if (auto *DL = dyn_cast<DILabel>(DN)) {
-        ensureAbstractEntityIsCreated(TheCU, DL, DL->getScope());
-      }
+      if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
+
+      const MDNode *Scope = nullptr;
+      if (auto *DV = dyn_cast<DILocalVariable>(DN))
+  Scope = DV->getScope();
+      else if (auto *DL = dyn_cast<DILabel>(DN))
+  Scope = DL->getScope();
+      else
+        llvm_unreachable("Unexpected DI type!");
+
+      // Collect info for variables/labels that were optimized out.
+      ensureAbstractEntityIsCreated(TheCU, DN, Scope);
     }
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 
   ProcessedSPNodes.insert(SP);
   TheCU.constructSubprogramScopeDIE(SP, FnScope);
   if (auto *SkelCU = TheCU.getSkeleton())
     if (!LScopes.getAbstractScopesList().empty() &&

test/DebugInfo/Generic/debug-label.ll

 ; RUN: llc -fast-isel=false -O0 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
 ; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label.c
 ; CHECK-NEXT: DW_AT_decl_line [DW_FORM_data1] {{.*}}4
 ; CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] {{.*}}{{0x[0-9a-f]+}}
 ; CHECK: DW_TAG_label
 ; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"done"
 ; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label.c
 ; CHECK-NEXT: DW_AT_decl_line [DW_FORM_data1] {{.*}}7
 ; CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] {{.*}}{{0x[0-9a-f]+}}
+; CHECK-NOT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
 ;
 ; RUN: llc -fast-isel=false -O0 -o - %s | FileCheck %s -check-prefix=ASM
 ;
 ; ASM: [[TOP_LOW_PC:[.0-9a-zA-Z]+]]:{{[[:space:]].*}}DEBUG_LABEL: foo:top
 ; ASM: [[DONE_LOW_PC:[.0-9a-zA-Z]+]]:{{[[:space:]].*}}DEBUG_LABEL: foo:done
 ; ASM-LABEL: .debug_str
 ; ASM: [[TOP_LABEL:[.0-9a-zA-Z]+]]:{{[[:space:]].*}}"top"
 ; ASM: [[DONE_LABEL:[.0-9a-zA-Z]+]]:{{[[:space:]].*}}"done"

 declare void @llvm.dbg.label(metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!4}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, isOptimized: false, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "debug-label.c", directory: "./")
 !2 = !{}
+!3 = !{!10}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
-!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, retainedNodes: !2)
+!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, retainedNodes: !3)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!9, !9, !9}
 !9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !10 = !DILabel(scope: !6, name: "top", file: !1, line: 4)
 !11 = !DILocation(line: 4, column: 1, scope: !6)
 !12 = !DILabel(scope: !6, name: "done", file: !1, line: 7)
 !13 = !DILocation(line: 7, column: 1, scope: !6)
 !14 = !DILocation(line: 8, column: 3, scope: !6)