[llvm] [1/3][AMDGPU][NFC] Add virtual prefix to GCN trackers (PR #203667)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 12 21:30:20 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-amdgpu
Author: Dhruva Chakrabarti (dhruvachak)
<details>
<summary>Changes</summary>
The renames are to clarify that these fields capture virtual register attributes and are in preparation for physical register support.
Replaces https://github.com/llvm/llvm-project/pull/183673.
---
Patch is 37.09 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/203667.diff
6 Files Affected:
- (modified) llvm/lib/Target/AMDGPU/GCNIterativeScheduler.cpp (+4-4)
- (modified) llvm/lib/Target/AMDGPU/GCNRegPressure.cpp (+72-69)
- (modified) llvm/lib/Target/AMDGPU/GCNRegPressure.h (+27-28)
- (modified) llvm/lib/Target/AMDGPU/GCNSchedStrategy.cpp (+55-52)
- (modified) llvm/lib/Target/AMDGPU/GCNSchedStrategy.h (+12-11)
- (modified) llvm/lib/Target/AMDGPU/SIFormMemoryClauses.cpp (+1-1)
``````````diff
diff --git a/llvm/lib/Target/AMDGPU/GCNIterativeScheduler.cpp b/llvm/lib/Target/AMDGPU/GCNIterativeScheduler.cpp
index dff153cebdd4c..f2e91e9c1be70 100644
--- a/llvm/lib/Target/AMDGPU/GCNIterativeScheduler.cpp
+++ b/llvm/lib/Target/AMDGPU/GCNIterativeScheduler.cpp
@@ -80,12 +80,12 @@ static void printLivenessInfo(raw_ostream &OS,
auto *const BB = Begin->getParent();
const auto &MRI = BB->getParent()->getRegInfo();
- const auto LiveIns = getLiveRegsBefore(*Begin, *LIS);
- OS << "LIn RP: " << print(getRegPressure(MRI, LiveIns));
+ const auto LiveIns = getVirtLiveRegsBefore(*Begin, *LIS);
+ OS << "LIn RP: " << print(getVirtRegPressure(MRI, LiveIns));
const auto BottomMI = End == BB->end() ? std::prev(End) : End;
- const auto LiveOuts = getLiveRegsAfter(*BottomMI, *LIS);
- OS << "LOt RP: " << print(getRegPressure(MRI, LiveOuts));
+ const auto LiveOuts = getVirtLiveRegsAfter(*BottomMI, *LIS);
+ OS << "LOt RP: " << print(getVirtRegPressure(MRI, LiveOuts));
}
LLVM_DUMP_METHOD
diff --git a/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp b/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp
index 54e67d9d2a808..c05e37ed44f4e 100644
--- a/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp
+++ b/llvm/lib/Target/AMDGPU/GCNRegPressure.cpp
@@ -488,11 +488,11 @@ LaneBitmask llvm::getLiveLaneMask(const LiveInterval &LI, SlotIndex SI,
return LiveMask;
}
-GCNRPTracker::LiveRegSet llvm::getLiveRegs(SlotIndex SI,
- const LiveIntervals &LIS,
- const MachineRegisterInfo &MRI,
- GCNRegPressure::RegKind RegKind) {
- GCNRPTracker::LiveRegSet LiveRegs;
+GCNRPTracker::LiveRegSet
+llvm::getVirtLiveRegs(SlotIndex SI, const LiveIntervals &LIS,
+ const MachineRegisterInfo &MRI,
+ GCNRegPressure::RegKind RegKind) {
+ GCNRPTracker::LiveRegSet VirtLiveRegs;
for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
auto Reg = Register::index2VirtReg(I);
if (RegKind != GCNRegPressure::TOTAL_KINDS &&
@@ -502,33 +502,32 @@ GCNRPTracker::LiveRegSet llvm::getLiveRegs(SlotIndex SI,
continue;
auto LiveMask = getLiveLaneMask(Reg, SI, LIS, MRI);
if (LiveMask.any())
- LiveRegs[Reg] = LiveMask;
+ VirtLiveRegs[Reg] = LiveMask;
}
- return LiveRegs;
+ return VirtLiveRegs;
}
void GCNRPTracker::reset(const MachineInstr &MI,
- const LiveRegSet *LiveRegsCopy,
- bool After) {
+ const LiveRegSet *VirtLiveRegsCopy, bool After) {
const MachineFunction &MF = *MI.getMF();
MRI = &MF.getRegInfo();
- if (LiveRegsCopy) {
- if (&LiveRegs != LiveRegsCopy)
- LiveRegs = *LiveRegsCopy;
+ if (VirtLiveRegsCopy) {
+ if (&VirtLiveRegs != VirtLiveRegsCopy)
+ VirtLiveRegs = *VirtLiveRegsCopy;
} else {
- LiveRegs = After ? getLiveRegsAfter(MI, LIS)
- : getLiveRegsBefore(MI, LIS);
+ VirtLiveRegs =
+ After ? getVirtLiveRegsAfter(MI, LIS) : getVirtLiveRegsBefore(MI, LIS);
}
- MaxPressure = CurPressure = getRegPressure(*MRI, LiveRegs);
+ MaxPressure = CurPressure = getVirtRegPressure(*MRI, VirtLiveRegs);
}
-void GCNRPTracker::reset(const MachineRegisterInfo &MRI_,
- const LiveRegSet &LiveRegs_) {
- MRI = &MRI_;
- LiveRegs = LiveRegs_;
+void GCNRPTracker::reset(const MachineRegisterInfo &MRInfo,
+ const LiveRegSet &VirtLiveRegsSet) {
+ MRI = &MRInfo;
+ VirtLiveRegs = VirtLiveRegsSet;
LastTrackedMI = nullptr;
- MaxPressure = CurPressure = getRegPressure(MRI_, LiveRegs_);
+ MaxPressure = CurPressure = getVirtRegPressure(MRInfo, VirtLiveRegsSet);
}
/// Mostly copy/paste from CodeGen/RegisterPressure.cpp
@@ -569,8 +568,8 @@ void GCNUpwardRPTracker::recede(const MachineInstr &MI) {
} else
DefPressure.inc(Reg, LaneBitmask::getNone(), DefMask, *MRI);
- auto I = LiveRegs.find(Reg);
- if (I == LiveRegs.end())
+ auto I = VirtLiveRegs.find(Reg);
+ if (I == VirtLiveRegs.end())
continue;
LaneBitmask &LiveMask = I->second;
@@ -578,7 +577,7 @@ void GCNUpwardRPTracker::recede(const MachineInstr &MI) {
LiveMask &= ~DefMask;
CurPressure.inc(Reg, PrevMask, LiveMask, *MRI);
if (LiveMask.none())
- LiveRegs.erase(I);
+ VirtLiveRegs.erase(I);
}
// Update MaxPressure with defs pressure.
@@ -591,7 +590,7 @@ void GCNUpwardRPTracker::recede(const MachineInstr &MI) {
SmallVector<VRegMaskOrUnit, 8> RegUses;
collectVirtualRegUses(RegUses, MI, LIS, *MRI);
for (const VRegMaskOrUnit &U : RegUses) {
- LaneBitmask &LiveMask = LiveRegs[U.VRegOrUnit.asVirtualReg()];
+ LaneBitmask &LiveMask = VirtLiveRegs[U.VRegOrUnit.asVirtualReg()];
LaneBitmask PrevMask = LiveMask;
LiveMask |= U.LaneMask;
CurPressure.inc(U.VRegOrUnit.asVirtualReg(), PrevMask, LiveMask, *MRI);
@@ -601,14 +600,14 @@ void GCNUpwardRPTracker::recede(const MachineInstr &MI) {
MaxPressure = HasECDefs ? max(CurPressure + ECDefPressure, MaxPressure)
: max(CurPressure, MaxPressure);
- assert(CurPressure == getRegPressure(*MRI, LiveRegs));
+ assert(CurPressure == getVirtRegPressure(*MRI, VirtLiveRegs));
}
////////////////////////////////////////////////////////////////////////////////
// GCNDownwardRPTracker
bool GCNDownwardRPTracker::reset(const MachineInstr &MI,
- const LiveRegSet *LiveRegsCopy) {
+ const LiveRegSet *VirtLiveRegsCopy) {
MRI = &MI.getMF()->getRegInfo();
LastTrackedMI = nullptr;
MBBEnd = MI.getParent()->end();
@@ -616,7 +615,7 @@ bool GCNDownwardRPTracker::reset(const MachineInstr &MI,
NextMI = skipDebugInstructionsForward(NextMI, MBBEnd);
if (NextMI == MBBEnd)
return false;
- GCNRPTracker::reset(*NextMI, LiveRegsCopy, false);
+ GCNRPTracker::reset(*NextMI, VirtLiveRegsCopy, false);
return true;
}
@@ -655,12 +654,12 @@ bool GCNDownwardRPTracker::advanceBeforeNext(MachineInstr *MI,
continue;
const LiveInterval &LI = LIS.getInterval(MO.getReg());
if (LI.hasSubRanges()) {
- auto It = LiveRegs.end();
+ auto It = VirtLiveRegs.end();
for (const auto &S : LI.subranges()) {
if (!S.liveAt(SI)) {
- if (It == LiveRegs.end()) {
- It = LiveRegs.find(MO.getReg());
- if (It == LiveRegs.end())
+ if (It == VirtLiveRegs.end()) {
+ It = VirtLiveRegs.find(MO.getReg());
+ if (It == VirtLiveRegs.end())
llvm_unreachable("register isn't live");
}
auto PrevMask = It->second;
@@ -668,14 +667,14 @@ bool GCNDownwardRPTracker::advanceBeforeNext(MachineInstr *MI,
CurPressure.inc(MO.getReg(), PrevMask, It->second, *MRI);
}
}
- if (It != LiveRegs.end() && It->second.none())
- LiveRegs.erase(It);
+ if (It != VirtLiveRegs.end() && It->second.none())
+ VirtLiveRegs.erase(It);
} else if (!LI.liveAt(SI)) {
- auto It = LiveRegs.find(MO.getReg());
- if (It == LiveRegs.end())
+ auto It = VirtLiveRegs.find(MO.getReg());
+ if (It == VirtLiveRegs.end())
llvm_unreachable("register isn't live");
CurPressure.inc(MO.getReg(), It->second, LaneBitmask::getNone(), *MRI);
- LiveRegs.erase(It);
+ VirtLiveRegs.erase(It);
}
}
@@ -702,7 +701,7 @@ void GCNDownwardRPTracker::advanceToNext(MachineInstr *MI,
Register Reg = MO.getReg();
if (!Reg.isVirtual())
continue;
- auto &LiveMask = LiveRegs[Reg];
+ auto &LiveMask = VirtLiveRegs[Reg];
auto PrevMask = LiveMask;
LiveMask |= getDefRegMask(MO, *MRI);
CurPressure.inc(Reg, PrevMask, LiveMask, *MRI);
@@ -732,8 +731,8 @@ bool GCNDownwardRPTracker::advance(MachineBasicBlock::const_iterator End) {
bool GCNDownwardRPTracker::advance(MachineBasicBlock::const_iterator Begin,
MachineBasicBlock::const_iterator End,
- const LiveRegSet *LiveRegsCopy) {
- reset(*Begin, LiveRegsCopy);
+ const LiveRegSet *VirtLiveRegsCopy) {
+ reset(*Begin, VirtLiveRegsCopy);
return advance(End);
}
@@ -803,8 +802,9 @@ GCNDownwardRPTracker::bumpDownwardPressure(const MachineInstr *MI,
if (LastUseMask.none())
continue;
- auto It = LiveRegs.find(Reg);
- LaneBitmask LiveMask = It != LiveRegs.end() ? It->second : LaneBitmask(0);
+ auto It = VirtLiveRegs.find(Reg);
+ LaneBitmask LiveMask =
+ It != VirtLiveRegs.end() ? It->second : LaneBitmask(0);
LaneBitmask NewMask = LiveMask & ~LastUseMask;
TempPressure.inc(Reg, LiveMask, NewMask, *MRI);
}
@@ -814,8 +814,9 @@ GCNDownwardRPTracker::bumpDownwardPressure(const MachineInstr *MI,
if (!Def.VRegOrUnit.isVirtualReg())
continue;
Register Reg = Def.VRegOrUnit.asVirtualReg();
- auto It = LiveRegs.find(Reg);
- LaneBitmask LiveMask = It != LiveRegs.end() ? It->second : LaneBitmask(0);
+ auto It = VirtLiveRegs.find(Reg);
+ LaneBitmask LiveMask =
+ It != VirtLiveRegs.end() ? It->second : LaneBitmask(0);
LaneBitmask NewMask = LiveMask | Def.LaneMask;
TempPressure.inc(Reg, LiveMask, NewMask, *MRI);
}
@@ -825,8 +826,8 @@ GCNDownwardRPTracker::bumpDownwardPressure(const MachineInstr *MI,
bool GCNUpwardRPTracker::isValid() const {
const auto &SI = LIS.getInstructionIndex(*LastTrackedMI).getBaseIndex();
- const auto LISLR = llvm::getLiveRegs(SI, LIS, *MRI);
- const auto &TrackedLR = LiveRegs;
+ const auto LISLR = llvm::getVirtLiveRegs(SI, LIS, *MRI);
+ const auto &TrackedLR = VirtLiveRegs;
if (!isEqual(LISLR, TrackedLR)) {
dbgs() << "\nGCNUpwardRPTracker error: Tracked and"
@@ -836,7 +837,7 @@ bool GCNUpwardRPTracker::isValid() const {
return false;
}
- auto LISPressure = getRegPressure(*MRI, LISLR);
+ auto LISPressure = getVirtRegPressure(*MRI, LISLR);
if (LISPressure != CurPressure) {
dbgs() << "GCNUpwardRPTracker error: Pressure sets different\nTracked: "
<< print(CurPressure) << "LIS rpt: " << print(LISPressure);
@@ -845,14 +846,14 @@ bool GCNUpwardRPTracker::isValid() const {
return true;
}
-Printable llvm::print(const GCNRPTracker::LiveRegSet &LiveRegs,
+Printable llvm::print(const GCNRPTracker::LiveRegSet &VirtLiveRegs,
const MachineRegisterInfo &MRI) {
- return Printable([&LiveRegs, &MRI](raw_ostream &OS) {
+ return Printable([&VirtLiveRegs, &MRI](raw_ostream &OS) {
const TargetRegisterInfo *TRI = MRI.getTargetRegisterInfo();
for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
Register Reg = Register::index2VirtReg(I);
- auto It = LiveRegs.find(Reg);
- if (It != LiveRegs.end() && It->second.any())
+ auto It = VirtLiveRegs.find(Reg);
+ if (It != VirtLiveRegs.end() && It->second.any())
OS << ' ' << printReg(Reg, TRI) << ':' << PrintLaneMask(It->second);
}
OS << '\n';
@@ -940,18 +941,18 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) {
SlotIndex MBBStartSlot = LIS.getSlotIndexes()->getMBBStartIdx(&MBB);
SlotIndex MBBLastSlot = LIS.getSlotIndexes()->getMBBLastIdx(&MBB);
- GCNRPTracker::LiveRegSet LiveIn, LiveOut;
+ GCNRPTracker::LiveRegSet VirtLiveIn, VirtLiveOut;
GCNRegPressure RPAtMBBEnd;
if (UseDownwardTracker) {
if (MBB.empty()) {
- LiveIn = LiveOut = getLiveRegs(MBBStartSlot, LIS, MRI);
- RPAtMBBEnd = getRegPressure(MRI, LiveIn);
+ VirtLiveIn = VirtLiveOut = getVirtLiveRegs(MBBStartSlot, LIS, MRI);
+ RPAtMBBEnd = getVirtRegPressure(MRI, VirtLiveIn);
} else {
GCNDownwardRPTracker RPT(LIS);
RPT.reset(MBB.front());
- LiveIn = RPT.getLiveRegs();
+ VirtLiveIn = RPT.getVirtLiveRegs();
while (!RPT.advanceBeforeNext()) {
GCNRegPressure RPBeforeMI = RPT.getPressure();
@@ -959,14 +960,14 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) {
RP.emplace_back(RPBeforeMI, RPT.getPressure());
}
- LiveOut = RPT.getLiveRegs();
+ VirtLiveOut = RPT.getVirtLiveRegs();
RPAtMBBEnd = RPT.getPressure();
}
} else {
GCNUpwardRPTracker RPT(LIS);
RPT.reset(MRI, MBBLastSlot);
- LiveOut = RPT.getLiveRegs();
+ VirtLiveOut = RPT.getVirtLiveRegs();
RPAtMBBEnd = RPT.getPressure();
for (auto &MI : reverse(MBB)) {
@@ -976,12 +977,13 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) {
RP.emplace_back(RPT.getPressure(), RPT.getMaxPressure());
}
- LiveIn = RPT.getLiveRegs();
+ VirtLiveIn = RPT.getVirtLiveRegs();
}
- OS << PFX " Live-in: " << llvm::print(LiveIn, MRI);
+ OS << PFX " Live-in: " << llvm::print(VirtLiveIn, MRI);
if (!UseDownwardTracker)
- ReportLISMismatchIfAny(LiveIn, getLiveRegs(MBBStartSlot, LIS, MRI));
+ ReportLISMismatchIfAny(VirtLiveIn,
+ getVirtLiveRegs(MBBStartSlot, LIS, MRI));
OS << PFX " SGPR VGPR\n";
int I = 0;
@@ -997,13 +999,14 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) {
}
OS << printRP(RPAtMBBEnd) << '\n';
- OS << PFX " Live-out:" << llvm::print(LiveOut, MRI);
+ OS << PFX " Live-out:" << llvm::print(VirtLiveOut, MRI);
if (UseDownwardTracker)
- ReportLISMismatchIfAny(LiveOut, getLiveRegs(MBBLastSlot, LIS, MRI));
+ ReportLISMismatchIfAny(VirtLiveOut,
+ getVirtLiveRegs(MBBLastSlot, LIS, MRI));
GCNRPTracker::LiveRegSet LiveThrough;
- for (auto [Reg, Mask] : LiveIn) {
- LaneBitmask MaskIntersection = Mask & LiveOut.lookup(Reg);
+ for (auto [Reg, Mask] : VirtLiveIn) {
+ LaneBitmask MaskIntersection = Mask & VirtLiveOut.lookup(Reg);
if (MaskIntersection.any()) {
LaneBitmask LTMask = getRegLiveThroughMask(
MRI, LIS, Reg, MBBStartSlot, MBBLastSlot, MaskIntersection);
@@ -1012,7 +1015,7 @@ bool GCNRegPressurePrinter::runOnMachineFunction(MachineFunction &MF) {
}
}
OS << PFX " Live-thr:" << llvm::print(LiveThrough, MRI);
- OS << printRP(getRegPressure(MRI, LiveThrough)) << '\n';
+ OS << printRP(getVirtRegPressure(MRI, LiveThrough)) << '\n';
}
OS << "...\n";
return false;
@@ -1053,14 +1056,14 @@ LLVM_DUMP_METHOD void llvm::dumpMaxRegPressure(MachineFunction &MF,
// diagnostic code.
SlotIndex ECSlot = MISlot.getRegSlot(true);
SlotIndex RSlot = MISlot.getRegSlot(false);
- GCNRPTracker::LiveRegSet ECLiveSet = getLiveRegs(ECSlot, LIS, MRI, Kind);
- GCNRPTracker::LiveRegSet RLiveSet = getLiveRegs(RSlot, LIS, MRI, Kind);
- unsigned ECNumRegs = getRegPressure(MRI, ECLiveSet).getNumRegs(Kind);
- unsigned RNumRegs = getRegPressure(MRI, RLiveSet).getNumRegs(Kind);
+ GCNRPTracker::LiveRegSet ECLiveSet = getVirtLiveRegs(ECSlot, LIS, MRI, Kind);
+ GCNRPTracker::LiveRegSet RLiveSet = getVirtLiveRegs(RSlot, LIS, MRI, Kind);
+ unsigned ECNumRegs = getVirtRegPressure(MRI, ECLiveSet).getNumRegs(Kind);
+ unsigned RNumRegs = getVirtRegPressure(MRI, RLiveSet).getNumRegs(Kind);
GCNRPTracker::LiveRegSet *LiveSet =
ECNumRegs > RNumRegs ? &ECLiveSet : &RLiveSet;
SlotIndex MaxPressureSlot = ECNumRegs > RNumRegs ? ECSlot : RSlot;
- assert(getRegPressure(MRI, *LiveSet).getNumRegs(Kind) == MaxNumRegs);
+ assert(getVirtRegPressure(MRI, *LiveSet).getNumRegs(Kind) == MaxNumRegs);
// Split live registers into single-def and multi-def sets.
GCNRegPressure SDefPressure, MDefPressure;
diff --git a/llvm/lib/Target/AMDGPU/GCNRegPressure.h b/llvm/lib/Target/AMDGPU/GCNRegPressure.h
index 52064dca1c3af..d7aff50822b50 100644
--- a/llvm/lib/Target/AMDGPU/GCNRegPressure.h
+++ b/llvm/lib/Target/AMDGPU/GCNRegPressure.h
@@ -320,14 +320,14 @@ class GCNRPTracker {
protected:
const LiveIntervals &LIS;
- LiveRegSet LiveRegs;
+ LiveRegSet VirtLiveRegs;
GCNRegPressure CurPressure, MaxPressure;
const MachineInstr *LastTrackedMI = nullptr;
mutable const MachineRegisterInfo *MRI = nullptr;
GCNRPTracker(const LiveIntervals &LIS_) : LIS(LIS_) {}
- void reset(const MachineInstr &MI, const LiveRegSet *LiveRegsCopy,
+ void reset(const MachineInstr &MI, const LiveRegSet *VirtLiveRegsCopy,
bool After);
/// Mostly copy/paste from CodeGen/RegisterPressure.cpp
@@ -337,37 +337,36 @@ class GCNRPTracker {
public:
// reset tracker and set live register set to the specified value.
- void reset(const MachineRegisterInfo &MRI_, const LiveRegSet &LiveRegs_);
+ void reset(const MachineRegisterInfo &MRInfo,
+ const LiveRegSet &VirtLiveRegsSet);
// live regs for the current state
- const decltype(LiveRegs) &getLiveRegs() const { return LiveRegs; }
+ const decltype(VirtLiveRegs) &getVirtLiveRegs() const { return VirtLiveRegs; }
const MachineInstr *getLastTrackedMI() const { return LastTrackedMI; }
void clearMaxPressure() { MaxPressure.clear(); }
GCNRegPressure getPressure() const { return CurPressure; }
- decltype(LiveRegs) moveLiveRegs() {
- return std::move(LiveRegs);
- }
+ decltype(VirtLiveRegs) moveVirtLiveRegs() { return std::move(VirtLiveRegs); }
};
GCNRPTracker::LiveRegSet
-getLiveRegs(SlotIndex SI, const LiveIntervals &LIS,
- const MachineRegisterInfo &MRI,
- GCNRegPressure::RegKind RegKind = GCNRegPressure::TOTAL_KINDS);
+getVirtLiveRegs(SlotIndex SI, const LiveIntervals &LIS,
+ const MachineRegisterInfo &MRI,
+ GCNRegPressure::RegKind RegKind = GCNRegPressure::TOTAL_KINDS);
////////////////////////////////////////////////////////////////////////////////
// GCNUpwardRPTracker
class GCNUpwardRPTracker : public GCNRPTracker {
public:
- GCNUpwardRPTracker(const LiveIntervals &LIS_) : GCNRPTracker(LIS_) {}
+ GCNUpwardRPTracker(const LiveIntervals &LIS) : GCNRPTracker(LIS) {}
using GCNRPTracker::reset;
/// reset tracker at the specified slot index \p SI.
void reset(const MachineRegisterInfo &MRI, SlotIndex SI) {
- GCNRPTracker::reset(MRI, llvm::getLiveRegs(SI, LIS, MRI));
+ GCNRPTracker::reset(MRI, llvm::getVirtLiveRegs(SI, LIS, MRI));
}
/// reset tracker to the end of the \p MBB.
@@ -425,9 +424,9 @@ class GCNDownwardRPTracker : public GCNRPTracker {
}
/// Reset tracker to the point before the \p MI
- /// filling \p LiveRegs upon this point using LIS.
+ /// filling \p VirtLiveRegs upon this point using LIS.
/// \p returns false if block is empty except debug values.
- bool reset(const MachineInstr &MI, const LiveRegSet *LiveRegs = nullptr);
+ bool reset(const MachineInstr &MI, const LiveRegSet *VirtLiveRegs = nullptr);
/// Move to the state right before the next MI or after the end of MBB.
/// \p returns false if reached end of the block.
@@ -464,7 +463,7 @@ class GCNDownwardRPTracker : public GCNRPTracker {
/// Reset to \p Begin and advance to \p End.
bool advance(MachineBasicBlock::const_iterator Begin,
MachineBasicBlock::const_iterator End,
- const LiveRegSet *LiveRegsCopy = nullptr);
+ const LiveRegSet *VirtLiveRegsCopy = nullptr);
/// Mostly copy/paste from CodeGen/RegisterPressure.cpp
/// Calculate the impact \p MI will have on CurPressure and \return the
@@ -493,8 +492,8 @@ LaneBitmask getLiveLaneMask(const LiveInterval &LI, SlotIndex SI,
/// Note: there is no entry in the map for instructions with empty live reg set
/// Complexity = O(NumVirtRegs * averageLiveRangeSegmentsPerReg * lg(R))
template <typename Range>
-DenseMap<MachineInstr*, GCNRPTracker::LiveRegSet>
-getLiveRegMap(Range &&R, bool After, LiveIntervals &LIS) {
+DenseMap<MachineInstr *, GCNRPTracker::LiveRegSet>
+getVirtLiveRegMap(Range &&R, bool After, LiveIntervals &LIS) {
std::vector<SlotIndex> Indexes;
Indexes.reserve(llvm::size(R));
auto &SII = *LIS.getSlotIndexes();
@@ -531,21 +530,21 @@ getLiveRegMap(Range &&R, bool After, LiveIntervals &LIS) {
return LiveRegMap;
}
-inline GCNRPTracker::LiveRegSet getLiveRegsAfter(const MachineInstr &MI,
- const LiveIntervals &LIS) {
- return getLiveRegs(LIS.getInstructionIndex(MI).getDeadSlot(...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/203667
More information about the llvm-commits
mailing list