[llvm] [DwarfDebug] Associate subprogram DIEs with their Functions (PR #162852)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Oct 10 07:21:40 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-debuginfo
Author: Vladislav Dzhidzhoev (dzhidzhoev)
<details>
<summary>Changes</summary>
Depends on:
* https://github.com/llvm/llvm-project/pull/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).
---
Patch is 27.12 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/162852.diff
7 Files Affected:
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp (+10-5)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h (+9-17)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp (+9-6)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h (+2-1)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfFile.h (+143-33)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp (+45-34)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h (+19-2)
``````````diff
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
index 518121e200190..ba8daf7662319 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
@@ -178,7 +178,7 @@ unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
// Check for pre-existence.
- if (DIE *Die = getDIE(GV))
+ if (DIE *Die = getDIEs(GV).getVariableDIE(GV))
return Die;
assert(GV);
@@ -795,7 +795,9 @@ DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
auto *VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
- insertDIE(DV.getVariable(), VariableDie);
+ getDIEs(DV.getVariable())
+ .getLVs()
+ .insertDIE(DV.getVariable(), &DV, VariableDie, Abstract);
DV.setDIE(*VariableDie);
// Abstract variables don't get common attributes later, so apply them now.
if (Abstract) {
@@ -1010,7 +1012,9 @@ DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
const LexicalScope &Scope) {
auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
- insertDIE(DL.getLabel(), LabelDie);
+ getDIEs(DL.getLabel())
+ .getLabels()
+ .insertDIE(DL.getLabel(), &DL, LabelDie, Scope.isAbstractScope());
DL.setDIE(*LabelDie);
if (Scope.isAbstractScope())
@@ -1472,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
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
index a3bbc8364599d..b0dcc3e432a03 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
@@ -79,16 +79,10 @@ class DwarfCompileUnit final : public DwarfUnit {
// List of concrete lexical block scopes belong to subprograms within this CU.
DenseMap<const DILocalScope *, DIE *> LexicalBlockDIEs;
- // List of abstract local scopes (either DISubprogram or DILexicalBlock).
- DenseMap<const DILocalScope *, DIE *> AbstractLocalScopeDIEs;
- SmallPtrSet<const DISubprogram *, 8> FinalizedAbstractSubprograms;
-
// List of inlined lexical block scopes that belong to subprograms within this
// CU.
DenseMap<const DILocalScope *, SmallVector<DIE *, 2>> InlinedLocalScopeDIEs;
- DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
-
/// DWO ID for correlating skeleton and split units.
uint64_t DWOId = 0;
@@ -126,22 +120,20 @@ class DwarfCompileUnit final : public DwarfUnit {
bool isDwoUnit() const override;
- DenseMap<const DILocalScope *, DIE *> &getAbstractScopeDIEs() {
- if (isDwoUnit() && !DD->shareAcrossDWOCUs())
- return AbstractLocalScopeDIEs;
- return DU->getAbstractScopeDIEs();
+ DwarfInfoHolder &getDIEs(const DINode *N) { return DwarfUnit::getDIEs(N); }
+
+ DwarfInfoHolder &getDIEs() { return getDIEs(nullptr); }
+
+ DwarfInfoHolder::AbstractScopeMapT &getAbstractScopeDIEs() {
+ return getDIEs().getLocalScopes().getAbstractDIEs();
}
DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
- if (isDwoUnit() && !DD->shareAcrossDWOCUs())
- return AbstractEntities;
- return DU->getAbstractEntities();
+ return getDIEs().getAbstractEntities();
}
auto &getFinalizedAbstractSubprograms() {
- if (isDwoUnit() && !DD->shareAcrossDWOCUs())
- return FinalizedAbstractSubprograms;
- return DU->getFinalizedAbstractSubprograms();
+ return getDIEs().getFinalizedAbstractSubprograms();
}
void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
@@ -327,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();
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
index d751a7f9f01ef..5aa8b932facdc 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
@@ -502,7 +502,8 @@ void DwarfDebug::addSubprogramNames(
// well into the name table. Only do that if we are going to actually emit
// that name.
if (LinkageName != "" && SP->getName() != LinkageName &&
- (useAllLinkageNames() || InfoHolder.getAbstractScopeDIEs().lookup(SP)))
+ (useAllLinkageNames() ||
+ 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
@@ -1263,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);
+ });
}
}
@@ -2784,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())
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h
index 1a1b28a6fc035..42ac225e2d17e 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h
+++ b/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
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
index ef1524d875c84..94d4e5f0b7f05 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
@@ -15,9 +15,12 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/CodeGen/DIE.h"
+#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/Support/Allocator.h"
+#include <functional>
#include <map>
#include <memory>
+#include <optional>
#include <utility>
namespace llvm {
@@ -26,9 +29,6 @@ class AsmPrinter;
class DbgEntity;
class DbgVariable;
class DbgLabel;
-class DINode;
-class DILocalScope;
-class DISubprogram;
class DwarfCompileUnit;
class DwarfUnit;
class LexicalScope;
@@ -53,6 +53,144 @@ struct RangeSpanList {
SmallVector<RangeSpan, 2> Ranges;
};
+/// Tracks abstract and concrete DIEs for debug info entities of a certain type.
+template <typename DINodeT, typename DbgEntityT> class DINodeInfoHolder {
+public:
+ using AbstractMapT = DenseMap<const DINodeT *, DIE *>;
+ using ConcreteMapT =
+ DenseMap<const DINodeT *, SmallDenseMap<const DbgEntityT *, DIE *, 2>>;
+
+private:
+ AbstractMapT AbstractMap;
+ ConcreteMapT ConcreteMap;
+
+public:
+ void insertAbstractDIE(const DINodeT *N, DIE *D) {
+ auto [_, Inserted] = AbstractMap.try_emplace(N, D);
+ assert(Inserted && "Duplicate abstract DIE for debug info node");
+ }
+
+ void insertConcreteDIE(const DINodeT *N, const DbgEntityT *E, DIE *D) {
+ auto [_, Inserted] = ConcreteMap[N].try_emplace(E, D);
+ assert(Inserted && "Duplicate concrete DIE for debug info node");
+ }
+
+ void insertDIE(const DINodeT *N, const DbgEntityT *E, DIE *D, bool Abstract) {
+ if (Abstract)
+ insertAbstractDIE(N, D);
+ else
+ insertConcreteDIE(N, E, D);
+ }
+
+ DIE *getAbstractDIE(const DINodeT *N) const { return AbstractMap.lookup(N); }
+
+ std::optional<
+ std::reference_wrapper<const typename ConcreteMapT::mapped_type>>
+ getConcreteDIEs(const DINodeT *N) const {
+ if (auto I = ConcreteMap.find(N); I != ConcreteMap.end())
+ return std::make_optional(std::ref(I->second));
+ return std::nullopt;
+ }
+
+ DIE *getConcreteDIE(const DINodeT *N, const DbgEntityT *E) const {
+ if (auto I = getConcreteDIEs(N))
+ return I->get().lookup(E);
+ return nullptr;
+ }
+
+ DIE *getAnyConcreteDIE(const DINodeT *N) const {
+ if (auto I = getConcreteDIEs(N))
+ return I->get().empty() ? nullptr : I->get().begin()->second;
+ return nullptr;
+ }
+
+ /// Returns abstract DIE for the entity.
+ /// If no abstract DIE was created, returns any concrete DIE for the entity.
+ DIE *getDIE(const DINodeT *N) const {
+ if (DIE *D = getAbstractDIE(N))
+ return D;
+
+ return getAnyConcreteDIE(N);
+ }
+
+ AbstractMapT &getAbstractDIEs() { return AbstractMap; }
+};
+
+/// Tracks DIEs for debug info entites.
+/// These DIEs can be shared across CUs, that is why we keep the map here
+/// instead of in DwarfCompileUnit.
+class DwarfInfoHolder {
+public:
+ using LocalScopeHolderT = DINodeInfoHolder<DILocalScope, Function>;
+ using AbstractScopeMapT = LocalScopeHolderT::AbstractMapT;
+
+private:
+ /// DIEs of local DbgVariables.
+ DINodeInfoHolder<DILocalVariable, DbgVariable> LVHolder;
+ /// DIEs of labels.
+ DINodeInfoHolder<DILabel, DbgLabel> LabelHolder;
+ DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
+ /// DIEs of abstract local scopes and concrete non-inlined subprograms.
+ /// Inlined subprograms and concrete lexical blocks are not stored here.
+ LocalScopeHolderT LSHolder;
+ /// Keeps track of abstract subprograms to populate them only once.
+ // FIXME: merge creation and population of abstract scopes.
+ SmallPtrSet<const DISubprogram *, 8> FinalizedAbstractSubprograms;
+
+ /// Other DINodes with the corresponding DIEs.
+ DenseMap<const DINode *, DIE *> MDNodeToDieMap;
+
+public:
+ void insertDIE(const DINode *N, DIE *Die) {
+ assert((!isa<DILabel>(N) && !isa<DILocalVariable>(N) &&
+ !isa<DILocalScope>(N)) &&
+ "Use getLabels().insertDIE() for labels or getLVs().insertDIE() for "
+ "local variables, or getSubprogram().insertDIE() for subprograms.");
+ auto [_, Inserted] = MDNodeToDieMap.try_emplace(N, Die);
+ 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) &&
+ !isa<DILocalScope>(N))) &&
+ "Use getLabels().getDIE() for labels or getLVs().getDIE() for "
+ "local variables, or getLocalScopes().getDIE() for local scopes.");
+ return D;
+ }
+
+ auto &getLVs() { return LVHolder; }
+ auto &getLVs() const { return LVHolder; }
+
+ auto &getLabels() { return LabelHolder; }
+ auto &getLabels() const { return LabelHolder; }
+
+ auto &getLocalScopes() { return LSHolder; }
+ auto &getLocalScopes() const { return LSHolder; }
+
+ /// For a global variable, returns DIE of the variable.
+ ///
+ /// For a local variable, returns abstract DIE of the variable.
+ /// If no abstract DIE was created, returns any concrete DIE of the variable.
+ DIE *getVariableDIE(const DIVariable *V) const {
+ if (auto *LV = dyn_cast<DILocalVariable>(V))
+ if (DIE *D = getLVs().getDIE(LV))
+ return D;
+ return getDIE(V);
+ }
+
+ DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
+ return AbstractEntities;
+ }
+
+ auto &getFinalizedAbstractSubprograms() {
+ return FinalizedAbstractSubprograms;
+ }
+};
+
class DwarfFile {
// Target of Dwarf emission, used for sizing of abbreviations.
AsmPrinter *Asm;
@@ -93,17 +231,7 @@ class DwarfFile {
using LabelList = SmallVector<DbgLabel *, 4>;
DenseMap<LexicalScope *, LabelList> ScopeLabels;
- // Collection of abstract subprogram DIEs.
- DenseMap<const DILocalScope *, DIE *> AbstractLocalScopeDIEs;
- DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
- /// Keeps track of abstract subprograms to populate them only once.
- // FIXME: merge creation and population of abstract scopes.
- SmallPtrSet<const DISubprogram *, 8> FinalizedAbstractSubprograms;
-
- /// 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;
+ DwarfInfoHolder InfoHolder;
public:
DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
@@ -171,25 +299,7 @@ class DwarfFile {
return ScopeLabels;
}
- DenseMap<const DILocalScope *, DIE *> &getAbstractScopeDIEs() {
- return AbstractLocalScopeDIEs;
- }
-
- DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
- return AbstractEntities;
- }
-
- auto &getFinalizedAbstractSubprograms() {
- return FinalizedAbstractSubprograms;
- }
-
- void insertDIE(const MDNode *TypeMD, DIE *Die) {
- DITypeNodeToDieMap.insert(std::make_pair(TypeMD, Die));
- }
-
- DIE *getDIE(const MDNode *TypeMD) {
- return DITypeNodeToDieMap.lookup(TypeMD);
- }
+ DwarfInfoHolder &getDIEs() { return InfoHolder; }
};
} // end namespace llvm
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index aa078f3f81d49..b0d0fa147b3fc 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -188,28 +188,16 @@ bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
// together.
if (isDwoUnit() && !DD->shareAcrossDWOCUs())
return false;
- return (isa<DIType>(D) ||
- (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
- !DD->generateTypeUnits();
-}
-
-DIE *DwarfUnit::getDIE(const DINode *D) const {
- if (isShareableAcrossCUs(D))
- return DU->getDIE(D);
- return MDNodeToDieMap.lookup(D);
+ return !D || ((isa<DIType>(D) || (isa<DISubprogram>(D) &&
+ !cast<DISubprogram>(D)->isDefinition())) &&
+ !DD->generateTypeUnits());
}
void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
- if (isShareableAcrossCUs(Desc)) {
- DU->insertDIE(Desc, D);
- return;
- }
- MDNodeToDieMap.insert(std::make_pair(Desc, D));
+ getDIEs(Desc).insertDIE(Desc, D);
}
-void DwarfUnit::insertDIE(DIE *D) {
- MDNodeToDieMap.insert(std::make_pair(nullptr, D));
-}
+void DwarfUnit::insertDIE(DIE *D) { InfoHolder.insertDIE(D); }
void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
if (DD->getDwarfVersion() >= 4)
@@ -424,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.
@@ -803,7 +799,7 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIStringType *STy) {
addString(Buffer, dwarf::DW_AT_name, Name);
if (DIVariable *Var = STy->getStringLength()) {
- if (auto *VarDIE = getDIE(Var))
+ if (auto *VarDIE = getDIEs(Var).getVariableDIE(Var))
addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
} else if (DIExpression *Expr = STy->getStringLengthExp()) {
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
@@ -1122,8 +1118,8 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
constructTypeDIE(VariantPart, Composite);
}
} else if (Tag == dwarf::DW_TAG_namelist) {
- auto *Var = dyn_cast<DINode>(Element);
- auto *VarDIE = getDIE(Var);
+ auto *Var = dyn_cast<DIVariable>(Element);
+ auto *VarDIE = getDIEs(Var).getVariableDIE(Var);
if (VarDIE) {
DIE &ItemDie = createAndAddDIE(dwarf::DW_TAG_namelist_item, Buffer);
addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
@@ -1185,7 +1181,7 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
Tag == dwarf::DW_TAG_union_type) {
if (auto *Var = dyn_cast_or_null<DIVariable>(CTy->getRawSizeInBits())) {
- if (auto *VarDIE = getDIE(Var))
+ if (auto *VarDIE = getDIEs(Var).getVariableDIE(Var))
addDIEEntry(Buffer, dwarf::DW_AT_bit_size, *VarDIE);
} else if (auto *Exp =
dyn_cast_or_null<DIExpression>(CTy->getRawSizeInBits())) {
@@ -1340,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
@@ -1348,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()) {
@@ -1360,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.
@@ -1392,7 +1401,8 @@ bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
if (DefinitionArgs[0] != nullptr && DeclArgs[0] != DefinitionArgs[0])
addType(SPDie, Definiti...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/162852
More information about the llvm-commits
mailing list