Fixed debug info generation for function static variables, typedef, and records

[aaboud]

Summary

A Fix for Bug 19238.
Function static variable defined inside a lexical scope, same as typedef and record (class, struct or union), which are declared inside a lexical scope, were all associated to the function as its parent scope, rather than to the lexical scope they are defined or declared inside.

This patch provides a fix for all these three cases in the LLVM DWARF debug info generation.

[aaboud]

I did not get feedback on the fix, yet.
Can you please approve or comment if you disagree on this code change?

[probinson]

I don't claim to be deeply familiar with this code, but it looks like your patch does two things: first, refactor how we eliminate redundant/useless lexical blocks (doing it after processing everything else, instead of right away); second, make sure global (static) variables are attached to the correct scope.
The refactoring part should probably be done as its own patch first; that patch should refer to a test that shows we eliminate redundant scopes correctly, or add one if we don't already have such a test.
Then a follow-on patch would correct how globals are attached to their scopes.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

554

"Dies" is a vector of compile units, which will never have DW_TAG_lexical_block. You would need to be doing a depth-first traversal of lexical blocks.

[aaboud]

Split the fix into two change lists as Paul suggested.
You may find the other change list in D9960.

[aaboud]

Applied changes according to David Blaikie commits.
Lexical Block DIE are created as before (no change to the order).
However, global variables and retained types are now handled similar to imported entities and captured in a map indexed by their lexical scope context.
Later, this map will be used to add these entries to the lexical block DIE once it is created.

[friss]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

101

A comment for the new argument would be nice (here or in the header).

339–340

I think the local types and static vars should respect this flag like the imported entities does. If we go the way of unifying the 3 maps (se comments bellow), then everything can be handled inside that if.

345–346

This could just query .empty() on the containers.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

453

Is that condition always safe to check if the scope is function-local? Just looking at the name of the function, it looks like we could change that one day to do something different for local scope (like create them right away like the name implies) and this would break the logic here.

lib/CodeGen/AsmPrinter/DwarfDebug.h

260–261

Not related to your patch, but this look like an orphaned comment.

262–265

Couldn't we just merge the 3 maps. That are all used only in one and same place, and their handling is really similar. The fundamental difference between the 2 new ones and the existing one is that the DIEs created by getOrCreate{Type,Variable}DIE are automatically added to their parents, which doesn't happen for the imported entities. Maybe we should just unify all that? (I think David has written this part, so he might have an opinion on this)

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

744–745

Why is that new shortcut needed?

[aaboud]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

339–340

I see no reason to add them to the minimal flag.
We did not skip emitting local variable due to this flag, did we?
Imported Entities should respect the flag, but you will need to explain why other should!

345–346

I wish it have.
the iterator_range container has no "empty()" method.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

453

If this function would be able to create a lexical block DIE, I would not need to implement this patch from the first place, right?
Also, if you check line 490. when we construct the Imported Entities, it does the same check. Actually, I copied this from their.

lib/CodeGen/AsmPrinter/DwarfDebug.h

260–261

OK, will remove.

262–265

I do not mind merging them, just need some good ideas on how to do that.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

744–745

Yes, I thought it is new, it is not. I just moved it from below.

1. I see no good reason to create the context if we already have the DIE itself.
2. For Type DIEs with lexical block context, the function ContextDIE from below will be nullptr at this point.

[friss]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

339–340

Actually we do not emit locals in that case. If you lookup the function includeMinimalInlineScopes() you'll see that it is true in line-tables-only mode in which we do not emit locals.

345–346

righto, I thought this returned a container and I didn't come back to it when reading the function definitions below.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

453

Sorry, you didn't get my point. You are no just calling function that looks up the scope DIE. As its name implies, it can create things. I'm asking if the side effects of that function are safe to apply here. And if they ever change to return a scope where they don't return any today would it break the logic in getOrCreateGlobalVariable()? Looking at the code there, it seems safe on both fronts because that function is called anyway as one the the very first things (and this also applies to the getOrCreateType() call below).

lib/CodeGen/AsmPrinter/DwarfDebug.h

262–265

Well, I'd try to put everything in the same map (renaming it beforehand to something like 'LocalDeclMap'. Then in constructScopeDIE, discriminate between the different types using dyn_cast (and handle everything in the same loop under the includeMinimalInlineScopes() condition). Is there anything I'm missing that makes this impractical?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

744–745

The comment a few lines below ("Construct the context before querying for the existence of the DIE in case such construction creates the DIE") makes it seem like this is deliberate. Anyway if it's not needed for the patch it shouldn't be here (if you think it is a good idea, it can be the subject of another patch).

[aaboud]

Applied more changes following comments from Frederic and Dave.
Thanks guys for the comments.

[dblaikie]

include/llvm/ADT/iterator_range.h

42

I wouldn't add this here - the range concept is just "begin" and "end" - so there may be other ranges that don't have "empty". So we don't want to make our range-based algorithms overly restrictive by requiring that their ranges have 'empty'.

Instead this should be a free function:

template<typename R>
bool empty(const R& r) { return begin(r) == end(r); }

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

357

Please include the '*' for auto bindings to pointer type. ie:

if (auto *IE = dyn_cast<DIImportedEntity>(DI.second))

etc

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

81–85

I think we have auto-brief on now, so there's no need to put \brief there.

Also, capitalize 'g' in get.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

454

Do we need to actually try to build the context here or is there something cheaper/more specific we could do? Check the node type of the scope To see if it's a lexical or function scope, perhaps?

471

same here

test/DebugInfo/LB-class.ll

1 ↗

(On Diff #26856)

What's the "LB" suffix in these tests?

It seems like these could all be in a single test, probably? The tests should probably be simpler, too. Like:

void func() {
  {
  struct foo {
  };
  foo f;
  typedef int bar;
  bar b;
  }
}

etc?

[aaboud]

include/llvm/ADT/iterator_range.h

42

Done.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

357

Done.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

81–85

Done.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

454

Checking if the scope is lexical scope might be cheaper, only for the cases where the answer is true.
However, I am keeping same implementation as the imported entries, see the condition used in "constructAndAddImportedEntityDIE".

Also, to make the implementation complete and prevent it from break in the future, we should try to build the context, because the return value of this function is the reason why we want to delay creation of the children DIEs.

So, right now it is only lexical blocks that this function does not handle (and returns NULL for), but if you add (or remove) more cases, then no need to go back and change the condition here, we will still be safe with calling the getOrCreateContextDIE.

Also, notice that there is no way that we are creating a context DIE that we will not be creating later, and as we are using map, we will not pay the cost twice.

Do you still think we should check for lexical scope parent instead of the current condition?

test/DebugInfo/LB-class.ll

1 ↗

(On Diff #26856)

LB stands for Lexical Block, as all the cases are related to lexical block handling in Clang and LLVM assembler.

I do not mind simplify the tests, I just was not sure if test like the above will create any code, but will give it a shot.
However, I am not sure that having one test instead of 3 separate tests is better, it will be easier to catch the right problem when any of the 3 tests fail, rather than investigate the failure of the all in one test.

Alright, I tried to generate code using the example test above, but there was no assembly code generated for this test, and thus no debug info DIEs for "foo: and "bar".

If you still think the tests should be simplify, I will try reduce them a little.
Please, let me know if I should.

[aaboud]

Dave, can you answer my questions below?
Do you still want me to try reduce the tests?

Thanks,
Amjad

[aaboud]

I updated the patch according to Dave comments.
I also merged all the 4 LIT test into one LIT test and tried minimized it as much as possible why still be able to check all the corner cases I intended to check in the first place. The test also contains description on what it tries to check.

Please, let me know if you have more comments, or approve the patch for commit.

Thanks

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

454

The code in constructAndAddImportedEntityDIE is a bit more legible because the context is used. In this case we call this "getOrCreate" but then discard the result - it looks weird/confusing.

We could change the other APIs to take the context and we could pass it in to the getOrCreate functions. I still feel like maybe a comment would be warranted... something like "// defer until the context is created lazily"...

But the thing is, we only look in the ScopedWtihLocalDeclNodes when creating local scopes - so it's incorrect to imply that if we change the things that getOrCreateScope builds, the code will work.

... I'm inclined to switch this to a scope check (& possibly include the same condition as an assert in findLocalDeclsForScope). Could an an assert that in the non-local case the entity is actually created - but we don't do that already, so I'm not sure we need to do that after the change?

test/DebugInfo/LB-class.ll

1 ↗

(On Diff #26856)

Looks like you managed to simplify and rename the test - looks good to me

[aaboud]

Applied Dave last comments.
Also, updated the LLVM version to 240893 (close to top of trunk preparing for commit).

[aaboud]

Followed David suggestion.
Now, "findLocalDeclNodesForScope()" is called only if "includeMinimalInlineScopes" is not present.

This, should improve performance and clarity of code.

[dblaikie]

Looks good - thanks for your patience and perseverance!

Please commit, or, if you don't have commit access, I can commit for you.

include/llvm/ADT/iterator_range.h

 public:
   iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
       : begin_iterator(std::move(begin_iterator)),
         end_iterator(std::move(end_iterator)) {}
 
   IteratorT begin() const { return begin_iterator; }
   IteratorT end() const { return end_iterator; }
 };
 
 /// \brief Convenience function for iterating over sub-ranges.
 ///
 /// This provides a bit of syntactic sugar to make using sub-ranges
 /// in for loops a bit easier. Analogous to std::make_pair().
 template <class T> iterator_range<T> make_range(T x, T y) {
   return iterator_range<T>(std::move(x), std::move(y));
 }
 
 template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
   return iterator_range<T>(std::move(p.first), std::move(p.second));
 }
 }
 
+template <typename R>
+bool empty(const R& r) { return begin(r) == end(r); }
+
 #endif

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 
   void initStmtList();
 
   /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
   void applyStmtList(DIE &D);
 
-  /// getOrCreateGlobalVariableDIE - get or create global variable DIE.
-  DIE *getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV);
+  /// Get or create global variable DIE.
+  /// \param GV Global Variable Node
+  /// \param ContextDIE DIE scope for GV Node, if available.
+  DIE *getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
+                                    DIE *ContextDIE = nullptr);
 
   /// addLabelAddress - Add a dwarf label attribute data and value using
   /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
   void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label);
 
   /// addLocalLabelAddress - Add a dwarf label attribute data and value using
   /// DW_FORM_addr only.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
   if (!isa<ConstantInt>(CE->getOperand(2)))
     return nullptr;
 
   return CE;
 }
 
 /// getOrCreateGlobalVariableDIE - get or create global variable DIE.
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
-    const DIGlobalVariable *GV) {
+  const DIGlobalVariable *GV, DIE *ContextDIE) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
 
   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);
+  if (ContextDIE == nullptr)
+    ContextDIE = getOrCreateContextDIE(GVContext);
 
   // 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());
if (Scope->getParent() && isa<DISubprogram>(DS)) {
     if (DD->isLexicalScopeDIENull(Scope))
       return;
 
     unsigned ChildScopeCount;
 
     // 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 &E : DD->findImportedEntitiesForScope(DS))
-        Children.push_back(
-            constructImportedEntityDIE(cast<DIImportedEntity>(E.second)));
-    }
+    auto LocalDeclNodeRangeForScope = DD->findLocalDeclNodesForScope(DS);
     
     // 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 (Children.size() == ChildScopeCount &&
+        (includeMinimalInlineScopes() || empty(LocalDeclNodeRangeForScope))) {
       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.");
+
+    // Skip local decls in gmlt-like data.
+    if (!includeMinimalInlineScopes()) {
+      for (const auto &DI : LocalDeclNodeRangeForScope) {
+        if (auto *IE = dyn_cast<DIImportedEntity>(DI.second))
+          Children.push_back(constructImportedEntityDIE(IE));
+        else if (auto *GV = dyn_cast<DIGlobalVariable>(DI.second))
+          getOrCreateGlobalVariableDIE(GV, ScopeDIE.get());
+        else if (auto *RT = dyn_cast<DIType>(DI.second))
+          getOrCreateTypeDIE(RT, ScopeDIE.get());
+      }
+    }
   }
 
   // Add children
   for (auto &I : Children)
     ScopeDIE->addChild(std::move(I));
 
   FinalChildren.push_back(std::move(ScopeDIE));
 }

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public AsmPrinterHandler {
   const DwarfCompileUnit *PrevCU;
 
   // As an optimization, there is no need to emit an entry in the directory
   // table for the same directory as DW_AT_comp_dir.
   StringRef CompilationDir;
 
   // Holder for the file specific debug information.
   DwarfFile InfoHolder;
 
-  // Holders for the various debug information flags that we might need to
-  // have exposed. See accessor functions below for description.
-
-  // Holder for imported entities.
+  // Holder for local declaration DI nodes per scope.
   typedef SmallVector<std::pair<const MDNode *, const MDNode *>, 32>
-  ImportedEntityMap;
-  ImportedEntityMap ScopesWithImportedEntities;
+  LocalDeclMap;
+  LocalDeclMap ScopesWithLocalDeclNodes;
 
   // Map from MDNodes for user-defined types to the type units that describe
   // them.
   DenseMap<const MDNode *, const DwarfTypeUnit *> DwarfTypeUnits;
 
   SmallVector<
       std::pair<std::unique_ptr<DwarfTypeUnit>, const DICompositeType *>, 1>
       TypeUnitsUnderConstruction;
 
public:
   void addAccelObjC(StringRef Name, const DIE &Die);
 
   void addAccelNamespace(StringRef Name, const DIE &Die);
 
   void addAccelType(StringRef Name, const DIE &Die, char Flags);
 
   const MachineFunction *getCurrentFunction() const { return CurFn; }
 
-  iterator_range<ImportedEntityMap::const_iterator>
-  findImportedEntitiesForScope(const MDNode *Scope) const {
+  iterator_range<LocalDeclMap::const_iterator>
+  findLocalDeclNodesForScope(const MDNode *Scope) const {
     return make_range(std::equal_range(
-        ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
+        ScopesWithLocalDeclNodes.begin(), ScopesWithLocalDeclNodes.end(),
         std::pair<const MDNode *, const MDNode *>(Scope, nullptr),
         less_first()));
   }
 
   /// \brief A helper function to check whether the DIE for a given Scope is
   /// going to be null.
   bool isLexicalScopeDIENull(LexicalScope *Scope);
 

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::beginModule() {
   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())
-      ScopesWithImportedEntities.push_back(std::make_pair(IE->getScope(), IE));
-    // Stable sort to preserve the order of appearance of imported entities.
-    // This is to avoid out-of-order processing of interdependent declarations
-    // within the same scope, e.g. { namespace A = base; namespace B = A; }
-    std::stable_sort(ScopesWithImportedEntities.begin(),
-                     ScopesWithImportedEntities.end(), less_first());
-    for (auto *GV : CUNode->getGlobalVariables())
+      ScopesWithLocalDeclNodes.push_back(std::make_pair(IE->getScope(), IE));
+    for (auto *GV : CUNode->getGlobalVariables()) {
+      if (CU.getOrCreateContextDIE(GV->getScope()))
         CU.getOrCreateGlobalVariableDIE(GV);
+      else
+        ScopesWithLocalDeclNodes.push_back(std::make_pair(GV->getScope(), 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.
-      CU.getOrCreateTypeDIE(cast<DIType>(resolve(Ty->getRef())));
+      DIType *RT = cast<DIType>(resolve(Ty->getRef()));
+      auto *Context = resolve(Ty->getScope());
+      if (CU.getOrCreateContextDIE(Context))
+        CU.getOrCreateTypeDIE(RT);
+      else
+        ScopesWithLocalDeclNodes.push_back(std::make_pair(Context, RT));
     }
     // Emit imported_modules last so that the relevant context is already
     // available.
     for (auto *IE : CUNode->getImportedEntities())
       constructAndAddImportedEntityDIE(CU, IE);
+
+    // Stable sort to preserve the order of appearance of imported entities.
+    // This is to avoid out-of-order processing of interdependent declarations
+    // within the same scope, e.g. { namespace A = base; namespace B = A; }
+    std::stable_sort(ScopesWithLocalDeclNodes.begin(),
+                     ScopesWithLocalDeclNodes.end(), less_first());
   }
 
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
 }
 
 void DwarfDebug::finishVariableDefinitions() {
   for (const auto &Var : ConcreteVariables) {
void DwarfDebug::finalizeModuleInfo() {
   // Collect info for variables that were optimized out.
   collectDeadVariables();
 
   // Handle anything that needs to be done on a per-unit basis after
   // all other generation.
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
     // Emit DW_AT_containing_type attribute to connect types with their
     // vtable holding type.
     TheCU.constructContainingTypeDIEs();
 
     // Add CU specific attributes if we need to add any.
     // If we're splitting the dwarf out now that we've got the entire
     // CU then add the dwo id to it.
     auto *SkCU = TheCU.getSkeleton();
     if (useSplitDwarf()) {
       // Emit a unique identifier for this CU.

lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
 
   DIE *getOrCreateNameSpace(const DINamespace *NS);
   DIE *getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal = false);
 
   void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
                                  bool Minimal = false);
 
   /// \brief Find existing DIE or create new DIE for the given type.
-  DIE *getOrCreateTypeDIE(const MDNode *N);
+  /// \param N Type Node
+  /// \param ContextDIE DIE scope for N Node, if available.
+  DIE *getOrCreateTypeDIE(const MDNode *N, DIE *ContextDIE = nullptr);
 
   /// \brief Get context owner's DIE.
   DIE *createTypeDIE(const DICompositeType *Ty);
 
   /// \brief Get context owner's DIE.
   DIE *getOrCreateContextDIE(const DIScope *Context);
 
   /// \brief Construct DIEs for types that contain vtables.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 
   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
 
   updateAcceleratorTables(Context, Ty, TyDIE);
   return &TyDIE;
 }
 
-DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
+DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode, DIE *ContextDIE) {
   if (!TyNode)
     return nullptr;
 
   auto *Ty = cast<DIType>(TyNode);
   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()));
+    return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()),
+                              ContextDIE);
 
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE.
   auto *Context = resolve(Ty->getScope());
-  DIE *ContextDIE = getOrCreateContextDIE(Context);
-  assert(ContextDIE);
+  if (ContextDIE == nullptr)
+    ContextDIE = getOrCreateContextDIE(Context);
 
   if (DIE *TyDIE = getDIE(Ty))
     return TyDIE;
 
+  assert(ContextDIE);
+
   // Create new type.
   DIE &TyDIE = 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))

test/DebugInfo/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 folowing:
+;; 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
+; CHECK:        DW_AT_name {{.*}} "foo"
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+
+; 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|NULL}}
+; CHECK:        DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:          DW_AT_name {{.*}} "c"
+
+; 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}}
+; CHECK:        NULL
+
+
+%struct.X = type { i32 }
+
+@_ZZ3foovE1c = internal global i32 0, align 4
+
+; Function Attrs: nounwind
+define i32 @_Z3foov() #0 {
+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 = !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 = !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: i32 ()* @_Z3foov, 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(tag: DW_TAG_auto_variable, name: "a", scope: !17, file: !1, line: 9, type: !4)
+!22 = !DIExpression()
+!23 = !DILocation(line: 9, scope: !17)
+!24 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "b", scope: !17, file: !1, line: 10, type: !13)
+!25 = !DILocation(line: 10, scope: !17)
+!26 = !DILocation(line: 12, scope: !17)