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

550

"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).

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.

347–348

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

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

459

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

261–262

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

266–268

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 ↗

(On Diff #26676)

Why is that new shortcut needed?

[aaboud]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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!

347–348

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

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

459

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

261–262

OK, will remove.

266–268

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

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

744–745 ↗

(On Diff #26676)

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

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.

347–348

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

459

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

266–268

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 ↗

(On Diff #26676)

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 ↗

(On Diff #26856)

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

355

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 ↗

(On Diff #26856)

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

460

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?

478

same here

test/DebugInfo/LB-class.ll

2

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 ↗

(On Diff #26856)

Done.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

355

Done.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

81 ↗

(On Diff #26856)

Done.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

460

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

2

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

460

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

2

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/CodeGen/DIE.h

public:
   ///
   void addChild(std::unique_ptr<DIE> Child) {
     assert(!Child->getParent());
     Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
     Child->Parent = this;
     Children.push_back(std::move(Child));
   }
 
+  /// collapseChild - Add Child's children to Child's parent DIE, 
+  ///                 and remove Child DIE.
+  ///
+  void collapseChild(DIE* Child) {
+    assert(Child->getParent() == this);
+    for (auto &Grandchild : Child->Children) {
+      Grandchild->Parent = nullptr;
+      addChild(std::move(Grandchild));
+    }
+    Child->Parent = nullptr;
+    Children.erase(std::remove_if(Children.begin(), Children.end(),
+        [Child](std::unique_ptr<DIE> &I) { return I.get() == Child; }));
+
+    if (Children.empty())
+      Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_no);
+  }
+
   /// findAttribute - Find a value in the DIE with the attribute given,
   /// returns NULL if no such attribute exists.
   DIEValue *findAttribute(dwarf::Attribute Attribute) const;
 
 #ifndef NDEBUG
   void print(raw_ostream &O, unsigned IndentCount = 0) const;
   void dump();
 #endif

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) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
 
   assert(GV);
 
   auto *GVContext = GV->getScope();
   auto *GTy = DD->resolve(GV->getType());
if (Scope->getParent() && isa<DISubprogram>(DS)) {
 
     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)));
     }
 
-    // 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) {
-      FinalChildren.insert(FinalChildren.end(),
-                           std::make_move_iterator(Children.begin()),
-                           std::make_move_iterator(Children.end()));
-      return;
-    }
+    // We create DIE for all debug info lexical scopes. Latter, 
+    // lexical scope that has only other scopes as children will collapsed.
     ScopeDIE = constructLexicalScopeDIE(Scope);
     assert(ScopeDIE && "Scope DIE should not be null.");
+    // Add DIE lexical scope to scope map.
+    insertDIE(Scope->getScopeNode(), ScopeDIE.get());
   }
 
   // Add children
   for (auto &I : Children)
     ScopeDIE->addChild(std::move(I));
 
   FinalChildren.push_back(std::move(ScopeDIE));
 }
 
 void DwarfCompileUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                                        const MCSymbol *Hi, const MCSymbol *Lo) {

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public AsmPrinterHandler {
 
   // 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.
   typedef SmallVector<std::pair<const MDNode *, const MDNode *>, 32>
   ImportedEntityMap;
   ImportedEntityMap ScopesWithImportedEntities;
 
   // 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;
 
class DwarfDebug : public AsmPrinterHandler {
 
   /// \brief Collect info for variables that were optimized out.
   void collectDeadVariables();
 
   void finishVariableDefinitions();
 
   void finishSubprogramDefinitions();
 
+  /// \brief Collapse all lexical scope DIEs that have only other scope DIEs
+  /// as their children.
+  void finalizeLexicalScopeDefinitions();
+
   /// \brief Finish off debug information after all functions have been
   /// processed.
   void finalizeModuleInfo();
 
   /// \brief Emit the debug info section.
   void emitDebugInfo();
 
   /// \brief Emit the abbreviation section.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (MDNode *N : CU_Nodes->operands()) {
     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())
+    for (auto *GV : CUNode->getGlobalVariables()) {
+      auto GVContext = GV->getScope();
+
+      // Skip, variables defined in a lexical block (e.g. static variables). We
+      // will revisit these variables after all lexical scope DIEs are created.
+      if (!GVContext || !DILexicalBlock::classof(GVContext))
         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.
       CU.getOrCreateTypeDIE(cast<DIType>(resolve(Ty->getRef())));
     }
     // Emit imported_modules last so that the relevant context is already
     // available.
     for (auto *IE : CUNode->getImportedEntities())
       constructAndAddImportedEntityDIE(CU, IE);
   }
 
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
 }
for (MDNode *N : CU_Nodes->operands()) {
         if (ProcessedSPNodes.count(SP) != 0)
           continue;
         SPCU->collectDeadVariables(SP);
       }
     }
   }
 }
 
+void DwarfDebug::finalizeLexicalScopeDefinitions() {
+  std::vector<DIE*> Dies;
+  for (const auto &P : CUMap) {
+    DwarfCompileUnit* TheU = P.second;
+    Dies.push_back(&TheU->getUnitDie());
+    if (auto *Skeleton = TheU->getSkeleton())
+      Dies.push_back(&Skeleton->getUnitDie());
+  }
+
+  while (!Dies.empty()) {
+    DIE* Die = Dies.back();
+    Dies.pop_back();
+
+    // If there are only other scopes as children, put them directly in the
+    // parent instead, as this scope would serve no purpose.
+    bool Skip = Die->getAbbrev().getTag() == dwarf::DW_TAG_lexical_block;
+    for (auto &Child : Die->getChildren()) {
+      Dies.push_back(&*Child);
+      Skip &= (Child->getAbbrev().getTag() == dwarf::DW_TAG_lexical_block ||
+               Child->getAbbrev().getTag() == dwarf::DW_TAG_inlined_subroutine);
+    }
+
+    if (Skip)
+      Die->getParent()->collapseChild(Die);
+  }
+}
+
 void DwarfDebug::finalizeModuleInfo() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
+  // Now, after we generated all lexical scope DIEs, it is time to
+  // run over variables defined in a lexical scope and collect them.
+  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);
+      DwarfCompileUnit *SPCU =
+        static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
+      for (auto *GV : TheCU->getGlobalVariables()) {
+        auto GVContext = GV->getScope();
+
+        if (GVContext && DILexicalBlock::classof(GVContext))
+          SPCU->getOrCreateGlobalVariableDIE(GV);
+      }
+    }
+  }
+
   finishSubprogramDefinitions();
 
   finishVariableDefinitions();
 
   // Collect info for variables that were optimized out.
   collectDeadVariables();
 
+  finalizeLexicalScopeDefinitions();
+
   // 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();
 

test/DebugInfo/LB-class.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm class.cpp 
+;; Where class.cpp:
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;int foo(int x) { 
+;;  if(x) { 
+;;    class X {
+;;    public:
+;;     char z;
+;;      X(int y) : z(y) {}
+;;    };
+;;    {
+;;      X a(x);
+;;      return a.z;
+;;    }
+;;  }
+;;  return 0; 
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; CHECK:      DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK:        DW_AT_name {{.*}} "foo"
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+; CHECK-NEXT:   DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:   DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:        DW_TAG_lexical_block
+; CHECK-NEXT:     DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:     DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "a"
+; CHECK:          NULL
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_class
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "X"
+
+%class.X = type { i8 }
+
+; Function Attrs: nounwind
+define i32 @_Z3fooi(i32 %x) #0 {
+entry:
+  %retval = alloca i32, align 4
+  %x.addr = alloca i32, align 4
+  %a = alloca %class.X, align 1
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !23, metadata !24), !dbg !25
+  %0 = load i32, i32* %x.addr, align 4, !dbg !26
+  %tobool = icmp ne i32 %0, 0, !dbg !26
+  br i1 %tobool, label %if.then, label %if.end, !dbg !27
+
+if.then:                                          ; preds = %entry
+  call void @llvm.dbg.declare(metadata %class.X* %a, metadata !28, metadata !24), !dbg !30
+  %1 = load i32, i32* %x.addr, align 4, !dbg !30
+  call void @_ZZ3fooiEN1XC1Ei(%class.X* %a, i32 %1), !dbg !30
+  %z = getelementptr inbounds %class.X, %class.X* %a, i32 0, i32 0, !dbg !31
+  %2 = load i8, i8* %z, align 1, !dbg !31
+  %conv = sext i8 %2 to i32, !dbg !31
+  store i32 %conv, i32* %retval, !dbg !31
+  br label %return, !dbg !31
+
+if.end:                                           ; preds = %entry
+  store i32 0, i32* %retval, !dbg !32
+  br label %return, !dbg !32
+
+return:                                           ; preds = %if.end, %if.then
+  %3 = load i32, i32* %retval, !dbg !33
+  ret i32 %3, !dbg !33
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind
+define internal void @_ZZ3fooiEN1XC1Ei(%class.X* %this, i32 %y) unnamed_addr #0 align 2 {
+entry:
+  %this.addr = alloca %class.X*, align 8
+  %y.addr = alloca i32, align 4
+  store %class.X* %this, %class.X** %this.addr, align 8
+  call void @llvm.dbg.declare(metadata %class.X** %this.addr, metadata !34, metadata !24), !dbg !36
+  store i32 %y, i32* %y.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !37, metadata !24), !dbg !38
+  %this1 = load %class.X*, %class.X** %this.addr
+  %0 = load i32, i32* %y.addr, align 4, !dbg !38
+  call void @_ZZ3fooiEN1XC2Ei(%class.X* %this1, i32 %0), !dbg !38
+  ret void, !dbg !38
+}
+
+; Function Attrs: nounwind
+define internal void @_ZZ3fooiEN1XC2Ei(%class.X* %this, i32 %y) unnamed_addr #0 align 2 {
+entry:
+  %this.addr = alloca %class.X*, align 8
+  %y.addr = alloca i32, align 4
+  store %class.X* %this, %class.X** %this.addr, align 8
+  call void @llvm.dbg.declare(metadata %class.X** %this.addr, metadata !39, metadata !24), !dbg !40
+  store i32 %y, i32* %y.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !41, metadata !24), !dbg !42
+  %this1 = load %class.X*, %class.X** %this.addr
+  %z = getelementptr inbounds %class.X, %class.X* %this1, i32 0, i32 0, !dbg !42
+  %0 = load i32, i32* %y.addr, align 4, !dbg !42
+  %conv = trunc i32 %0 to i8, !dbg !42
+  store i8 %conv, i8* %z, align 1, !dbg !42
+  ret void, !dbg !42
+}
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!20, !21}
+!llvm.ident = !{!22}
+
+!0 = !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 236102)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!1 = !DIFile(filename: "class.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !8, !19}
+!4 = !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: i32 (i32)* @_Z3fooi, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7}
+!7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !DISubprogram(name: "X", linkageName: "_ZZ3fooiEN1XC1Ei", scope: !9, file: !1, line: 6, type: !16, isLocal: true, isDefinition: true, scopeLine: 6, flags: DIFlagPrototyped, isOptimized: false, function: void (%class.X*, i32)* @_ZZ3fooiEN1XC1Ei, declaration: !15, variables: !2)
+!9 = !DICompositeType(tag: DW_TAG_class_type, name: "X", scope: !10, file: !1, line: 3, size: 8, align: 8, elements: !12)
+!10 = distinct !DILexicalBlock(scope: !11, file: !1, line: 2)
+!11 = distinct !DILexicalBlock(scope: !4, file: !1, line: 2)
+!12 = !{!13, !15}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "z", scope: !9, file: !1, line: 5, baseType: !14, size: 8, align: 8, flags: DIFlagPublic)
+!14 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!15 = !DISubprogram(name: "X", scope: !9, file: !1, line: 6, type: !16, isLocal: false, isDefinition: false, scopeLine: 6, flags: DIFlagPublic | DIFlagPrototyped, isOptimized: false)
+!16 = !DISubroutineType(types: !17)
+!17 = !{null, !18, !7}
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64, align: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!19 = !DISubprogram(name: "X", linkageName: "_ZZ3fooiEN1XC2Ei", scope: !9, file: !1, line: 6, type: !16, isLocal: true, isDefinition: true, scopeLine: 6, flags: DIFlagPrototyped, isOptimized: false, function: void (%class.X*, i32)* @_ZZ3fooiEN1XC2Ei, declaration: !15, variables: !2)
+!20 = !{i32 2, !"Dwarf Version", i32 4}
+!21 = !{i32 2, !"Debug Info Version", i32 3}
+!22 = !{!"clang version 3.7.0 (trunk 236102)"}
+!23 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!24 = !DIExpression()
+!25 = !DILocation(line: 1, scope: !4)
+!26 = !DILocation(line: 2, scope: !11)
+!27 = !DILocation(line: 2, scope: !4)
+!28 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "a", scope: !29, file: !1, line: 9, type: !9)
+!29 = distinct !DILexicalBlock(scope: !10, file: !1, line: 8)
+!30 = !DILocation(line: 9, scope: !29)
+!31 = !DILocation(line: 10, scope: !29)
+!32 = !DILocation(line: 13, scope: !4)
+!33 = !DILocation(line: 14, scope: !4)
+!34 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "this", arg: 1, scope: !8, type: !35, flags: DIFlagArtificial | DIFlagObjectPointer)
+!35 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64, align: 64)
+!36 = !DILocation(line: 0, scope: !8)
+!37 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2, scope: !8, file: !1, line: 6, type: !7)
+!38 = !DILocation(line: 6, scope: !8)
+!39 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "this", arg: 1, scope: !19, type: !35, flags: DIFlagArtificial | DIFlagObjectPointer)
+!40 = !DILocation(line: 0, scope: !19)
+!41 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2, scope: !19, file: !1, line: 6, type: !7)
+!42 = !DILocation(line: 6, scope: !19)

test/DebugInfo/LB-static.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm static.cpp 
+;; Where static.cpp:
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;int foo(int x) { 
+;;  if(x) { 
+;;    static int bar = 0;
+;;    {
+;;      int a = bar++;
+;;      return a;
+;;    }
+;;  } 
+;;  return 0; 
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; CHECK:      DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK:        DW_AT_name {{.*}} "foo"
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+; CHECK-NEXT:   DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:   DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:        DW_TAG_lexical_block
+; CHECK-NEXT:     DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:     DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "a"
+; CHECK:          NULL
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "bar"
+
+
+@_ZZ3fooiE3bar = internal global i32 0, align 4
+
+; Function Attrs: nounwind
+define i32 @_Z3fooi(i32 %x) #0 {
+entry:
+  %retval = alloca i32, align 4
+  %x.addr = alloca i32, align 4
+  %a = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !15, metadata !16), !dbg !17
+  %0 = load i32, i32* %x.addr, align 4, !dbg !18
+  %tobool = icmp ne i32 %0, 0, !dbg !18
+  br i1 %tobool, label %if.then, label %if.end, !dbg !19
+
+if.then:                                          ; preds = %entry
+  call void @llvm.dbg.declare(metadata i32* %a, metadata !20, metadata !16), !dbg !22
+  %1 = load i32, i32* @_ZZ3fooiE3bar, align 4, !dbg !22
+  %inc = add nsw i32 %1, 1, !dbg !22
+  store i32 %inc, i32* @_ZZ3fooiE3bar, align 4, !dbg !22
+  store i32 %1, i32* %a, align 4, !dbg !22
+  %2 = load i32, i32* %a, align 4, !dbg !23
+  store i32 %2, i32* %retval, !dbg !23
+  br label %return, !dbg !23
+
+if.end:                                           ; preds = %entry
+  store i32 0, i32* %retval, !dbg !24
+  br label %return, !dbg !24
+
+return:                                           ; preds = %if.end, %if.then
+  %3 = load i32, i32* %retval, !dbg !25
+  ret i32 %3, !dbg !25
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!12, !13}
+!llvm.ident = !{!14}
+
+!0 = !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 236102)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !8, imports: !2)
+!1 = !DIFile(filename: "static.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: i32 (i32)* @_Z3fooi, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7}
+!7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !{!9}
+!9 = !DIGlobalVariable(name: "bar", scope: !10, file: !1, line: 3, type: !7, isLocal: true, isDefinition: true, variable: i32* @_ZZ3fooiE3bar)
+!10 = distinct !DILexicalBlock(scope: !11, file: !1, line: 2)
+!11 = distinct !DILexicalBlock(scope: !4, file: !1, line: 2)
+!12 = !{i32 2, !"Dwarf Version", i32 4}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!14 = !{!"clang version 3.7.0 (trunk 236102)"}
+!15 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!16 = !DIExpression()
+!17 = !DILocation(line: 1, scope: !4)
+!18 = !DILocation(line: 2, scope: !11)
+!19 = !DILocation(line: 2, scope: !4)
+!20 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "a", scope: !21, file: !1, line: 5, type: !7)
+!21 = distinct !DILexicalBlock(scope: !10, file: !1, line: 4)
+!22 = !DILocation(line: 5, scope: !21)
+!23 = !DILocation(line: 6, scope: !21)
+!24 = !DILocation(line: 9, scope: !4)
+!25 = !DILocation(line: 10, scope: !4)

test/DebugInfo/LB-typedef.ll

+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -filetype=obj -O0 < %s  | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+
+;; This test was generated by running following command:
+;; clang -cc1 -O0 -g -emit-llvm typedef.cpp 
+;; Where typedef.cpp
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;int foo(int x) { 
+;;  if(x) { 
+;;    typedef char X;
+;;    {
+;;      X a = x;
+;;      return a;
+;;    }
+;;  }
+;;  return 0; 
+;;}
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; CHECK:      DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK:        DW_AT_name {{.*}} "foo"
+; CHECK-NOT: NULL
+; CHECK:      DW_TAG_lexical_block
+; CHECK-NEXT:   DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:   DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:        DW_TAG_lexical_block
+; CHECK-NEXT:     DW_AT_low_pc [DW_FORM_addr]
+; CHECK-NEXT:     DW_AT_high_pc [DW_FORM_{{.*}}]
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_variable
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "a"
+; CHECK:          NULL
+; CHECK-NOT: {{DW_|NULL}}
+; CHECK:          DW_TAG_typedef
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:            DW_AT_name {{.*}} "X"
+
+
+; Function Attrs: nounwind
+define i32 @_Z3fooi(i32 %x) #0 {
+entry:
+  %retval = alloca i32, align 4
+  %x.addr = alloca i32, align 4
+  %a = alloca i8, align 1
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !11, metadata !12), !dbg !13
+  %0 = load i32, i32* %x.addr, align 4, !dbg !14
+  %tobool = icmp ne i32 %0, 0, !dbg !14
+  br i1 %tobool, label %if.then, label %if.end, !dbg !16
+
+if.then:                                          ; preds = %entry
+  call void @llvm.dbg.declare(metadata i8* %a, metadata !17, metadata !12), !dbg !22
+  %1 = load i32, i32* %x.addr, align 4, !dbg !22
+  %conv = trunc i32 %1 to i8, !dbg !22
+  store i8 %conv, i8* %a, align 1, !dbg !22
+  %2 = load i8, i8* %a, align 1, !dbg !23
+  %conv1 = sext i8 %2 to i32, !dbg !23
+  store i32 %conv1, i32* %retval, !dbg !23
+  br label %return, !dbg !23
+
+if.end:                                           ; preds = %entry
+  store i32 0, i32* %retval, !dbg !24
+  br label %return, !dbg !24
+
+return:                                           ; preds = %if.end, %if.then
+  %3 = load i32, i32* %retval, !dbg !25
+  ret i32 %3, !dbg !25
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 236102)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!1 = !DIFile(filename: "typedef.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: i32 (i32)* @_Z3fooi, variables: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7}
+!7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 3.7.0 (trunk 236102)"}
+!11 = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!12 = !DIExpression()
+!13 = !DILocation(line: 1, scope: !4)
+!14 = !DILocation(line: 2, scope: !15)
+!15 = distinct !DILexicalBlock(scope: !4, file: !1, line: 2)
+!16 = !DILocation(line: 2, scope: !4)
+!17 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "a", scope: !18, file: !1, line: 5, type: !20)
+!18 = distinct !DILexicalBlock(scope: !19, file: !1, line: 4)
+!19 = distinct !DILexicalBlock(scope: !15, file: !1, line: 2)
+!20 = !DIDerivedType(tag: DW_TAG_typedef, name: "X", scope: !19, file: !1, line: 3, baseType: !21)
+!21 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!22 = !DILocation(line: 5, scope: !18)
+!23 = !DILocation(line: 6, scope: !18)
+!24 = !DILocation(line: 9, scope: !4)
+!25 = !DILocation(line: 10, scope: !4)