aboutsummaryrefslogtreecommitdiff
path: root/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp')
-rw-r--r--llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp154
1 files changed, 79 insertions, 75 deletions
diff --git a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
index 52774c7..0917795 100644
--- a/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
+++ b/llvm/lib/CodeGen/AssignmentTrackingAnalysis.cpp
@@ -215,7 +215,8 @@ void FunctionVarLocs::init(FunctionVarLocsBuilder &Builder) {
// Insert a contiguous block of VarLocInfos for each instruction, mapping it
// to the start and end position in the vector with VarLocsBeforeInst. This
- // block includes VarLocs for any DPValues attached to that instruction.
+ // block includes VarLocs for any DbgVariableRecords attached to that
+ // instruction.
for (auto &P : Builder.VarLocsBeforeInst) {
// Process VarLocs attached to a DbgRecord alongside their marker
// Instruction.
@@ -226,12 +227,12 @@ void FunctionVarLocs::init(FunctionVarLocsBuilder &Builder) {
// Any VarLocInfos attached to a DbgRecord should now be remapped to their
// marker Instruction, in order of DbgRecord appearance and prior to any
// VarLocInfos attached directly to that instruction.
- for (const DPValue &DPV : filterDbgVars(I->getDbgRecordRange())) {
- // Even though DPV defines a variable location, VarLocsBeforeInst can
+ for (const DbgVariableRecord &DVR : filterDbgVars(I->getDbgRecordRange())) {
+ // Even though DVR defines a variable location, VarLocsBeforeInst can
// still be empty if that VarLoc was redundant.
- if (!Builder.VarLocsBeforeInst.count(&DPV))
+ if (!Builder.VarLocsBeforeInst.count(&DVR))
continue;
- for (const VarLocInfo &VarLoc : Builder.VarLocsBeforeInst[&DPV])
+ for (const VarLocInfo &VarLoc : Builder.VarLocsBeforeInst[&DVR])
VarLocRecords.emplace_back(VarLoc);
}
for (const VarLocInfo &VarLoc : P.second)
@@ -830,10 +831,10 @@ class MemLocFragmentFill {
void process(BasicBlock &BB, VarFragMap &LiveSet) {
BBInsertBeforeMap[&BB].clear();
for (auto &I : BB) {
- for (DPValue &DPV : filterDbgVars(I.getDbgRecordRange())) {
- if (const auto *Locs = FnVarLocs->getWedge(&DPV)) {
+ for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange())) {
+ if (const auto *Locs = FnVarLocs->getWedge(&DVR)) {
for (const VarLocInfo &Loc : *Locs) {
- addDef(Loc, &DPV, *I.getParent(), LiveSet);
+ addDef(Loc, &DVR, *I.getParent(), LiveSet);
}
}
}
@@ -1027,7 +1028,7 @@ public:
/// i.e. for all values x and y where x != y:
/// join(x, x) = x
/// join(x, y) = NoneOrPhi
- using AssignRecord = PointerUnion<DbgAssignIntrinsic *, DPValue *>;
+ using AssignRecord = PointerUnion<DbgAssignIntrinsic *, DbgVariableRecord *>;
struct Assignment {
enum S { Known, NoneOrPhi } Status;
/// ID of the assignment. nullptr if Status is not Known.
@@ -1054,16 +1055,16 @@ public:
else if (isa<DbgAssignIntrinsic *>(Source))
OS << Source.get<DbgAssignIntrinsic *>();
else
- OS << Source.get<DPValue *>();
+ OS << Source.get<DbgVariableRecord *>();
OS << ")";
}
static Assignment make(DIAssignID *ID, DbgAssignIntrinsic *Source) {
return Assignment(Known, ID, Source);
}
- static Assignment make(DIAssignID *ID, DPValue *Source) {
+ static Assignment make(DIAssignID *ID, DbgVariableRecord *Source) {
assert(Source->isDbgAssign() &&
- "Cannot make an assignment from a non-assign DPValue");
+ "Cannot make an assignment from a non-assign DbgVariableRecord");
return Assignment(Known, ID, Source);
}
static Assignment make(DIAssignID *ID, AssignRecord Source) {
@@ -1084,7 +1085,7 @@ public:
// If the Status is Known then we expect there to be an assignment ID.
assert(Status == NoneOrPhi || ID);
}
- Assignment(S Status, DIAssignID *ID, DPValue *Source)
+ 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);
@@ -1119,10 +1120,10 @@ private:
/// Clear the location definitions currently cached for insertion after /p
/// After.
void resetInsertionPoint(Instruction &After);
- void resetInsertionPoint(DPValue &After);
+ void resetInsertionPoint(DbgVariableRecord &After);
// emitDbgValue can be called with:
- // Source=[AssignRecord|DbgValueInst*|DbgAssignIntrinsic*|DPValue*]
+ // 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
@@ -1355,9 +1356,10 @@ private:
/// attachment, \p I.
void processUntaggedInstruction(Instruction &I, BlockInfo *LiveSet);
void processDbgAssign(AssignRecord Assign, BlockInfo *LiveSet);
- void processDPValue(DPValue &DPV, BlockInfo *LiveSet);
- void processDbgValue(PointerUnion<DbgValueInst *, DPValue *> DbgValueRecord,
- BlockInfo *LiveSet);
+ void processDbgVariableRecord(DbgVariableRecord &DVR, BlockInfo *LiveSet);
+ void processDbgValue(
+ PointerUnion<DbgValueInst *, DbgVariableRecord *> DbgValueRecord,
+ 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.
@@ -1457,10 +1459,10 @@ static DIAssignID *getIDFromMarker(const DbgAssignIntrinsic &DAI) {
return cast<DIAssignID>(DAI.getAssignID());
}
-static DIAssignID *getIDFromMarker(const DPValue &DPV) {
- assert(DPV.isDbgAssign() &&
- "Cannot get a DIAssignID from a non-assign DPValue!");
- return DPV.getAssignID();
+static DIAssignID *getIDFromMarker(const DbgVariableRecord &DVR) {
+ assert(DVR.isDbgAssign() &&
+ "Cannot get a DIAssignID from a non-assign DbgVariableRecord!");
+ return DVR.getAssignID();
}
/// Return true if \p Var has an assignment in \p M matching \p AV.
@@ -1493,10 +1495,10 @@ const char *locStr(AssignmentTrackingLowering::LocKind Loc) {
}
#endif
-VarLocInsertPt getNextNode(const DbgRecord *DPV) {
- auto NextIt = ++(DPV->getIterator());
- if (NextIt == DPV->getMarker()->getDbgRecordRange().end())
- return DPV->getMarker()->MarkedInstr;
+VarLocInsertPt getNextNode(const DbgRecord *DVR) {
+ auto NextIt = ++(DVR->getIterator());
+ if (NextIt == DVR->getMarker()->getDbgRecordRange().end())
+ return DVR->getMarker()->MarkedInstr;
return &*NextIt;
}
VarLocInsertPt getNextNode(const Instruction *Inst) {
@@ -1515,10 +1517,10 @@ DbgAssignIntrinsic *CastToDbgAssign(DbgVariableIntrinsic *DVI) {
return cast<DbgAssignIntrinsic>(DVI);
}
-DPValue *CastToDbgAssign(DPValue *DPV) {
- assert(DPV->isDbgAssign() &&
- "Attempted to cast non-assign DPValue to DPVAssign.");
- return DPV;
+DbgVariableRecord *CastToDbgAssign(DbgVariableRecord *DVR) {
+ assert(DVR->isDbgAssign() &&
+ "Attempted to cast non-assign DbgVariableRecord to DVRAssign.");
+ return DVR;
}
void AssignmentTrackingLowering::emitDbgValue(
@@ -1527,7 +1529,7 @@ void AssignmentTrackingLowering::emitDbgValue(
if (isa<DbgAssignIntrinsic *>(Source))
emitDbgValue(Kind, cast<DbgAssignIntrinsic *>(Source), After);
else
- emitDbgValue(Kind, cast<DPValue *>(Source), After);
+ emitDbgValue(Kind, cast<DbgVariableRecord *>(Source), After);
}
template <typename T>
void AssignmentTrackingLowering::emitDbgValue(
@@ -1674,7 +1676,7 @@ void AssignmentTrackingLowering::processUntaggedInstruction(
void AssignmentTrackingLowering::processTaggedInstruction(
Instruction &I, AssignmentTrackingLowering::BlockInfo *LiveSet) {
auto Linked = at::getAssignmentMarkers(&I);
- auto LinkedDPAssigns = at::getDPVAssignmentMarkers(&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
@@ -1757,8 +1759,8 @@ void AssignmentTrackingLowering::processTaggedInstruction(
};
for (DbgAssignIntrinsic *DAI : Linked)
ProcessLinkedAssign(DAI);
- for (DPValue *DPV : LinkedDPAssigns)
- ProcessLinkedAssign(DPV);
+ for (DbgVariableRecord *DVR : LinkedDPAssigns)
+ ProcessLinkedAssign(DVR);
}
void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
@@ -1803,13 +1805,13 @@ void AssignmentTrackingLowering::processDbgAssign(AssignRecord Assign,
emitDbgValue(LocKind::Val, DbgAssign, DbgAssign);
}
};
- if (isa<DPValue *>(Assign))
- return ProcessDbgAssignImpl(cast<DPValue *>(Assign));
+ if (isa<DbgVariableRecord *>(Assign))
+ return ProcessDbgAssignImpl(cast<DbgVariableRecord *>(Assign));
return ProcessDbgAssignImpl(cast<DbgAssignIntrinsic *>(Assign));
}
void AssignmentTrackingLowering::processDbgValue(
- PointerUnion<DbgValueInst *, DPValue *> DbgValueRecord,
+ PointerUnion<DbgValueInst *, DbgVariableRecord *> DbgValueRecord,
BlockInfo *LiveSet) {
auto ProcessDbgValueImpl = [&](auto *DbgValue) {
// Only other tracking variables that are at some point stack homed.
@@ -1834,8 +1836,8 @@ void AssignmentTrackingLowering::processDbgValue(
setLocKind(LiveSet, Var, LocKind::Val);
emitDbgValue(LocKind::Val, DbgValue, DbgValue);
};
- if (isa<DPValue *>(DbgValueRecord))
- return ProcessDbgValueImpl(cast<DPValue *>(DbgValueRecord));
+ if (isa<DbgVariableRecord *>(DbgValueRecord))
+ return ProcessDbgValueImpl(cast<DbgVariableRecord *>(DbgValueRecord));
return ProcessDbgValueImpl(cast<DbgValueInst *>(DbgValueRecord));
}
@@ -1860,16 +1862,16 @@ void AssignmentTrackingLowering::processDbgInstruction(
else if (auto *DVI = dyn_cast<DbgValueInst>(&I))
processDbgValue(DVI, LiveSet);
}
-void AssignmentTrackingLowering::processDPValue(
- DPValue &DPV, AssignmentTrackingLowering::BlockInfo *LiveSet) {
+void AssignmentTrackingLowering::processDbgVariableRecord(
+ DbgVariableRecord &DVR, AssignmentTrackingLowering::BlockInfo *LiveSet) {
// Ignore assignments to zero bits of the variable.
- if (hasZeroSizedFragment(DPV))
+ if (hasZeroSizedFragment(DVR))
return;
- if (DPV.isDbgAssign())
- processDbgAssign(&DPV, LiveSet);
- else if (DPV.isDbgValue())
- processDbgValue(&DPV, LiveSet);
+ if (DVR.isDbgAssign())
+ processDbgAssign(&DVR, LiveSet);
+ else if (DVR.isDbgValue())
+ processDbgValue(&DVR, LiveSet);
}
void AssignmentTrackingLowering::resetInsertionPoint(Instruction &After) {
@@ -1879,7 +1881,7 @@ void AssignmentTrackingLowering::resetInsertionPoint(Instruction &After) {
return;
R->second.clear();
}
-void AssignmentTrackingLowering::resetInsertionPoint(DPValue &After) {
+void AssignmentTrackingLowering::resetInsertionPoint(DbgVariableRecord &After) {
auto *R = InsertBeforeMap.find(getNextNode(&After));
if (R == InsertBeforeMap.end())
return;
@@ -1919,9 +1921,9 @@ void AssignmentTrackingLowering::process(BasicBlock &BB, BlockInfo *LiveSet) {
// Skip over non-variable debug records (i.e., labels). They're going to
// be read from IR (possibly re-ordering them within the debug record
// range) rather than from the analysis results.
- for (DPValue &DPV : filterDbgVars(II->getDbgRecordRange())) {
- resetInsertionPoint(DPV);
- processDPValue(DPV, LiveSet);
+ for (DbgVariableRecord &DVR : filterDbgVars(II->getDbgRecordRange())) {
+ resetInsertionPoint(DVR);
+ processDbgVariableRecord(DVR, LiveSet);
assert(LiveSet->isValid());
}
}
@@ -2000,9 +2002,11 @@ AssignmentTrackingLowering::joinAssignment(const Assignment &A,
return A.Source;
if (!A.Source || !B.Source)
return AssignRecord();
- assert(isa<DPValue *>(A.Source) == isa<DPValue *>(B.Source));
- if (isa<DPValue *>(A.Source) &&
- cast<DPValue *>(A.Source)->isEquivalentTo(*cast<DPValue *>(B.Source)))
+ 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(
@@ -2123,8 +2127,8 @@ DbgDeclareInst *DynCastToDbgDeclare(DbgVariableIntrinsic *DVI) {
return dyn_cast<DbgDeclareInst>(DVI);
}
-DPValue *DynCastToDbgDeclare(DPValue *DPV) {
- return DPV->isDbgDeclare() ? DPV : nullptr;
+DbgVariableRecord *DynCastToDbgDeclare(DbgVariableRecord *DVR) {
+ return DVR->isDbgDeclare() ? DVR : nullptr;
}
/// Build a map of {Variable x: Variables y} where all variable fragments
@@ -2161,7 +2165,7 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
// We need to add fragments for untagged stores too so that we can correctly
// clobber overlapped fragment locations later.
SmallVector<DbgDeclareInst *> InstDeclares;
- SmallVector<DPValue *> DPDeclares;
+ SmallVector<DbgVariableRecord *> DPDeclares;
auto ProcessDbgRecord = [&](auto *Record, auto &DeclareList) {
if (auto *Declare = DynCastToDbgDeclare(Record)) {
DeclareList.push_back(Declare);
@@ -2176,8 +2180,8 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
};
for (auto &BB : Fn) {
for (auto &I : BB) {
- for (DPValue &DPV : filterDbgVars(I.getDbgRecordRange()))
- ProcessDbgRecord(&DPV, DPDeclares);
+ for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
+ ProcessDbgRecord(&DVR, DPDeclares);
if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
ProcessDbgRecord(DII, InstDeclares);
} else if (auto Info = getUntaggedStoreAssignmentInfo(
@@ -2218,8 +2222,8 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
};
for (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(Info->Base))
HandleDbgAssignForStore(DAI);
- for (DPValue *DPV : at::getDPVAssignmentMarkers(Info->Base))
- HandleDbgAssignForStore(DPV);
+ for (DbgVariableRecord *DVR : at::getDVRAssignmentMarkers(Info->Base))
+ HandleDbgAssignForStore(DVR);
}
}
}
@@ -2269,10 +2273,10 @@ static AssignmentTrackingLowering::OverlapMap buildOverlapMapAndRecordDeclares(
for (auto *DDI : InstDeclares)
FnVarLocs->addSingleLocVar(DebugVariable(DDI), DDI->getExpression(),
DDI->getDebugLoc(), DDI->getWrappedLocation());
- for (auto *DPV : DPDeclares)
- FnVarLocs->addSingleLocVar(DebugVariable(DPV), DPV->getExpression(),
- DPV->getDebugLoc(),
- RawLocationWrapper(DPV->getRawLocation()));
+ for (auto *DVR : DPDeclares)
+ FnVarLocs->addSingleLocVar(DebugVariable(DVR), DVR->getExpression(),
+ DVR->getDebugLoc(),
+ RawLocationWrapper(DVR->getRawLocation()));
return Map;
}
@@ -2466,9 +2470,9 @@ bool AssignmentTrackingLowering::emitPromotedVarLocs(
for (auto &BB : Fn) {
for (auto &I : BB) {
// Skip instructions other than dbg.values and dbg.assigns.
- for (DPValue &DPV : filterDbgVars(I.getDbgRecordRange()))
- if (DPV.isDbgValue() || DPV.isDbgAssign())
- TranslateDbgRecord(&DPV);
+ for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
+ if (DVR.isDbgValue() || DVR.isDbgAssign())
+ TranslateDbgRecord(&DVR);
auto *DVI = dyn_cast<DbgValueInst>(&I);
if (DVI)
TranslateDbgRecord(DVI);
@@ -2568,8 +2572,8 @@ removeRedundantDbgLocsUsingBackwardScan(const BasicBlock *BB,
}
};
HandleLocsForWedge(&I);
- for (DPValue &DPV : reverse(filterDbgVars(I.getDbgRecordRange())))
- HandleLocsForWedge(&DPV);
+ for (DbgVariableRecord &DVR : reverse(filterDbgVars(I.getDbgRecordRange())))
+ HandleLocsForWedge(&DVR);
}
return Changed;
@@ -2633,8 +2637,8 @@ removeRedundantDbgLocsUsingForwardScan(const BasicBlock *BB,
}
};
- for (DPValue &DPV : filterDbgVars(I.getDbgRecordRange()))
- HandleLocsForWedge(&DPV);
+ for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
+ HandleLocsForWedge(&DVR);
HandleLocsForWedge(&I);
}
@@ -2719,8 +2723,8 @@ removeUndefDbgLocsFromEntryBlock(const BasicBlock *BB,
Changed = true;
}
};
- for (DPValue &DPV : filterDbgVars(I.getDbgRecordRange()))
- HandleLocsForWedge(&DPV);
+ for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange()))
+ HandleLocsForWedge(&DVR);
HandleLocsForWedge(&I);
}
@@ -2753,8 +2757,8 @@ static DenseSet<DebugAggregate> findVarsWithStackSlot(Function &Fn) {
for (DbgAssignIntrinsic *DAI : at::getAssignmentMarkers(&I)) {
Result.insert({DAI->getVariable(), DAI->getDebugLoc().getInlinedAt()});
}
- for (DPValue *DPV : at::getDPVAssignmentMarkers(&I)) {
- Result.insert({DPV->getVariable(), DPV->getDebugLoc().getInlinedAt()});
+ for (DbgVariableRecord *DVR : at::getDVRAssignmentMarkers(&I)) {
+ Result.insert({DVR->getVariable(), DVR->getDebugLoc().getInlinedAt()});
}
}
}
generated by cgit v1.1 at 2025-08-04 04:54:07 +0000