[llvm] [RemoveDIs][NFC] Remove dbg intrinsic handling code from AssignmentTrackingAnalysis (PR #144674)
Orlando Cazalet-Hyams via llvm-commits
llvm-commits at lists.llvm.org
Tue Jun 24 04:34:59 PDT 2025
https://github.com/OCHyams updated https://github.com/llvm/llvm-project/pull/144674
>From 5ad00d675502fef4dd6dc0ebc353ac33600848d0 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:30:16 +0100
Subject: [PATCH 01/13] processDbgInstruction
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 25 -------------------
1 file changed, 25 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index ffdf08eec9963..793da977270d0 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1353,7 +1353,6 @@ class AssignmentTrackingLowering {
/// location information).
///@{
void processNonDbgInstruction(Instruction &I, BlockInfo *LiveSet);
- void processDbgInstruction(DbgInfoIntrinsic &I, BlockInfo *LiveSet);
/// Update \p LiveSet after encountering an instruction with a DIAssignID
/// attachment, \p I.
void processTaggedInstruction(Instruction &I, BlockInfo *LiveSet);
@@ -1906,21 +1905,6 @@ template <typename T> static bool hasZeroSizedFragment(T &DbgValue) {
return false;
}
-void AssignmentTrackingLowering::processDbgInstruction(
- DbgInfoIntrinsic &I, AssignmentTrackingLowering::BlockInfo *LiveSet) {
- auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I);
- if (!DVI)
- return;
-
- // Ignore assignments to zero bits of the variable.
- if (hasZeroSizedFragment(*DVI))
- return;
-
- if (auto *DAI = dyn_cast<DbgAssignIntrinsic>(&I))
- processDbgAssign(DAI, LiveSet);
- else if (auto *DVI = dyn_cast<DbgValueInst>(&I))
- processDbgValue(DVI, LiveSet);
-}
void AssignmentTrackingLowering::processDbgVariableRecord(
DbgVariableRecord &DVR, AssignmentTrackingLowering::BlockInfo *LiveSet) {
// Ignore assignments to zero bits of the variable.
@@ -1987,15 +1971,6 @@ void AssignmentTrackingLowering::process(BasicBlock &BB, BlockInfo *LiveSet) {
}
}
ProcessedLeadingDbgRecords = true;
- while (II != EI) {
- auto *Dbg = dyn_cast<DbgInfoIntrinsic>(&*II);
- if (!Dbg)
- break;
- resetInsertionPoint(*II);
- processDbgInstruction(*Dbg, LiveSet);
- assert(LiveSet->isValid());
- ++II;
- }
// II is now a non-debug instruction either with no attached DbgRecords, or
// with attached processed DbgRecords. II has not been processed, and all
// debug instructions or DbgRecords in the frame preceding II have been
>From 26f7b3f62809431826cee2efc15a3f44585fe88b Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:17:54 +0100
Subject: [PATCH 02/13] processDbgValue
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 54 ++++++++-----------
1 file changed, 23 insertions(+), 31 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 793da977270d0..82536107cbf64 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1363,9 +1363,7 @@ class AssignmentTrackingLowering {
BlockInfo *LiveSet);
void processDbgAssign(AssignRecord Assign, BlockInfo *LiveSet);
void processDbgVariableRecord(DbgVariableRecord &DVR, BlockInfo *LiveSet);
- void processDbgValue(
- PointerUnion<DbgValueInst *, DbgVariableRecord *> DbgValueRecord,
- BlockInfo *LiveSet);
+ void processDbgValue(DbgVariableRecord *DbgValue, BlockInfo *LiveSet);
/// Add an assignment to memory for the variable /p Var.
void addMemDef(BlockInfo *LiveSet, VariableID Var, const Assignment &AV);
/// Add an assignment to the variable /p Var.
@@ -1868,35 +1866,29 @@ void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
return ProcessDbgAssignImpl(cast<DbgAssignIntrinsic *>(Assign));
}
-void AssignmentTrackingLowering::processDbgValue(
- PointerUnion<DbgValueInst *, DbgVariableRecord *> DbgValueRecord,
- BlockInfo *LiveSet) {
- auto ProcessDbgValueImpl = [&](auto *DbgValue) {
- // Only other tracking variables that are at some point stack homed.
- // Other variables can be dealt with trivally later.
- if (!VarsWithStackSlot->count(getAggregate(DbgValue)))
- return;
-
- VariableID Var = getVariableID(DebugVariable(DbgValue));
- // We have no ID to create an Assignment with so we mark this assignment as
- // NoneOrPhi. Note that the dbg.value still exists, we just cannot determine
- // the assignment responsible for setting this value.
- // This is fine; dbg.values are essentially interchangable with unlinked
- // dbg.assigns, and some passes such as mem2reg and instcombine add them to
- // PHIs for promoted variables.
- Assignment AV = Assignment::makeNoneOrPhi();
- addDbgDef(LiveSet, Var, AV);
-
- LLVM_DEBUG(dbgs() << "processDbgValue on " << *DbgValue << "\n";);
- LLVM_DEBUG(dbgs() << " LiveLoc " << locStr(getLocKind(LiveSet, Var))
- << " -> Val, dbg.value override");
+void AssignmentTrackingLowering::processDbgValue(DbgVariableRecord *DbgValue,
+ BlockInfo *LiveSet) {
+ // Only other tracking variables that are at some point stack homed.
+ // Other variables can be dealt with trivally later.
+ if (!VarsWithStackSlot->count(getAggregate(DbgValue)))
+ return;
- setLocKind(LiveSet, Var, LocKind::Val);
- emitDbgValue(LocKind::Val, DbgValue, DbgValue);
- };
- if (isa<DbgVariableRecord *>(DbgValueRecord))
- return ProcessDbgValueImpl(cast<DbgVariableRecord *>(DbgValueRecord));
- return ProcessDbgValueImpl(cast<DbgValueInst *>(DbgValueRecord));
+ VariableID Var = getVariableID(DebugVariable(DbgValue));
+ // We have no ID to create an Assignment with so we mark this assignment as
+ // NoneOrPhi. Note that the dbg.value still exists, we just cannot determine
+ // the assignment responsible for setting this value.
+ // This is fine; dbg.values are essentially interchangable with unlinked
+ // dbg.assigns, and some passes such as mem2reg and instcombine add them to
+ // PHIs for promoted variables.
+ Assignment AV = Assignment::makeNoneOrPhi();
+ addDbgDef(LiveSet, Var, AV);
+
+ LLVM_DEBUG(dbgs() << "processDbgValue on " << *DbgValue << "\n";);
+ LLVM_DEBUG(dbgs() << " LiveLoc " << locStr(getLocKind(LiveSet, Var))
+ << " -> Val, dbg.value override");
+
+ setLocKind(LiveSet, Var, LocKind::Val);
+ emitDbgValue(LocKind::Val, DbgValue, DbgValue);
}
template <typename T> static bool hasZeroSizedFragment(T &DbgValue) {
>From 8d75813bbdc4bd09b0070afbebf213799476a343 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:22:14 +0100
Subject: [PATCH 03/13] buildOverlapMapAndRecordDeclares
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 23 +++++--------------
1 file changed, 6 insertions(+), 17 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 82536107cbf64..bd5e46ae9cf86 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -2213,11 +2213,10 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
// we can't determine the fragment overlap.
// We need to add fragments for untagged stores too so that we can correctly
// clobber overlapped fragment locations later.
- SmallVector<DbgDeclareInst *> InstDeclares;
SmallVector<DbgVariableRecord *> DPDeclares;
- auto ProcessDbgRecord = [&](auto *Record, auto &DeclareList) {
+ auto ProcessDbgRecord = [&](DbgVariableRecord *Record) {
if (auto *Declare = DynCastToDbgDeclare(Record)) {
- DeclareList.push_back(Declare);
+ DPDeclares.push_back(Declare);
return;
}
DebugVariable DV = DebugVariable(Record);
@@ -2230,13 +2229,10 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
for (auto &BB : Fn) {
for (auto &I : BB) {
for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
- ProcessDbgRecord(&DVR, DPDeclares);
- if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
- ProcessDbgRecord(DII, InstDeclares);
- } else if (auto Info = getUntaggedStoreAssignmentInfo(
- I, Fn.getDataLayout())) {
+ ProcessDbgRecord(&DVR);
+ if (auto Info = getUntaggedStoreAssignmentInfo(I, Fn.getDataLayout())) {
// Find markers linked to this alloca.
- auto HandleDbgAssignForStore = [&](auto *Assign) {
+ auto HandleDbgAssignForStore = [&](DbgVariableRecord *Assign) {
std::optional<DIExpression::FragmentInfo> FragInfo;
// Skip this assignment if the affected bits are outside of the
@@ -2269,13 +2265,11 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
if (Seen.insert(DV).second)
FragmentMap[DA].push_back(DV);
};
- for (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(Info->Base))
- HandleDbgAssignForStore(DAI);
for (DbgVariableRecord *DVR : at::getDVRAssignmentMarkers(Info->Base))
HandleDbgAssignForStore(DVR);
} else if (auto *AI = getUnknownStore(I, Fn.getDataLayout())) {
// Find markers linked to this alloca.
- auto HandleDbgAssignForUnknownStore = [&](auto *Assign) {
+ auto HandleDbgAssignForUnknownStore = [&](DbgVariableRecord *Assign) {
// Because we can't currently represent the fragment info for this
// store, we treat it as an unusable store to the whole variable.
DebugVariable DV =
@@ -2288,8 +2282,6 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
// Cache this info for later.
UnknownStoreVars[&I].push_back(FnVarLocs->insertVariable(DV));
};
- for (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(AI))
- HandleDbgAssignForUnknownStore(DAI);
for (DbgVariableRecord *DVR : at::getDVRAssignmentMarkers(AI))
HandleDbgAssignForUnknownStore(DVR);
}
@@ -2338,9 +2330,6 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
// Finally, insert the declares afterwards, so the first IDs are all
// partially stack homed vars.
- for (auto *DDI : InstDeclares)
- FnVarLocs->addSingleLocVar(DebugVariable(DDI), DDI->getExpression(),
- DDI->getDebugLoc(), DDI->getWrappedLocation());
for (auto *DVR : DPDeclares)
FnVarLocs->addSingleLocVar(DebugVariable(DVR), DVR->getExpression(),
DVR->getDebugLoc(),
>From 69d753ff44065f712db5c0a6ba73ec1997ff51bd Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:24:43 +0100
Subject: [PATCH 04/13] processTaggedInstruction & findVarsWithStackSlot
---
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp | 10 ++--------
1 file changed, 2 insertions(+), 8 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index bd5e46ae9cf86..376025fe074cd 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1731,17 +1731,16 @@ void AssignmentTrackingLowering::processUntaggedInstruction(
void AssignmentTrackingLowering::processTaggedInstruction(
Instruction &I, AssignmentTrackingLowering::BlockInfo *LiveSet) {
- auto Linked = at::getAssignmentMarkers(&I);
auto LinkedDPAssigns = at::getDVRAssignmentMarkers(&I);
// No dbg.assign intrinsics linked.
// FIXME: All vars that have a stack slot this store modifies that don't have
// a dbg.assign linked to it should probably treat this like an untagged
// store.
- if (Linked.empty() && LinkedDPAssigns.empty())
+ if (LinkedDPAssigns.empty())
return;
LLVM_DEBUG(dbgs() << "processTaggedInstruction on " << I << "\n");
- auto ProcessLinkedAssign = [&](auto *Assign) {
+ auto ProcessLinkedAssign = [&](DbgVariableRecord *Assign) {
VariableID Var = getVariableID(DebugVariable(Assign));
// Something has gone wrong if VarsWithStackSlot doesn't contain a variable
// that is linked to a store.
@@ -1813,8 +1812,6 @@ void AssignmentTrackingLowering::processTaggedInstruction(
} break;
}
};
- for (DbgAssignIntrinsic *DAI : Linked)
- ProcessLinkedAssign(DAI);
for (DbgVariableRecord *DVR : LinkedDPAssigns)
ProcessLinkedAssign(DVR);
}
@@ -2810,9 +2807,6 @@ static DenseSet<DebugAggregate> findVarsWithStackSlot(Function &Fn) {
// DIAssignID might get dropped from an alloca but not stores. In that
// case, we need to consider the variable interesting for NFC behaviour
// with this change. TODO: Consider only looking at allocas.
- for (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(&I)) {
- Result.insert({DAI->getVariable(), DAI->getDebugLoc().getInlinedAt()});
- }
for (DbgVariableRecord *DVR : at::getDVRAssignmentMarkers(&I)) {
Result.insert({DVR->getVariable(), DVR->getDebugLoc().getInlinedAt()});
}
>From 4cf7a011be726192ec163f79d6942c11c3614996 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:27:17 +0100
Subject: [PATCH 05/13] processDbgAssign
---
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 376025fe074cd..284f476a904d2 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1818,7 +1818,7 @@ void AssignmentTrackingLowering::processTaggedInstruction(
void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
BlockInfo *LiveSet) {
- auto ProcessDbgAssignImpl = [&](auto *DbgAssign) {
+ auto ProcessDbgAssignImpl = [&](DbgVariableRecord *DbgAssign) {
// Only bother tracking variables that are at some point stack homed. Other
// variables can be dealt with trivially later.
if (!VarsWithStackSlot->count(getAggregate(DbgAssign)))
@@ -1858,9 +1858,7 @@ void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
emitDbgValue(LocKind::Val, DbgAssign, DbgAssign);
}
};
- if (isa<DbgVariableRecord *>(Assign))
- return ProcessDbgAssignImpl(cast<DbgVariableRecord *>(Assign));
- return ProcessDbgAssignImpl(cast<DbgAssignIntrinsic *>(Assign));
+ ProcessDbgAssignImpl(cast<DbgVariableRecord *>(Assign));
}
void AssignmentTrackingLowering::processDbgValue(DbgVariableRecord *DbgValue,
>From 600ad1125f1261c5fa646975b88f198dd86a5a6d Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:37:31 +0100
Subject: [PATCH 06/13] rmredundant
---
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 284f476a904d2..0624c58ddd7b4 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -2549,10 +2549,8 @@ removeRedundantDbgLocsUsingBackwardScan(const BasicBlock *BB,
// FnVarLocs, because wedges in FnVarLocs may only be separated by debug
// instructions.
for (const Instruction &I : reverse(*BB)) {
- if (!isa<DbgVariableIntrinsic>(I)) {
- // Sequence of consecutive defs ended. Clear map for the next one.
- VariableDefinedBytes.clear();
- }
+ // Sequence of consecutive defs ended. Clear map for the next one.
+ VariableDefinedBytes.clear();
auto HandleLocsForWedge = [&](auto *WedgePosition) {
// Get the location defs that start just before this instruction.
>From 262dc11837ac59be949559e6ba51a30d808089e9 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:45:17 +0100
Subject: [PATCH 07/13] process
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 23 ++++++-------------
1 file changed, 7 insertions(+), 16 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 0624c58ddd7b4..1dcf53f982005 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -328,9 +328,6 @@ getDerefOffsetInBytes(const DIExpression *DIExpr) {
/// A whole (unfragmented) source variable.
using DebugAggregate = std::pair<const DILocalVariable *, const DILocation *>;
-static DebugAggregate getAggregate(const DbgVariableIntrinsic *DII) {
- return DebugAggregate(DII->getVariable(), DII->getDebugLoc().getInlinedAt());
-}
static DebugAggregate getAggregate(const DebugVariable &Var) {
return DebugAggregate(Var.getVariable(), Var.getInlinedAt());
}
@@ -1459,10 +1456,6 @@ static DIAssignID *getIDFromInst(const Instruction &I) {
return cast<DIAssignID>(I.getMetadata(LLVMContext::MD_DIAssignID));
}
-static DIAssignID *getIDFromMarker(const DbgAssignIntrinsic &DAI) {
- return cast<DIAssignID>(DAI.getAssignID());
-}
-
static DIAssignID *getIDFromMarker(const DbgVariableRecord &DVR) {
assert(DVR.isDbgAssign() &&
"Cannot get a DIAssignID from a non-assign DbgVariableRecord!");
@@ -1886,7 +1879,7 @@ void AssignmentTrackingLowering::processDbgValue(DbgVariableRecord *DbgValue,
emitDbgValue(LocKind::Val, DbgValue, DbgValue);
}
-template <typename T> static bool hasZeroSizedFragment(T &DbgValue) {
+static bool hasZeroSizedFragment(DbgVariableRecord &DbgValue) {
if (auto F = DbgValue.getExpression()->getFragmentInfo())
return F->SizeInBits == 0;
return false;
@@ -1935,14 +1928,12 @@ void AssignmentTrackingLowering::process(BasicBlock &BB, BlockInfo *LiveSet) {
// attached DbgRecords, or a non-debug instruction with attached processed
// DbgRecords.
// II has not been processed.
- if (!isa<DbgInfoIntrinsic>(&*II)) {
- if (II->isTerminator())
- break;
- resetInsertionPoint(*II);
- processNonDbgInstruction(*II, LiveSet);
- assert(LiveSet->isValid());
- ++II;
- }
+ if (II->isTerminator())
+ break;
+ resetInsertionPoint(*II);
+ processNonDbgInstruction(*II, LiveSet);
+ assert(LiveSet->isValid());
+ ++II;
}
// II is now either a debug intrinsic, a non-debug instruction with no
// attached DbgRecords, or a non-debug instruction with attached unprocessed
>From e075946aba7c28c6a2585614da90b79179372800 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 10:23:29 +0100
Subject: [PATCH 08/13] emitPromotedVarLocs
---
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 1dcf53f982005..95943f768f467 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -2498,7 +2498,7 @@ bool AssignmentTrackingLowering::emitPromotedVarLocs(
bool InsertedAnyIntrinsics = false;
// Go through every block, translating debug intrinsics for fully promoted
// variables into FnVarLocs location defs. No analysis required for these.
- auto TranslateDbgRecord = [&](auto *Record) {
+ auto TranslateDbgRecord = [&](DbgVariableRecord *Record) {
// Skip variables that haven't been promoted - we've dealt with those
// already.
if (VarsWithStackSlot->contains(getAggregate(Record)))
@@ -2516,9 +2516,6 @@ bool AssignmentTrackingLowering::emitPromotedVarLocs(
for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
if (DVR.isDbgValue() || DVR.isDbgAssign())
TranslateDbgRecord(&DVR);
- auto *DVI = dyn_cast<DbgValueInst>(&I);
- if (DVI)
- TranslateDbgRecord(DVI);
}
}
return InsertedAnyIntrinsics;
>From 2b83ddb98def69086c428ef9616a9bf96e6f4b08 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:54:24 +0100
Subject: [PATCH 09/13] untemplate emitDbgValue
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 25 +++----------------
1 file changed, 4 insertions(+), 21 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 95943f768f467..576509e1e7516 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1124,15 +1124,7 @@ class AssignmentTrackingLowering {
void resetInsertionPoint(Instruction &After);
void resetInsertionPoint(DbgVariableRecord &After);
- // emitDbgValue can be called with:
- // Source=[AssignRecord|DbgValueInst*|DbgAssignIntrinsic*|DbgVariableRecord*]
- // Since AssignRecord can be cast to one of the latter two types, and all
- // other types have a shared interface, we use a template to handle the latter
- // three types, and an explicit overload for AssignRecord that forwards to
- // the template version with the right type.
- void emitDbgValue(LocKind Kind, AssignRecord Source, VarLocInsertPt After);
- template <typename T>
- void emitDbgValue(LocKind Kind, const T Source, VarLocInsertPt After);
+ void emitDbgValue(LocKind Kind, DbgVariableRecord *, VarLocInsertPt After);
static bool mapsAreEqual(const BitVector &Mask, const AssignmentMap &A,
const AssignmentMap &B) {
@@ -1521,16 +1513,7 @@ DbgVariableRecord *CastToDbgAssign(DbgVariableRecord *DVR) {
}
void AssignmentTrackingLowering::emitDbgValue(
- AssignmentTrackingLowering::LocKind Kind,
- AssignmentTrackingLowering::AssignRecord Source, VarLocInsertPt After) {
- if (isa<DbgAssignIntrinsic *>(Source))
- emitDbgValue(Kind, cast<DbgAssignIntrinsic *>(Source), After);
- else
- emitDbgValue(Kind, cast<DbgVariableRecord *>(Source), After);
-}
-template <typename T>
-void AssignmentTrackingLowering::emitDbgValue(
- AssignmentTrackingLowering::LocKind Kind, const T Source,
+ AssignmentTrackingLowering::LocKind Kind, DbgVariableRecord *Source,
VarLocInsertPt After) {
DILocation *DL = Source->getDebugLoc();
@@ -1617,7 +1600,7 @@ void AssignmentTrackingLowering::processUnknownStoreToVariable(
LLVM_DEBUG(dbgs() << "Switching to fallback debug value: ";
DbgAV.dump(dbgs()); dbgs() << "\n");
setLocKind(LiveSet, Var, LocKind::Val);
- emitDbgValue(LocKind::Val, DbgAV.Source, &I);
+ emitDbgValue(LocKind::Val, cast<DbgVariableRecord *>(DbgAV.Source), &I);
return;
}
// Otherwise, find a suitable insert point, before the next instruction or
@@ -1790,7 +1773,7 @@ void AssignmentTrackingLowering::processTaggedInstruction(
LLVM_DEBUG(dbgs() << "Val, Debug value is Known\n";);
setLocKind(LiveSet, Var, LocKind::Val);
if (DbgAV.Source) {
- emitDbgValue(LocKind::Val, DbgAV.Source, &I);
+ emitDbgValue(LocKind::Val, cast<DbgVariableRecord *>(DbgAV.Source), &I);
} else {
// PrevAV.Source is nullptr so we must emit undef here.
emitDbgValue(LocKind::None, Assign, &I);
>From 39a5c20c6b590c730dd307ffd489c83aff7ea3d4 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 09:57:33 +0100
Subject: [PATCH 10/13] simplify: replace cast helpers
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 25 +++----------------
1 file changed, 4 insertions(+), 21 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 576509e1e7516..78f77c312e2f2 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1502,16 +1502,6 @@ VarLocInsertPt getNextNode(VarLocInsertPt InsertPt) {
return getNextNode(cast<const DbgRecord *>(InsertPt));
}
-DbgAssignIntrinsic *CastToDbgAssign(DbgVariableIntrinsic *DVI) {
- return cast<DbgAssignIntrinsic>(DVI);
-}
-
-DbgVariableRecord *CastToDbgAssign(DbgVariableRecord *DVR) {
- assert(DVR->isDbgAssign() &&
- "Attempted to cast non-assign DbgVariableRecord to DVRAssign.");
- return DVR;
-}
-
void AssignmentTrackingLowering::emitDbgValue(
AssignmentTrackingLowering::LocKind Kind, DbgVariableRecord *Source,
VarLocInsertPt After) {
@@ -1539,7 +1529,8 @@ void AssignmentTrackingLowering::emitDbgValue(
// NOTE: This block can mutate Kind.
if (Kind == LocKind::Mem) {
- const auto *Assign = CastToDbgAssign(Source);
+ assert(Source->isDbgAssign());
+ const DbgVariableRecord *Assign = Source;
// Check the address hasn't been dropped (e.g. the debug uses may not have
// been replaced before deleting a Value).
if (Assign->isKillAddress()) {
@@ -2138,14 +2129,6 @@ AllocaInst *getUnknownStore(const Instruction &I, const DataLayout &Layout) {
return dyn_cast<AllocaInst>(Base);
}
-DbgDeclareInst *DynCastToDbgDeclare(DbgVariableIntrinsic *DVI) {
- return dyn_cast<DbgDeclareInst>(DVI);
-}
-
-DbgVariableRecord *DynCastToDbgDeclare(DbgVariableRecord *DVR) {
- return DVR->isDbgDeclare() ? DVR : nullptr;
-}
-
/// Build a map of {Variable x: Variables y} where all variable fragments
/// contained within the variable fragment x are in set y. This means that
/// y does not contain all overlaps because partial overlaps are excluded.
@@ -2184,8 +2167,8 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
// clobber overlapped fragment locations later.
SmallVector<DbgVariableRecord *> DPDeclares;
auto ProcessDbgRecord = [&](DbgVariableRecord *Record) {
- if (auto *Declare = DynCastToDbgDeclare(Record)) {
- DPDeclares.push_back(Declare);
+ if (Record->isDbgDeclare()) {
+ DPDeclares.push_back(Record);
return;
}
DebugVariable DV = DebugVariable(Record);
>From 452826d70d487a324cf0e9df857aee87a9396fb6 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 10:07:00 +0100
Subject: [PATCH 11/13] replace ptrunion with DbgVariableRecord
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 58 +++++--------------
1 file changed, 16 insertions(+), 42 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 78f77c312e2f2..3bdc90a02e04b 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1025,14 +1025,13 @@ class AssignmentTrackingLowering {
/// i.e. for all values x and y where x != y:
/// join(x, x) = x
/// join(x, y) = NoneOrPhi
- using AssignRecord = PointerUnion<DbgAssignIntrinsic *, DbgVariableRecord *>;
struct Assignment {
enum S { Known, NoneOrPhi } Status;
/// ID of the assignment. nullptr if Status is not Known.
DIAssignID *ID;
/// The dbg.assign that marks this dbg-def. Mem-defs don't use this field.
/// May be nullptr.
- AssignRecord Source;
+ DbgVariableRecord *Source = nullptr;
bool isSameSourceAssignment(const Assignment &Other) const {
// Don't include Source in the equality check. Assignments are
@@ -1047,24 +1046,17 @@ class AssignmentTrackingLowering {
else
OS << "null";
OS << ", s=";
- if (Source.isNull())
+ if (!Source)
OS << "null";
- else if (const auto *DAI = dyn_cast<DbgAssignIntrinsic *>(Source))
- OS << DAI;
else
- OS << cast<DbgVariableRecord *>(Source);
+ OS << Source;
OS << ")";
}
- static Assignment make(DIAssignID *ID, DbgAssignIntrinsic *Source) {
- return Assignment(Known, ID, Source);
- }
static Assignment make(DIAssignID *ID, DbgVariableRecord *Source) {
- assert(Source->isDbgAssign() &&
- "Cannot make an assignment from a non-assign DbgVariableRecord");
- return Assignment(Known, ID, Source);
- }
- static Assignment make(DIAssignID *ID, AssignRecord Source) {
+ assert((!Source ||
+ Source->isDbgAssign()) &&
+ "Cannot make an assignment from a non-assign DbgVariableRecord");
return Assignment(Known, ID, Source);
}
static Assignment makeFromMemDef(DIAssignID *ID) {
@@ -1077,21 +1069,11 @@ class AssignmentTrackingLowering {
// If the Status is Known then we expect there to be an assignment ID.
assert(Status == NoneOrPhi || ID);
}
- Assignment(S Status, DIAssignID *ID, DbgAssignIntrinsic *Source)
- : Status(Status), ID(ID), Source(Source) {
- // If the Status is Known then we expect there to be an assignment ID.
- assert(Status == NoneOrPhi || ID);
- }
Assignment(S Status, DIAssignID *ID, DbgVariableRecord *Source)
: Status(Status), ID(ID), Source(Source) {
// If the Status is Known then we expect there to be an assignment ID.
assert(Status == NoneOrPhi || ID);
}
- Assignment(S Status, DIAssignID *ID, AssignRecord Source)
- : Status(Status), ID(ID), Source(Source) {
- // If the Status is Known then we expect there to be an assignment ID.
- assert(Status == NoneOrPhi || ID);
- }
};
using AssignmentMap = SmallVector<Assignment>;
@@ -1350,7 +1332,7 @@ class AssignmentTrackingLowering {
void processUntaggedInstruction(Instruction &I, BlockInfo *LiveSet);
void processUnknownStoreToVariable(Instruction &I, VariableID &Var,
BlockInfo *LiveSet);
- void processDbgAssign(AssignRecord Assign, BlockInfo *LiveSet);
+ void processDbgAssign(DbgVariableRecord *Assign, BlockInfo *LiveSet);
void processDbgVariableRecord(DbgVariableRecord &DVR, BlockInfo *LiveSet);
void processDbgValue(DbgVariableRecord *DbgValue, BlockInfo *LiveSet);
/// Add an assignment to memory for the variable /p Var.
@@ -1591,7 +1573,7 @@ void AssignmentTrackingLowering::processUnknownStoreToVariable(
LLVM_DEBUG(dbgs() << "Switching to fallback debug value: ";
DbgAV.dump(dbgs()); dbgs() << "\n");
setLocKind(LiveSet, Var, LocKind::Val);
- emitDbgValue(LocKind::Val, cast<DbgVariableRecord *>(DbgAV.Source), &I);
+ emitDbgValue(LocKind::Val, DbgAV.Source, &I);
return;
}
// Otherwise, find a suitable insert point, before the next instruction or
@@ -1764,7 +1746,7 @@ void AssignmentTrackingLowering::processTaggedInstruction(
LLVM_DEBUG(dbgs() << "Val, Debug value is Known\n";);
setLocKind(LiveSet, Var, LocKind::Val);
if (DbgAV.Source) {
- emitDbgValue(LocKind::Val, cast<DbgVariableRecord *>(DbgAV.Source), &I);
+ emitDbgValue(LocKind::Val, DbgAV.Source, &I);
} else {
// PrevAV.Source is nullptr so we must emit undef here.
emitDbgValue(LocKind::None, Assign, &I);
@@ -1783,7 +1765,7 @@ void AssignmentTrackingLowering::processTaggedInstruction(
ProcessLinkedAssign(DVR);
}
-void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
+void AssignmentTrackingLowering::processDbgAssign(DbgVariableRecord *Assign,
BlockInfo *LiveSet) {
auto ProcessDbgAssignImpl = [&](DbgVariableRecord *DbgAssign) {
// Only bother tracking variables that are at some point stack homed. Other
@@ -1825,7 +1807,7 @@ void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
emitDbgValue(LocKind::Val, DbgAssign, DbgAssign);
}
};
- ProcessDbgAssignImpl(cast<DbgVariableRecord *>(Assign));
+ ProcessDbgAssignImpl(Assign);
}
void AssignmentTrackingLowering::processDbgValue(DbgVariableRecord *DbgValue,
@@ -1983,24 +1965,16 @@ AssignmentTrackingLowering::joinAssignment(const Assignment &A,
// Here the same assignment (!1) was performed in both preds in the source,
// but we can't use either one unless they are identical (e.g. .we don't
// want to arbitrarily pick between constant values).
- auto JoinSource = [&]() -> AssignRecord {
+ auto JoinSource = [&]() -> DbgVariableRecord * {
if (A.Source == B.Source)
return A.Source;
if (!A.Source || !B.Source)
- return AssignRecord();
- assert(isa<DbgVariableRecord *>(A.Source) ==
- isa<DbgVariableRecord *>(B.Source));
- if (isa<DbgVariableRecord *>(A.Source) &&
- cast<DbgVariableRecord *>(A.Source)->isEquivalentTo(
- *cast<DbgVariableRecord *>(B.Source)))
- return A.Source;
- if (isa<DbgAssignIntrinsic *>(A.Source) &&
- cast<DbgAssignIntrinsic *>(A.Source)->isIdenticalTo(
- cast<DbgAssignIntrinsic *>(B.Source)))
+ return nullptr;
+ if (A.Source->isEquivalentTo(*B.Source))
return A.Source;
- return AssignRecord();
+ return nullptr;
};
- AssignRecord Source = JoinSource();
+ DbgVariableRecord *Source = JoinSource();
assert(A.Status == B.Status && A.Status == Assignment::Known);
assert(A.ID == B.ID);
return Assignment::make(A.ID, Source);
>From ee574bfdef22a1b52e88063d0cd114ce43d198e8 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Wed, 18 Jun 2025 10:22:16 +0100
Subject: [PATCH 12/13] unlambdaify
---
.../CodeGen/AssignmentTrackingAnalysis.cpp | 81 +++++++++----------
1 file changed, 38 insertions(+), 43 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 3bdc90a02e04b..bc8022d0d9d72 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1689,7 +1689,7 @@ void AssignmentTrackingLowering::processTaggedInstruction(
return;
LLVM_DEBUG(dbgs() << "processTaggedInstruction on " << I << "\n");
- auto ProcessLinkedAssign = [&](DbgVariableRecord *Assign) {
+ for (DbgVariableRecord *Assign : LinkedDPAssigns) {
VariableID Var = getVariableID(DebugVariable(Assign));
// Something has gone wrong if VarsWithStackSlot doesn't contain a variable
// that is linked to a store.
@@ -1760,54 +1760,49 @@ void AssignmentTrackingLowering::processTaggedInstruction(
setLocKind(LiveSet, Var, LocKind::None);
} break;
}
- };
- for (DbgVariableRecord *DVR : LinkedDPAssigns)
- ProcessLinkedAssign(DVR);
+ }
}
-void AssignmentTrackingLowering::processDbgAssign(DbgVariableRecord *Assign,
+void AssignmentTrackingLowering::processDbgAssign(DbgVariableRecord *DbgAssign,
BlockInfo *LiveSet) {
- auto ProcessDbgAssignImpl = [&](DbgVariableRecord *DbgAssign) {
- // Only bother tracking variables that are at some point stack homed. Other
- // variables can be dealt with trivially later.
- if (!VarsWithStackSlot->count(getAggregate(DbgAssign)))
- return;
-
- VariableID Var = getVariableID(DebugVariable(DbgAssign));
- Assignment AV = Assignment::make(getIDFromMarker(*DbgAssign), DbgAssign);
- addDbgDef(LiveSet, Var, AV);
+ // Only bother tracking variables that are at some point stack homed. Other
+ // variables can be dealt with trivially later.
+ if (!VarsWithStackSlot->count(getAggregate(DbgAssign)))
+ return;
- LLVM_DEBUG(dbgs() << "processDbgAssign on " << *DbgAssign << "\n";);
- LLVM_DEBUG(dbgs() << " LiveLoc " << locStr(getLocKind(LiveSet, Var))
- << " -> ");
+ VariableID Var = getVariableID(DebugVariable(DbgAssign));
+ Assignment AV = Assignment::make(getIDFromMarker(*DbgAssign), DbgAssign);
+ addDbgDef(LiveSet, Var, AV);
- // Check if the DebugValue and StackHomeValue both hold the same
- // Assignment.
- if (hasVarWithAssignment(LiveSet, BlockInfo::Stack, Var, AV)) {
- // They match. We can use the stack home because the debug intrinsics
- // state that an assignment happened here, and we know that specific
- // assignment was the last one to take place in memory for this variable.
- LocKind Kind;
- if (DbgAssign->isKillAddress()) {
- LLVM_DEBUG(
- dbgs()
- << "Val, Stack matches Debug program but address is killed\n";);
- Kind = LocKind::Val;
- } else {
- LLVM_DEBUG(dbgs() << "Mem, Stack matches Debug program\n";);
- Kind = LocKind::Mem;
- };
- setLocKind(LiveSet, Var, Kind);
- emitDbgValue(Kind, DbgAssign, DbgAssign);
+ LLVM_DEBUG(dbgs() << "processDbgAssign on " << *DbgAssign << "\n";);
+ LLVM_DEBUG(dbgs() << " LiveLoc " << locStr(getLocKind(LiveSet, Var))
+ << " -> ");
+
+ // Check if the DebugValue and StackHomeValue both hold the same
+ // Assignment.
+ if (hasVarWithAssignment(LiveSet, BlockInfo::Stack, Var, AV)) {
+ // They match. We can use the stack home because the debug intrinsics
+ // state that an assignment happened here, and we know that specific
+ // assignment was the last one to take place in memory for this variable.
+ LocKind Kind;
+ if (DbgAssign->isKillAddress()) {
+ LLVM_DEBUG(
+ dbgs()
+ << "Val, Stack matches Debug program but address is killed\n";);
+ Kind = LocKind::Val;
} else {
- // The last assignment to the memory location isn't the one that we want
- // to show to the user so emit a dbg.value(Value). Value may be undef.
- LLVM_DEBUG(dbgs() << "Val, Stack contents is unknown\n";);
- setLocKind(LiveSet, Var, LocKind::Val);
- emitDbgValue(LocKind::Val, DbgAssign, DbgAssign);
- }
- };
- ProcessDbgAssignImpl(Assign);
+ LLVM_DEBUG(dbgs() << "Mem, Stack matches Debug program\n";);
+ Kind = LocKind::Mem;
+ };
+ setLocKind(LiveSet, Var, Kind);
+ emitDbgValue(Kind, DbgAssign, DbgAssign);
+ } else {
+ // The last assignment to the memory location isn't the one that we want
+ // to show to the user so emit a dbg.value(Value). Value may be undef.
+ LLVM_DEBUG(dbgs() << "Val, Stack contents is unknown\n";);
+ setLocKind(LiveSet, Var, LocKind::Val);
+ emitDbgValue(LocKind::Val, DbgAssign, DbgAssign);
+ }
}
void AssignmentTrackingLowering::processDbgValue(DbgVariableRecord *DbgValue,
>From 093bbaadfdfc4c14b5508d6d66822ac3b761ea93 Mon Sep 17 00:00:00 2001
From: Orlando Cazalet-Hyams <orlando.hyams at sony.com>
Date: Tue, 24 Jun 2025 12:34:27 +0100
Subject: [PATCH 13/13] fix formatting issue
---
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index bc8022d0d9d72..2753360e65f21 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -1054,9 +1054,8 @@ class AssignmentTrackingLowering {
}
static Assignment make(DIAssignID *ID, DbgVariableRecord *Source) {
- assert((!Source ||
- Source->isDbgAssign()) &&
- "Cannot make an assignment from a non-assign DbgVariableRecord");
+ assert((!Source || Source->isDbgAssign()) &&
+ "Cannot make an assignment from a non-assign DbgVariableRecord");
return Assignment(Known, ID, Source);
}
static Assignment makeFromMemDef(DIAssignID *ID) {
More information about the llvm-commits
mailing list