[DwarfDebug] Associate subprogram DIEs with their Functions

Depends on:
* llvm#152680

With this change, DINodeInfoHolder is used to store abstract
and concrete out-of-line subprogram DIEs in DwarfInfoHolder.

Every definition subprogram DIE is associated with a corresponding
llvm::Function (declaration subprograms are associated with nullptr).
When a concrete subprogram DIE is queried via `getOrCreateSubprogramDIE`,
the corresponding llvm::Function should be provided. If none is provided:

* DwarfUnit/DwarfTypeUnit falls back and returns any concrete DIE for
  the given DISubprogram,
* DwarfCompileUnit is expected to return abstract DIE.

This is a step to support attachment of a DISubprogram to multiple
llvm::Functions (and to establish one-to-one-to-many correspondence between
DISubprograms, abstract DIEs and function clones, and, later,
to make the backend use uniquied DISubprograms).

Author: dzhidzhoev

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -1476,8 +1476,9 @@ DIE *DwarfCompileUnit::getOrCreateImportedEntityDIE(
   return IMDie;
 }
 
-void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
-  DIE *D = getDIE(SP);
+void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP,
+                                                  const Function *F) {
+  DIE *D = getDIEs(SP).getLocalScopes().getConcreteDIE(SP, F);
   if (DIE *AbsSPDIE = getAbstractScopeDIEs().lookup(SP)) {
     if (D)
       // If this subprogram has an abstract definition, reference that

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

@@ -124,8 +124,8 @@ class DwarfCompileUnit final : public DwarfUnit {
 
   DwarfInfoHolder &getDIEs() { return getDIEs(nullptr); }
 
-  DenseMap<const DILocalScope *, DIE *> &getAbstractScopeDIEs() {
-    return getDIEs().getAbstractScopeDIEs();
+  DwarfInfoHolder::AbstractScopeMapT &getAbstractScopeDIEs() {
+    return getDIEs().getLocalScopes().getAbstractDIEs();
   }
 
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
@@ -319,7 +319,7 @@ class DwarfCompileUnit final : public DwarfUnit {
   DIE *getOrCreateImportedEntityDIE(const DIImportedEntity *IE);
   DIE *constructImportedEntityDIE(const DIImportedEntity *IE);
 
-  void finishSubprogramDefinition(const DISubprogram *SP);
+  void finishSubprogramDefinition(const DISubprogram *SP, const Function *F);
   void finishEntityDefinition(const DbgEntity *Entity);
   void attachLexicalScopesAbstractOrigins();
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -503,7 +503,7 @@ void DwarfDebug::addSubprogramNames(
   // that name.
   if (LinkageName != "" && SP->getName() != LinkageName &&
       (useAllLinkageNames() ||
-       InfoHolder.getDIEs().getAbstractScopeDIEs().lookup(SP)))
+       InfoHolder.getDIEs().getLocalScopes().getAbstractDIEs().lookup(SP)))
     addAccelName(Unit, NameTableKind, LinkageName, Die);
 
   // If this is an Objective-C selector name add it to the ObjC accelerator
@@ -1264,11 +1264,13 @@ void DwarfDebug::finishEntityDefinitions() {
 }
 
 void DwarfDebug::finishSubprogramDefinitions() {
-  for (const DISubprogram *SP : ProcessedSPNodes) {
+  for (auto SPF : ProcessedSPNodes) {
+    const DISubprogram *SP = SPF.first;
     assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
-    forBothCUs(
-        getOrCreateDwarfCompileUnit(SP->getUnit()),
-        [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
+    forBothCUs(getOrCreateDwarfCompileUnit(SP->getUnit()),
+               [&](DwarfCompileUnit &CU) {
+                 CU.finishSubprogramDefinition(SP, SPF.second);
+               });
   }
 }
 
@@ -2785,7 +2787,7 @@ void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 
-  ProcessedSPNodes.insert(SP);
+  ProcessedSPNodes.insert(std::make_pair(SP, &F));
   DIE &ScopeDIE =
       TheCU.constructSubprogramScopeDIE(SP, F, FnScope, FunctionLineTableLabel);
   if (auto *SkelCU = TheCU.getSkeleton())

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

@@ -373,7 +373,8 @@ class DwarfDebug : public DebugHandlerBase {
 
   /// This is a collection of subprogram MDNodes that are processed to
   /// create DIEs.
-  SmallSetVector<const DISubprogram *, 16> ProcessedSPNodes;
+  SmallSetVector<std::pair<const DISubprogram *, const Function *>, 16>
+      ProcessedSPNodes;
 
   /// Map function-local imported entities to their parent local scope
   /// (either DILexicalBlock or DISubprogram) for a processed function

llvm/lib/CodeGen/AsmPrinter/DwarfFile.h

@@ -119,18 +119,20 @@ class DwarfInfoHolder {
 public:
   using LVMapT = DINodeMap<DILocalVariable, DbgVariable>;
   using LabelMapT = DINodeMap<DILabel, DbgLabel>;
+  using LocalScopeMapT = DINodeMap<DILocalScope, Function>;
   using AbstractEntityMapT =
       DenseMap<const DINode *, std::unique_ptr<DbgEntity>>;
-  using AbstractScopeMapT = DenseMap<const DILocalScope *, DIE *>;
+  using AbstractScopeMapT = LocalScopeMapT::AbstractMapT;
 
 private:
   /// DIEs of local DbgVariables.
   LVMapT LVMap;
   /// DIEs of labels.
   LabelMapT LabelMap;
   AbstractEntityMapT AbstractEntities;
-  // List of abstract local scopes (either DISubprogram or DILexicalBlock).
-  AbstractScopeMapT AbstractLocalScopeDIEs;
+  /// DIEs of abstract local scopes and concrete non-inlined subprograms.
+  /// Inlined subprograms and concrete lexical blocks are not stored here.
+  LocalScopeMapT LSMap;
   /// Keeps track of abstract subprograms to populate them only once.
   // FIXME: merge creation and population of abstract scopes.
   SmallPtrSet<const DISubprogram *, 8> FinalizedAbstractSubprograms;
@@ -140,21 +142,23 @@ class DwarfInfoHolder {
 
 public:
   void insertDIE(const DINode *N, DIE *Die) {
-    assert((!isa<DILabel>(N) && !isa<DILocalVariable>(N)) &&
+    assert((!isa<DILabel>(N) && !isa<DILocalVariable>(N) &&
+            !isa<DILocalScope>(N)) &&
            "Use getLabels().insertDIE() for labels or getLVs().insertDIE() for "
-           "local variables");
+           "local variables, or getSubprogram().insertDIE() for subprograms.");
     auto [_, Inserted] = MDNodeToDieMap.try_emplace(N, Die);
-    assert((Inserted || isa<DISubprogram>(N) || isa<DIType>(N)) &&
+    assert((Inserted || isa<DIType>(N)) &&
            "DIE for this DINode has already been added");
   }
 
   void insertDIE(DIE *D) { MDNodeToDieMap.try_emplace(nullptr, D); }
 
   DIE *getDIE(const DINode *N) const {
     DIE *D = MDNodeToDieMap.lookup(N);
-    assert((!D || (!isa<DILabel>(N) && !isa<DILocalVariable>(N))) &&
+    assert((!D || (!isa<DILabel>(N) && !isa<DILocalVariable>(N) &&
+                   !isa<DILocalScope>(N))) &&
            "Use getLabels().getDIE() for labels or getLVs().getDIE() for "
-           "local variables");
+           "local variables, or getLocalScopes().getDIE() for local scopes.");
     return D;
   }
 
@@ -164,6 +168,9 @@ class DwarfInfoHolder {
   LabelMapT &getLabels() { return LabelMap; }
   const LabelMapT &getLabels() const { return LabelMap; }
 
+  LocalScopeMapT &getLocalScopes() { return LSMap; }
+  const LocalScopeMapT &getLocalScopes() const { return LSMap; }
+
   /// For a global variable, returns DIE of the variable.
   ///
   /// For a local variable, returns abstract DIE of the variable.
@@ -175,8 +182,6 @@ class DwarfInfoHolder {
     return getDIE(V);
   }
 
-  AbstractScopeMapT &getAbstractScopeDIEs() { return AbstractLocalScopeDIEs; }
-
   AbstractEntityMapT &getAbstractEntities() { return AbstractEntities; }
 
   auto &getFinalizedAbstractSubprograms() {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

@@ -412,6 +412,14 @@ DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) {
   return Die;
 }
 
+DIE &DwarfUnit::createAndAddSubprogramDIE(DIE &Parent, const DISubprogram *SP,
+                                          const Function *F) {
+  DIE &Die =
+      Parent.addChild(DIE::get(DIEValueAllocator, dwarf::DW_TAG_subprogram));
+  getDIEs(SP).getLocalScopes().insertConcreteDIE(SP, F, &Die);
+  return Die;
+}
+
 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
   Loc->computeSize(Asm->getDwarfFormParams());
   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
@@ -1328,6 +1336,19 @@ DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
   return &MDie;
 }
 
+DIE *DwarfUnit::getExistingSubprogramDIE(const DISubprogram *SP,
+                                         const Function *F) const {
+  if (!F) {
+    if (DIE *SPDie = getDIEs(SP).getLocalScopes().getAnyConcreteDIE(SP))
+      return SPDie;
+  } else {
+    if (DIE *SPDie = getDIEs(SP).getLocalScopes().getConcreteDIE(SP, F))
+      return SPDie;
+  }
+
+  return nullptr;
+}
+
 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP,
                                          const Function *FnHint, bool Minimal) {
   // Construct the context before querying for the existence of the DIE in case
@@ -1336,7 +1357,7 @@ DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP,
   DIE *ContextDIE =
       getOrCreateSubprogramContextDIE(SP, shouldPlaceInUnitDIE(SP, Minimal));
 
-  if (DIE *SPDie = getDIE(SP))
+  if (DIE *SPDie = getExistingSubprogramDIE(SP, FnHint))
     return SPDie;
 
   if (auto *SPDecl = SP->getDeclaration()) {
@@ -1348,13 +1369,13 @@ DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP,
       // FIXME: Should the creation of definition subprogram DIE during
       // the creation of declaration subprogram DIE be allowed?
       // See https://github.com/llvm/llvm-project/pull/154636.
-      if (DIE *SPDie = getDIE(SP))
+      if (DIE *SPDie = getExistingSubprogramDIE(SP, FnHint))
         return SPDie;
     }
   }
 
   // DW_TAG_inlined_subroutine may refer to this DIE.
-  DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
+  DIE &SPDie = createAndAddSubprogramDIE(*ContextDIE, SP, FnHint);
 
   // Stop here and fill this in later, depending on whether or not this
   // subprogram turns out to have inlined instances or not.
@@ -1380,7 +1401,8 @@ bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
         if (DefinitionArgs[0] != nullptr && DeclArgs[0] != DefinitionArgs[0])
           addType(SPDie, DefinitionArgs[0]);
 
-      DeclDie = getDIE(SPDecl);
+      DeclDie =
+          getDIEs(SPDecl).getLocalScopes().getConcreteDIE(SPDecl, nullptr);
       assert(DeclDie && "This DIE should've already been constructed when the "
                         "definition DIE was created in "
                         "getOrCreateSubprogramDIE");
@@ -1405,7 +1427,7 @@ bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
   // Always emit linkage name for abstract subprograms.
   if (DeclLinkageName != LinkageName &&
       (DD->useAllLinkageNames() ||
-       DU->getDIEs().getAbstractScopeDIEs().lookup(SP)))
+       DU->getDIEs().getLocalScopes().getAbstractDIEs().lookup(SP)))
     addLinkageName(SPDie, LinkageName);
 
   if (!DeclDie)

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

@@ -298,6 +298,8 @@ class DwarfUnit : public DIEUnit {
   /// Create a DIE with the given Tag, add the DIE to its parent, and
   /// call insertDIE if MD is not null.
   DIE &createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N = nullptr);
+  DIE &createAndAddSubprogramDIE(DIE &Parent, const DISubprogram *SP,
+                                 const Function *F);
 
   bool useSegmentedStringOffsetsTable() const {
     return DD->useSegmentedStringOffsetsTable();
@@ -399,6 +401,9 @@ class DwarfUnit : public DIEUnit {
   void constructTemplateValueParameterDIE(DIE &Buffer,
                                           const DITemplateValueParameter *TVP);
 
+  DIE *getExistingSubprogramDIE(const DISubprogram *SP,
+                                const Function *FnHint) const;
+
   /// Return the default lower bound for an array.
   ///
   /// If the DWARF version doesn't handle the language, return -1.