[DebugInfo] Generate DWARF debug information for labels.

[HsiangKai]

Summary

There are two forms for label debug information in DWARF format.

1. Labels in a non-inlined function:

DW_TAG_label

DW_AT_name
DW_AT_decl_file
DW_AT_decl_line
DW_AT_low_pc

2. Labels in an inlined function:

DW_TAG_label

DW_AT_abstract_origin
DW_AT_low_pc

We will collect label information from DBG_LABEL. Before every DBG_LABEL,
we will generate a temporary symbol to denote the location of the label.
The symbol could be used to get DW_AT_low_pc afterwards. So, we create a
mapping between 'inlined label' and DBG_LABEL MachineInstr in DebugHandlerBase.
The DBG_LABEL in the mapping is used to query the symbol before it.

The AbstractLabels in DwarfCompileUnit is used to process labels in inlined
functions.

We also keep a mapping between scope and labels in DwarfFile to help to
generate correct tree structure of DIEs.

[aprantl]

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

53

Often it's better for readability to just define a struct with named members so we can access .label and .loc instead of .first and .second.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

490

Please put the doxygen comment on the declaration and don't repeat the function name.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1232

This and the next function looks like it is almost the same code as createConcreteVariable and collectVariableInfo. Could the implementation be shared (see my comment on DwarfLabel)?

lib/CodeGen/AsmPrinter/DwarfDebug.h

191

Could this share a common base with DbgVariable?

198

///

202

/// @{
/// Accessors.

208

/// @}

210

///

[HsiangKai]

Update according to reviewers' comments.
Update test cases.

[HsiangKai]

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

53

If I group DILabel and DILocation in a struct, I need to add isEqual(), getHashValue(), getEmptyKey(), etc to conform the interface of MapVector. I think it is too complex for the purpose. std::pair is ready to use as the 'Key Type' of MapVector.

Use MapVector is easier to establish the mapping between InlinedLabel and MachineInstr.

[aprantl]

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

170

This comment should go to the declaration.

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

53

Fair point. One trick I've used in the past for situations like this is to define a struct that inherits from std::pair<> and defines a getLabel() and a getLocation() accessor function. Feel free to adopt this pattern if you think that it improves readability.

lib/CodeGen/AsmPrinter/DwarfDebug.h

191

Is this feasible?

[HsiangKai]

About combining DwarfLabel and DbgVariable.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1232

I took DILocalVariable as the reference model. So, you will find that some implementation is similar. However, processing of labels is much simpler than processing of variables. I do not need to handle location list for variables, instruction ranges that variables are accessible, local variables v.s. argument variables, and data types, etc.

The only similarity is they are both local entities in a function. They have function scope. They have DILocation to tell users where they are. I have no idea how to combine these two classes and make label processing simple and make sense.

lib/CodeGen/AsmPrinter/DwarfDebug.h

191

The only similar data members are DILocation, and DIE *. The only similar member function is getTag(). It seems that there is few benefits to combine these two classes under a common base.

Processing labels is much simpler than variables. I have no idea how to combine these two classes and let the implementation simple and make sense.

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1232

+ @dblaikie: Do you also agree that it is better to keep labels and variables separate or should we make an effort to share bits of the implementation?

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1232

Yeah, it certainly looks like many of these functions are similar/the same - though the label things talk about "inlined" instead of "abstract" - is there a reason for that? I would've thought it'd be exactly the same.

As for commoning the code - I would guess, in general, all the abstract handling should be basically the same (with a switch/if-chain on "how to populate abstract attributes for these entities" - variables would have name, type, location, and labels would just have name and location?)

[HsiangKai]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1232

There will be 'abstract labels' in inlined functions. So, I use the specific name, 'inlined label' for it. It is fine to follow the naming of variables.

If we want to combine the processing of abstract variables and labels, we need to review all processing for abstract variables. Not only create a common base class for DbgVariable and DwarfLabel, but all processing of abstract variables need to be reviewed. I need some time to refactor all of the related data structures and functions.

[HsiangKai]

TODO: Refactor the patch to abstract the processing flow of abstract variables and abstract labels. The refactoring will start after mid of May.

[HsiangKai]

Refactoring is done.

@aprantl: Please help me to review this patch. Thanks a lot.

[tyb0807]

Thank you for the patch.

It seems to me that with requireLabelBeforeInsn, the label will later be emitted as a temporary symbol with a unique but unspecified name (in DebugHandleBase::beginInstruction()). Is it correct?

Btw, can anyone tell me how to add inlined comments? Or I have to be in the reviewer list I guess?

[aprantl]

Just click on the line number.

[HsiangKai]

In D45556#1114350, @tyb0807 wrote:

Thank you for the patch.

It seems to me that with requireLabelBeforeInsn, the label will later be emitted as a temporary symbol with a unique but unspecified name (in DebugHandleBase::beginInstruction()). Is it correct?

Yes, I generate a temporary label before the label intrinsic. In this way, I could get the address of the label afterward.

Btw, can anyone tell me how to add inlined comments? Or I have to be in the reviewer list I guess?

[tyb0807]

In D45556#1117242, @HsiangKai wrote:

In D45556#1114350, @tyb0807 wrote:

Thank you for the patch.

It seems to me that with requireLabelBeforeInsn, the label will later be emitted as a temporary symbol with a unique but unspecified name (in DebugHandleBase::beginInstruction()). Is it correct?

Yes, I generate a temporary label before the label intrinsic. In this way, I could get the address of the label afterward.

Yes, I mean that the label will later be named differently in the asm file than in the source? I don't know if this is something we should care about though, I'm just speaking from an user point of view

[HsiangKai]

In D45556#1120815, @tyb0807 wrote:

In D45556#1117242, @HsiangKai wrote:

In D45556#1114350, @tyb0807 wrote:

Thank you for the patch.

It seems to me that with requireLabelBeforeInsn, the label will later be emitted as a temporary symbol with a unique but unspecified name (in DebugHandleBase::beginInstruction()). Is it correct?

Yes, I generate a temporary label before the label intrinsic. In this way, I could get the address of the label afterward.

Yes, I mean that the label will later be named differently in the asm file than in the source? I don't know if this is something we should care about though, I'm just speaking from an user point of view

There is no 'label' entity in LLVM IR. The 'label' in C source code will be transformed into 'basic block' in LLVM.
So, we could not get the original name except from dbg.label intrinsic and metadata. That is why I created new kind of intrinsic and metadata for labels for debugging purpose.
I will print the label name in asm comments.

[aprantl]

This is not super important, but: contrary to to DBG_VALUE intrinsics, DBG_LABELs don't have live ranges associated with them. I wonder if we really need to rename DbgValueHistoryCalculator. We're not calculating any "history" of labels, do we?

[HsiangKai]

In D45556#1125471, @aprantl wrote:

This is not super important, but: contrary to to DBG_VALUE intrinsics, DBG_LABELs don't have live ranges associated with them. I wonder if we really need to rename DbgValueHistoryCalculator. We're not calculating any "history" of labels, do we?

I need to get the mapping between “InlinedLabel” and DBG_LABEL MI. I put the operation in calculateDbgValueHistory(). Because calculateDbgValueHistory() no longer only calculates DbgValueHistoryMap, it also calculates DbgLabelInstrMap. So, I rename it.

Should I put DbgLabelInstrMap calculation in a new file, maybe called DbgLabelInstrCalculator.cpp/h?

[HsiangKai]

Ping.

[aprantl]

I think this is starting to look good. I have a few more comments inline.

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.h

57 ↗

(On Diff #148545)

Please add a Doxygen comment explaining what this class is used for.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

833

The old code on the left had more comments :-)

839

can this be anything else? Should this be a static cast instead?

882

Please don't check in commented-out code.

899–901

I think you may be able to write this more compactly by

auto &MapEntry = getAbstractEntities()[Node];
if (...) {
  MapEntry = llvm>::make_unique(...)
  DU->addScopeVariable(Scope, cast<DbgVariable>(MapEntry.get());
} else

lib/CodeGen/AsmPrinter/DwarfDebug.h

64

Doxygen comment?

79

You can define group comments like this:

/// Accessors
/// @{
...
/// @}

[HsiangKai]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

839

Entity could be DbgVariable or DbgLabel. I use dyn_cast<> to cast and check their type. In this way, I could put them in if statement to ensure they are correct type before entering if block/else block.

[aprantl]

A couple of cosmetic changes in line, but otherwise this LGTM.

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.h

61 ↗

(On Diff #154344)

/// For each inlined instance of a source-level label, keep ...

63 ↗

(On Diff #154344)

a temporary (assembler) label ...

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

895

we use llvm_unreachable( instead of assert(0 &&

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1224–1225

if (auto *DV = dyn_cast<DILocalVariable>(DN)) {
    if (!Processed.insert(InlinedVariable(DV, nullptr)).second)
      continue;
if (LexicalScope *Scope = LScopes.findLexicalScope(DN->getScope()))
   createConcreteEntity(TheCU, *Scope, DN, nullptr);

?

1242

point

lib/CodeGen/AsmPrinter/DwarfDebug.h

70

Would be nice to rename to to InlinedAt in a follow-up commit.

lib/CodeGen/AsmPrinter/DwarfFile.h

62

/// ... .

[HsiangKai]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1224–1225

There is no apparent default version of getScope() in DINode. So, I could not merge these two code fragments into one.

lib/CodeGen/AsmPrinter/DebugHandlerBase.h

struct DbgVariableLocation {
   /// This will only work if Instruction is a debug value instruction
   /// and the associated DIExpression is in one of the supported forms.
   /// If these requirements are not met, the returned Optional will not
   /// have a value.
   static Optional<DbgVariableLocation>
   extractFromMachineInstruction(const MachineInstr &Instruction);
 };
 
+using InlinedLabel =
+      std::pair<const DILabel *, const DILocation *>;
+using LabelInstrMap = MapVector<InlinedLabel, const MachineInstr *>;
+
 /// Base class for debug information backends. Common functionality related to
 /// tracking which variables and scopes are alive at a given PC live here.
 class DebugHandlerBase : public AsmPrinterHandler {
 protected:
   DebugHandlerBase(AsmPrinter *A);
 
   /// Target of debug info emission.
   AsmPrinter *Asm;
protected:
   const MachineInstr *CurMI = nullptr;
 
   LexicalScopes LScopes;
 
   /// History of DBG_VALUE and clobber instructions for each user
   /// variable.  Variables are listed in order of appearance.
   DbgValueHistoryMap DbgValues;
 
+  /// Mapping of inlined labels and DBG_LABEL machine instruction.
+  LabelInstrMap DbgLabels;
+
   /// Maps instruction with label emitted before instruction.
   /// FIXME: Make this private from DwarfDebug, we have the necessary accessors
   /// for it.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
 
   /// Maps instruction with label emitted after instruction.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
 
   /// Indentify instructions that are marking the beginning of or
   /// ending of a scope.
   void identifyScopeMarkers();
 
   /// Ensure that a label will be emitted before MI.
   void requestLabelBeforeInsn(const MachineInstr *MI) {
     LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
   }
 
   /// Ensure that a label will be emitted after MI.
   void requestLabelAfterInsn(const MachineInstr *MI) {
     LabelsAfterInsn.insert(std::make_pair(MI, nullptr));
   }
 
+  void collectDbgLabels(const MachineFunction *MF);
+
   virtual void beginFunctionImpl(const MachineFunction *MF) = 0;
   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
   virtual void skippedNonDebugFunction() {}
 
   // AsmPrinterHandler overrides.
 public:
   void beginInstruction(const MachineInstr *MI) override;
   void endInstruction() override;

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

if (!SP)
     return false;
   assert(SP->getUnit());
   auto EK = SP->getUnit()->getEmissionKind();
   if (EK == DICompileUnit::NoDebug)
     return false;
   return true;
 }
 
+/// Collect labels in this machine function into DebugHandlerBase::DbgLabels.
+///
+/// When we encounter a DBG_LABEL, we will get the inlined location of it and
+/// create the mapping of this inlined label to the DBG_LABEL.
+/// In addition, we will create a temp symbol before the inlined label to get
+/// its address afterward.
+void DebugHandlerBase::collectDbgLabels(const MachineFunction *MF) {
+  for (const auto &MBB : *MF) {
+    for (const auto &MI : MBB) {
+      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");
+        // Ensure there is a symbol before DBG_LABEL.
+        requestLabelBeforeInsn(&MI);
+        // 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());
+        DbgLabels[L] = &MI;
+      }
+    }
+  }
+}
+
 void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   PrevInstBB = nullptr;
 
   if (!Asm || !hasDebugInfo(MMI, MF)) {
     skippedNonDebugFunction();
     return;
   }
 
for (const auto &I : DbgValues) {
 
     for (const auto &Range : Ranges) {
       requestLabelBeforeInsn(Range.first);
       if (Range.second)
         requestLabelAfterInsn(Range.second);
     }
   }
 
+  // Collect label's information from DBG_LABEL in this machine function.
+  collectDbgLabels(MF);
+
   PrevInstLoc = DebugLoc();
   PrevLabel = Asm->getFunctionBegin();
   beginFunctionImpl(MF);
 }
 
 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
   if (!MMI->hasDebugInfo())
     return;

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

class DwarfCompileUnit final : public DwarfUnit {
   SmallVector<RangeSpan, 2> CURanges;
 
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
+  DenseMap<const MDNode *, std::unique_ptr<DwarfLabel>> AbstractLabels;
 
   /// \brief Construct a DIE for the given DbgVariable without initializing the
   /// DbgVariable's DIE reference.
   DIE *constructVariableDIEImpl(const DbgVariable &DV, bool Abstract);
 
   bool isDwoUnit() const override;
 
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
       return AbstractSPDies;
     return DU->getAbstractSPDies();
   }
 
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> &getAbstractVariables() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
       return AbstractVariables;
     return DU->getAbstractVariables();
   }
 
+  DenseMap<const MDNode *, std::unique_ptr<DwarfLabel>> &getAbstractLabels() {
+    if (isDwoUnit() && !DD->shareAcrossDWOCUs())
+      return AbstractLabels;
+    return DU->getAbstractLabels();
+  }
+
 public:
   DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
                    DwarfDebug *DW, DwarfFile *DWU);
 
   unsigned getUniqueID() const { return UniqueID; }
 
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
public:
   DIE *constructLexicalScopeDIE(LexicalScope *Scope);
 
   /// constructVariableDIE - Construct a DIE for the given DbgVariable.
   DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
 
   DIE *constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope,
                             DIE *&ObjectPointer);
 
+  /// constructLabelDIE - Construct a DIE for the given DwarfLabel.
+  DIE *constructLabelDIE(DwarfLabel &DL, const LexicalScope &Scope);
+
   /// A helper function to create children of a Scope DIE.
   DIE *createScopeChildrenDIE(LexicalScope *Scope,
                               SmallVectorImpl<DIE *> &Children,
                               bool *HasNonScopeChildren = nullptr);
 
   /// \brief Construct a DIE for this subprogram scope.
   void constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope);
 
   DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
 
   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 DwarfLabel &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);
 
+  /// Find abstract label associated with inlined label.
+  DwarfLabel *getExistingInlinedLabel(InlinedLabel IL,
+                                      const DILabel *&Label);
+  DwarfLabel *getExistingInlinedLabel(InlinedLabel IL);
+  void createInlinedLabel(const DILabel *DL, LexicalScope *Scope);
+
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
 
   unsigned getLength() {
     return sizeof(uint32_t) + // Length field
         getHeaderSize() + getUnitDie().getSize();
   }
 
public:
   void applyVariableAttributes(const DbgVariable &Var, DIE &VariableDie);
 
   /// Add a Dwarf expression attribute data and value.
   void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
 
   void applySubprogramAttributesToDefinition(const DISubprogram *SP,
                                              DIE &SPDie);
 
+  void applyLabelAttributes(const DwarfLabel &Label, DIE &LabelDie);
+
   /// getRangeLists - Get the vector of range lists.
   const SmallVectorImpl<RangeSpanList> &getRangeLists() const {
     return (Skeleton ? Skeleton : this)->CURangeLists;
   }
 
   /// getRanges - Get the list of ranges for this unit.
   const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
   SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 
 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
 DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
   auto D = constructVariableDIEImpl(DV, Abstract);
   DV.setDIE(*D);
   return D;
 }
 
+/// constructLabelDIE - Construct a DIE for the given DwarfLabel.
+DIE *DwarfCompileUnit::constructLabelDIE(DwarfLabel &DL,
+                                         const LexicalScope &Scope) {
+  auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
+  insertDIE(DL.getLabel(), LabelDie);
+  DL.setDIE(*LabelDie);
+
+  if (Scope.isAbstractScope())
+    applyLabelAttributes(DL, *LabelDie);
+
+  return LabelDie;
+}
+
 DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
                                                 bool Abstract) {
   // Define variable debug information entry.
   auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
   insertDIE(DV.getVariable(), VariableDie);
 
   if (Abstract) {
     applyVariableAttributes(DV, *VariableDie);
if (!includeMinimalInlineScopes()) {
     for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
       Children.push_back(
           constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
   }
 
   if (HasNonScopeChildren)
     *HasNonScopeChildren = !Children.empty();
 
+  for (DwarfLabel *DL : DU->getScopeLabels().lookup(Scope))
+    Children.push_back(constructLabelDIE(*DL, *Scope));
+
   for (LexicalScope *LS : Scope->getChildren())
     constructScopeDIE(LS, Children);
 
   return ObjectPointer;
 }
 
 void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) {
   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
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::applyLabelAttributes(const DwarfLabel &Label,
+                                            DIE &LabelDie) {
+  StringRef Name = Label.getName();
+  if (!Name.empty())
+    addString(LabelDie, dwarf::DW_AT_name, Name);
+  const auto *DILabel = Label.getLabel();
+  addSourceLine(LabelDie, DILabel);
+}
+
+void DwarfCompileUnit::finishLabelDefinition(const DwarfLabel &Label) {
+  DwarfLabel *InlinedDwarfLabel = getExistingInlinedLabel(
+      InlinedLabel(Label.getLabel(), Label.getInlinedAt()));
+  auto *LabelDie = Label.getDIE();
+  if (InlinedDwarfLabel && InlinedDwarfLabel->getDIE()) {
+    addDIEEntry(*LabelDie, dwarf::DW_AT_abstract_origin,
+                *InlinedDwarfLabel->getDIE());
+  } else
+    applyLabelAttributes(Label, *LabelDie);
+
+  const MCSymbol *Sym = Label.getSymbol();
+  addLabelAddress(*LabelDie, dwarf::DW_AT_low_pc, Sym);
+}
+
+DwarfLabel *DwarfCompileUnit::getExistingInlinedLabel(InlinedLabel IL) {
+  const DILabel *Label;
+  return getExistingInlinedLabel(IL, Label);
+}
+
+DwarfLabel *DwarfCompileUnit::getExistingInlinedLabel(
+    InlinedLabel IL, const DILabel *&Label) {
+  Label = IL.first;
+  auto &InlinedLabels = getAbstractLabels();
+  auto I = InlinedLabels.find(Label);
+  if (I != InlinedLabels.end())
+    return I->second.get();
+  return nullptr;
+}
+
+void DwarfCompileUnit::createInlinedLabel(const DILabel *Label,
+                                          LexicalScope *Scope) {
+  assert(Scope && Scope->isAbstractScope());
+  auto AbsDwarfLabel = llvm::make_unique<DwarfLabel>(Label,
+                                                     nullptr /* IA */,
+                                                     nullptr /* Sym */);
+  DU->addScopeLabel(Scope, AbsDwarfLabel.get());
+  getAbstractLabels()[Label] = std::move(AbsDwarfLabel);
+}
+
 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) {
   // More then one inlined variable corresponds to one abstract variable.
   Cleansed = IV.first;
   auto &AbstractVariables = getAbstractVariables();
   auto I = AbstractVariables.find(Cleansed);
   if (I != AbstractVariables.end())
     return I->second.get();
   return nullptr;
 }
 
 void DwarfCompileUnit::createAbstractVariable(const DILocalVariable *Var,
                                         LexicalScope *Scope) {
   assert(Scope && Scope->isAbstractScope());
   auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr);
   DU->addScopeVariable(Scope, AbsDbgVariable.get());
   getAbstractVariables()[Var] = std::move(AbsDbgVariable);
 }
 
 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
   // Don't bother labeling the .dwo unit, as its offset isn't used.
   if (!Skeleton && !DD->useSectionsAsReferences()) {
     LabelBegin = Asm->createTempSymbol("cu_begin");
     Asm->OutStreamer->EmitLabel(LabelBegin);

lib/CodeGen/AsmPrinter/DwarfDebug.h

 class DwarfUnit;
 class LexicalScope;
 class MachineFunction;
 class MCSection;
 class MCSymbol;
 class MDNode;
 class Module;
 
 //===----------------------------------------------------------------------===//
 /// This class is used to track local variable information.
 ///
 /// Variables can be created from allocas, in which case they're generated from
 /// the MMI table.  Such variables can have multiple expressions and frame
 /// indices.
 ///
 /// Variables can be created from \c DBG_VALUE instructions.  Those whose
 /// location changes over time use \a DebugLocListIndex, while those with a
 /// single instruction use \a MInsn and (optionally) a single entry of \a Expr.
 ///
 /// Variables that have been optimized out use none of these fields.
 class DbgVariable {
   const DILocalVariable *Var;                /// Variable Descriptor.
   const DILocation *IA;                      /// Inlined at location.
   DIE *TheDIE = nullptr;                     /// Variable DIE.
   unsigned DebugLocListIndex = ~0u;          /// Offset in DebugLocs.
   const MachineInstr *MInsn = nullptr;       /// DBG_VALUE instruction.
 
   struct FrameIndexExpr {
     int FI;
     const DIExpression *Expr;
   };
   mutable SmallVector<FrameIndexExpr, 1>
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 are collected from \c DBG_LABEL instructions.
+class DwarfLabel {
+  const DILabel *Label;                 /// Label Descriptor.
+  const DILocation *IA;                 /// Inlined at location.
+  const MCSymbol *Sym;                  /// Symbol before DBG_LABEL instruction.
+  DIE *TheDIE = nullptr;                /// Label DIE.
+
+public:
+  // We need MCSymbol information to generate DW_AT_low_pc.
+  DwarfLabel(const DILabel *L, const DILocation *IA, const MCSymbol *Sym)
+      : Label(L), IA(IA), Sym(Sym) {}
+
+  // Accessors.
+  const DILabel *getLabel() const { return Label; }
+  const DILocation *getInlinedAt() const { return IA; }
+  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 user labels.
+  SmallVector<std::unique_ptr<DwarfLabel>, 4> UserLabels;
+
   /// 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);
 
+  void ensureInlinedLabelIsCreated(DwarfCompileUnit &CU, InlinedLabel Label,
+                                   const MDNode *Scope);
+  void ensureInlinedLabelIsCreatedIfScoped(DwarfCompileUnit &CU, InlinedLabel Label,
+                                           const MDNode *Scope);
+
+  void createConcreteLabel(DwarfCompileUnit &TheCU,
+                           LexicalScope &Scope, InlinedLabel IL, MCSymbol *Sym);
+
   /// 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();
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, const DISubprogram *SP);
+
   /// 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

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 : UserLabels) {
+    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
void DwarfDebug::ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU,
   if (CU.getExistingAbstractVariable(IV, Cleansed))
     return;
 
   if (LexicalScope *Scope =
           LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
     CU.createAbstractVariable(Cleansed, Scope);
 }
 
+void DwarfDebug::ensureInlinedLabelIsCreated(DwarfCompileUnit &CU, InlinedLabel IL,
+                                             const MDNode *ScopeNode) {
+  const DILabel *Label = nullptr;
+  if (CU.getExistingInlinedLabel(IL, Label))
+    return;
+
+  CU.createInlinedLabel(Label, LScopes.getOrCreateAbstractScope(
+                        cast<DILocalScope>(ScopeNode)));
+}
+
+void DwarfDebug::ensureInlinedLabelIsCreatedIfScoped(DwarfCompileUnit &CU,
+    InlinedLabel IL, const MDNode *ScopeNode) {
+  const DILabel *Label = nullptr;
+  if (CU.getExistingInlinedLabel(IL, Label))
+    return;
+
+  if (LexicalScope *Scope =
+          LScopes.findAbstractScope(cast_or_null<DILocalScope>(ScopeNode)))
+    CU.createInlinedLabel(Label, Scope);
+}
+
 // Collect variable information from side table maintained by MF.
 void DwarfDebug::collectVariableInfoFromMFTable(
     DwarfCompileUnit &TheCU, DenseSet<InlinedVariable> &Processed) {
   SmallDenseMap<InlinedVariable, DbgVariable *> MFVars;
   for (const auto &VI : Asm->MF->getVariableDbgInfo()) {
     if (!VI.Var)
       continue;
     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
for (const auto &I : DbgValues) {
     const DIBasicType *BT = dyn_cast<DIBasicType>(
         static_cast<const Metadata *>(IV.first->getType()));
 
     // Finalize the entry by lowering it into a DWARF bytestream.
     for (auto &Entry : Entries)
       Entry.finalize(*Asm, List, BT);
   }
 
   // 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));
   }
 }
 
+void DwarfDebug::createConcreteLabel(DwarfCompileUnit &TheCU,
+                                     LexicalScope &Scope,
+                                     InlinedLabel IL,
+                                     MCSymbol *Sym) {
+  ensureInlinedLabelIsCreatedIfScoped(TheCU, IL, Scope.getScopeNode());
+  // Keep a list of DwarfLabel in DwarfDebug::UserLabels.
+  // We will use the list to go through all labels in this machine
+  // function and fill all detail information of DW_TAG_label in
+  // finishLabelDefinitions().
+  UserLabels.push_back(make_unique<DwarfLabel>(IL.first, IL.second, Sym));
+  // Create 'scope to labels' mappings. When we construct DIE tree, we
+  // need to know which scope the label DIE is in.
+  InfoHolder.addScopeLabel(&Scope, UserLabels.back().get());
+}
+
+// Dwarf-specific handling of DebugHandlerBase::DbgLabels
+void DwarfDebug::collectLabelInfo(DwarfCompileUnit &TheCU,
+                                  const DISubprogram *SP) {
+  // For each InlinedLabel collected from DBG_LABEL instructions, convert to
+  // DWARF-related DwarfLabel.
+  for (const auto &I : DbgLabels) {
+    InlinedLabel IL = I.first;
+    const MachineInstr *MI = I.second;
+    if (MI == nullptr)
+      continue;
+
+    LexicalScope *Scope = nullptr;
+    // Get inlined DILocation if it is inlined label.
+    if (const DILocation *IA = IL.second)
+      Scope = LScopes.findInlinedScope(IL.first->getScope(), IA);
+    else
+      Scope = LScopes.findLexicalScope(IL.first->getScope());
+    // If label scope is not found then skip this label.
+    if (!Scope)
+      continue;
+
+    MCSymbol *Sym = getLabelBeforeInsn(MI);
+    createConcreteLabel(TheCU, *Scope, IL, Sym);
+  }
+
+  // Collect info for labels that were optimized out.
+  for (const DILabel *DL : SP->getLabels()) {
+    if (LexicalScope *Scope = LScopes.findLexicalScope(DL->getScope()))
+      createConcreteLabel(TheCU, *Scope, InlinedLabel(DL, nullptr), nullptr);
+  }
+}
+
 // 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, SP);
+
   // 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 &&
for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
     for (const DILocalVariable *DV : SP->getVariables()) {
       if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
         continue;
       ensureAbstractVariableIsCreated(TheCU, InlinedVariable(DV, nullptr),
                                       DV->getScope());
       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
              && "ensureAbstractVariableIsCreated inserted abstract scopes");
     }
+    // Collect info for labels that were optimized out.
+    for (const DILabel *DL : SP->getLabels()) {
+      ensureInlinedLabelIsCreated(TheCU, InlinedLabel(DL, nullptr),
+                                  DL->getScope());
+    }
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 
   ProcessedSPNodes.insert(SP);
   TheCU.constructSubprogramScopeDIE(SP, FnScope);
   if (auto *SkelCU = TheCU.getSkeleton())
     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 DwarfLabel;
 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
+  using LabelList = SmallVector<DwarfLabel *, 4>;
+  DenseMap<LexicalScope *, LabelList> ScopeLabels;
+
   // Collection of abstract subprogram DIEs.
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
+  DenseMap<const MDNode *, std::unique_ptr<DwarfLabel>> AbstractLabels;
 
   /// 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:
   DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
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, DwarfLabel *Label);
+
   DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
     return ScopeVariables;
   }
 
+  DenseMap<LexicalScope *, LabelList> &getScopeLabels() {
+    return ScopeLabels;
+  }
+
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     return AbstractSPDies;
   }
 
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> &getAbstractVariables() {
     return AbstractVariables;
   }
 
+  DenseMap<const MDNode *, std::unique_ptr<DwarfLabel>> &getAbstractLabels() {
+    return AbstractLabels;
+  }
+
   void insertDIE(const MDNode *TypeMD, DIE *Die) {
     DITypeNodeToDieMap.insert(std::make_pair(TypeMD, Die));
   }
 
   DIE *getDIE(const MDNode *TypeMD) {
     return DITypeNodeToDieMap.lookup(TypeMD);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H

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, DwarfLabel *Label) {
+  SmallVectorImpl<DwarfLabel *> &Labels = ScopeLabels[LS];
+  Labels.push_back(Label);
+}

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);

test/DebugInfo/Generic/debug-label-inline.ll

+; RUN: llc -O2 -filetype=obj -o - %s | llvm-dwarfdump -v - | FileCheck %s
+;
+; CHECK: .debug_info contents:
+; CHECK: [[LABEL_ORIGIN:0x[0-9a-zA-Z]+]]:{{ *}}DW_TAG_label
+; CHECK-NEXT: DW_AT_name [DW_FORM_strp] {{.*}}"top"
+; CHECK-NEXT: DW_AT_decl_file [DW_FORM_data1] {{.*}}debug-label-inline.c
+; CHECK-NEXT: DW_AT_decl_line [DW_FORM_data1] {{.*}}8
+; CHECK: DW_TAG_label
+; CHECK-NEXT: DW_AT_abstract_origin [DW_FORM_ref4] {{.*}}{[[LABEL_ORIGIN]]} "top"
+; CHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] {{.*}}{{0x[0-9a-f]+}}
+
+source_filename = "debug-label-inline.c"
+
+@ga = external local_unnamed_addr global i32, align 4
+@gb = external local_unnamed_addr global i32, align 4
+
+define i32 @f2() local_unnamed_addr #0 !dbg !6 {
+entry:
+  %0 = load i32, i32* @ga, align 4, !dbg !13
+  %1 = load i32, i32* @gb, align 4, !dbg !13
+  call void @llvm.dbg.value(metadata i32 %0, metadata !18, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %1, metadata !23, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.label(metadata !26), !dbg !29
+  %add.i = add nsw i32 %1, %0, !dbg !30
+  call void @llvm.dbg.value(metadata i32 %add.i, metadata !24, metadata !DIExpression()), !dbg !31
+  call void @llvm.dbg.value(metadata i32 %add.i, metadata !12, metadata !DIExpression()), !dbg !32
+  ret i32 %add.i, !dbg !33
+}
+
+declare void @llvm.dbg.label(metadata)
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+attributes #0 = { nounwind readonly }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !7, isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!2 = !{}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!6 = distinct !DISubprogram(name: "f2", scope: !7, file: !7, line: 15, type: !8, isLocal: false, isDefinition: true, scopeLine: 15, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !11, labels: !2)
+!7 = !DIFile(filename: "debug-label-inline.c", directory: "./")
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "result", scope: !6, file: !7, line: 16, type: !10)
+!13 = !DILocation(line: 18, scope: !6)
+!18 = !DILocalVariable(name: "a", arg: 1, scope: !19, file: !7, line: 5, type: !10)
+!19 = distinct !DISubprogram(name: "f1", scope: !7, file: !7, line: 5, type: !20, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !22, labels: !25)
+!20 = !DISubroutineType(types: !21)
+!21 = !{!10, !10, !10}
+!22 = !{!18, !23, !24}
+!23 = !DILocalVariable(name: "b", arg: 2, scope: !19, file: !7, line: 5, type: !10)
+!24 = !DILocalVariable(name: "sum", scope: !19, file: !7, line: 6, type: !10)
+!25 = !{!26}
+!26 = !DILabel(scope: !19, name: "top", file: !7, line: 8)
+!27 = !DILocation(line: 5, scope: !19, inlinedAt: !28)
+!28 = distinct !DILocation(line: 18, scope: !6)
+!29 = !DILocation(line: 8, scope: !19, inlinedAt: !28)
+!30 = !DILocation(line: 9, scope: !19, inlinedAt: !28)
+!31 = !DILocation(line: 6, scope: !19, inlinedAt: !28)
+!32 = !DILocation(line: 16, scope: !6)
+!33 = !DILocation(line: 21, scope: !6)

test/DebugInfo/Generic/debug-label.ll

+; RUN: llc -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]+}}
+;
+; RUN: llc -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"
+; ASM-LABEL: .debug_info
+; ASM: DW_TAG_label
+; ASM-NEXT: [[TOP_LABEL]] # DW_AT_name
+; ASM-NEXT: 1 # DW_AT_decl_file
+; ASM-NEXT: 4 # DW_AT_decl_line
+; ASM-NEXT: [[TOP_LOW_PC]] # DW_AT_low_pc
+; ASM: DW_TAG_label
+; ASM-NEXT: [[DONE_LABEL]] # DW_AT_name
+; ASM-NEXT: 1 # DW_AT_decl_file
+; ASM-NEXT: 7 # DW_AT_decl_line
+; ASM-NEXT: [[DONE_LOW_PC]] # DW_AT_low_pc
+
+source_filename = "debug-label.c"
+
+define dso_local i32 @foo(i32 %a, i32 %b) !dbg !6 {
+entry:
+  %a.addr = alloca i32, align 4
+  %b.addr = alloca i32, align 4
+  %sum = alloca i32, align 4
+  store i32 %a, i32* %a.addr, align 4
+  store i32 %b, i32* %b.addr, align 4
+  br label %top
+
+top:
+  call void @llvm.dbg.label(metadata !10), !dbg !11
+  %0 = load i32, i32* %a.addr, align 4
+  %1 = load i32, i32* %b.addr, align 4
+  %add = add nsw i32 %0, %1
+  store i32 %add, i32* %sum, align 4
+  br label %done
+
+done:
+  call void @llvm.dbg.label(metadata !12), !dbg !13
+  %2 = load i32, i32* %sum, align 4
+  ret i32 %2, !dbg !14
+}
+
+declare void @llvm.dbg.label(metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "debug-label.c", directory: "./")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!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)