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

[aaboud]

Summary

A Fix for Bugs PR19238 & PR24008.
This patch introduces an improvement to "D9758", which did not consider optimized code (especially inline).

Requires D12426 to be committed first.

Changes include:

1. Allow creating DIEs that have a lexical block scope without attaching them to a context.
2. Collect these DIEs in information container associated with the lexical scope.
3. Collect abstract, inline, and concrete lexical block DIEs in information container associated with the lexical scope.
4. Assure lexical scope contains local DI nodes to have an entry in the abstract function, if such exists.
5. At "endModule()", move collected local DIEs to the abstract lexical block DIE, if exists. Otherwise, move them to the concrete lexical block.

Even with this patch we still have the following issues (Could be solved in separate following patch/es):

1. types and local static variables declared in the function scope are still handled as before, i.e. will always be emitted in the concrete function, even when an abstract function exist.
2. In the inline lexical block there is no mention for the type and local static variable, even not an entry with "abstract_origin" attribute.
3. The lexical block hierarchy of inline function might defer from one inline site to another, however, the abstract function contains a unification of all these hierarchies.

[aaboud]

Any comment on this approach?

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.h

267

I can't quite follow it - why are these two data structures necessary now (but weren't necessary prior to your proposed change)?

[aaboud]

lib/CodeGen/AsmPrinter/DwarfDebug.h

267

In my original solution I did not consider optimized code, especially inline functions.
Now as I need to take care of these cases, it led us to the need for handling function static variables for function been inlined.

Notice that in the today implementation, where the function static variable is always associated to the function regardless of the lexical block it is defined in, the function static variable is being defined once even when the function is being inlined.
This means that you will not have access to that variable from the caller function.

With this patch, I am not just solving the static lexical block issue but also assure have access to that static variable from the caller function.

If you think that I should not bother solving this debugging issue, I might be able to do less changes and keep the current behavior (of losing debug info when inline).

What do you think?

[aaboud]

Removed the handle of abstract/concrete function static variables, following comment from David, and will discuss it in separate thread.

[aaboud]

David,
Do you want to comment on the last uploaded patch?

[dblaikie]

Thanks again for your reminders and patience...

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

341–342

Could probably just roll the local variable into the for loop header.

343–344

Should we be adding imported entity DIEs in inlined or abstract definitions? Not sure... I suppose maybe.

What does it mean not to add the types and static variables to these cases? (if we inline away all uses of a function - won't we lose the local types and static variables & the user won't be able to print/interact with them?)

352–353

Formatting (run clang-format over your change?)

354–356

Doesn't "getOrCreateTypeDIE" already do the getDIE check? (that would be implied by the "get" part of "get or create" in the name, I would hope)

372–374

I'm somewhat confused about what this code is about/for. Could you help explain it further?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

743–744

When do we do this while not skipping context?

(also - creating a lexical block that doesn't contain any code may be rather useless - the debugger will never be at a location inside that scope, so it may be difficult to access the variables, etc, there if the debugger implements correct scoping rules... - but I'm not sure. What do other compilers do here?)

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

21

Rather than using -O2 which changes a bunch of other stuff in the debug info too, it would be preferable to use no optimizations and add attribute((alwaysinline)) (or is it forceinline? I always forget the name) to the function that must be inlined.

[aaboud]

Thanks David for your comments. I tried to answer all of them.
Hopefully, the answers are clear.

Also, I agreed to fix some code according to your comments, but I prefer to hear your reply on the other comments before I upload a new patch.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

341–342

I will.
I just thought that "findLocalDeclNodesForScope()" function is not cheap, and was not sure that calling it in the "for" loop header is guaranteed to happen once.
If you think that it will not be a performance issue, I will move it to the "for" loop header.

343–344

First of all, notice that we agreed to keep the current behavior of how types/static variables are handled.
Right now, we are emitting them only in the original function (the one that did not get inline, regardless if it has a code or not), the only difference is that we used to emit them always in the function scope, and this patch assure emitting them in the right lexical scope.
We will discuss how to improve that in a separate thread once we are done with this patch.

Imported entries however, are correctly supported (also with inline) and they will always be added to the lexical scope, no matter if it is inline, abstract or regular scope. Thus, there is no need to change that.
If you ask me, once we handle the abstract/concrete static variable, we will end up emitting them too in all kind of lexical scopes.

352–353

I will do before I upload a new patch.

354–356

True, however, if the getDIE in the getOrCreateTypeDIE returns an entry we will not know that and will end up adding this entry twice to the parent scope. This could happen, because types might be created bottom-up and added to the lexical block before handling the lexical scope itself (top-down). This is not the case for static variables, they will never be created bottom-up, that is why we have only an assertion there.
This is why we need to check "getDIE" for types separately before calling "getOrCreateTypeDIE()" function.

If we can differ creating types till all lexical scopes are created, this will prevent the above case for types, but it is not trivial thing to do.

Another thing, which I thought to discuss later with the abstract/concrete static variables, is to emit the type in all kind of lexical scope (inline, abstract, regular). However, we need to discuss it separately as type entry might not be small like the imported entry.

372–374

Let's start from the lines that was not changed (385-386), these are clear, we are creating a new lexical scope.
And if we know that it is a regular lexical scope, we want to add it to the scope map (387-388).

However, because now we are adding regular lexical scope to the map, we want to make sure we do not have this lexical block already created.
It could be created already in case we created a type that belongs to this lexical scope (or to one of its children scopes), as I said before types are not differed till all lexical block are created!
So, we want to check in the map for the lexical scope (379) but only for regular scope (378).
And if we find the lexical scope in the map, this means that it was already added to its parent scope (380-383), so we mark that flag to prevent adding it twice to the parent scope (396-397).

When we discuss the abstract/concrete static variables and differing type creation, we might find a way to prevent this.
But for now, we will need this code.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

743–744

We do that because for some reason LLVM decide to emit debug info for functions that has no code (see the test PR24008.ll below).
even though the static member function "Run()" has no code and even when it was inline there is no instructions related to it, LLVM decided at endModule to create entry for this function, but it is a method, so it end up creating the class Bar type, which happens to be defined inside a lexical block that has no code!

If it was not a type, I would agree with you and say we should not be doing that, but type entries are needed to complete other entries, and we should emit them even if the parent scope of these types has no code.

GCC does that too, in his own way with his own gaps (if you ask me)...I still did not see a compiler that does this perfectly, hopefully we can eventually make LLVM do that the best.

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

21

I am not sure if this will work.
But I can run clang with -O0, then run inline/always-inline pass using opt if this sounds better to get less noise from other passes.
I will then comment that in the test description.

[aaboud]

David,
Do you agree with my answers to your comments?
Some of the answers will need a confirmation or a disagreement.

Thanks,
Amjad

[dblaikie]

test/DebugInfo/X86/PR24008.ll

17

What are the important features of this test? Why are they important? It might be helpful to comment them.

At the moment this looks like it could be simplified down to:

void f1() {
  while (true) {
    struct nested {
      static void f2() {}
    };
    nested::f2();
  }
}

Though even then, I'm not sure what the tricky part of this test is. You've tested nested types in other test cases - was there something in the code you had to write specifically to support this nested type compared to the other tests?

(is there something in your patch I could remove that would cause this test to fail, but not the other tests?)

[aaboud]

David, thanks for the feedback.
I quoted your comments as it did not appear by itself, and answered your questions.
I hope that we are converging :)
Let me know if you agree with the below answers.
In the meanwhile, I will update the code with the few changes we already agreed on.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

341–342

Ah, no worries. See the code sample in the "Explanation" section here: http://en.cppreference.com/w/cpp/language/range-for - that shows pretty much exactly the code the C++ range-for loop translates to.

343–344

"regardless of if it has a code or not" - I'm not quite sure what you mean by this, but I'll take a stab:

There are up to 3 different "functions" that we end up producing in the debug info:

1. the abstract definition
2. the concrete definition
3. the inline definitions

If any inlining happens, we always produce (1) and (3), and if not all call sites were inlined, we produce (2) as well.

You're saying that currently we only emit local types and local static variables into (2) (thus if all calls are inlined, and (2) is not emitted, we do not emit these types and static variables at all? What do we do if there's a variable of that type in the inlined code? wow, we produce a weird little pseudo-(2) that just has the nested type in it... huh)

You got it right.
I meant that we will end up creating the concrete definition (2) "regardless of if it has a code or not".
This is because the function contains a local static variable, or alternatively it has a type declared inside it and used in one of the local variables in the inline version (3).
The perfect implementation would be to have both, the local static variable and the type declaration, defined in the inline (or abstract) version of the function. This could mean duplication of the debug info entries, but at least we will not lose debug info.

Do you have a test case for a situation like that? (maybe it's not relevant to your patch - if it's just existing weird behavior, but if you had to write code to preserve it, we should test it - even if it's not the desirable end state (& maybe it is the right end state, I'm not sure)) Here's the test case I was just playing with, I'm not sure it adds anything compared to your existing tests:

void f1(void*)
inline __attribute__((always_inline)) void f2() {
  struct foo {} f;
  f1(&f);
}
void f3() {
  f2();
}

In fact, the below tests cover all the corner cases I am discussing with you.
The case with the concrete function that has no code but still got an entry in the debug info to house the local static variable and the type declaration is covered by test "lexical-block-inline.ll", I just thought that we should not add the "CHECK" lines for the result, as we know that it is not how it should be.

If I understand you correctly, you are suggesting that I do add the "CHECK" lines, and once we fix this in the future, we can modify the test accordingly, correct?

354–356

When does this happen (that the type is created before the scope it is in)? Does one of your tests cover this (I guess the empty scope case in the PR24008.ll test exercises this - the scope is not created (because it is empty when the function's debug info is generated) but then later on we try to build the local type (to reference from the definition of Run()) and fail because there's no context to put it in?)?

Hmm, PR24008.ll exercises the case where the scope is built (& possibly non-existent) before the type, but not the other way around, which seems to be the case here. That the scope is created before we are generating code for this function and its scopes - what sort of source code leads to that situation? (I can think of some, but not sure if they're tested here, etc)

Actually, I thought that "lexical-block.ll" covers this, but it is not, so here is a test that does, (we can modify "lexical-block.ll" to do that too):

1.int foo(void) { 
2.  {
3.    typedef int Y;
4.    static Y c;
5.    return c;
6.  }
7.}

Let's take a look on lexical block starts at line 2. when we visit lexical block <2> we do the following:
a. Check for any imported entry, local static variable, or type and add them to the children list.
b. Create all its other children (the order between (a.) & (b.) is important to reduce the number of cases where the type can be created before the scope, but it does not solve all the cases)
c. Create the lexical block.

But when we check for local static variables and types in the "LocalDeclNodes" list, we could handle the local static variable "c" before the type "typedef Y" (order is not guaranteed, in fact the current order will assure "c" appears before "Y").
Once we create local static variable "c" we also creates its type, ending up with creating "Y" and adding it to the map before revisiting it later when we hit it in the "LocalDeclNodes" list.

Another example would be when we have inline function, but also the concrete function.
Notice that type will always be created in the concrete function, so if we end up creating the inline function first, when we get to the concrete function, the type was already created before the scope.

372–374

OK, so I think this & related parts of the change are still a source of confusion (for me) and complexity that I'm a bit concerned about.

It sounds like you're suggesting that scopes can be created both before a function is being processed (in the case of a nested type being needed prematurely - such as if that type is referenced by a function template, or the definition of one of its members, etc), and after (the same situation, but where the reference comes after the function and the scope had no code in it to begin with) - is that the case? Do you have clear test cases demonstrating both these situations?

Is that what causes all this complexity with regards to scope creation and access? Are there other weird corner cases? Can we simplify this at all?

I think you got it right, all the complexity is due to these both cases (1) where we might create the lexical scope before processing the function and (2) when we skip creating the lexical scope during processing the function but end up creating it later.
Examples:
(1) See the previous comment, I add an example there for this case, we can modify "lexical-block.ll" to cover this.
(2) "PR24008.ll" cover this case, when we process "Foo::TestBody()" function we skip lexical block "do {" because it has no code, but later we end up creating debug info entry for "Bar::Run()" function, which is a method of class "Bar" that is declared at lexical block "do {" so we end up creating the lexical block after we done processing the function.
By the way, we create entry for "Bar::Run() because of this code (Lazily construct the subprogram if we didn't see either concrete or inlined versions during codegen):

void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
  DIE *D = getDIE(SP);
  if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
    if (D)
      // 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)
      // And attach the attributes
      applySubprogramAttributesToDefinition(SP, *D);
  }
}

Why doesn't the code end up looking more like:

/* find all the things for the scope */

if there are things
  getOrCreateScope
  add things to scope

It seems there are many more variants to this...

If it will be more clear I can move the code to "getOrCreateLexicalScope()" function, but this function will have to return both the lexical scope and an indicator if it was created or not.

(do we create the local scope chain when we create the local type before the outer function? That seems difficult... (because we might not want the intermediate scopes - they may be empty))

With the current implementation, we might end up with empty intermediate scopes when we creates local type before outer function. However, as you realized on your next comment, if we collapse these empty scopes, we might interfere with other names present there.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

743–744

Yes, that seems true - and we can't just remove their parent scope & collapse them into their grandeparent's scope (that would possibly shadow/interfere with other names present there).

I think it's quite right/the only thing to do, to emit them into an "empty" scope like that, when the type is needed.

It'd be interesting to talk about what /is/ perfect here. I see a lot of tradeoffs, but nothing terribly elegant... but perhaps there's an option

test/DebugInfo/X86/PR24008.ll

17

This test checks "when we skip creating the lexical scope during processing the function but end up creating it later" [see previous comments @line 389] , it is not the same like the other one.

However, you might be right about the simple test above.
I will verify that it covers the same case, and if it does, I will simplify the test using your example.

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

21

Certainly worth a shot. I've usually done this with all my inlining tests, if it's just inlining you need - it's a little harder to make an empty scope, but not impossible (force inline an empty function as the only code in the scope, I suppose). Even if you have to run optimizations to make a scope empty, probably still worth having the inline attributes to make it clear what's necessary to be inlined, etc.

[aaboud]

Improved the solution after discussion with David.
Please, take a look on the new description (Summary).

[dblaikie]

It'd be good to split this up as much as possible - it'll make review & commit history easier, etc.

Could you create a separate review just for the "don't omit declarations for unused (fully inlined and optimized away) functions" part that we discussed & you've included here?

After that I think, if I recall our conversation correctly, it might be handy to look at delaying the adding of static variables and local types until the end of the module - and put them in the abstract origin when there is one (rather than always putting them in the concrete definition - and losing them if there is no concrete definition? (that's the current behavior, yes?)).

Then after that, look at trying to keep track of the right scopes, the minimal scopes, etc?

[aaboud]

In D11180#234335, @dblaikie wrote:

It'd be good to split this up as much as possible - it'll make review & commit history easier, etc.

Could you create a separate review just for the "don't omit declarations for unused (fully inlined and optimized away) functions" part that we discussed & you've included here?

Yes, it will make sense to commit the " don't emit declarations for unused (fully inlined and optimized away) functions" separately, but before the other changes.
I will move this part out of this review and open a new one asap.

After that I think, if I recall our conversation correctly, it might be handy to look at delaying the adding of static variables and local types until the end of the module - and put them in the abstract origin when there is one (rather than always putting them in the concrete definition - and losing them if there is no concrete definition? (that's the current behavior, yes?)).

As you agreed, now the local DIEs (i.e. local static variable and local types) are created without being attached to a context and only in at "endModule()" function we call the "finishLexicalBlockDefinitions()" that will attach these DIEs either to the abstract lexical block (if available), or to the concrete lexical block.

Then after that, look at trying to keep track of the right scopes, the minimal scopes, etc?

The minimal scope is guaranteed as we still create lexical block the same way we did before, so there is no empty lexical block created.
However, you might see empty lexical block in the inline function, but that is only because in the equivalent lexical block in the abstract function there is a DIE.
After committing this patch, we might want to add a DIE to the inline lexical block with the "abstract_origin" attribute pointing to the DIE in the abstract lexical block.

Please, read the new summary, I tried to explain the current design/implementation plus what we might want to do as next step.

[aaboud]

Right, what I'm suggesting is that part could be done separately from the scope handling stuff.

I understand the benefit of splitting code into as much patches as possible.

This change would ensure that the DIEs go in the right function (the abstract one or the concrete one) - which would fix bugs that occur when there is no concrete DIE, if I understand correctly?

Actually, what we agreed on that the DIEs would go to abstract one if it exists, otherwise to the concrete. So if we have abstract and concrete the DIE will be only in the abstract.
And this is what I implemented above.

For example, currently if you have a static local variable in a function that is inlined we produce an abstract definition, an inlined subroutine, but then we also produce this weird stub-concrete definition (a subprogram tag with /only/ an abstract_origin attribute, and the child DW_TAG_variable for the static variable). If we delay the addition of the local types and static variables and just put them in the abstract definition if there is one, we shouldn't end up producing the weird stub concrete definition (that's not really a concrete definition anyway).

But the “currently” you are mentioning is not true anymore, once we changed the design to create the DIE without attaching it to a scope, the weird stub-concrete definition is not created anymore.
So, unless we handle these DIEs at end of module processing and put them in the correct scope (abstract or concrete), we will end up having flying (unattached) DIEs.

So that would be a good, separable, incremental step. /then/ we can have a separate (3rd) patch or patches to try to put it in the right scopes?

We improved the design, there is no reason to go one step back, just to commit two patches that none of them make sense as itself.

[aaboud]

Moved out "omitting debug info for function with no code" to separate patch (D12426).
Reverted format fixes on unrelated code.

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
   /// \brief Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
 
+  void finishLexicalBlockDefinitions();
+
   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();

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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);
+  bool IsLBScope = GVContext && isa<DILexicalBlockBase>(GVContext);
+  assert(ContextDIE || IsLBScope);
+
+  // Create new global variable and add to map.
+  DIE *VariableDIE = IsLBScope
+                         ? 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 (Scope->getParent() && isa<DISubprogram>(DS)) {
     // Early exit when we know the scope DIE is going to be null.
     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.
+    bool HasLocalDclDie = false;
+    // Skip local decls 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)));
+      for (const auto &DI : DD->findLocalDeclNodesForScope(DS)) {
+        if (auto *IE = dyn_cast<DIImportedEntity>(DI.second))
+          Children.push_back(constructImportedEntityDIE(IE));
+        else {
+          DIE *D = nullptr;
+          if (auto *GV = dyn_cast<DIGlobalVariable>(DI.second))
+            D = getOrCreateGlobalVariableDIE(GV);
+          else if (auto *RT = dyn_cast<DIType>(DI.second))
+            D = getOrCreateTypeDIE(RT);
+          else
+            assert(false && "Unexpected DI node.");
+          DU->addLocalDieToLBScope(Scope, D);
+          HasLocalDclDie = true;
+        }
+      }
     }
 
     // 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 (!HasLocalDclDie && Children.size() == ChildScopeCount) {
       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.");
+    DU->addLBDieToLBScope(Scope, ScopeDIE);
   }
 
   // Add children
   for (auto &I : Children)
     ScopeDIE->addChild(std::move(I));
 
   FinalChildren.push_back(std::move(ScopeDIE));
 }
 
if (!D && !includeMinimalInlineScopes())
       // inlined versions during codegen. (except in -gmlt ^ where we want
       // to omit these entirely)
       D = getOrCreateSubprogramDIE(SP);
     if (D)
       // And attach the attributes
       applySubprogramAttributesToDefinition(SP, *D);
   }
 }
+
+void DwarfCompileUnit::finishLexicalBlockDefinitions() {
+  for (const auto &I : DU->getLBDieInfoMap()) {
+    auto LBInfo = I.second;
+    DIE *LBDie = (LBInfo.AbstractLBDie) ? (LBInfo.AbstractLBDie)
+                                        : (LBInfo.ConcreteLBDie);
+    assert(LBDie || LBInfo.LocalDclDies.empty());
+    for (auto &D : LBInfo.LocalDclDies)
+      LBDie->addChild(std::move(D));
+  }
+}
+
 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;
 

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;
 
   /// This is a collection of subprogram MDNodes that are processed to
   /// create DIEs.
   SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
 
   /// Maps instruction with label emitted before instruction.
   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
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.
+  /// 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;
class DwarfDebug : public AsmPrinterHandler {
 
   /// Collect info for variables that were optimized out.
   void collectDeadVariables();
 
   void finishVariableDefinitions();
 
   void finishSubprogramDefinitions();
 
+  void finishLexicalBlockDefinitions();
+
   /// 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 with lexical scope node.
+  /// Return true if node was collected, false otherwise.
+  bool collectLexicalScopedNode(DIScope *S, const MDNode * N);
+
   /// 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:
   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 {
+    assert(DILexicalBlockBase::classof(Scope) && "Expected LexicalBlock scope");
     return make_range(std::equal_range(
-        ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
+        ScopesWithLocalDeclNodes.begin(), ScopesWithLocalDeclNodes.end(),
         std::pair<const MDNode *, const MDNode *>(Scope, nullptr),
         less_first()));
   }
 
   /// A helper function to check whether the DIE for a given Scope is
   /// going to be null.
   bool isLexicalScopeDIENull(LexicalScope *Scope);
 
   /// Return Label preceding the instruction.
   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
 
   /// 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));
 }
 
+static const DISubprogram *getSubprogramScope(const DIScope *S) {
+  assert(S && "Expected a valid scope.");
+  if (const DISubprogram *SP = dyn_cast<DISubprogram>(S))
+    return SP;
+  if (const DILexicalBlockBase *LB = dyn_cast<DILexicalBlockBase>(S))
+    return getSubprogramScope(LB->getScope());
+  assert(false && "Unexpected scope.");
+}
+
+bool DwarfDebug::collectLexicalScopedNode(DIScope *S, const MDNode * N) {
+  auto *LB = dyn_cast_or_null<DILexicalBlockBase>(S);
+  if (!LB)
+    return false;
+  getLocalScopes(getSubprogramScope(S)).insert(LB);
+  ScopesWithLocalDeclNodes.push_back(std::make_pair(S, N));
+  return true;
+}
+
 // 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();
 
   FunctionDIs = makeSubprogramMap(*M);
 
   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())
-      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 (!collectLexicalScopedNode(GV->getScope(), GV))
         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 (!collectLexicalScopedNode(resolve(Ty->getScope()), RT))
         CU.getOrCreateTypeDIE(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::finishSubprogramDefinitions() {
   for (const auto &P : SPMap)
     forBothCUs(*P.second, [&](DwarfCompileUnit &CU) {
       CU.finishSubprogramDefinition(cast<DISubprogram>(P.first));
     });
 }
 
+void DwarfDebug::finishLexicalBlockDefinitions() {
+  for (const auto &I : CUMap)
+    forBothCUs(*I.second, [&](DwarfCompileUnit &CU) {
+      CU.finishLexicalBlockDefinitions();
+    });
+}
 
 // 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();
 
+  finishLexicalBlockDefinitions();
+
   finishVariableDefinitions();
 
   // 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) {
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 lexical scope created for each one contains local DIEs.
+    for (const DILocalScope *LS : getLocalScopes(SP)) {
+      LScopes.getOrCreateAbstractScope(cast<DILocalScope>(LS));
+    }
     constructAbstractSubprogramScopeDIE(AScope);
   }
 
   TheCU.constructSubprogramScopeDIE(FnScope);
   if (auto *SkelCU = TheCU.getSkeleton())
     if (!LScopes.getAbstractScopesList().empty())
       SkelCU->constructSubprogramScopeDIE(FnScope);
 

lib/CodeGen/AsmPrinter/DwarfFile.h

 //===-- llvm/CodeGen/DwarfFile.h - Dwarf Debug Framework -------*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DWARFFILE_H
 
 #include "AddressPool.h"
 #include "DwarfStringPool.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Allocator.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
class DwarfFile {
   DwarfStringPool StrPool;
 
   // Collection of dbg variables of a scope.
   DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8>> ScopeVariables;
 
   // Collection of abstract subprogram DIEs.
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
 
+  struct LBDieInfo {
+    DIE *ConcreteLBDie;
+    DIE *AbstractLBDie;
+    SetVector<DIE *> InlineLBDies;
+    SetVector<DIE *> LocalDclDies;
+
+    LBDieInfo() : ConcreteLBDie(nullptr), AbstractLBDie(nullptr) {}
+  };
+  // Collection of lexical scope DIE info.
+  DenseMap<const MDNode *, LBDieInfo> LBDieInfoMap;
+
   /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
   /// be shared across CUs, that is why we keep the map here instead
   /// of in DwarfCompileUnit.
   DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
 
 public:
   DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
 
public:
   DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8>> &getScopeVariables() {
     return ScopeVariables;
   }
 
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     return AbstractSPDies;
   }
 
+  DenseMap<const MDNode *, LBDieInfo> &getLBDieInfoMap() {
+    return LBDieInfoMap;
+  }
+
+  /// Add lexical block DIE entry to lexical scope info.
+  void addLBDieToLBScope(LexicalScope *LS, DIE *D);
+  /// Add DIE entry to lexical-block info.
+  /// Add local declaration DIE entry to lexical scope info.
+  void addLocalDieToLBScope(LexicalScope *LS, DIE *D);
+
   void insertDIE(const MDNode *TypeMD, DIE *Die) {
     DITypeNodeToDieMap.insert(std::make_pair(TypeMD, Die));
   }
   DIE *getDIE(const MDNode *TypeMD) {
     return DITypeNodeToDieMap.lookup(TypeMD);
   }
 };
 }
 #endif

lib/CodeGen/AsmPrinter/DwarfFile.cpp

if (unsigned ArgNum = DV->getArg()) {
     }
     Vars.insert(I, Var);
     return true;
   }
 
   Vars.push_back(Var);
   return true;
 }
+
+void DwarfFile::addLBDieToLBScope(LexicalScope *LS, DIE *D) {
+  auto &LBInfo = getLBDieInfoMap()[LS->getScopeNode()];
+  if (LS->isAbstractScope()) {
+    assert(!LBInfo.AbstractLBDie && "Adding abstract LB DIE twice.");
+    LBInfo.AbstractLBDie = D;
+    return;
+  }
+  if (LS->getInlinedAt()) {
+    assert(!LBInfo.InlineLBDies.count(D) && "Adding inline LB DIE twice.");
+    LBInfo.InlineLBDies.insert(D);
+    return;
+  }
+
+  assert(!LBInfo.ConcreteLBDie && "Adding cocncrete LB DIE twice.");
+  LBInfo.ConcreteLBDie = D;
+  return;
+}
+
+void DwarfFile::addLocalDieToLBScope(LexicalScope *LS, DIE *D) {
+  auto &LBInfo = getLBDieInfoMap()[LS->getScopeNode()];
+  LBInfo.LocalDclDies.insert(D);
+  return;
+}
 }

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 *DwarfUnit::createDIE(unsigned Tag, const DINode *N) {
   assert(Tag != dwarf::DW_TAG_auto_variable &&
          Tag != dwarf::DW_TAG_arg_variable);
-  DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
+  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);
DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
   // 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.
   auto *Context = resolve(Ty->getScope());
   DIE *ContextDIE = getOrCreateContextDIE(Context);
-  assert(ContextDIE);
+  bool IsLBScope = Context && isa<DILexicalBlockBase>(Context);
+  assert(ContextDIE || IsLBScope);
 
   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 = IsLBScope ? *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/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 {
+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 = !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: void ()* @_Z2f1v, variables: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{null}
+!9 = !{!10}
+!10 = !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 = !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/lexical-block-inline.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.
+;; 3. "bar" function, which was inlined into "foo" function, are 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:      DW_TAG_lexical_block
+
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:        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:      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
+
+
+; 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_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]]}
+
+;; FIXME: Here should appear variable DW_TAG_variable "c" with only
+;;        DW_AT_abstract_origin to "Offset_c".
+;;        The following check will fail when LLVM support this.
+; 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 {
+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}
+!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 = !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 = !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 19, type: !8, isLocal: false, isDefinition: true, scopeLine: 19, flags: DIFlagPrototyped, isOptimized: false, function: i32 (i32)* @_Z3fooi, 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(tag: DW_TAG_arg_variable, name: "i", arg: 1, scope: !15, file: !1, line: 19, type: !10)
+!23 = !DIExpression()
+!24 = !DILocation(line: 19, scope: !15)
+!25 = !DILocalVariable(tag: DW_TAG_arg_variable, 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(tag: DW_TAG_auto_variable, name: "a", scope: !18, file: !1, line: 9, type: !"_ZTSZ3bariE1X")
+!29 = !DILocation(line: 9, scope: !18, inlinedAt: !27)
+!30 = !DILocalVariable(tag: DW_TAG_auto_variable, 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)

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 {
+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)