[llvm] db72f6c - [RemoveDIs][NFC] Remove dbg intrinsic handling code from AssignmentTrackingAnalysis (#144674)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Jun 24 05:07:35 PDT 2025
Author: Orlando Cazalet-Hyams
Date: 2025-06-24T13:07:31+01:00
New Revision: db72f6cbe6344581e98c2aa2ef7f82c04c74d3d7
URL: https://github.com/llvm/llvm-project/commit/db72f6cbe6344581e98c2aa2ef7f82c04c74d3d7
DIFF: https://github.com/llvm/llvm-project/commit/db72f6cbe6344581e98c2aa2ef7f82c04c74d3d7.diff
LOG: [RemoveDIs][NFC] Remove dbg intrinsic handling code from AssignmentTrackingAnalysis (#144674)
See PR for breakdown into individual commits.
Added:
Modified:
llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 7da01e331b5a6..ff265b505b5da 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());
}
@@ -1028,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
@@ -1050,26 +1046,18 @@ 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() &&
+ assert((!Source || Source->isDbgAssign()) &&
"Cannot make an assignment from a non-assign DbgVariableRecord");
return Assignment(Known, ID, Source);
}
- static Assignment make(DIAssignID *ID, AssignRecord Source) {
- return Assignment(Known, ID, Source);
- }
static Assignment makeFromMemDef(DIAssignID *ID) {
return Assignment(Known, ID);
}
@@ -1080,21 +1068,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>;
@@ -1127,15 +1105,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) {
@@ -1353,7 +1323,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);
@@ -1362,11 +1331,9 @@ 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(
- 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.
@@ -1462,10 +1429,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!");
@@ -1520,27 +1483,8 @@ 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,
- 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();
@@ -1566,7 +1510,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()) {
@@ -1734,17 +1679,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) {
+ 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.
@@ -1815,112 +1759,82 @@ void AssignmentTrackingLowering::processTaggedInstruction(
setLocKind(LiveSet, Var, LocKind::None);
} break;
}
- };
- for (DbgAssignIntrinsic *DAI : Linked)
- ProcessLinkedAssign(DAI);
- for (DbgVariableRecord *DVR : LinkedDPAssigns)
- ProcessLinkedAssign(DVR);
+ }
}
-void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
+void AssignmentTrackingLowering::processDbgAssign(DbgVariableRecord *DbgAssign,
BlockInfo *LiveSet) {
- auto ProcessDbgAssignImpl = [&](auto *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);
-
- LLVM_DEBUG(dbgs() << "processDbgAssign on " << *DbgAssign << "\n";);
- LLVM_DEBUG(dbgs() << " LiveLoc " << locStr(getLocKind(LiveSet, Var))
- << " -> ");
+ // 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;
- // 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);
+ VariableID Var = getVariableID(DebugVariable(DbgAssign));
+ Assignment AV = Assignment::make(getIDFromMarker(*DbgAssign), DbgAssign);
+ addDbgDef(LiveSet, Var, AV);
+
+ 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);
- }
- };
- if (isa<DbgVariableRecord *>(Assign))
- return ProcessDbgAssignImpl(cast<DbgVariableRecord *>(Assign));
- return ProcessDbgAssignImpl(cast<DbgAssignIntrinsic *>(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(
- 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) {
+static bool hasZeroSizedFragment(DbgVariableRecord &DbgValue) {
if (auto F = DbgValue.getExpression()->getFragmentInfo())
return F->SizeInBits == 0;
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.
@@ -1964,14 +1878,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
@@ -1987,15 +1899,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
@@ -2056,24 +1959,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);
@@ -2202,14 +2097,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.
@@ -2246,11 +2133,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) {
- if (auto *Declare = DynCastToDbgDeclare(Record)) {
- DeclareList.push_back(Declare);
+ auto ProcessDbgRecord = [&](DbgVariableRecord *Record) {
+ if (Record->isDbgDeclare()) {
+ DPDeclares.push_back(Record);
return;
}
DebugVariable DV = DebugVariable(Record);
@@ -2263,13 +2149,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
@@ -2302,13 +2185,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 =
@@ -2321,8 +2202,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);
}
@@ -2371,9 +2250,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(),
@@ -2556,7 +2432,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)))
@@ -2574,9 +2450,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;
@@ -2598,10 +2471,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.
@@ -2854,9 +2725,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()});
}
More information about the llvm-commits
mailing list