[WIP][POC][DebugInfo] Support for DW_AT_start_scope for scoped variables

[SouraVX]

Summary

This patch is POC for correctly capturing scope information for
reduced scope variables.

For more context please refer to llvm-dev discussion:
http://lists.llvm.org/pipermail/llvm-dev/2020-April/140962.html

Intent of this patch is to convey overall design/functionality,
seek feedback and converge.
There was an unfortunate delay between the patch and discussion,
Overall design was also discussed in above link(later).

Impact on debug-info statistics(collected from compiling trunk-clang
before and after this patch):

Before this patch:

llvm-dwarfdump --show-section-sizes bin/clang
file: bin/clang
----------------------------------------------------
SECTION        SIZE (b)
-------------  ---------
.debug_info    900357322 (58.29%)
.debug_loc        868784 (0.06%)
.debug_ranges   33411008 (2.16%)
.debug_abbrev    4227906 (0.27%)
.debug_line    117115289 (7.58%)
.debug_str     182932094 (11.84%)

 Total Size: 1238912403  (80.21%)
 Total File Size: 1544622040
----------------------------------------------------

After this patch:

llvm-dwarfdump --show-section-sizes bin/clang
----------------------------------------------------
file: bin/clang
----------------------------------------------------
SECTION        SIZE (b)
-------------  ---------
.debug_info    902111430 (57.62%)
.debug_loc      19768599 (1.26%)
.debug_ranges   33412752 (2.13%)
.debug_abbrev    4305427 (0.28%)
.debug_line    117266710 (7.49%)
.debug_str     182933982 (11.69%)

 Total Size: 1259798900  (80.47%)
 Total File Size: 1565509704
----------------------------------------------------

[SouraVX]

Please ignore these test cases dwarfdump-dataLocationVar.ll and dwarfdump-dataLocationExp.ll. These were generated with flang at the time when it was having bug of emitting dummy LexicalBlock. I've an approved PR in flang for this, once merged I'll correct these test cases(separately).

[Orlando]

llvm/test/DebugInfo/X86/DW_AT_start_scope.ll

6

Hi, I was just skimming the patch and noticed this.

CHECK; -> CHECK:

Also, since this test is only checking for a single variable, you could use llvm-dwarfdump -name Local - here and possibly drop this CHECK line?

[SouraVX]

llvm/test/DebugInfo/X86/DW_AT_start_scope.ll

6

Thanks for pointing this out! I'll fix this up when I revise.
BTW, please share feedback on this(overall) patch :)

[dblaikie]

https://github.com/google/bloaty might be a clearer way to compare the section sizes before/after. Though also comparing variable statistics (llvm-dwarfdump --statistics) might be helpful (though I'm guessing --statistics doesn't understand start-scope yet).

I assume in the previous discussion we discussed the complexities of what start_scope means for a variable without a contiguous address range? What was the answer to that? (if a variable/its enclosing scope has multiple discontiguous address ranges, what's the meaning of the start scope? Which ranges are/aren't in scope?)

I'll probably punt most of this review to @aprantl & co who have more context for variable location tracking.

[djtodoro]

From the [0], I've understood that this should affect debug build only (-g + -O0) ?

[0] http://lists.llvm.org/pipermail/llvm-dev/2020-April/140962.html

llvm/test/DebugInfo/X86/DW_AT_start_scope.ll

10

This should also be ';;'.

67

Usually we don't need these attributes.

101

Probably you can attach all these to the same di-location (with the same scope).

[djtodoro]

According to the --show-section-sizes output, the .debug_loc has been increased?

[SouraVX]

In D85018#2193489, @djtodoro wrote:

According to the --show-section-sizes output, the .debug_loc has been increased?

Thanks for reviewing this! Yea that's one of the drawback(Added FIXME for the same). Since I've used dbg.value intrinsic for representing this variable(all reduced scope variables), this is resulting in a location list entry. We should avoid this somehow, this is because, In our local GDB implementation DW_AT_start_scope is the only thing necessary for capturing the scope info correctly.
BTW, as per @dblaikie comment, do llvm-dwarfdump needs to be aware of DW_AT_start_scope ? How does it calculate size ? Getting the raw section size(that should capture DW_AT_start_scope too) ? Or some other mehachnism ?

[dblaikie]

In D85018#2193545, @SouraVX wrote:

In D85018#2193489, @djtodoro wrote:

According to the --show-section-sizes output, the .debug_loc has been increased?

Thanks for reviewing this! Yea that's one of the drawback(Added FIXME for the same).

When you say "this causes loc list emission even at -O0" could you be more precise? Does the debug_info actually use a location list somewhere? If so, where, if not - does debug_loc contain an unused location list? Does it contain no location lists, but gets emitted (though empty) when it'd otherwise not be emitted at all?

Since I've used dbg.value intrinsic for representing this variable(all reduced scope variables), this is resulting in a location list entry. We should avoid this somehow, this is because, In our local GDB implementation DW_AT_start_scope is the only thing necessary for capturing the scope info correctly.
BTW, as per @dblaikie comment, do llvm-dwarfdump needs to be aware of DW_AT_start_scope ?

My complaint wasn't so much about llvm-dwarfdump --show-section-sizes' output - it's fine for what it is, and it doesn't need to be aware of DW_AT_strat_scope - all it's doing is dumping the size of the sections, without any knowledge of what those sections contain (at least I hope that's how it's implemented - I usually use llvm-objdump -h | grep debug_ for that task, personally). I just meant something like 'bloaty' can do a clearer job of comparing two ELF files for relative sizes - whereas looking at the two dumps of show-section-sizes isn't as easy to visually compare the numbers.

[djtodoro]

In D85018#2194109, @dblaikie wrote:

In D85018#2193545, @SouraVX wrote:

In D85018#2193489, @djtodoro wrote:

According to the --show-section-sizes output, the .debug_loc has been increased?

Thanks for reviewing this! Yea that's one of the drawback(Added FIXME for the same).

When you say "this causes loc list emission even at -O0" could you be more precise? Does the debug_info actually use a location list somewhere? If so, where, if not - does debug_loc contain an unused location list? Does it contain no location lists, but gets emitted (though empty) when it'd otherwise not be emitted at all?

+1 for this question(s).

Since I've used dbg.value intrinsic for representing this variable(all reduced scope variables), this is resulting in a location list entry. We should avoid this somehow, this is because, In our local GDB implementation DW_AT_start_scope is the only thing necessary for capturing the scope info correctly.
BTW, as per @dblaikie comment, do llvm-dwarfdump needs to be aware of DW_AT_start_scope ?

My complaint wasn't so much about llvm-dwarfdump --show-section-sizes' output - it's fine for what it is, and it doesn't need to be aware of DW_AT_strat_scope - all it's doing is dumping the size of the sections, without any knowledge of what those sections contain (at least I hope that's how it's implemented - I usually use llvm-objdump -h | grep debug_ for that task, personally). I just meant something like 'bloaty' can do a clearer job of comparing two ELF files for relative sizes - whereas looking at the two dumps of show-section-sizes isn't as easy to visually compare the numbers.

Yes, the --show-section-sizes just looks for sections sizes (debug sections: .debug*, _debug*, _zdebug*, _gdb* etc.). There should be an option for comparing two object files, I think there is a TODO for that. :)

The DW_AT_start_scope might be interesting when calculating location coverage stats (and I guess that is what @dblaikie has thought) with llvm-dwarfdump --statistics or llvm-locstats (these create the location coverage buckets).

[SouraVX]

Sorry for the confusion/churn. This is the resultant DWARF(for the variable of interest) for this test case.

0x0000007a:       DW_TAG_variable
                    **DW_AT_location      (0x00000000:
                       [0x0000000000401178, 0x00000000004011c1): DW_OP_breg6 RBP-24)** // This is what causing increased in location list(even at "-O0 -g")
                    DW_AT_name  ("Local")
                    DW_AT_decl_file     ("/Scope.c")
                    DW_AT_decl_line     (7)
                    DW_AT_type  (0x0000008f "int")
                    DW_AT_start_scope   (0x00000017)

[dblaikie]

In D85018#2195562, @djtodoro wrote:

The DW_AT_start_scope might be interesting when calculating location coverage stats (and I guess that is what @dblaikie has thought) with llvm-dwarfdump --statistics or llvm-locstats (these create the location coverage buckets).

Right. More follow-up/after this work than anything.

In D85018#2196802, @SouraVX wrote:

Sorry for the confusion/churn. This is the resultant DWARF(for the variable of interest) for this test case.

0x0000007a:       DW_TAG_variable
                    **DW_AT_location      (0x00000000:
                       [0x0000000000401178, 0x00000000004011c1): DW_OP_breg6 RBP-24)** // This is what causing increased in location list(even at "-O0 -g")
                    DW_AT_name  ("Local")
                    DW_AT_decl_file     ("/Scope.c")
                    DW_AT_decl_line     (7)
                    DW_AT_type  (0x0000008f "int")
                    DW_AT_start_scope   (0x00000017)

How does the start scope compare to the location range of the variable, and the scope range of the enclosing scope?

In any case - this seems a bit backwards - one of the benefits of start_scope is that we should be able to use singular variable locations in more places because the scope will already be appropriately truncated by the start_scope value.

Also, general question: Why are you implementing this feature? Do you have a debugger that can/will consume this? I hesitate to add features (especially ones with a lot of surface area/additional complexity) that don't have a consumer/customer use case readily available.

Also - the spec describes start_scope as being able to contain a range list - for cases where the scope of the variable name is discontiguous. This seems relevant/useful/necessary as well (& would further help reduce the need for location lists on variables if the variable is live for its actual scope - though overall I've more concerns about the scope_start feature creating more expensive IR and DWARF than saving us anything, just that maybe the costs can be mitigated somewhat) & if the feature is important, maybe should be implemented more generally to handle discontiguous scopes.

[SouraVX]

How does the start scope compare to the location range of the variable, and the scope range of the enclosing scope?

DW_AT_start_scope value in contiguous scope case is offset from start of the Lex Block(i.e low_pc of enclosing scope).

In any case - this seems a bit backwards - one of the benefits of start_scope is that we should be able to use singular variable locations in more places because the scope will already be appropriately truncated by the start_scope value.

Indeed, that's the primary problem we want to overcome.

Also, general question: Why are you implementing this feature? Do you have a debugger that can/will consume this? I hesitate to add features (especially ones with a lot of surface area/additional complexity) that don't have a consumer/customer use case readily available.

The problem is real, reported here also https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93844, here pointer is also involved(try with clang). We have a downstream GDB that solves these sort of problems with the help of DW_AT_start_scope. Again up-streaming that is also chicken-egg problem, since no producer(that I'm aware) of produces DW_AT_start_scope. And yes (In our downstream GDB) location-list is not needed, start_scope is just enough to show the variable value correctly)

Also - the spec describes start_scope as being able to contain a range list - for cases where the scope of the variable name is discontiguous. This seems relevant/useful/necessary as well (& would further help reduce the need for location lists on variables if the variable is live for its actual scope - though overall I've more concerns about the scope_start feature creating more expensive IR and DWARF than saving us anything, just that maybe the costs can be mitigated somewhat) & if the feature is important, maybe should be implemented more generally to handle discontiguous scopes.

I started to handle/tackle contiguous scope case first and generalize subsequently. But overall it seems like debug.value based representation and capturing info has landed us here. Introducing a new intrinsic(dedicated) *MAY* help to solve the problem, but that will also cost a lot. I'm still looking/exploring the best way to do this.

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

we can avoid creating .debug_loc list by introducing new DbgEntity, e.g. called DbgScopedVariable which is handled in a special way (by always creating a single location for it)? Or to set isSafeForSingleLocation (from DwarfDebug::buildLocationList) to true if ScopeBeginSym != nullptr?

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

Thank you for your inputs!, I think I've been to this route(or not). Let me give it one more shot.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

Not sure introducing a new kind of DbgEntity is going to be the right general solution - I'd think the right general solution could only be achieved by introducing a new kind of scope - and having every variable in its own DIVariableScope (like DILexicalScope/DiLexicalScopeFile) - with the slight problem that DIVariableScopes can overlap... which would be problematic, since then a location could be in more than one scope.

I guess they could all nest, because C++/scoped languages do create explicitly nested scopes, almost... I think there are some quirks around variables declared in conditionals, but might work out OK?

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

I agree that this would address this issue locally and may be just a mask/workaround for this implementation.
That is neat idea, and I think we should try to generalize it that way. A "disadvantage" may be the fact we'd need to carry that metadata throughout pipeline (IR && MIR).

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

I agree that this would address this issue locally and may be just a mask/workaround for this implementation.

The first "this" here is referring to your DbgEntity suggestion?

That is neat idea, and I think we should try to generalize it that way. A "disadvantage" may be the fact we'd need to carry that metadata throughout pipeline (IR && MIR).

Yeah, I don't think it's cheap (Either to implement, or in terms of metadata overhead) to implement - which is one of the reasons I'm fairly hesitant about the feature in general. But I do think if it's going to be implemented, I'm not sure there's really an "incremental" approach that improves the fidelity of scope_start in steps starting from this patch - I think we do have to look at what it'd take to have fairly full fidelity - and I know of no other way than having DI scopes for each variable - and I think even then I'm worried that there are some cases where they're not strictly nested inside each other, which would be extra difficult to represent.

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1817–1818

I agree that this would address this issue locally and may be just a mask/workaround for this implementation.

The first "this" here is referring to your DbgEntity suggestion?

Yes, sorry for the confusion.

That is neat idea, and I think we should try to generalize it that way. A "disadvantage" may be the fact we'd need to carry that metadata throughout pipeline (IR && MIR).

Yeah, I don't think it's cheap (Either to implement, or in terms of metadata overhead) to implement - which is one of the reasons I'm fairly hesitant about the feature in general. But I do think if it's going to be implemented, I'm not sure there's really an "incremental" approach that improves the fidelity of scope_start in steps starting from this patch - I think we do have to look at what it'd take to have fairly full fidelity - and I know of no other way than having DI scopes for each variable - and I think even then I'm worried that there are some cases where they're not strictly nested inside each other, which would be extra difficult to represent.

[SouraVX]

code is pretty stale here, primary problem still persists. Abandoning for now.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 #include "llvm/MC/MachineLocation.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <iterator>
 #include <string>
 #include <utility>
 
+#define DEBUG_TYPE "dwarfdebug"
+
 using namespace llvm;
 
 static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) {
 
   //  According to DWARF Debugging Information Format Version 5,
   //  3.1.2 Skeleton Compilation Unit Entries:
   //  "When generating a split DWARF object file (see Section 7.3.2
   //  on page 187), the compilation unit in the .debug_info section
void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
   auto *Die = Entity->getDIE();
   /// Label may be used to generate DW_AT_low_pc, so put it outside
   /// if/else block.
   const DbgLabel *Label = nullptr;
   if (AbsEntity && AbsEntity->getDIE()) {
     addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE());
     Label = dyn_cast<const DbgLabel>(Entity);
   } else {
-    if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity))
+    if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity)) {
       applyVariableAttributes(*Var, *Die);
-    else if ((Label = dyn_cast<const DbgLabel>(Entity)))
+      // Check if this is a scoped variable, if so try creating/inserting
+      // DW_AT_start_scope.
+      if (dyn_cast_or_null<const DILexicalBlock>(
+              Var->getVariable()->getScope()))
+        if (Var->getVarSymbol() && Var->getScopeBeginSymbol()) {
+          addLabelDelta(*Die, dwarf::DW_AT_start_scope, Var->getVarSymbol(),
+                        Var->getScopeBeginSymbol());
+          LLVM_DEBUG(dbgs() << "Inserted DW_AT_start_scope in variable : "
+                            << Var->getName() << "\n";);
+        }
+    } else if ((Label = dyn_cast<const DbgLabel>(Entity)))
       applyLabelAttributes(*Label, *Die);
     else
       llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.");
   }
 
   if (Label)
     if (const auto *Sym = Label->getSymbol())
       addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

 /// indices.
 ///
 /// Variables can be created from \c DBG_VALUE instructions.  Those whose
 /// location changes over time use \a DebugLocListIndex, while those with a
 /// single location use \a ValueLoc and (optionally) a single entry of \a Expr.
 ///
 /// Variables that have been optimized out use none of these fields.
 class DbgVariable : public DbgEntity {
+  /// Symbol associated with the variable or a label.
+  const MCSymbol *Sym;
+  /// Symbol assoicated with the enclosing scope of the scoped variable.
+  const MCSymbol *ScopeBeginSym;
   /// Offset in DebugLocs.
   unsigned DebugLocListIndex = ~0u;
   /// DW_OP_LLVM_tag_offset value from DebugLocs.
   Optional<uint8_t> DebugLocListTagOffset;
 
   /// Single value location description.
   std::unique_ptr<DbgValueLoc> ValueLoc = nullptr;
 
   struct FrameIndexExpr {
     int FI;
     const DIExpression *Expr;
   };
   mutable SmallVector<FrameIndexExpr, 1>
       FrameIndexExprs; /// Frame index + expression.
 
 public:
   /// Construct a DbgVariable.
   ///
   /// Creates a variable without any DW_AT_location.  Call \a initializeMMI()
   /// for MMI entries, or \a initializeDbgValue() for DBG_VALUE instructions.
-  DbgVariable(const DILocalVariable *V, const DILocation *IA)
-      : DbgEntity(V, IA, DbgVariableKind) {}
+  DbgVariable(const DILocalVariable *V, const DILocation *IA,
+              const MCSymbol *Sym = nullptr,
+              const MCSymbol *ScopeBeginSym = nullptr)
+      : DbgEntity(V, IA, DbgVariableKind), Sym(Sym),
+        ScopeBeginSym(ScopeBeginSym) {}
 
   /// Initialize from the MMI table.
   void initializeMMI(const DIExpression *E, int FI) {
     assert(FrameIndexExprs.empty() && "Already initialized?");
     assert(!ValueLoc.get() && "Already initialized?");
 
     assert((!E || E->isValid()) && "Expected valid expression");
     assert(FI != std::numeric_limits<int>::max() && "Expected valid index");
public:
   void setDebugLocListTagOffset(uint8_t O) { DebugLocListTagOffset = O; }
   Optional<uint8_t> getDebugLocListTagOffset() const { return DebugLocListTagOffset; }
   StringRef getName() const { return getVariable()->getName(); }
   const DbgValueLoc *getValueLoc() const { return ValueLoc.get(); }
   /// Get the FI entries, sorted by fragment offset.
   ArrayRef<FrameIndexExpr> getFrameIndexExprs() const;
   bool hasFrameIndexExprs() const { return !FrameIndexExprs.empty(); }
   void addMMIEntry(const DbgVariable &V);
+  const MCSymbol *getVarSymbol() const { return Sym; }
+  const MCSymbol *getScopeBeginSymbol() const { return ScopeBeginSym; }
 
   // Translate tag to proper Dwarf tag.
   dwarf::Tag getTag() const {
     // FIXME: Why don't we just infer this tag and store it all along?
     if (getVariable()->isParameter())
       return dwarf::DW_TAG_formal_parameter;
 
     return dwarf::DW_TAG_variable;
class DwarfDebug : public DebugHandlerBase {
 
   void ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
                                      const DINode *Node,
                                      const MDNode *Scope);
   void ensureAbstractEntityIsCreatedIfScoped(DwarfCompileUnit &CU,
                                              const DINode *Node,
                                              const MDNode *Scope);
 
-  DbgEntity *createConcreteEntity(DwarfCompileUnit &TheCU,
-                                  LexicalScope &Scope,
+  DbgEntity *createConcreteEntity(DwarfCompileUnit &TheCU, LexicalScope &Scope,
                                   const DINode *Node,
                                   const DILocation *Location,
-                                  const MCSymbol *Sym = nullptr);
+                                  const MCSymbol *Sym = nullptr,
+                                  const MCSymbol *ScopeBeginSym = nullptr);
 
   /// Construct a DIE for this abstract scope.
   void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
 
   /// Construct a DIE for the subprogram definition \p SP and return it.
   DIE &constructSubprogramDefinitionDIE(const DISubprogram *SP);
 
   /// Construct DIEs for call site entries describing the calls in \p MF.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (VeryLargeBlocks.count(StartDebugMI->getParent()))
     return false;
   return validThroughout(LScopes, StartDebugMI, EndMI);
 }
 
 DbgEntity *DwarfDebug::createConcreteEntity(DwarfCompileUnit &TheCU,
                                             LexicalScope &Scope,
                                             const DINode *Node,
                                             const DILocation *Location,
-                                            const MCSymbol *Sym) {
+                                            const MCSymbol *Sym,
+                                            const MCSymbol *ScopeBeginSym) {
   ensureAbstractEntityIsCreatedIfScoped(TheCU, Node, Scope.getScopeNode());
   if (isa<const DILocalVariable>(Node)) {
-    ConcreteEntities.push_back(
-        std::make_unique<DbgVariable>(cast<const DILocalVariable>(Node),
-                                       Location));
+    ConcreteEntities.push_back(std::make_unique<DbgVariable>(
+        cast<const DILocalVariable>(Node), Location, Sym, ScopeBeginSym));
     InfoHolder.addScopeVariable(&Scope,
         cast<DbgVariable>(ConcreteEntities.back().get()));
   } else if (isa<const DILabel>(Node)) {
     ConcreteEntities.push_back(
         std::make_unique<DbgLabel>(cast<const DILabel>(Node),
                                     Location, Sym));
     InfoHolder.addScopeLabel(&Scope,
         cast<DbgLabel>(ConcreteEntities.back().get()));
if (const DILocation *IA = IV.second)
       Scope = LScopes.findInlinedScope(LocalVar->getScope(), IA);
     else
       Scope = LScopes.findLexicalScope(LocalVar->getScope());
     // If variable scope is not found then skip this variable.
     if (!Scope)
       continue;
 
     Processed.insert(IV);
-    DbgVariable *RegVar = cast<DbgVariable>(createConcreteEntity(TheCU,
-                                            *Scope, LocalVar, IV.second));
 
     const MachineInstr *MInsn = HistoryMapEntries.front().getInstr();
     assert(MInsn->isDebugValue() && "History must begin with debug value");
 
+    DbgVariable *RegVar = nullptr;
+    // For scoped variables, codegen has emitted DBG_VALUE instructions.
+    // let's use DBG_VALUE and associated info to create/intialize `Sym`
+    // and `ScopeBeginSym` symbols, these symbols will be utilized later
+    // while synthesizing `DW_AT_start_scope` for this scoped variable.
+    if (dyn_cast_or_null<const DILexicalBlock>(LocalVar->getScope())) {
+      MCSymbol *ScopeBeginSym = nullptr;
+      for (const InsnRange &R : Scope->getRanges())
+        ScopeBeginSym = getLabelBeforeInsn(R.first);
+      // FIXME: This causes loclist emission even at `-O0` is there way
+      // we can avoid this ?
+      RegVar = cast<DbgVariable>(
+          createConcreteEntity(TheCU, *Scope, LocalVar, IV.second,
+                               getLabelBeforeInsn(MInsn), ScopeBeginSym));
+    } else
+      RegVar = cast<DbgVariable>(
+          createConcreteEntity(TheCU, *Scope, LocalVar, IV.second));
+
     // Check if there is a single DBG_VALUE, valid throughout the var's scope.
     // If the history map contains a single debug value, there may be an
     // additional entry which clobbers the debug value.
     size_t HistSize = HistoryMapEntries.size();
     bool SingleValueWithClobber =
         HistSize == 2 && HistoryMapEntries[1].isClobber();
     if (HistSize == 1 || SingleValueWithClobber) {
       const auto *End =

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

case Intrinsic::dbg_declare: {
     }
 
     const Value *Address = DI->getAddress();
     if (!Address || isa<UndefValue>(Address)) {
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI
                         << " (bad/undef address)\n");
       return true;
     }
+    // Create FI based DBG_VALUE instruction for scoped variable.
+    if (dyn_cast_or_null<const DILexicalBlock>(DI->getVariable()->getScope())) {
+      const Value *Address = DI->getVariableLocation();
+      int FI = std::numeric_limits<int>::max();
+      if (const auto *AI =
+              dyn_cast<AllocaInst>(Address->stripInBoundsConstantOffsets())) {
+        if (AI->isStaticAlloca()) {
+          auto I = FuncInfo.StaticAllocaMap.find(AI);
+          if (I != FuncInfo.StaticAllocaMap.end())
+            FI = I->second;
+          BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
+                  TII.get(TargetOpcode::DBG_VALUE))
+              .addFrameIndex(FI)
+              .addImm(0U)
+              .addMetadata(DI->getVariable())
+              .addMetadata(DI->getExpression());
+          LLVM_DEBUG(dbgs()
+                         << "FastIsel: Created DBG_VALUE for scoped variable: "
+                         << DI->getVariable()->getName()
+                         << " with FrameIndex: " << FI << "\n";);
+          return true;
+        }
+      }
+    }
 
     // Byval arguments with frame indices were already handled after argument
     // lowering and before isel.
     const auto *Arg =
         dyn_cast<Argument>(Address->stripInBoundsConstantOffsets());
     if (Arg && FuncInfo.getArgumentFrameIndex(Arg) != INT_MAX)
       return true;
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::dbg_declare: {
     // llvm.dbg.addr is control dependent and always generates indirect
     // DBG_VALUE instructions. llvm.dbg.declare is handled as a frame index in
     // the MachineFunction variable table.
     if (FI != std::numeric_limits<int>::max()) {
       if (Intrinsic == Intrinsic::dbg_addr) {
         SDDbgValue *SDV = DAG.getFrameIndexDbgValue(
             Variable, Expression, FI, /*IsIndirect*/ true, dl, SDNodeOrder);
         DAG.AddDbgValue(SDV, getRoot().getNode(), isParameter);
-      } else {
+      }
+      // Create SDDbgValue node for scoped variable, this will be translated
+      // later as DBG_VALUE instructions by codegen pipeline.
+      else if (dyn_cast_or_null<const DILexicalBlock>(
+                   DI.getVariable()->getScope())) {
+        SDDbgValue *SDV = DAG.getFrameIndexDbgValue(
+            Variable, Expression, FI, /*IsIndirect*/ true, dl, SDNodeOrder);
+        DAG.AddDbgValue(SDV, getRoot().getNode(), isParameter);
+        LLVM_DEBUG(
+            dbgs()
+                << "SelectionDAG: Created SDDbgValue node for scoped variable: "
+                << DI.getVariable()->getName() << "\n";);
+      } else
         LLVM_DEBUG(dbgs() << "Skipping " << DI
                           << " (variable info stashed in MF side table)\n");
-      }
       return;
     }
 
     SDValue &N = NodeMap[Address];
     if (!N.getNode() && isa<Argument>(Address))
       // Check unused arguments map.
       N = UnusedArgNodeMap[Address];
     SDDbgValue *SDV;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

for (const Instruction &I : BB) {
       APInt Offset(DL.getTypeSizeInBits(Address->getType()), 0);
       Address = Address->stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
 
       // Check if the variable is a static alloca or a byval or inalloca
       // argument passed in memory. If it is not, then we will ignore this
       // intrinsic and handle this during isel like dbg.value.
       int FI = std::numeric_limits<int>::max();
       if (const auto *AI = dyn_cast<AllocaInst>(Address)) {
+
+        // Skip processing of scoped variables, these will be handled later
+        // in pipeline.
+        // Specifically we want to create DBG_VALUE instruction for each
+        // scoped variable, this will enable later pipeline stages  in
+        // synthesizing `DW_AT_start_scope` for this variable.
+        if (dyn_cast_or_null<const DILexicalBlock>(
+                DI->getVariable()->getScope())) {
+          const Value *Address = DI->getVariableLocation();
+          if (!(!Address || isa<UndefValue>(Address) ||
+                (Address->use_empty() && !isa<Argument>(Address)))) {
+            LLVM_DEBUG(dbgs() << "processDbgDeclares skipping " << *DI
+                              << " (scoped variable)\n");
+            continue;
+          }
+        }
         auto SI = FuncInfo.StaticAllocaMap.find(AI);
         if (SI != FuncInfo.StaticAllocaMap.end())
           FI = SI->second;
       } else if (const auto *Arg = dyn_cast<Argument>(Address))
         FI = FuncInfo.getArgumentFrameIndex(Arg);
 
       if (FI == std::numeric_limits<int>::max())
         continue;

llvm/test/DebugInfo/X86/DW_AT_start_scope.ll

+;; This test checks for emission DW_AT_start_scope for a
+;; scoped variable.
+
+; RUN: %llc_dwarf %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
+
+; CHECK; DW_AT_name  ("Local")
+; CHECK: DW_AT_decl_line     (7)
+; CHECK: DW_AT_start_scope (0x{{.*}})
+
+; c source code for this IR
+; int main(int Argc, char **Argv) {
+;         int Local = 6;
+;         printf("%d\n",Local);
+;
+;         {
+;         printf("%d\n",Local);
+;         int Local = 7;
+;         printf("%d\n",Local);
+;         Local = 8;
+;         printf("%d\n",Local);
+;         }
+;
+;         return 0;
+; }
+
+; ModuleID = 'MainScope.c'
+source_filename = "MainScope.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @main(i32 %Argc, i8** %Argv) #0 !dbg !7 {
+entry:
+  %retval = alloca i32, align 4
+  %Argc.addr = alloca i32, align 4
+  %Argv.addr = alloca i8**, align 8
+  %Local = alloca i32, align 4
+  %Local2 = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  store i32 %Argc, i32* %Argc.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %Argc.addr, metadata !14, metadata !DIExpression()), !dbg !15
+  store i8** %Argv, i8*** %Argv.addr, align 8
+  call void @llvm.dbg.declare(metadata i8*** %Argv.addr, metadata !16, metadata !DIExpression()), !dbg !17
+  call void @llvm.dbg.declare(metadata i32* %Local, metadata !18, metadata !DIExpression()), !dbg !19
+  store i32 6, i32* %Local, align 4, !dbg !19
+  %0 = load i32, i32* %Local, align 4, !dbg !20
+  %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %0), !dbg !21
+  %1 = load i32, i32* %Local, align 4, !dbg !22
+  %call1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %1), !dbg !24
+  call void @llvm.dbg.declare(metadata i32* %Local2, metadata !25, metadata !DIExpression()), !dbg !26
+  store i32 7, i32* %Local2, align 4, !dbg !26
+  %2 = load i32, i32* %Local2, align 4, !dbg !27
+  %call3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %2), !dbg !28
+  store i32 8, i32* %Local2, align 4, !dbg !29
+  %3 = load i32, i32* %Local2, align 4, !dbg !30
+  %call4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %3), !dbg !31
+  ret i32 0, !dbg !32
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+declare dso_local i32 @printf(i8*, ...) #2
+
+attributes #0 = { noinline nounwind optnone uwtable }
+attributes #1 = { nounwind readnone speculatable willreturn }
+attributes #2 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0"}
+!7 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10, !11}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64)
+!12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)
+!13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!14 = !DILocalVariable(name: "Argc", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!15 = !DILocation(line: 1, column: 14, scope: !7)
+!16 = !DILocalVariable(name: "Argv", arg: 2, scope: !7, file: !1, line: 1, type: !11)
+!17 = !DILocation(line: 1, column: 27, scope: !7)
+!18 = !DILocalVariable(name: "Local", scope: !7, file: !1, line: 2, type: !10)
+!19 = !DILocation(line: 2, column: 6, scope: !7)
+!20 = !DILocation(line: 3, column: 16, scope: !7)
+!21 = !DILocation(line: 3, column: 2, scope: !7)
+!22 = !DILocation(line: 6, column: 16, scope: !23)
+!23 = distinct !DILexicalBlock(scope: !7, file: !1, line: 5, column: 2)
+!24 = !DILocation(line: 6, column: 2, scope: !23)
+!25 = !DILocalVariable(name: "Local", scope: !23, file: !1, line: 7, type: !10)
+!26 = !DILocation(line: 7, column: 6, scope: !23)
+!27 = !DILocation(line: 8, column: 16, scope: !23)
+!28 = !DILocation(line: 8, column: 2, scope: !23)
+!29 = !DILocation(line: 9, column: 8, scope: !23)
+!30 = !DILocation(line: 10, column: 16, scope: !23)
+!31 = !DILocation(line: 10, column: 2, scope: !23)
+!32 = !DILocation(line: 13, column: 2, scope: !7)

llvm/test/DebugInfo/X86/op_deref.ll

 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj \
 ; RUN:     | llvm-dwarfdump -v -debug-info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF4
 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin < %s -filetype=obj -dwarf-version=3 \
 ; RUN:     | llvm-dwarfdump -v -debug-info - \
 ; RUN:     | FileCheck %s -check-prefix=CHECK -check-prefix=DWARF3
 
 ; DWARF4: DW_AT_location [DW_FORM_sec_offset]                      (0x00000000
 ; DWARF4-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
 
 ; DWARF3: DW_AT_location [DW_FORM_data4]                      (0x00000000
 ; DWARF3-NEXT:  {{.*}}: DW_OP_breg2 RCX+0, DW_OP_deref
 
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name [DW_FORM_strp]  ( .debug_str[0x00000067] = "vla")
+; CHECK: DW_AT_name [DW_FORM_strp]  ( .debug_str[0x00000065] = "vla")
 
 ; Check the DEBUG_VALUE comments for good measure.
 ; RUN: llc -O0 -mtriple=x86_64-apple-darwin %s -o - -filetype=asm | FileCheck %s -check-prefix=ASM-CHECK
 ; vla should have a register-indirect address at one point.
 ; ASM-CHECK: DEBUG_VALUE: vla <- [DW_OP_deref] [$rcx+0]
 ; ASM-CHECK: DW_OP_breg2
 
 ; RUN: llvm-as %s -o - | llvm-dis - | FileCheck %s --check-prefix=PRETTY-PRINT

llvm/test/DebugInfo/dwarfdump-dataLocationExp.ll

 ;; This test checks whether DW_AT_data_location attribute
 ;; accepts DIExpression.
 ; REQUIRES: x86_64-linux
 
 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu %s -filetype=obj -o %t.o
 ; RUN: llvm-dwarfdump  %t.o | FileCheck %s
 
 ;; Test whether DW_AT_data_location is generated.
 ; CHECK-LABEL:  DW_TAG_array_type
 
-; CHECK:        DW_AT_data_location (DW_OP_constu 0x1a85)
+; CHECK:        DW_AT_data_location (DW_OP_constu 0x1a81
 ; CHECK:        DW_TAG_subrange_type
 
 ;; Test case is hand written with the help of below testcase
 ;;------------------------------
 ;;program main
 ;;integer, allocatable :: arr(:)
 ;;allocate(arr(2:20))
-;;arr(2)=99
+;;arr(2)=55
 ;;print *, arr
 ;;end program main
 ;;------------------------------
 
 ; ModuleID = 'fortsubrange.ll'
 source_filename = "fortsubrange.ll"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @MAIN_() !dbg !5 {
 L.entry:
   %.Z0640_333 = alloca i32*, align 8
-  %"arr$sd1_349" = alloca [16 x i64], align 8
-  call void @llvm.dbg.declare(metadata [16 x i64]* %"arr$sd1_349", metadata !8, metadata !DIExpression()), !dbg !14
+  %"arr$sd1_345" = alloca [16 x i64], align 8
+  call void @llvm.dbg.declare(metadata [16 x i64]* %"arr$sd1_345", metadata !8, metadata !DIExpression()), !dbg !14
   call void @llvm.dbg.declare(metadata i32** %.Z0640_333, metadata !15, metadata !DIExpression()), !dbg !14
   ret void, !dbg !17
 }
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!0, !1}
 !llvm.dbg.cu = !{!2}
 
 !0 = !{i32 2, !"Dwarf Version", i32 4}
 !1 = !{i32 2, !"Debug Info Version", i32 3}
-!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4)
-!3 = !DIFile(filename: "fortsubrange.f90", directory: "/dir")
+!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F50 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4)
+!3 = !DIFile(filename: "fortsubrange.f50", directory: "/dir")
 !4 = !{}
 !5 = distinct !DISubprogram(name: "main", scope: !2, file: !3, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !2)
 !6 = !DISubroutineType(cc: DW_CC_program, types: !7)
 !7 = !{null}
-!8 = !DILocalVariable(name: "arr", scope: !9, file: !3, type: !10)
-!9 = !DILexicalBlock(scope: !5, file: !3, line: 1, column: 1)
+!8 = !DILocalVariable(name: "arr", scope: !5, file: !3, type: !10)
 ;; We intend to use DW_OP_push_object_address, since that is not available yet,
 ;; we are using meaning less expression
 ;;!10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !11, size: 32, align: 32, elements: !12, dataLocation: !DIExpression(DW_OP_push_object_address, DW_OP_deref))
-!10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !11, size: 32, align: 32, elements: !12, dataLocation: !DIExpression(DW_OP_constu, 6789))
+!10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !11, size: 32, align: 32, elements: !12, dataLocation: !DIExpression(DW_OP_constu, 6785))
 !11 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !12 = !{!13}
-!13 = !DISubrange(count: 19, lowerBound: 2)
-!14 = !DILocation(line: 0, scope: !9)
-!15 = distinct !DILocalVariable(scope: !9, file: !3, type: !16, flags: DIFlagArtificial)
+!13 = !DISubrange(count: 15, lowerBound: 2)
+!14 = !DILocation(line: 0, scope: !5)
+!15 = distinct !DILocalVariable(scope: !5, file: !3, type: !16, flags: DIFlagArtificial)
 !16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 32, align: 32)
-!17 = !DILocation(line: 6, column: 1, scope: !9)
+!17 = !DILocation(line: 6, column: 1, scope: !5)

llvm/test/DebugInfo/dwarfdump-dataLocationVar.ll

 ; CHECK:  DW_TAG_array_type
 ; CHECK-NEXT:    DW_AT_data_location     ([[LOCDIE]])
 
 ;; Test case is hand written with the help of below testcase
 ;;------------------------------
 ;;program main
 ;;integer, allocatable :: arr(:)
 ;;allocate(arr(2:20))
-;;arr(2)=99
+;;arr(2)=55
 ;;print *, arr
 ;;end program main
 ;;------------------------------
 
 ; ModuleID = 'fortsubrange.ll'
 source_filename = "fortsubrange.ll"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @MAIN_() !dbg !5 {
 L.entry:
   %.Z0640_333 = alloca i32*, align 8
-  %"arr$sd1_349" = alloca [16 x i64], align 8
-  call void @llvm.dbg.declare(metadata [16 x i64]* %"arr$sd1_349", metadata !8, metadata !DIExpression()), !dbg !16
+  %"arr$sd1_345" = alloca [16 x i64], align 8
+  call void @llvm.dbg.declare(metadata [16 x i64]* %"arr$sd1_345", metadata !8, metadata !DIExpression()), !dbg !16
   call void @llvm.dbg.declare(metadata i32** %.Z0640_333, metadata !14, metadata !DIExpression()), !dbg !16
   ret void, !dbg !17
 }
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!0, !1}
 !llvm.dbg.cu = !{!2}
 
 !0 = !{i32 2, !"Dwarf Version", i32 4}
 !1 = !{i32 2, !"Debug Info Version", i32 3}
-!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4)
-!3 = !DIFile(filename: "fortsubrange.f90", directory: "/dir")
+!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F50 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4)
+!3 = !DIFile(filename: "fortsubrange.f50", directory: "/dir")
 !4 = !{}
 !5 = distinct !DISubprogram(name: "main", scope: !2, file: !3, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !2)
 !6 = !DISubroutineType(cc: DW_CC_program, types: !7)
 !7 = !{null}
-!8 = !DILocalVariable(name: "arr", scope: !9, file: !3, type: !10)
-!9 = !DILexicalBlock(scope: !5, file: !3, line: 1, column: 1)
+!8 = !DILocalVariable(name: "arr", scope: !5, file: !3, type: !10)
 !10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !11, size: 32, align: 32, elements: !12, dataLocation: !14)
 !11 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !12 = !{!13}
-!13 = !DISubrange(count: 19, lowerBound: 2)
-!14 = distinct !DILocalVariable(scope: !9, file: !3, type: !15, flags: DIFlagArtificial)
+!13 = !DISubrange(count: 15, lowerBound: 2)
+!14 = distinct !DILocalVariable(scope: !5, file: !3, type: !15, flags: DIFlagArtificial)
 !15 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 32, align: 32)
-!16 = !DILocation(line: 0, scope: !9)
-!17 = !DILocation(line: 6, column: 1, scope: !9)
+!16 = !DILocation(line: 0, scope: !5)
+!17 = !DILocation(line: 6, column: 1, scope: !5)