Supporting all entities declared in lexical scope in LLVM debug info

[aaboud]

Summary

This is the full implementation in LLVM of the proposal:
http://lists.llvm.org/pipermail/llvm-dev/2015-December/093313.html

Notice that it contains also the changes from D12426 & D12913.
If it helps, I can do the commits separately, but I would need approval for all three patches in order to do so.

In addition to the few LIT tests I added, I needed to fix few others to affect the changes, including entry order changes that occurred.

[dblaikie]

This is looking really good and/or I'm starting to get the hang of what's going on here (& I think our design discussions have converged a lot too - I can see all the code I expect to see, delaying adding entities to the scopes until we know whether to add it to the concrete or abstract, adding in the abstract_origin as well, etc)

A few practical comments, but I think we're pretty close to having this sorted out. Thanks, as always, for your patience!

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

573

Rename "HasNoneScopeChild" to "HasNonScopeChild" (or "HasNonScopeChildren") - that took me a while to figure out what it was trying to express, but I think that's what you were going for, "none" as in "not any of" wasn't intended, but "has non-scope child" (children that are something other than a scope) is - then it make sense :)

713

drop all the parens around the variables here

DIE *LBDie = LSInfo.AbstractLSDie ? LSInfo.AbstractLSDie : LSInfo.ConcreteLSDie;

716

Drop {} from single line loop

733

Drop {} from single line loop

733

It's possible that this part of the code (& the InlineLSDies member of LSInfo) is not needed - whenever we create an inline instance we /know/ there's a concrete instance and we know (I think) that it will have the abstract-only DIEs on it that mean it needs an abstract_origin, right? So if we put it on up-front, it'll save us having to cache the list of inlined instances, etc, perhaps?

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

467

replace assert(false) with llvm_unreachable (& drop the "return" after it - it's dead/not needed)

489–490

Can drop the {} here if you like (as noted below, this isn't a certain/consistent rule in the LLVM codebase)

511–512

Can drop the {} if you like - this one is less clear. Some parts/developers of LLVM drop {} around any single statement block (anywhere it's valid, basically), some only drop them around single /line/ blocks.

547

What does the output of this loop look like for split-dwarf? I would expect that this change should have no impact on skeleton DIEs (including the GMLT-like DIEs produced as children of the skeleton CU DIE), yes?

Indeed, it looks like DwarfCompileUnit::finishLocalScopeDefinitions only uses the contents of the DwarfFile anyway - so perhaps the function should be moved up to the DwarfFile level (rather than calling down into the DwarfCompileUnit, then up into the DwarfFile) & only run on the non-skeleton file since it is/should be a no-op on the skeleton unit?

1281

Drop {} from single line block

lib/CodeGen/AsmPrinter/DwarfFile.h

66 ↗

(On Diff #44269)

You can just use in class initializers for this:

DIE *ConcreteLSDie = nullptr;
DIE *AbstractLSDie = nullptr;

[aaboud]

Thanks David for the comments.
I fixed most of them, see answers below.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

573

Yes that what I meant.
Sorry for misleading with the wrong word in the name, I keep doing this mistake between the "None" and "Non" :)

733

Could work, assuming that we created the abstract lexical scope before we create the inline lexical scope.
However, to figure out that the lexical scope is an inline, we need to add a check that would not make the code clean.

So, I suggest that I implement this suggestion as a follow up, after commenting this implementation.
Then, you can give it a second thought to decide if you still want to stick with the suggestion, or stay with the current code.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

467

I just figure out that I do not need this function.
Just replaced it with DILocalScope::getSubprogram().

547

I admit, I have no clue how split-dwarf looks like.
I guessed that I might need to handle it like I did here, but if you are convinced that it is redundant, I will follow your suggestion.

Also, the "DwarfCompileUnit ::finishLocalScopeDefinitions()" method invokes the "DwarfUnit ::addDIEEntry()".
If you still think that we move the "finishLocalScopeDefinitions()" method to DwarfFile, then how should we access the "DwarfUnit ::addDIEEntry()" method from there?

[aaboud]

Modified code according to David comments.
Also, now code supports both solutions from the proposal, the one with DW_AT_abstract_origin on lexical blocks and the workaround solution.
The default is the workaround solution, as LLDB and older GDB debuggers will not provide information with the abstract-origin solution.

To enable the abstract-origin solution user can compile with "-use-abstract-origin-on-ls" flag.

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

19

I'd really prefer not to have this option/backcompat feature.

Do you have a need to support older GDBs (or LLDB) with this change? Otherwise I think this is a sufficiently narrow case we could probably take the change optimistically and let other debuggers deal with it as a bug. I don't think it'll disrupt that many users. (though I could be wrong/happy to deal with it differently if we have contributing developers who feel strongly that they need a workaround for their users until their platform debuggers catch up)

I realize it doesn't cost too much (your implementation has made it quite simple to support both) - this isn't all teh cost. We'd have to plumb the option up through into the frontend, or make it a debugger tuning feature (how would we tune it for GDB if we want to support old GDBs here? I would imagine this should be a "do the good thing by default, but fall back to the bad thing if we're specifically targeting known bad compilers, like LLDB" - though I think Adrian mentioned he'd be willing to just take this as an LLDB bug, but I'm not 100% sure)

567

This should be llvm_unreachable rather than assert(false)

733

Sure, that can wait

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

467

Great!

547

Could you try this out with split-dwarf? Or would you like me to take a look?

If we were to put it in DwarfFile, we would just specifically access the non-skeleton DwarfUnit to add DIEs, etc. there are other parts of the code that do this, if I recall correctly.

[aaboud]

Applied few changes according to David comments.

1. Now LIT tests checks for -split-dwarf=Enable case.
2. Removed the workaround solution.
3. Replaced an assertion with "llvm_unreachable()" function.

[aaboud]

Sorry for the late response, please see new patch and below comments.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

19

OK, I agree.
I just wanted to show you (record) the changes need to be done to support older debuggers.
I will stick to the new behavior, and assume LLDB will have a fix soon to suit this new behavior.

If we get any complains from Clang users we can reconsider support the workaround.

Do you agree to this?

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

547

OK, I updated the test to run also with "split-dwarf=ENABLE", and even check manually against older behavior, and in both cases the debug info is emitted to the ".debug_dwo" section.

So, I guess the current implementation is fine, what do you think?

[dblaikie]

Just simplify the finishLocalScopeDefinitions call as suggested & please commit after that. (no need for another round of review, the change is simple/obvious enough)

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

547

Just looking at the code, I think the right thing here is just to call:

I.second->finishLocalScopeDefinitions()

We shouldn't have any local scope definitions in the skeleton CU, so the other call is just a no-op anyway, so far as I can tell.

[aaboud]

There was a minor issue with the implementation, which I fixed in this patch and improved the LIT tests to catch it as well.
Because the local entry information was saved in the DwarfFile, it could be accessed by all CompileUnits, and the way it was handled caused two different CompileUnits to handle same local entry twice leading into hitting assertion during compilation.
The fix was to move the data to the DwarfCompileUnit class, i.e. in this final patch there is no modification to the DwarfFile.h/cpp files.

Also, ran Clang-format and fixed few lines accordingly.

David, please give it a fast look, nothing changed except moving the structures from one file to another.

[dblaikie]

looks good - thanks! Please commit when ready

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

 // This file contains support for writing dwarf compile unit.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFCOMPILEUNIT_H
 
 #include "DwarfUnit.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/Support/Dwarf.h"
 
 namespace llvm {
 
 class AsmPrinter;
 class DIE;
 class DwarfDebug;
 class DwarfFile;
 class MCSymbol;
 class LexicalScope;
 
 class DwarfCompileUnit : public DwarfUnit {
   /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
   /// the need to search for it in applyStmtList.
   DIE::value_iterator StmtListValue;
 
   /// Skeleton unit associated with this unit.
   DwarfCompileUnit *Skeleton;
 
   /// The start of the unit within its section.
   MCSymbol *LabelBegin;
 
-  typedef llvm::SmallVector<const MDNode *, 8> ImportedEntityList;
-  typedef llvm::DenseMap<const MDNode *, ImportedEntityList>
-  ImportedEntityMap;
+  typedef llvm::SmallVector<const MDNode *, 8> LocalDeclNodeList;
+  typedef llvm::DenseMap<const MDNode *, LocalDeclNodeList> LocalScopesMap;
 
-  ImportedEntityMap ImportedEntities;
+  LocalScopesMap LocalDeclNodes;
 
   /// GlobalNames - A map of globally visible named entities for this unit.
   StringMap<const DIE *> GlobalNames;
 
   /// GlobalTypes - A map of globally visible types for this unit.
   StringMap<const DIE *> GlobalTypes;
 
   // List of range lists for a given compile unit, separate from the ranges for
   // the CU itself.
   SmallVector<RangeSpanList, 1> CURangeLists;
 
   // List of ranges for a given compile unit.
   SmallVector<RangeSpan, 2> CURanges;
 
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress;
 
+  struct LocalScopeDieInfo {
+    DIE *ConcreteLSDie = nullptr;
+    DIE *AbstractLSDie = nullptr;
+    SetVector<DIE *> InlineLSDies;
+    SetVector<DIE *> LocalDclDies;
+  };
+  // Collection of local scope DIE info.
+  DenseMap<const MDNode *, LocalScopeDieInfo> LocalScopeDieInfoMap;
+
   /// \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;
 
   bool includeMinimalInlineScopes() const;
 
public:
   /// addSectionDelta - Add a label delta attribute data and value.
   DIE::value_iterator addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                       const MCSymbol *Hi, const MCSymbol *Lo);
 
   DwarfCompileUnit &getCU() override { return *this; }
 
   unsigned getOrCreateSourceID(StringRef FileName, StringRef DirName) override;
 
-  void addImportedEntity(const DIImportedEntity* IE) {
-    ImportedEntities[IE->getScope()].push_back(IE);
+  void addLocalDeclNode(const DINode *DI, DILocalScope *Scope) {
+    LocalDeclNodes[Scope].push_back(DI);
   }
 
   /// addRange - Add an address range to the list of ranges for this unit.
   void addRange(RangeSpan Range);
 
   void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
 
   /// addSectionLabel - Add a Dwarf section label attribute data and value.
public:
   DIE *constructVariableDIE(DbgVariable &DV, bool Abstract = false);
 
   DIE *constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope,
                             DIE *&ObjectPointer);
 
   /// A helper function to create children of a Scope DIE.
   DIE *createScopeChildrenDIE(LexicalScope *Scope,
                               SmallVectorImpl<DIE *> &Children,
-                              unsigned *ChildScopeCount = nullptr);
+                              bool *HasNonScopeChildren = nullptr);
 
   /// \brief Construct a DIE for this subprogram scope.
   void constructSubprogramScopeDIE(LexicalScope *Scope);
 
   DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
+  /// \brief Get or create import_module DIE.
+  DIE *getOrCreateImportedEntityDIE(const DIImportedEntity *Module);
   /// \brief Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
 
+  void finishLocalScopeDefinitions();
+
   void collectDeadVariables(const DISubprogram *SP);
 
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
 
   const MCSymbol *getSectionSym() const {
     assert(Section);
     return Section->getBeginSymbol();
public:
   }
 
   /// getRanges - Get the list of ranges for this unit.
   const SmallVectorImpl<RangeSpan> &getRanges() const { return CURanges; }
   SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }
 
   void setBaseAddress(const MCSymbol *Base) { BaseAddress = Base; }
   const MCSymbol *getBaseAddress() const { return BaseAddress; }
+
+  DenseMap<const MDNode *, LocalScopeDieInfo> &getLSDieInfoMap() {
+    return LocalScopeDieInfoMap;
+  }
+
+  /// Add local scope DIE entry to lexical scope info.
+  void addLocalScopeDieToLexicalScope(LexicalScope *LS, DIE *D);
+  /// Add local declaration DIE entry to lexical scope info.
+  void addLocalDclDieToLexicalScope(LexicalScope *LS, DIE *D);
 };
 
 } // end llvm namespace
 
 #endif

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 
 namespace llvm {
 
 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
                                    AsmPrinter *A, DwarfDebug *DW,
                                    DwarfFile *DWU)
     : DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU),
       Skeleton(nullptr), BaseAddress(nullptr) {
   insertDIE(Node, &getUnitDie());
 }
 
 /// addLabelAddress - Add a dwarf label attribute data and value using
DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
 
   assert(GV);
 
   auto *GVContext = GV->getScope();
   auto *GTy = DD->resolve(GV->getType());
 
   // Construct the context before querying for the existence of the DIE in
   // case such construction creates the DIE.
-  DIE *ContextDIE = getOrCreateContextDIE(GVContext);
+  // For Local Scope, do not construct context DIE.
+  bool IsLocalScope = GVContext && isa<DILocalScope>(GVContext);
+  DIE *ContextDIE = IsLocalScope ? nullptr : getOrCreateContextDIE(GVContext);
+  assert(ContextDIE || IsLocalScope);
+
+  // Create new global variable and add to map.
+  DIE *VariableDIE = IsLocalScope
+                         ? createDIE(GV->getTag(), GV)
+                         : &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
 
-  // Add to map.
-  DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
   DIScope *DeclContext;
   if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
     DeclContext = resolve(SDMDecl->getScope());
     assert(SDMDecl->isStaticMember() && "Expected static member decl");
     assert(GV->isDefinition());
     // We need the declaration DIE that is in the static member's class.
     DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
     addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
if (!ScopeDIE)
       return;
     // We create children when the scope DIE is not null.
     createScopeChildrenDIE(Scope, Children);
   } else {
     // Early exit when we know the scope DIE is going to be null.
     if (DD->isLexicalScopeDIENull(Scope))
       return;
 
-    unsigned ChildScopeCount;
+    bool HasNonScopeChildren;
 
     // We create children here when we know the scope DIE is not going to be
     // null and the children will be added to the scope DIE.
-    createScopeChildrenDIE(Scope, Children, &ChildScopeCount);
-
-    // Skip imported directives in gmlt-like data.
-    if (!includeMinimalInlineScopes()) {
-      // There is no need to emit empty lexical block DIE.
-      for (const auto *IE : ImportedEntities[DS])
-        Children.push_back(
-            constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
-    }
+    createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
 
     // If there are only other scopes as children, put them directly in the
     // parent instead, as this scope would serve no purpose.
-    if (Children.size() == ChildScopeCount) {
+    if (!HasNonScopeChildren) {
       FinalChildren.insert(FinalChildren.end(),
                            std::make_move_iterator(Children.begin()),
                            std::make_move_iterator(Children.end()));
       return;
     }
     ScopeDIE = constructLexicalScopeDIE(Scope);
     assert(ScopeDIE && "Scope DIE should not be null.");
   }
 
   // Add children
   for (auto &I : Children)
     ScopeDIE->addChild(std::move(I));
 
   FinalChildren.push_back(std::move(ScopeDIE));
+  addLocalScopeDieToLexicalScope(Scope, ScopeDIE);
 }
 
 DIE::value_iterator
 DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                   const MCSymbol *Hi, const MCSymbol *Lo) {
   return Die.addValue(DIEValueAllocator, Attribute,
                       DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                                  : dwarf::DW_FORM_data4,
DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
   auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
   if (DV.isObjectPointer())
     ObjectPointer = Var;
   return Var;
 }
 
 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
                                               SmallVectorImpl<DIE *> &Children,
-                                              unsigned *ChildScopeCount) {
+                                              bool *HasNonScopeChildren) {
   DIE *ObjectPointer = nullptr;
+  bool HasLocalDclDie = false;
+  auto *DS = Scope->getScopeNode();
 
   for (DbgVariable *DV : DU->getScopeVariables().lookup(Scope))
     Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
 
-  unsigned ChildCountWithoutScopes = Children.size();
+  // Skip local declarations in gmlt-like data.
+  if (!includeMinimalInlineScopes()) {
+    for (const auto *DI : LocalDeclNodes[DS]) {
+      DIE *D = nullptr;
+      if (auto *IE = dyn_cast<DIImportedEntity>(DI))
+        D = getOrCreateImportedEntityDIE(IE);
+      else if (auto *GV = dyn_cast<DIGlobalVariable>(DI))
+        D = getOrCreateGlobalVariableDIE(GV);
+      else if (auto *RT = dyn_cast<DIType>(DI))
+        D = getOrCreateTypeDIE(RT);
+      else
+        llvm_unreachable("Unexpected DI node!");
+      addLocalDclDieToLexicalScope(Scope, D);
+      HasLocalDclDie = true;
+    }
+  }
+
+  if (HasNonScopeChildren)
+    *HasNonScopeChildren = !Children.empty() || HasLocalDclDie;
 
   for (LexicalScope *LS : Scope->getChildren())
     constructScopeDIE(LS, Children);
 
-  if (ChildScopeCount)
-    *ChildScopeCount = Children.size() - ChildCountWithoutScopes;
-
   return ObjectPointer;
 }
 
 void DwarfCompileUnit::constructSubprogramScopeDIE(LexicalScope *Scope) {
   assert(Scope && Scope->getScopeNode());
   assert(!Scope->getInlinedAt());
   assert(!Scope->isAbstractScope());
   auto *Sub = cast<DISubprogram>(Scope->getScopeNode());
DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
   // We create children when the scope DIE is not null.
   SmallVector<DIE *, 8> Children;
   DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
 
   // Add children
   for (auto &I : Children)
     ScopeDIE.addChild(std::move(I));
 
+  addLocalScopeDieToLexicalScope(Scope, &ScopeDIE);
+
   return ObjectPointer;
 }
 
 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
     LexicalScope *Scope) {
   DIE *&AbsDef = DU->getAbstractSPDies()[Scope->getScopeNode()];
   if (AbsDef)
     return;
void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
   applySubprogramAttributesToDefinition(SP, *AbsDef);
 
   if (!includeMinimalInlineScopes())
     addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
   if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, *AbsDef))
     addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
 }
 
+DIE *DwarfCompileUnit::getOrCreateImportedEntityDIE(
+    const DIImportedEntity *Module) {
+  if (DIE *Die = getDIE(Module))
+    return Die;
+
+  return constructImportedEntityDIE(Module);
+}
+
 DIE *DwarfCompileUnit::constructImportedEntityDIE(
     const DIImportedEntity *Module) {
-  DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
-  insertDIE(Module, IMDie);
+
+  assert(!getDIE(Module));
+
+  DIE *IMDie = createDIE(Module->getTag(), Module);
   DIE *EntityDie;
   auto *Entity = resolve(Module->getEntity());
   if (auto *NS = dyn_cast<DINamespace>(Entity))
     EntityDie = getOrCreateNameSpace(NS);
   else if (auto *M = dyn_cast<DIModule>(Entity))
     EntityDie = getOrCreateModule(M);
   else if (auto *SP = dyn_cast<DISubprogram>(Entity))
     EntityDie = getOrCreateSubprogramDIE(SP);
DIE *DwarfCompileUnit::constructImportedEntityDIE(
   StringRef Name = Module->getName();
   if (!Name.empty())
     addString(*IMDie, dwarf::DW_AT_name, Name);
 
   return IMDie;
 }
 
 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
-  DIE *D = getDIE(SP);
-  if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
-    if (D)
+  if (DIE *D = getDIE(SP)) {
+    if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP))
       // If this subprogram has an abstract definition, reference that
       addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
-  } else {
-    if (!D && !includeMinimalInlineScopes())
-      // Lazily construct the subprogram if we didn't see either concrete or
-      // inlined versions during codegen. (except in -gmlt ^ where we want
-      // to omit these entirely)
-      D = getOrCreateSubprogramDIE(SP);
-    if (D)
+    else
       // And attach the attributes
       applySubprogramAttributesToDefinition(SP, *D);
   }
 }
+
+void DwarfCompileUnit::finishLocalScopeDefinitions() {
+  for (const auto &I : getLSDieInfoMap()) {
+    auto LSInfo = I.second;
+    // Attach all local dcl DIEs to abstract local scope if available,
+    // otherwise attach it to concrete local scope.
+    DIE *LBDie =
+        LSInfo.AbstractLSDie ? LSInfo.AbstractLSDie : LSInfo.ConcreteLSDie;
+    assert(LBDie || LSInfo.LocalDclDies.empty());
+    for (auto &D : LSInfo.LocalDclDies)
+      LBDie->addChild(std::move(D));
+
+    if (isa<DISubprogram>(I.first))
+      // For function scope there is nothing else to do.
+      // "abstract_origin" dwarf attribute was added somewhere else.
+      continue;
+
+    if (LSInfo.AbstractLSDie) {
+      // Add "abstract_origin" dwarf attribute to concrete local scope pointing
+      // to the corresponding abstract local scope.
+      if (LSInfo.ConcreteLSDie)
+        addDIEEntry(*LSInfo.ConcreteLSDie, dwarf::DW_AT_abstract_origin,
+                    *LSInfo.AbstractLSDie);
+      // Add "abstract_origin" dwarf attribute to inline local scope pointing
+      // to the corresponding abstract local scope.
+      for (auto &L : LSInfo.InlineLSDies)
+        addDIEEntry(*L, dwarf::DW_AT_abstract_origin, *LSInfo.AbstractLSDie);
+    }
+  }
+}
+
 void DwarfCompileUnit::collectDeadVariables(const DISubprogram *SP) {
   assert(SP && "CU's subprogram list contains a non-subprogram");
   assert(SP->isDefinition() &&
          "CU's subprogram list contains a subprogram declaration");
   auto Variables = SP->getVariables();
   if (Variables.size() == 0)
     return;
 
   DIE *SPDIE = DU->getAbstractSPDies().lookup(SP);
   if (!SPDIE)
-    SPDIE = getDIE(SP);
+    return;
   assert(SPDIE);
   for (const DILocalVariable *DV : Variables) {
     DbgVariable NewVar(DV, /* IA */ nullptr, DD);
     auto VariableDie = constructVariableDIE(NewVar);
     applyVariableAttributes(NewVar, *VariableDie);
     SPDIE->addChild(std::move(VariableDie));
   }
 }

 void DwarfCompileUnit::applySubprogramAttributesToDefinition(
     const DISubprogram *SP, DIE &SPDie) {
   auto *SPDecl = SP->getDeclaration();
   auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
   applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
   addGlobalName(SP->getName(), SPDie, Context);
 }
 
+void DwarfCompileUnit::addLocalScopeDieToLexicalScope(LexicalScope *LS,
+                                                      DIE *D) {
+  auto &LSInfo = getLSDieInfoMap()[LS->getScopeNode()];
+  if (LS->isAbstractScope()) {
+    assert(!LSInfo.AbstractLSDie && "Adding abstract LS DIE twice.");
+    LSInfo.AbstractLSDie = D;
+    return;
+  }
+  if (LS->getInlinedAt()) {
+    assert(!LSInfo.InlineLSDies.count(D) && "Adding inline LS DIE twice.");
+    LSInfo.InlineLSDies.insert(D);
+    return;
+  }
+  assert(!LSInfo.ConcreteLSDie && "Adding cocncrete LS DIE twice.");
+  LSInfo.ConcreteLSDie = D;
+  return;
+}
+
+void DwarfCompileUnit::addLocalDclDieToLexicalScope(LexicalScope *LS, DIE *D) {
+  auto &LSInfo = getLSDieInfoMap()[LS->getScopeNode()];
+  LSInfo.LocalDclDies.insert(D);
+  return;
+}
+
 bool DwarfCompileUnit::isDwoUnit() const {
   return DD->useSplitDwarf() && Skeleton;
 }
 
 bool DwarfCompileUnit::includeMinimalInlineScopes() const {
   return getCUNode()->getEmissionKind() == DIBuilder::LineTablesOnly ||
          (DD->useSplitDwarf() && !Skeleton);
 }
 } // end llvm namespace

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public AsmPrinterHandler {
   /// List of all labels used in aranges generation.
   std::vector<SymbolCU> ArangeLabels;
 
   /// Size of each symbol emitted (for those symbols that have a specific size).
   DenseMap<const MCSymbol *, uint64_t> SymSize;
 
   LexicalScopes LScopes;
 
+  /// Holder for scopes containing local declaration DI nodes per DI function.
+  DenseMap<const DISubprogram *, SmallPtrSet<const DILocalScope *, 16>>
+      LocalScopesMap;
+
   /// Collection of abstract variables.
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
   SmallVector<std::unique_ptr<DbgVariable>, 64> ConcreteVariables;
 
   /// Collection of DebugLocEntry. Stored in a linked list so that DIELocLists
   /// can refer to them in spite of insertions into this list.
   DebugLocStream DebugLocs;
 
class DwarfDebug : public AsmPrinterHandler {
 
   /// Collect info for variables that were optimized out.
   void collectDeadVariables();
 
   void finishVariableDefinitions();
 
   void finishSubprogramDefinitions();
 
+  void finishLocalScopeDefinitions();
+
   /// Finish off debug information after all functions have been
   /// processed.
   void finalizeModuleInfo();
 
   /// Emit the debug info section.
   void emitDebugInfo();
 
   /// Emit the abbreviation section.
class DwarfDebug : public AsmPrinterHandler {
   /// Create new DwarfCompileUnit for the given metadata node with tag
   /// DW_TAG_compile_unit.
   DwarfCompileUnit &constructDwarfCompileUnit(const DICompileUnit *DIUnit);
 
   /// Construct imported_module or imported_declaration DIE.
   void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
                                         const DIImportedEntity *N);
 
+  /// Collect MD Node located within local scope node.
+  /// Return true if node was collected, false otherwise.
+  bool collectLocalScopedNode(DIScope *S, const DINode *N,
+                              DwarfCompileUnit &CU);
+
   /// 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);
 
   /// Indentify instructions that are marking the beginning of or
   /// ending of a scope.
public:
   /// Return Label immediately following the instruction.
   MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
 
   // FIXME: Sink these functions down into DwarfFile/Dwarf*Unit.
 
   SmallPtrSet<const MDNode *, 16> &getProcessedSPNodes() {
     return ProcessedSPNodes;
   }
+
+  /// Return collection of function scopes that contains local declararion DIEs.
+  SmallPtrSet<const DILocalScope *, 16> &
+  getLocalScopes(const DISubprogram *SP) {
+    return LocalScopesMap[SP];
+  }
 };
 } // End of namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 }
 
 void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
                                                   const DIImportedEntity *N) {
   if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
     D->addChild(TheCU.constructImportedEntityDIE(N));
 }
 
+bool DwarfDebug::collectLocalScopedNode(DIScope *S, const DINode *N,
+                                        DwarfCompileUnit &CU) {
+  if (auto LS = dyn_cast_or_null<DILocalScope>(S)) {
+    getLocalScopes(LS->getSubprogram()).insert(LS);
+    CU.addLocalDeclNode(N, LS);
+    return true;
+  }
+  return false;
+}
+
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
 void DwarfDebug::beginModule() {
   if (DisableDebugInfoPrinting)
     return;
 
   const Module *M = MMI->getModule();
 
   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
   if (!CU_Nodes)
     return;
   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
 
   SingleCU = CU_Nodes->getNumOperands() == 1;
 
   for (MDNode *N : CU_Nodes->operands()) {
     auto *CUNode = cast<DICompileUnit>(N);
     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
-    for (auto *IE : CUNode->getImportedEntities())
-      CU.addImportedEntity(IE);
     for (auto *GV : CUNode->getGlobalVariables())
+      if (!collectLocalScopedNode(GV->getScope(), GV, CU))
         CU.getOrCreateGlobalVariableDIE(GV);
     for (auto *SP : CUNode->getSubprograms())
       SPMap.insert(std::make_pair(SP, &CU));
     for (auto *Ty : CUNode->getEnumTypes()) {
       // The enum types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       CU.getOrCreateTypeDIE(cast<DIType>(resolve(Ty->getRef())));
     }
     for (auto *Ty : CUNode->getRetainedTypes()) {
       // The retained types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       DIType *RT = cast<DIType>(resolve(Ty->getRef()));
-      if (!RT->isExternalTypeRef())
+      if (RT->isExternalTypeRef())
         // There is no point in force-emitting a forward declaration.
+        continue;
+      if (!collectLocalScopedNode(resolve(Ty->getScope()), RT, CU))
         CU.getOrCreateTypeDIE(RT);
     }
     // Emit imported_modules last so that the relevant context is already
     // available.
     for (auto *IE : CUNode->getImportedEntities())
+      if (!collectLocalScopedNode(IE->getScope(), IE, CU))
         constructAndAddImportedEntityDIE(CU, IE);
   }
 
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
 }
 
 void DwarfDebug::finishVariableDefinitions() {
   for (const auto &Var : ConcreteVariables) {

 
 void DwarfDebug::finishSubprogramDefinitions() {
   for (const auto &P : SPMap)
     forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
       CU.finishSubprogramDefinition(cast<DISubprogram>(P.first));
     });
 }
 
+void DwarfDebug::finishLocalScopeDefinitions() {
+  for (const auto &I : CUMap)
+    I.second->finishLocalScopeDefinitions();
+}
 
 // Collect info for variables that were optimized out.
 void DwarfDebug::collectDeadVariables() {
   const Module *M = MMI->getModule();
 
   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
     for (MDNode *N : CU_Nodes->operands()) {
       auto *TheCU = cast<DICompileUnit>(N);
void DwarfDebug::collectDeadVariables() {
   }
 }
 
 void DwarfDebug::finalizeModuleInfo() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
   finishSubprogramDefinitions();
 
+  finishLocalScopeDefinitions();
+
   finishVariableDefinitions();
 
   // Collect info for variables that were optimized out.
   collectDeadVariables();
 
   unsigned MacroOffset = 0;
   std::unique_ptr<AsmStreamerBase> AS(new SizeReporterAsmStreamer(Asm));
   // Handle anything that needs to be done on a per-unit basis after
for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
     for (const DILocalVariable *DV : SP->getVariables()) {
       if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
         continue;
       ensureAbstractVariableIsCreated(InlinedVariable(DV, nullptr),
                                       DV->getScope());
       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
              && "ensureAbstractVariableIsCreated inserted abstract scopes");
     }
+    // Assure abstract local scope created for each one contains local DIEs.
+    for (const DILocalScope *LS : getLocalScopes(SP))
+      LScopes.getOrCreateAbstractScope(LS);
     constructAbstractSubprogramScopeDIE(AScope);
   }
 
   TheCU.constructSubprogramScopeDIE(FnScope);
   if (auto *SkelCU = TheCU.getSkeleton())
     if (!LScopes.getAbstractScopesList().empty())
       SkelCU->constructSubprogramScopeDIE(FnScope);
 

lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   DIE *getOrCreateContextDIE(const DIScope *Context);
 
   /// Construct DIEs for types that contain vtables.
   void constructContainingTypeDIEs();
 
   /// Construct function argument DIEs.
   void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args);
 
+  /// Create a DIE with the given Tag, and call insertDIE if MD is not null.
+  DIE *createDIE(unsigned Tag, const DINode *N = nullptr);
+
   /// Create a DIE with the given Tag, add the DIE to its parent, and
   /// call insertDIE if MD is not null.
   DIE &createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N = nullptr);
 
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
   virtual unsigned getHeaderSize() const {
     return sizeof(int16_t) + // DWARF version number

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (!DieCU)
     DieCU = &getUnitDie();
   if (!EntryCU)
     EntryCU = &getUnitDie();
   Die.addValue(DIEValueAllocator, Attribute,
                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
                Entry);
 }
 
-DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
-  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
+DIE *DwarfUnit::createDIE(unsigned Tag, const DINode *N) {
+  DIE *Die = DIE::get(DIEValueAllocator, (dwarf::Tag)Tag);
   if (N)
-    insertDIE(N, &Die);
+    insertDIE(N, Die);
+  return Die;
+}
+
+DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
+  DIE &Die = Parent.addChild(createDIE(Tag, N));
   return Die;
 }
 
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
   Loc->ComputeSize(Asm);
   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
   Die.addValue(DIEValueAllocator, Attribute,
                Loc->BestForm(DD->getDwarfVersion()), Loc);
assert(Ty == resolve(Ty->getRef()) &&
          "type was not uniqued, possible ODR violation.");
 
   // DW_TAG_restrict_type is not supported in DWARF2
   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
 
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
+  // For Local Scope, do not construct context DIE.
   auto *Context = resolve(Ty->getScope());
-  DIE *ContextDIE = getOrCreateContextDIE(Context);
-  assert(ContextDIE);
+  bool IsLocalScope = Context && isa<DILocalScope>(Context);
+  DIE *ContextDIE = IsLocalScope ? nullptr : getOrCreateContextDIE(Context);
+  assert(ContextDIE || IsLocalScope);
 
   if (DIE *TyDIE = getDIE(Ty))
     return TyDIE;
 
-  // Create new type.
-  DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
+  // Create new type and add to map.
+  DIE &TyDIE = IsLocalScope ? *createDIE(Ty->getTag(), Ty)
+                            : createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 
   updateAcceleratorTables(Context, Ty, TyDIE);
 
   if (auto *BT = dyn_cast<DIBasicType>(Ty))
     constructTypeDIE(TyDIE, BT);
   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
     constructTypeDIE(TyDIE, STy);
   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {

test/DebugInfo/Generic/2010-04-06-NestedFnDbgInfo.ll

 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!40}
 !37 = !{!2, !10, !23}
 
 !0 = !DILocalVariable(name: "b", line: 16, scope: !1, file: !3, type: !8)
 !1 = distinct !DILexicalBlock(line: 15, column: 12, file: !38, scope: !2)
 !2 = distinct !DISubprogram(name: "main", linkageName: "main", line: 15, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: false, scopeLine: 15, file: !38, scope: !3, type: !5)
 !3 = !DIFile(filename: "one.cc", directory: "/tmp")
-!4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang 1.5", isOptimized: false, emissionKind: 0, file: !38, enums: !39, retainedTypes: !39, subprograms: !37, imports:  null)
+!4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang 1.5", isOptimized: false, emissionKind: 0, file: !38, enums: !39, retainedTypes: !41, subprograms: !37, imports:  null)
 !5 = !DISubroutineType(types: !6)
 !6 = !{!7}
 !7 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !8 = !DICompositeType(tag: DW_TAG_class_type, name: "B", line: 2, size: 8, align: 8, file: !38, scope: !3, elements: !9)
 !9 = !{!10}
 !10 = distinct !DISubprogram(name: "fn", linkageName: "_ZN1B2fnEv", line: 4, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: false, scopeLine: 4, file: !38, scope: !8, type: !11)
 !11 = !DISubroutineType(types: !12)
 !12 = !{!7, !13}

 !32 = !DILocation(line: 12, column: 3, scope: !10)
 !33 = !DILocalVariable(name: "this", line: 7, arg: 1, scope: !23, file: !3, type: !26)
 !34 = !DILocation(line: 7, column: 11, scope: !23)
 !35 = !DILocation(line: 7, column: 19, scope: !36)
 !36 = distinct !DILexicalBlock(line: 7, column: 17, file: !38, scope: !23)
 !38 = !DIFile(filename: "one.cc", directory: "/tmp")
 !39 = !{}
 !40 = !{i32 1, !"Debug Info Version", i32 3}
+!41 = !{!21}
 No newline at end of file

test/DebugInfo/Generic/2010-06-29-InlinedFnLocalVar.ll

entry:
   ret i32 %1, !dbg !23
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!28}
 
 !0 = distinct !DISubprogram(name: "foo", line: 9, isLocal: true, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 9, file: !27, scope: !1, type: !3, variables: !24)
 !1 = !DIFile(filename: "bar.c", directory: "/tmp/")
-!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !20, subprograms: !25, globals: !26, imports:  !20)
+!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !61, subprograms: !25, globals: !26, imports:  !20)
 !3 = !DISubroutineType(types: !4)
 !4 = !{!5, !5}
 !5 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = distinct !DISubprogram(name: "bar", linkageName: "bar", line: 14, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, file: !27, scope: !1, type: !7)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!5}
 !9 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !10 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
 
 !59 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !60 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
+!61 = !{!12}
 
 !11 = distinct !DILexicalBlock(line: 9, column: 0, file: !1, scope: !0)
 !12 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", line: 10, size: 64, align: 32, file: !27, scope: !0, elements: !13)
 !13 = !{!14, !15}
 !14 = !DIDerivedType(tag: DW_TAG_member, name: "a", line: 10, size: 32, align: 32, file: !27, scope: !12, baseType: !5)
 !15 = !DIDerivedType(tag: DW_TAG_member, name: "b", line: 10, size: 32, align: 32, offset: 32, file: !27, scope: !12, baseType: !5)
 !16 = !DIGlobalVariable(name: "i", line: 5, isLocal: false, isDefinition: true, scope: !1, file: !1, type: !5, variable: i32* @i)
 !17 = !DILocation(line: 15, scope: !18)

test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll

 ; int (*y)(int) = &func;
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "func"
 ; CHECK: DW_TAG_compile_unit
 
-; FIXME: Maybe we should drop the subprogram here - since the function was
+; Check that the subprogram is dropped in this CU - since the function was
 ; emitted in one CU, due to linkonce_odr uniquing. We certainly don't emit the
 ; subprogram here if the source location for this definition is the same (see
 ; test/DebugInfo/cross-cu-linkonce.ll), though it's very easy to tickle that
 ; into failing even without duplicating the source as has been done in this
 ; case (two cpp files in different directories, including the same header that
 ; contains an inline function - clang will produce distinct subprogram metadata
 ; that won't deduplicate owing to the file location information containing the
 ; directory of the source file even though the file name is absolute, not
 ; relative)
 
-; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG_subprogram
 
 @x = global i32 (i32)* @_Z4funci, align 8
 @y = global i32 (i32)* @_Z4funci, align 8
 
 ; Function Attrs: inlinehint nounwind uwtable
 define linkonce_odr i32 @_Z4funci(i32 %i) #0 !dbg !4 {
   %1 = alloca i32, align 4
   store i32 %i, i32* %1, align 4
   call void @llvm.dbg.declare(metadata i32* %1, metadata !22, metadata !DIExpression()), !dbg !23
   %2 = load i32, i32* %1, align 4, !dbg !24
   %3 = mul nsw i32 %2, 2, !dbg !24
   ret i32 %3, !dbg !24
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 attributes #0 = { inlinehint nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind readnone }
 
-!llvm.dbg.cu = !{!12, !0}
+!llvm.dbg.cu = !{!0, !12}
 !llvm.module.flags = !{!19, !20}
 !llvm.ident = !{!21, !21}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: 1, file: !1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !9, imports: !2)
 !1 = !DIFile(filename: "a.cpp", directory: "/tmp/dbginfo")
 !2 = !{}
 !3 = !{!4}
 !4 = distinct !DISubprogram(name: "func", linkageName: "_Z4funci", line: 1, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, scopeLine: 1, file: !1, scope: !5, type: !6, variables: !2)

test/DebugInfo/Generic/namespace.ll

 ; CHECK-NEXT: DW_AT_name{{.*}}= "var_fwd"
 ; CHECK-NOT: NULL
 ; CHECK: [[FOO:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name{{.*}}= "foo"
 ; CHECK-NEXT: DW_AT_declaration
 ; CHECK-NOT: NULL
 ; CHECK: [[BAR:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name{{.*}}= "bar"
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_MIPS_linkage_name
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}= "f1"
 ; CHECK: [[FUNC1:.*]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "f1"
 ; CHECK: [[BAZ:0x[0-9a-f]*]]:{{.*}}DW_TAG_typedef
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "baz"
 ; CHECK: [[VAR_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "var_decl"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_declaration
 ; CHECK: [[FUNC_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "func_decl"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_declaration
 ; CHECK: [[FUNC_FWD:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "func_fwd"
 ; CHECK-NOT: DW_AT_declaration
-; CHECK: DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_MIPS_linkage_name
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name{{.*}}= "f1"
 ; CHECK: NULL
 
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
 ; This is a bug, it should be in F2 but it inherits the file from its
 ; enclosing scope
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(15)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS2]]})
 ; CHECK: NULL
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_imported_module
 ; Same bug as above, this should be F2, not F1
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(18)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name{{.*}}= "__cxx_global_var_init"
+; CHECK-NOT: DW_TAG
+
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "func"
 ; CHECK-NOT: NULL
+; CHECK: DW_TAG_lexical_block
+; CHECK-NOT: NULL
+; CHECK: DW_TAG_imported_module
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
+; CHECK-NEXT: DW_AT_decl_line{{.*}}(23)
+; CHECK-NEXT: DW_AT_import{{.*}}=>
+; CHECK: NULL
+; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(26)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(27)

 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(36)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[VAR_FWD]]})
 ; CHECK: DW_TAG_imported_declaration
 ; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(37)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[FUNC_FWD]]})
 
-; CHECK: DW_TAG_lexical_block
-; CHECK-NOT: NULL
-; CHECK: DW_TAG_imported_module
-; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
-; CHECK-NEXT: DW_AT_decl_line{{.*}}(23)
-; CHECK-NEXT: DW_AT_import{{.*}}=>
-; CHECK: NULL
 ; CHECK: NULL
 ; CHECK: NULL
 
 ; IR generated from clang/test/CodeGenCXX/debug-info-namespace.cpp, file paths
 ; changed to protect the guilty. The C++ source code is:
 ; // RUN...
 ; // RUN...
 ; // RUN...

test/DebugInfo/Generic/nodebug.ll

 ; inline __attribute__((always_inline)) void f1() {
 ;   i = 3;
 ; }
 ;
 ; __attribute__((nodebug)) void f2() {
 ;   f1();
 ; }
 
-; Check that there's only one DW_TAG_subprogram, nothing for the 'f2' function.
-; CHECK: DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "f1"
+; Check that there is no DW_TAG_subprogram, nothing for the 'f2' function.
+; Note: No debug info was emitted for 'f1' function because it has no code.
 ; CHECK-NOT: DW_TAG_subprogram
 
 @i = external global i32
 
 ; Function Attrs: uwtable
 define void @_Z2f2v() #0 {
 entry:
   store i32 3, i32* @i, align 4, !dbg !11

test/DebugInfo/Mips/InlinedFnLocalVar.ll

entry:
   ret i32 %1, !dbg !23
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!28}
 
 !0 = distinct !DISubprogram(name: "foo", line: 9, isLocal: true, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 9, file: !27, scope: !1, type: !3, variables: !24)
 !1 = !DIFile(filename: "bar.c", directory: "/tmp/")
-!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !20, subprograms: !25, globals: !26, imports:  !20)
+!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !61, subprograms: !25, globals: !26, imports:  !20)
 !3 = !DISubroutineType(types: !4)
 !4 = !{!5, !5}
 !5 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = distinct !DISubprogram(name: "bar", linkageName: "bar", line: 14, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, file: !27, scope: !1, type: !7)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!5}
 !9 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !10 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
 
 !59 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !60 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
+!61 = !{!12}
 
 !11 = distinct !DILexicalBlock(line: 9, column: 0, file: !1, scope: !0)
 !12 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", line: 10, size: 64, align: 32, file: !27, scope: !0, elements: !13)
 !13 = !{!14, !15}
 !14 = !DIDerivedType(tag: DW_TAG_member, name: "a", line: 10, size: 32, align: 32, file: !27, scope: !12, baseType: !5)
 !15 = !DIDerivedType(tag: DW_TAG_member, name: "b", line: 10, size: 32, align: 32, offset: 32, file: !27, scope: !12, baseType: !5)
 !16 = !DIGlobalVariable(name: "i", line: 5, isLocal: false, isDefinition: true, scope: !1, file: !1, type: !5, variable: i32* @i)
 !17 = !DILocation(line: 15, scope: !18)

test/DebugInfo/X86/InlinedFnLocalVar.ll

entry:
   ret i32 %1, !dbg !23
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!28}
 
 !0 = distinct !DISubprogram(name: "foo", line: 9, isLocal: true, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 9, file: !27, scope: !1, type: !3, variables: !24)
 !1 = !DIFile(filename: "bar.c", directory: "/tmp/")
-!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !20, subprograms: !25, globals: !26, imports:  !20)
+!2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build)", isOptimized: true, emissionKind: 0, file: !27, enums: !20, retainedTypes: !111, subprograms: !25, globals: !26, imports:  !20)
 !3 = !DISubroutineType(types: !4)
 !4 = !{!5, !5}
 !5 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = distinct !DISubprogram(name: "bar", linkageName: "bar", line: 14, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, file: !27, scope: !1, type: !7)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!5}
 !9 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !10 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
 
 !109 = !DILocalVariable(name: "j", line: 9, arg: 1, scope: !0, file: !1, type: !5)
 !110 = !DILocalVariable(name: "xyz", line: 10, scope: !11, file: !1, type: !12)
+!111 = !{!12}
 
 !11 = distinct !DILexicalBlock(line: 9, column: 0, file: !1, scope: !0)
 !12 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", line: 10, size: 64, align: 32, file: !27, scope: !0, elements: !13)
 !13 = !{!14, !15}
 !14 = !DIDerivedType(tag: DW_TAG_member, name: "a", line: 10, size: 32, align: 32, file: !27, scope: !12, baseType: !5)
 !15 = !DIDerivedType(tag: DW_TAG_member, name: "b", line: 10, size: 32, align: 32, offset: 32, file: !27, scope: !12, baseType: !5)
 !16 = !DIGlobalVariable(name: "i", line: 5, isLocal: false, isDefinition: true, scope: !1, file: !1, type: !5, variable: i32* @i)
 !17 = !DILocation(line: 15, scope: !18)

test/DebugInfo/X86/PR24008.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+
+;; This test checks the following:
+;; 1. Compilation does not crash
+;; 2. "f1" function is defined.
+;; 3. "nested::f2" function is not defined.
+;;
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm foo.cpp -o - | opt -S -inline -sroa
+;; Where test.cpp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;void f1() {
+;;  while (true) {
+;;    struct nested {
+;;      static void f2() {}
+;;    };
+;;    nested::f2();
+;;  }
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; CHECK:      DW_TAG_compile_unit
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "f1"
+; CHECK:        NULL
+
+; CHECK-NOT: DW_TAG_subprogram
+
+
+; Function Attrs: nounwind
+define void @_Z2f1v() #0 !dbg !6 {
+entry:
+  br label %while.body, !dbg !16
+
+while.body:                                       ; preds = %while.body, %entry
+  br label %while.body, !dbg !16
+
+return:                                           ; No predecessors!
+  ret void, !dbg !17
+}
+
+attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!13, !14}
+!llvm.ident = !{!15}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !3, subprograms: !11)
+!1 = !DIFile(filename: "foo.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DICompositeType(tag: DW_TAG_structure_type, name: "nested", scope: !5, file: !1, line: 3, size: 8, align: 8, elements: !9)
+!5 = distinct !DILexicalBlock(scope: !6, file: !1, line: 2)
+!6 = distinct !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null}
+!9 = !{!10}
+!10 = distinct !DISubprogram(name: "f2", scope: !4, file: !1, line: 4, type: !7, isLocal: false, isDefinition: false, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false)
+!11 = !{!6, !12}
+!12 = distinct !DISubprogram(name: "f2", linkageName: "_ZZ2f1vEN6nested2f2Ev", scope: !4, file: !1, line: 4, type: !7, isLocal: true, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, declaration: !10, variables: !2)
+!13 = !{i32 2, !"Dwarf Version", i32 4}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{!"clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)"}
+!16 = !DILocation(line: 2, scope: !6)
+!17 = !DILocation(line: 8, scope: !6)

test/DebugInfo/X86/dbg-file-name.ll

 ; RUN: llc -enable-dwarf-directory -mtriple x86_64-apple-darwin10.0.0  < %s | FileCheck %s
 
 ; Radar 8884898
 ; CHECK: file 1 "simple.c"
 
 declare i32 @printf(i8*, ...) nounwind
 
 define i32 @main() nounwind !dbg !6 {
-  ret i32 0
+  ret i32 0, !dbg !13
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!12}
 
 !1 = !DIFile(filename: "simple.c", directory: "/Users/manav/one/two")
 !2 = distinct !DICompileUnit(language: DW_LANG_C89, producer: "LLVM build 00", isOptimized: true, emissionKind: 0, file: !10, enums: !11, retainedTypes: !11, subprograms: !9)
 !5 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = distinct !DISubprogram(name: "main", linkageName: "main", line: 9, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, file: !10, scope: !1, type: !7)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!5}
 !9 = !{!6}
 !10 = !DIFile(filename: "simple.c", directory: "/Users/manav/one/two")
 !11 = !{}
 !12 = !{i32 1, !"Debug Info Version", i32 3}
+!13 = !DILocation(line: 10, scope: !6)

test/DebugInfo/X86/debug-dead-local-var.ll

 ; RUN: llc -mtriple=x86_64-linux-gnu %s -filetype=obj -o %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 
 ; Reconstruct this via clang and -O2.
 ; static void foo() {
 ;   struct X { int a; int b; } xyz;
 ; }
 
 ; int bar() {
 ;   foo();
 ;   return 1;
 ; }
 
-; Check that we still have the structure type for X even though we're not
-; going to emit a low/high_pc for foo.
-; CHECK: DW_TAG_structure_type
+; Check that we will not have the structure type for X as we are going to omit
+; the function foo.
+; CHECK-NOT: DW_TAG_structure_type
 
 ; Function Attrs: nounwind readnone uwtable
 define i32 @bar() #0 !dbg !4 {
 entry:
   ret i32 1, !dbg !21
 }
 
 attributes #0 = { nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!18, !19}
 !llvm.ident = !{!20}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)", isOptimized: true, emissionKind: 1, file: !1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)", isOptimized: true, emissionKind: 1, file: !1, enums: !2, retainedTypes: !22, subprograms: !3, globals: !2, imports: !2)
 !1 = !DIFile(filename: "debug-dead-local-var.c", directory: "/usr/local/google/home/echristo")
 !2 = !{}
 !3 = !{!4, !9}
 !4 = distinct !DISubprogram(name: "bar", line: 11, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 11, file: !1, scope: !5, type: !6, variables: !2)
 !5 = !DIFile(filename: "debug-dead-local-var.c", directory: "/usr/local/google/home/echristo")
 !6 = !DISubroutineType(types: !7)
 !7 = !{!8}
 !8 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = distinct !DISubprogram(name: "foo", line: 6, isLocal: true, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 6, file: !1, scope: !5, type: !10, variables: !12)
 !10 = !DISubroutineType(types: !11)
 !11 = !{null}
 !12 = !{!13}
 !13 = !DILocalVariable(name: "xyz", line: 8, scope: !9, file: !5, type: !14)
 !14 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", line: 8, size: 64, align: 32, file: !1, scope: !9, elements: !15)
 !15 = !{!16, !17}
 !16 = !DIDerivedType(tag: DW_TAG_member, name: "a", line: 8, size: 32, align: 32, file: !1, scope: !14, baseType: !8)
 !17 = !DIDerivedType(tag: DW_TAG_member, name: "b", line: 8, size: 32, align: 32, offset: 32, file: !1, scope: !14, baseType: !8)
 !18 = !{i32 2, !"Dwarf Version", i32 4}
 !19 = !{i32 2, !"Debug Info Version", i32 3}
 !20 = !{!"clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)"}
 !21 = !DILocation(line: 13, scope: !4)
+!22 = !{!14}

test/DebugInfo/X86/gnu-public-names.ll

 ; CHECK: [[D:0x[0-9a-f]+]]: DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name {{.*}} "D"
 
 ; CHECK: [[GLOB_NS_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}} "global_namespace_function"
-
-; CHECK: DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "f3"
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK: [[F3_Z:.*]]:   DW_TAG_variable
-; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "z"
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:     DW_AT_location
-; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   NULL
 ; CHECK-NOT: {{DW_TAG|NULL}}
 
 ; CHECK: [[ANON:.*]]: DW_TAG_namespace
 ; CHECK-NOT:   DW_AT_name
 ; CHECK: [[ANON_I:.*]]: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_name {{.*}} "i"

 ; CHECK: DW_AT_specification {{.*}} "_ZN1C22static_member_functionEv"
 
 ; CHECK: [[GLOBAL_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}} "global_function"
 
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK:   DW_AT_name {{.*}} "f3"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK: [[F3_Z:.*]]:   DW_TAG_variable
+; CHECK-NOT: DW_TAG
+; CHECK:     DW_AT_name {{.*}} "z"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:     DW_AT_location
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:   NULL
+
 ; CHECK-LABEL: .debug_gnu_pubnames contents:
 ; CHECK-NEXT: length = {{.*}} version = 0x0002 unit_offset = 0x00000000 unit_size = {{.*}}
 ; CHECK-NEXT: Offset     Linkage  Kind     Name
 ; CHECK-NEXT:  [[GLOBAL_FUNC]] EXTERNAL FUNCTION "global_function"
 ; CHECK-NEXT:  [[NS]] EXTERNAL TYPE     "ns"
 ; CHECK-NEXT:  [[OUTER_ANON_C]] STATIC VARIABLE "outer::(anonymous namespace)::c"
 ; CHECK-NEXT:  [[ANON_I]] STATIC VARIABLE "(anonymous namespace)::i"
+; CHECK-NEXT:  [[ANON]] EXTERNAL TYPE "(anonymous namespace)"
 ; GCC Doesn't put local statics in pubnames, but it seems not unreasonable and
 ; comes out naturally from LLVM's implementation, so I'm OK with it for now. If
 ; it's demonstrated that this is a major size concern or degrades debug info
 ; consumer behavior, feel free to change it.
 ; CHECK-NEXT:  [[F3_Z]] STATIC VARIABLE "f3::z"
-; CHECK-NEXT:  [[ANON]] EXTERNAL TYPE "(anonymous namespace)"
 ; CHECK-NEXT:  [[OUTER_ANON]] EXTERNAL TYPE "outer::(anonymous namespace)"
 ; CHECK-NEXT:  [[ANON_INNER_B]] STATIC VARIABLE "(anonymous namespace)::inner::b"
 ; CHECK-NEXT:  [[OUTER]] EXTERNAL TYPE "outer"
 ; CHECK-NEXT:  [[MEM_FUNC]] EXTERNAL FUNCTION "C::member_function"
 ; CHECK-NEXT:  [[GLOB_VAR]] EXTERNAL VARIABLE "global_variable"
 ; CHECK-NEXT:  [[GLOB_NS_VAR]] EXTERNAL VARIABLE "ns::global_namespace_variable"
 ; CHECK-NEXT:  [[ANON_INNER]] EXTERNAL TYPE "(anonymous namespace)::inner"
 ; CHECK-NEXT:  [[D_VAR]] EXTERNAL VARIABLE "ns::d"

test/DebugInfo/X86/lexical-block-inline.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -split-dwarf=Enable -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info.dwo - | FileCheck %s
+
+;; This test checks the following:
+;; 1. Useless lexical block entry is not emitted.
+;; 2. Function static variable, typedef, records (structure, class and union)
+;;    that are defined in lexical basic block are emitted as children to
+;;    these lexical blocks.
+;;    * For typedef and record check that both are emitted in lexical block
+;;      where they are declared and not in the one where they are used.
+;; 3. "bar" function, which was inlined into "foo" function, is created as
+;;    abstract (with DW_AT_inline attribute).
+;;    All variables and types are defined in this abstract entry.
+;; 4. "bar" function is created in "foo" function as inlined function
+;;    (with DW_TAG_inlined_subroutine attribute), and all its local variables
+;;    are created as concrete variables pointing to the abstract suitable entry
+;;    defined under abstract "bar" function.
+;; 5. Lexical block entries created in the inline "bar" function entry have
+;;    "DW_AT_abstract_origin" attribute pointing to the equivalent abstract
+;;    lexical block entry.
+;;
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm foo.cpp -o - | opt -S -inline -sroa
+;; Where foo.cpp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;__inline int bar(int s) {
+;;  {
+;;    {
+;;      struct X {
+;;          int x;
+;;      };
+;;      typedef int Y;
+;;      {
+;;        X a = { s };
+;;        Y b(s);
+;;        static int c = 0;
+;;        return a.x + b + c++;
+;;      }
+;;    }
+;;  }
+;;}
+;;
+;;
+;;int foo(int i) {
+;;  return
+;;    bar(i);
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; CHECK:    [[Offset_bar:0x[0-9abcdef]+]]: DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      DW_AT_name {{.*}} "bar"
+; CHECK:      DW_AT_inline
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_LB2:0x[0-9abcdef]+]]: DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_a:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "a"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_b:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "b"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_c:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "c"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_location
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:        NULL
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      [[Offset_X:0x[0-9abcdef]+]]: DW_TAG_structure_type
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_AT_name {{.*}} "X"
+; CHECK:        NULL
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      [[Offset_Y:0x[0-9abcdef]+]]: DW_TAG_typedef
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_AT_name {{.*}} "Y"
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:      NULL
+
+
+; CHECK:    DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      DW_AT_name {{.*}} "foo"
+; CHECK-NOT: {{NULL}}
+; CHECK:      DW_TAG_inlined_subroutine
+; CHECK-NEXT:   DW_AT_abstract_origin {{.*}} {[[Offset_bar]]}
+
+; CHECK-NOT: {{NULL}}
+; CHECK:        DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_lexical_block
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:       DW_AT_abstract_origin {{.*}} {[[Offset_LB2]]}
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NEXT:       DW_AT_location
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} {[[Offset_a]]}
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NEXT:       DW_AT_location
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} {[[Offset_b]]}
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:      NULL
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:      NULL
+
+%struct.X = type { i32 }
+
+$_ZZ3bariE1c = comdat any
+
+@_ZZ3bariE1c = linkonce_odr global i32 0, comdat, align 4
+
+; Function Attrs: nounwind
+define i32 @_Z3fooi(i32 %i) #0 !dbg !15 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !22, metadata !23), !dbg !24
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !25, metadata !23), !dbg !26
+  call void @llvm.dbg.declare(metadata %struct.X* undef, metadata !28, metadata !23), !dbg !29
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !28, metadata !23), !dbg !29
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !30, metadata !23), !dbg !31
+  %add.i = add nsw i32 %i, %i, !dbg !32
+  %0 = load i32, i32* @_ZZ3bariE1c, align 4, !dbg !32
+  %inc.i = add nsw i32 %0, 1, !dbg !32
+  store i32 %inc.i, i32* @_ZZ3bariE1c, align 4, !dbg !32
+  %add2.i = add nsw i32 %add.i, %0, !dbg !32
+  ret i32 %add2.i, !dbg !33
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
+
+attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0, !34}
+!llvm.module.flags = !{!19, !20}
+!llvm.ident = !{!21}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !3, subprograms: !14, globals: !16)
+!1 = !DIFile(filename: "foo.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !13}
+!4 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", scope: !5, file: !1, line: 4, size: 32, align: 32, elements: !11, identifier: "_ZTSZ3bariE1X")
+!5 = distinct !DILexicalBlock(scope: !6, file: !1, line: 3)
+!6 = distinct !DILexicalBlock(scope: !7, file: !1, line: 2)
+!7 = distinct !DISubprogram(name: "bar", linkageName: "_Z3bari", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !"_ZTSZ3bariE1X", file: !1, line: 5, baseType: !10, size: 32, align: 32)
+!13 = !DIDerivedType(tag: DW_TAG_typedef, name: "Y", scope: !5, file: !1, line: 7, baseType: !10)
+!14 = !{!15, !7}
+!15 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 19, type: !8, isLocal: false, isDefinition: true, scopeLine: 19, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!16 = !{!17}
+!17 = !DIGlobalVariable(name: "c", scope: !18, file: !1, line: 11, type: !10, isLocal: false, isDefinition: true, variable: i32* @_ZZ3bariE1c)
+!18 = distinct !DILexicalBlock(scope: !5, file: !1, line: 8)
+!19 = !{i32 2, !"Dwarf Version", i32 4}
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = !{!"clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)"}
+!22 = !DILocalVariable(name: "i", arg: 1, scope: !15, file: !1, line: 19, type: !10)
+!23 = !DIExpression()
+!24 = !DILocation(line: 19, scope: !15)
+!25 = !DILocalVariable(name: "s", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!26 = !DILocation(line: 1, scope: !7, inlinedAt: !27)
+!27 = distinct !DILocation(line: 21, scope: !15)
+!28 = !DILocalVariable(name: "a", scope: !18, file: !1, line: 9, type: !"_ZTSZ3bariE1X")
+!29 = !DILocation(line: 9, scope: !18, inlinedAt: !27)
+!30 = !DILocalVariable(name: "b", scope: !18, file: !1, line: 10, type: !13)
+!31 = !DILocation(line: 10, scope: !18, inlinedAt: !27)
+!32 = !DILocation(line: 12, scope: !18, inlinedAt: !27)
+!33 = !DILocation(line: 20, scope: !15)
+
+; This line is manually added to check that the test does not crash when having
+; more than one compile unit!
+!34 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !2, globals: !2)
 No newline at end of file

test/DebugInfo/X86/lexical-block.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+
+;; This test checks the following:
+;; 1. Useless lexical block entry is not emitted.
+;; 2. Function static variable, typedef, records (structure, class and union)
+;;    that are defined in lexical basic block are emitted as children to
+;;    these lexical blocks.
+;;    * For typedef and record check that both are emitted in lexical block
+;;      where they are declared and not in the one where they are used.
+;;
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm foo.cpp 
+;; Where foo.cpp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;int foo(void) { 
+;;  {
+;;    {
+;;      struct X {
+;;        int x;
+;;      };
+;;      typedef int Y;
+;;      {
+;;        X a;
+;;        Y b;
+;;        static int c;
+;;        return a.x + b + c;
+;;      }
+;;    }
+;;  }
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; CHECK:    DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      DW_AT_name {{.*}} "foo"
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "a"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "b"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "c"
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:          NULL
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_structure_type
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "X"
+; CHECK:          NULL
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_typedef
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "Y"
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:          NULL
+
+%struct.X = type { i32 }
+
+@_ZZ3foovE1c = internal global i32 0, align 4
+
+; Function Attrs: nounwind
+define i32 @_Z3foov() #0 !dbg !7 {
+entry:
+  %a = alloca %struct.X, align 4
+  %b = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata %struct.X* %a, metadata !21, metadata !22), !dbg !23
+  call void @llvm.dbg.declare(metadata i32* %b, metadata !24, metadata !22), !dbg !25
+  %x = getelementptr inbounds %struct.X, %struct.X* %a, i32 0, i32 0, !dbg !26
+  %0 = load i32, i32* %x, align 4, !dbg !26
+  %1 = load i32, i32* %b, align 4, !dbg !26
+  %add = add nsw i32 %0, %1, !dbg !26
+  %2 = load i32, i32* @_ZZ3foovE1c, align 4, !dbg !26
+  %add1 = add nsw i32 %add, %2, !dbg !26
+  ret i32 %add1, !dbg !26
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!18, !19}
+!llvm.ident = !{!20}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 237245)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !3, subprograms: !14, globals: !15, imports: !2)
+!1 = !DIFile(filename: "foo.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !13}
+!4 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", scope: !5, file: !1, line: 4, size: 32, align: 32, elements: !11)
+!5 = distinct !DILexicalBlock(scope: !6, file: !1, line: 3)
+!6 = distinct !DILexicalBlock(scope: !7, file: !1, line: 2)
+!7 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !4, file: !1, line: 5, baseType: !10, size: 32, align: 32)
+!13 = !DIDerivedType(tag: DW_TAG_typedef, name: "Y", scope: !5, file: !1, line: 7, baseType: !10)
+!14 = !{!7}
+!15 = !{!16}
+!16 = !DIGlobalVariable(name: "c", scope: !17, file: !1, line: 11, type: !10, isLocal: true, isDefinition: true, variable: i32* @_ZZ3foovE1c)
+!17 = distinct !DILexicalBlock(scope: !5, file: !1, line: 8)
+!18 = !{i32 2, !"Dwarf Version", i32 4}
+!19 = !{i32 2, !"Debug Info Version", i32 3}
+!20 = !{!"clang version 3.7.0 (trunk 237245)"}
+!21 = !DILocalVariable(name: "a", scope: !17, file: !1, line: 9, type: !4)
+!22 = !DIExpression()
+!23 = !DILocation(line: 9, scope: !17)
+!24 = !DILocalVariable(name: "b", scope: !17, file: !1, line: 10, type: !13)
+!25 = !DILocation(line: 10, scope: !17)
+!26 = !DILocation(line: 12, scope: !17)

test/DebugInfo/X86/subprogram-inline.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -split-dwarf=Enable -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info.dwo - | FileCheck %s
+
+;; This test checks the following:
+;; 2. Function static variable, typedef, records (structure, class and union)
+;;    that are defined in lexical function scope are emitted as children to
+;;    the function scope, directly.
+;; 3. "bar" function, which was inlined into "foo" function, is created as
+;;    abstract (with DW_AT_inline attribute).
+;;    All variables and types are defined in this abstract entry.
+;; 4. "bar" function is created in "foo" function as inlined function
+;;    (with DW_TAG_inlined_subroutine attribute), and all its local variables
+;;    are created as concrete variables pointing to the abstract suitable entry
+;;    defined under abstract "bar" function.
+;;
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm foo.cpp -o - | opt -S -inline -sroa
+;; Where foo.cpp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;__inline int bar(int s) {
+;;
+;;
+;;      struct X {
+;;          int x;
+;;      };
+;;      typedef int Y;
+;;
+;;        X a = { s };
+;;        Y b(s);
+;;        static int c = 0;
+;;        return a.x + b + c++;
+;;
+;;
+;;
+;;}
+;;
+;;
+;;int foo(int i) {
+;;  return
+;;    bar(i);
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; CHECK:    [[Offset_bar:0x[0-9abcdef]+]]: DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      DW_AT_name {{.*}} "bar"
+; CHECK:      DW_AT_inline
+; CHECK-NOT: NULL
+
+; CHECK:        [[Offset_a:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "a"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_b:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "b"
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        [[Offset_c:0x[0-9abcdef]+]]: DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "c"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_location
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      [[Offset_X:0x[0-9abcdef]+]]: DW_TAG_structure_type
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_AT_name {{.*}} "X"
+; CHECK:        NULL
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      [[Offset_Y:0x[0-9abcdef]+]]: DW_TAG_typedef
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_AT_name {{.*}} "Y"
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:      NULL
+
+
+; CHECK:    DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:      DW_AT_name {{.*}} "foo"
+; CHECK-NOT: {{NULL}}
+; CHECK:      DW_TAG_inlined_subroutine
+; CHECK-NEXT:   DW_AT_abstract_origin {{.*}} {[[Offset_bar]]}
+
+; CHECK-NOT: {{NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NEXT:       DW_AT_location
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} {[[Offset_a]]}
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NEXT:       DW_AT_location
+; CHECK-NEXT:       DW_AT_abstract_origin {{.*}} {[[Offset_b]]}
+
+; CHECK-NOT: {{DW_TAG}}
+; CHECK:      NULL
+
+%struct.X = type { i32 }
+
+$_ZZ3bariE1c = comdat any
+
+@_ZZ3bariE1c = linkonce_odr global i32 0, comdat, align 4
+
+; Function Attrs: nounwind
+define i32 @_Z3fooi(i32 %i) #0 !dbg !13 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !18, metadata !19), !dbg !20
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !21, metadata !19), !dbg !22
+  call void @llvm.dbg.declare(metadata %struct.X* undef, metadata !24, metadata !19), !dbg !25
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !24, metadata !19), !dbg !25
+  call void @llvm.dbg.value(metadata i32 %i, i64 0, metadata !26, metadata !19), !dbg !27
+  %add.i = add nsw i32 %i, %i, !dbg !28
+  %0 = load i32, i32* @_ZZ3bariE1c, align 4, !dbg !28
+  %inc.i = add nsw i32 %0, 1, !dbg !28
+  store i32 %inc.i, i32* @_ZZ3bariE1c, align 4, !dbg !28
+  %add2.i = add nsw i32 %add.i, %0, !dbg !28
+  ret i32 %add2.i, !dbg !29
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
+
+attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0, !30}
+!llvm.module.flags = !{!16}
+!llvm.ident = !{!17}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 256818)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !3, subprograms: !12, globals: !14)
+!1 = !DIFile(filename: "foo.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !11}
+!4 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", scope: !5, file: !1, line: 4, size: 32, align: 32, elements: !9, identifier: "_ZTSZ3bariE1X")
+!5 = distinct !DISubprogram(name: "bar", linkageName: "_Z3bari", scope: !1, file: !1, line: 1, type: !6, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!6 = !DISubroutineType(types: !7)
+!7 = !{!8, !8}
+!8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!9 = !{!10}
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !"_ZTSZ3bariE1X", file: !1, line: 5, baseType: !8, size: 32, align: 32)
+!11 = !DIDerivedType(tag: DW_TAG_typedef, name: "Y", scope: !5, file: !1, line: 7, baseType: !8)
+!12 = !{!13, !5}
+!13 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 19, type: !6, isLocal: false, isDefinition: true, scopeLine: 19, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!14 = !{!15}
+!15 = !DIGlobalVariable(name: "c", scope: !5, file: !1, line: 11, type: !8, isLocal: false, isDefinition: true, variable: i32* @_ZZ3bariE1c)
+!16 = !{i32 2, !"Debug Info Version", i32 3}
+!17 = !{!"clang version 3.8.0 (trunk 256818)"}
+!18 = !DILocalVariable(name: "i", arg: 1, scope: !13, file: !1, line: 19, type: !8)
+!19 = !DIExpression()
+!20 = !DILocation(line: 19, scope: !13)
+!21 = !DILocalVariable(name: "s", arg: 1, scope: !5, file: !1, line: 1, type: !8)
+!22 = !DILocation(line: 1, scope: !5, inlinedAt: !23)
+!23 = distinct !DILocation(line: 21, scope: !13)
+!24 = !DILocalVariable(name: "a", scope: !5, file: !1, line: 9, type: !"_ZTSZ3bariE1X")
+!25 = !DILocation(line: 9, scope: !5, inlinedAt: !23)
+!26 = !DILocalVariable(name: "b", scope: !5, file: !1, line: 10, type: !11)
+!27 = !DILocation(line: 10, scope: !5, inlinedAt: !23)
+!28 = !DILocation(line: 12, scope: !5, inlinedAt: !23)
+!29 = !DILocation(line: 20, scope: !13)
+
+; This line is manually added to check that the test does not crash when having
+; more than one compile unit!
+!30 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 242994) (llvm/trunk 242995)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !2, globals: !2)
 No newline at end of file