Revert "[DwarfDebug] Support emitting function-local declaration for a lexical block"

This reverts commits
* ee69197 (D113741),
* 79d3132 (D114705)

due to lldb and dexter test failures.

Author: chbessonova

lld/test/wasm/debuginfo.test

@@ -44,23 +44,9 @@ CHECK-NEXT:              DW_AT_producer	("clang version 7.0.0 (trunk {{.*}})")
 CHECK-NEXT:              DW_AT_language	(DW_LANG_C99)
 CHECK-NEXT:              DW_AT_name	("hi_foo.c")
 
-CHECK:   DW_TAG_subprogram
-CHECK-NEXT:                DW_AT_low_pc
-CHECK-NEXT:                DW_AT_high_pc
-CHECK-NEXT:                DW_AT_frame_base
-CHECK-NEXT:                DW_AT_name	("foo")
-CHECK-NEXT:                DW_AT_decl_file	("{{.*}}hi_foo.c")
-CHECK-NEXT:                DW_AT_decl_line	(3)
-
-CHECK:     DW_TAG_formal_parameter
-CHECK-NEXT:                  DW_AT_location (DW_OP_WASM_location 0x0 0x0, DW_OP_stack_value)
-CHECK-NEXT:                  DW_AT_name	("p")
-CHECK-NEXT:                  DW_AT_decl_file	("{{.*}}hi_foo.c")
-CHECK-NEXT:                  DW_AT_decl_line	(3)
-
 CHECK:   DW_TAG_variable
 CHECK-NEXT:                DW_AT_name	("y")
-CHECK-NEXT:                DW_AT_type	(0x000000d4 "int[2]")
+CHECK-NEXT:                DW_AT_type	(0x000000ac "int[2]")
 CHECK-NEXT:                DW_AT_external	(true)
 CHECK-NEXT:                DW_AT_decl_file	("{{.*}}hi_foo.c")
 CHECK-NEXT:                DW_AT_decl_line	(1)
@@ -82,9 +68,23 @@ CHECK-NEXT:                DW_AT_encoding	(DW_ATE_unsigned)
 
 CHECK:   DW_TAG_variable
 CHECK-NEXT:                DW_AT_name	("z")
-CHECK-NEXT:                DW_AT_type	(0x000000d4 "int[2]")
+CHECK-NEXT:                DW_AT_type	(0x000000ac "int[2]")
 CHECK-NEXT:                DW_AT_external	(true)
 CHECK-NEXT:                DW_AT_decl_file	("{{.*}}hi_foo.c")
 CHECK-NEXT:                DW_AT_decl_line	(8)
 CHECK-NEXT:                DW_AT_location	(DW_OP_addr 0xffffffff)
 
+CHECK:   DW_TAG_subprogram
+CHECK-NEXT:                DW_AT_low_pc
+CHECK-NEXT:                DW_AT_high_pc
+CHECK-NEXT:                DW_AT_frame_base
+CHECK-NEXT:                DW_AT_name	("foo")
+CHECK-NEXT:                DW_AT_decl_file	("{{.*}}hi_foo.c")
+CHECK-NEXT:                DW_AT_decl_line	(3)
+
+CHECK:     DW_TAG_formal_parameter
+CHECK-NEXT:                  DW_AT_location (DW_OP_WASM_location 0x0 0x0, DW_OP_stack_value)
+CHECK-NEXT:                  DW_AT_name	("p")
+CHECK-NEXT:                  DW_AT_decl_file	("{{.*}}hi_foo.c")
+CHECK-NEXT:                  DW_AT_decl_line	(3)
+

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -551,18 +551,8 @@ void DwarfCompileUnit::constructScopeDIE(LexicalScope *Scope,
   // Emit lexical blocks.
   DIE *ScopeDIE = constructLexicalScopeDIE(Scope);
   assert(ScopeDIE && "Scope DIE should not be null.");
-  ParentScopeDIE.addChild(ScopeDIE);
-
-  // Track abstract and concrete lexical block scopes.
-  if (Scope->isAbstractScope()) {
-    assert(!getAbstractScopeDIEs().count(DS) &&
-           "Abstract DIE for this scope exists!");
-    getAbstractScopeDIEs()[DS] = ScopeDIE;
-  } else if (!Scope->getInlinedAt()) {
-    assert(!LocalScopeDIEs.count(DS) && "Concrete DIE for this scope exists!");
-    LocalScopeDIEs[DS] = ScopeDIE;
-  }
 
+  ParentScopeDIE.addChild(ScopeDIE);
   createAndAddScopeChildren(Scope, *ScopeDIE);
 }
 
@@ -656,7 +646,7 @@ DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
   auto *InlinedSP = getDISubprogram(DS);
   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
   // was inlined from another compile unit.
-  DIE *OriginDIE = getAbstractScopeDIEs()[InlinedSP];
+  DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
 
   auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
@@ -1011,12 +1001,6 @@ DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
   if (Scope) {
     assert(!Scope->getInlinedAt());
     assert(!Scope->isAbstractScope());
-
-    // Remember the subrogram before creating child entities.
-    assert(!LocalScopeDIEs.count(Sub) &&
-           "Concrete DIE for the subprogram exists!");
-    LocalScopeDIEs[Sub] = &ScopeDIE;
-
     // Collect lexical scope children first.
     // ObjectPointer might be a local (non-argument) local variable if it's a
     // block's synthetic this pointer.
@@ -1052,18 +1036,27 @@ DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
   for (DbgVariable *DV : Locals)
     ScopeDIE.addChild(constructVariableDIE(*DV, *Scope, ObjectPointer));
 
+  // Emit imported entities (skipped in gmlt-like data).
+  if (!includeMinimalInlineScopes()) {
+    for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
+      ScopeDIE.addChild(constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
+  }
+
   // Emit labels.
   for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope))
     ScopeDIE.addChild(constructLabelDIE(*DL, *Scope));
 
   // Emit inner lexical scopes.
-  auto needToEmitLexicalScope = [this](LexicalScope *LS) -> bool {
+  auto needToEmitLexicalScope = [this](LexicalScope *LS) {
     if (isa<DISubprogram>(LS->getScopeNode()))
       return true;
     auto Vars = DU->getScopeVariables().lookup(LS);
     if (!Vars.Args.empty() || !Vars.Locals.empty())
       return true;
-    return LocalScopesWithLocalDecls.count(LS->getScopeNode());
+    if (!includeMinimalInlineScopes() &&
+        !ImportedEntities[LS->getScopeNode()].empty())
+      return true;
+    return false;
   };
   for (LexicalScope *LS : Scope->getChildren()) {
     // If the lexical block doesn't have non-scope children, skip
@@ -1079,10 +1072,11 @@ DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
 
 void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
     LexicalScope *Scope) {
+  DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
+  if (AbsDef)
+    return;
 
   auto *SP = cast<DISubprogram>(Scope->getScopeNode());
-  if (auto *SPDie = getAbstractScopeDIEs().lookup(SP))
-    return;
 
   DIE *ContextDIE;
   DwarfCompileUnit *ContextCU = this;
@@ -1106,19 +1100,14 @@ void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
 
   // Passing null as the associated node because the abstract definition
   // shouldn't be found by lookup.
-  DIE &AbsDef = ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram,
-                                           *ContextDIE, nullptr);
-
-  // Store the DIE before creating children.
-  getAbstractScopeDIEs()[SP] = &AbsDef;
-
-  ContextCU->applySubprogramAttributesToDefinition(SP, AbsDef);
-  ContextCU->addSInt(AbsDef, dwarf::DW_AT_inline,
+  AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
+  ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
+  ContextCU->addSInt(*AbsDef, dwarf::DW_AT_inline,
                      DD->getDwarfVersion() <= 4 ? Optional<dwarf::Form>()
                                                 : dwarf::DW_FORM_implicit_const,
                      dwarf::DW_INL_inlined);
-  if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, AbsDef))
-    ContextCU->addDIEEntry(AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
+  if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
+    ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
 }
 
 bool DwarfCompileUnit::useGNUAnalogForDwarf5Feature() const {
@@ -1252,61 +1241,47 @@ void DwarfCompileUnit::constructCallSiteParmEntryDIEs(
   }
 }
 
-DIE *DwarfCompileUnit::createImportedEntityDIE(const DIImportedEntity *IE) {
-  DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)IE->getTag());
-  insertDIE(IE, IMDie);
-
+DIE *DwarfCompileUnit::constructImportedEntityDIE(
+    const DIImportedEntity *Module) {
+  DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
+  insertDIE(Module, IMDie);
   DIE *EntityDie;
-  auto *Entity = IE->getEntity();
+  auto *Entity = Module->getEntity();
   if (auto *NS = dyn_cast<DINamespace>(Entity))
     EntityDie = getOrCreateNameSpace(NS);
   else if (auto *M = dyn_cast<DIModule>(Entity))
     EntityDie = getOrCreateModule(M);
-  else if (auto *SP = dyn_cast<DISubprogram>(Entity)) {
-    // If we have abstract subprogram created, refer it.
-    if (auto *AbsSPDie = getAbstractScopeDIEs().lookup(SP))
-      EntityDie = AbsSPDie;
-    else
-      EntityDie = getOrCreateSubprogramDIE(SP);
-  } else if (auto *T = dyn_cast<DIType>(Entity))
+  else if (auto *SP = dyn_cast<DISubprogram>(Entity))
+    EntityDie = getOrCreateSubprogramDIE(SP);
+  else if (auto *T = dyn_cast<DIType>(Entity))
     EntityDie = getOrCreateTypeDIE(T);
   else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
     EntityDie = getOrCreateGlobalVariableDIE(GV, {});
   else
     EntityDie = getDIE(Entity);
   assert(EntityDie);
-
-  addSourceLine(*IMDie, IE->getLine(), IE->getFile());
+  addSourceLine(*IMDie, Module->getLine(), Module->getFile());
   addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
-  StringRef Name = IE->getName();
+  StringRef Name = Module->getName();
   if (!Name.empty())
     addString(*IMDie, dwarf::DW_AT_name, Name);
 
   // This is for imported module with renamed entities (such as variables and
   // subprograms).
-  DINodeArray Elements = IE->getElements();
+  DINodeArray Elements = Module->getElements();
   for (const auto *Element : Elements) {
     if (!Element)
       continue;
-    IMDie->addChild(createImportedEntityDIE(cast<DIImportedEntity>(Element)));
+    IMDie->addChild(
+        constructImportedEntityDIE(cast<DIImportedEntity>(Element)));
   }
-  return IMDie;
-}
 
-void DwarfCompileUnit::createAndAddImportedEntityDIE(
-    const DIImportedEntity *IE) {
-  DIE *ContextDIE = getOrCreateContextDIE(IE->getScope());
-  assert(ContextDIE &&
-         "Could not get or create scope for the imported entity!");
-  if (!ContextDIE)
-    return;
-
-  ContextDIE->addChild(createImportedEntityDIE(IE));
+  return IMDie;
 }
 
 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
   DIE *D = getDIE(SP);
-  if (DIE *AbsSPDIE = getAbstractScopeDIEs().lookup(SP)) {
+  if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
     if (D)
       // If this subprogram has an abstract definition, reference that
       addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
@@ -1596,38 +1571,3 @@ void DwarfCompileUnit::createBaseTypeDIEs() {
     Btr.Die = &Die;
   }
 }
-
-static DIE *
-findLocalScopeDIE(const DILocalScope *LS,
-                  DenseMap<const DILocalScope *, DIE *> &ScopeDIEs) {
-  DIE *ScopeDIE = ScopeDIEs.lookup(LS);
-  if (isa<DISubprogram>(LS) && !ScopeDIE)
-    return nullptr;
-  if (!ScopeDIE)
-    return findLocalScopeDIE(cast<DILocalScope>(LS->getScope()), ScopeDIEs);
-  return ScopeDIE;
-}
-
-DIE *DwarfCompileUnit::findLocalScopeDIE(const DIScope *S) {
-  auto *LScope = dyn_cast_or_null<DILocalScope>(S);
-  if (!LScope)
-    return nullptr;
-
-  // Check if we have an abstract tree.
-  if (getAbstractScopeDIEs().count(LScope->getSubprogram()))
-    return ::findLocalScopeDIE(LScope, getAbstractScopeDIEs());
-
-  return ::findLocalScopeDIE(LScope, LocalScopeDIEs);
-}
-
-DIE *DwarfCompileUnit::getOrCreateContextDIE(const DIScope *Context) {
-  if (auto *LScope = dyn_cast_or_null<DILocalScope>(Context)) {
-    if (DIE *ScopeDIE = findLocalScopeDIE(LScope))
-      return ScopeDIE;
-
-    // If nothing was found, fall back to DISubprogram and let
-    // DwarfUnit::getOrCreateContextDIE() create a new DIE for it.
-    Context = LScope->getSubprogram();
-  }
-  return DwarfUnit::getOrCreateContextDIE(Context);
-}

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

@@ -62,6 +62,11 @@ class DwarfCompileUnit final : public DwarfUnit {
   /// The start of the unit macro info within macro section.
   MCSymbol *MacroLabelBegin;
 
+  using ImportedEntityList = SmallVector<const MDNode *, 8>;
+  using ImportedEntityMap = DenseMap<const MDNode *, ImportedEntityList>;
+
+  ImportedEntityMap ImportedEntities;
+
   /// GlobalNames - A map of globally visible named entities for this unit.
   StringMap<const DIE *> GlobalNames;
 
@@ -75,14 +80,9 @@ class DwarfCompileUnit final : public DwarfUnit {
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
-  DenseMap<const DILocalScope *, DIE *> LocalScopeDIEs;
-  DenseMap<const DILocalScope *, DIE *> AbstractLocalScopeDIEs;
+  DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
 
-  /// LocalScopesWithLocalDecls - A list of non-empty local scopes
-  /// (with declaraions of static locals, function-local types, or imports).
-  SmallPtrSet<const DILocalScope *, 8> LocalScopesWithLocalDecls;
-
   /// DWO ID for correlating skeleton and split units.
   uint64_t DWOId = 0;
 
@@ -92,10 +92,10 @@ class DwarfCompileUnit final : public DwarfUnit {
 
   bool isDwoUnit() const override;
 
-  DenseMap<const DILocalScope *, DIE *> &getAbstractScopeDIEs() {
+  DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
-      return AbstractLocalScopeDIEs;
-    return DU->getAbstractScopeDIEs();
+      return AbstractSPDies;
+    return DU->getAbstractSPDies();
   }
 
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
@@ -169,6 +169,17 @@ class DwarfCompileUnit final : public DwarfUnit {
 
   unsigned getOrCreateSourceID(const DIFile *File) override;
 
+  void addImportedEntity(const DIImportedEntity* IE) {
+    DIScope *Scope = IE->getScope();
+    assert(Scope && "Invalid Scope encoding!");
+    if (!isa<DILocalScope>(Scope))
+      // No need to add imported enities that are not local declaration.
+      return;
+
+    auto *LocalScope = cast<DILocalScope>(Scope)->getNonLexicalBlockFileScope();
+    ImportedEntities[LocalScope].push_back(IE);
+  }
+
   /// addRange - Add an address range to the list of ranges for this unit.
   void addRange(RangeSpan Range);
 
@@ -210,9 +221,6 @@ class DwarfCompileUnit final : public DwarfUnit {
 
   void createBaseTypeDIEs();
 
-  DIE *findLocalScopeDIE(const DIScope *S);
-  DIE *getOrCreateContextDIE(const DIScope *Ty) override;
-
   /// Construct a DIE for this subprogram scope.
   DIE &constructSubprogramScopeDIE(const DISubprogram *Sub,
                                    LexicalScope *Scope);
@@ -251,9 +259,8 @@ class DwarfCompileUnit final : public DwarfUnit {
   void constructCallSiteParmEntryDIEs(DIE &CallSiteDIE,
                                       SmallVector<DbgCallSiteParam, 4> &Params);
 
-  /// Construct DIE for an imported entity.
-  DIE *createImportedEntityDIE(const DIImportedEntity *IE);
-  void createAndAddImportedEntityDIE(const DIImportedEntity *IE);
+  /// Construct import_module DIE.
+  DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
   void finishEntityDefinition(const DbgEntity *Entity);
@@ -350,10 +357,6 @@ class DwarfCompileUnit final : public DwarfUnit {
   bool hasDwarfPubSections() const;
 
   void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
-
-  void recordLocalScopeWithDecls(const DILocalScope *S) {
-    LocalScopesWithLocalDecls.insert(S);
-  }
 };
 
 } // end namespace llvm