Issue local statics in correct DWARF lexical scope

[FlameTop]

Summary

Currently all static vars local to a function are issued in the main scope of the function. This change ensures that statics local to a lexical block are issued in the DWARF in the correct lexical block.

For example:

void foo()
{

static int local = 1234;
{
  static  int local = 5678;
}

}

This change detects debug info meta data assigned to a lexical block and defers its issuing to DWARF until we are in the correct lexical block.

There is a matching change to clang to ensure the debug info meta-data is assigned to the lexical block.

A matching test is to be added to the debuginfo-tests repository.

[probinson]

+llvm-commits
See also the Clang change in D42370 and a debuginfo-tests test in D42371.

[probinson]

I'm not seeing where the add/getLocalLexicalDIEs APIs are being used.

include/llvm/IR/DebugInfoMetadata.h

477

Fix typos separately, rather than mixing them in with a functional change.

[vsk]

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

88

Can we allocate fewer DIE pointers inline? The first time a DenseMap grows, it allocates space for 64 entries, so this might get big a bit too quick.

142

Just return an Optional<LocalLexicalDIEs>? As written, I think this creates a distinct 'LocalLexicalDIEs Empty' object in each translation unit that includes the header.

[FlameTop]

Apologies, I had a lot of trouble getting svn setup on my machine. Seems I lost some changes in the original diff. Updated for code to issues the lexical DIEs.

[FlameTop]

In D42369#984155, @probinson wrote:

I'm not seeing where the add/getLocalLexicalDIEs APIs are being used.

Sorry Paul. My svn setup somehow lost some changes. Diff has been updated.

[probinson]

Did you see David's emailed comment?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

347

Looks like createAndAddDIE could become simply
return Parent.addChild(createDIE(Tag, N));
now or as an NFC follow-up, to reduce duplication.

include/llvm/IR/DebugInfoMetadata.h

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/CodeGen/DIE.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <type_traits>

 ///
 /// TODO: Merge with directory/file node (including users).
 /// TODO: Canonicalize paths on creation.
 class DIFile : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
 public:
-  // These values must be explictly set, as they end up in the final object
+  // These values must be explicitly set, as they end up in the final object
   // file.
   enum ChecksumKind {
     CSK_None = 0,
     CSK_MD5 = 1,
     CSK_SHA1 = 2,
     CSK_Last = CSK_SHA1 // Should be last enumeration.
   };
 

lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

class DwarfCompileUnit final : public DwarfUnit {
 
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const MDNode *, std::unique_ptr<DbgVariable>> AbstractVariables;
 
+  // DIEs that are to be issued local to lexical scopes.
+  typedef llvm::SmallVector<DIE *, 8> LocalLexicalDIEs;
+  llvm::DenseMap<const DILexicalBlock *, LocalLexicalDIEs> LocalLexicalDIEsMap;
+
   /// \brief Construct a DIE for the given DbgVariable without initializing the
   /// DbgVariable's DIE reference.
   DIE *constructVariableDIEImpl(const DbgVariable &DV, bool Abstract);
 
   bool isDwoUnit() const override;
 
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
struct GlobalExpr {
     const DIExpression *Expr;
   };
 
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
                                ArrayRef<GlobalExpr> GlobalExprs);
 
+  /// addLocalLexicalDIE - Add DIE(s) to local lexical scope
+  void addLocalLexicalDIE(DIE &Die, const DILexicalBlock *Scope) {
+    LocalLexicalDIEsMap[Scope].push_back(&Die);
+  }
+
+  /// getLocalLexicalDIEs - Return vector of local DIEs for lexical scope
+  const LocalLexicalDIEs& getLocalLexicalDIEs(const DILexicalBlock *Scope) {
+    static const LocalLexicalDIEs Empty;
+    auto Result = LocalLexicalDIEsMap.find(Scope);
+    if (Result != LocalLexicalDIEsMap.end())
+      return Result->second;
+    else
+      return Empty;
+  }
+
   /// addLabelAddress - Add a dwarf label attribute data and value using
   /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
   void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label);
 
   /// addLocalLabelAddress - Add a dwarf label attribute data and value using
   /// DW_FORM_addr only.
   void addLocalLabelAddress(DIE &Die, dwarf::Attribute Attribute,

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);
+  // For Lexical Scope, do not construct context DIE.
+  bool IsLexicalScope = GVContext && isa<DILexicalBlock>(GVContext);
+  DIE *ContextDIE = IsLexicalScope ? nullptr : getOrCreateContextDIE(GVContext);
+  assert(ContextDIE || IsLexicalScope);
+
+  // Create new type and add to map.
+  DIE *VariableDIE = IsLexicalScope ? createDIE(GV->getTag(), GVContext)
+    : &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 the global variable's type is different from the one in the class
     // member type, assume that it's more specific and also emit it.
     if (GTy != DD->resolve(SDMDecl->getBaseType()))
       addType(*VariableDIE, GTy);
   } else {
     DeclContext = GV->getScope();
     // Add name and type.
     addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
     addType(*VariableDIE, GTy);
 
     // Add scoping info.
     if (!GV->isLocalToUnit())
       addFlag(*VariableDIE, dwarf::DW_AT_external);
 
     // Add line number info.
     addSourceLine(*VariableDIE, GV);
+    
+    if (IsLexicalScope) {
+      DILexicalBlock* LS = static_cast<DILexicalBlock*>(GVContext);
+      addLocalLexicalDIE(*VariableDIE, LS);
+    }
   }
 
   if (!GV->isDefinition())
     addFlag(*VariableDIE, dwarf::DW_AT_declaration);
   else
     addGlobalName(GV->getName(), *VariableDIE, DeclContext);
 
   if (uint32_t AlignInBytes = GV->getAlignInBytes())
DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
   }
 
   if (HasNonScopeChildren)
     *HasNonScopeChildren = !Children.empty();
 
   for (LexicalScope *LS : Scope->getChildren())
     constructScopeDIE(LS, Children);
 
+  auto *DS = Scope->getScopeNode();
+  if (isa<DILexicalBlock>(DS)) {
+    auto LS = dyn_cast<DILexicalBlock>(DS);
+    auto DD = getLocalLexicalDIEs(LS);
+    for (DIE* D : DD )
+      Children.push_back(D);
+    if (HasNonScopeChildren)
+      *HasNonScopeChildren = !Children.empty();
+  }
+
   return ObjectPointer;
 }
 
 void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) {
   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
 
   if (Scope) {
     assert(!Scope->getInlinedAt());

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (!CU)
     CU = getUnitDie().getUnit();
   if (!EntryCU)
     EntryCU = getUnitDie().getUnit();
   Die.addValue(DIEValueAllocator, Attribute,
                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
                Entry);
 }
 
+DIE *DwarfUnit::createDIE(unsigned Tag, const DINode *N) {
+  DIE *Die = DIE::get(DIEValueAllocator, (dwarf::Tag)Tag);
+  if (N)
+    insertDIE(N, Die);
+  return Die;
+}
+
 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
   if (N)
     insertDIE(N, &Die);
   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);
 }