Skip to content

[MachineLICM] Remove CurPreheader parameter that is always nullptr #135554

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Apr 15, 2025
Merged

[MachineLICM] Remove CurPreheader parameter that is always nullptr #135554

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
77 changes: 29 additions & 48 deletions llvm/lib/CodeGen/MachineLICM.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -215,11 +215,9 @@ namespace {
: MI(mi), Def(def), FI(fi) {}
};

void HoistRegionPostRA(MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader);
void HoistRegionPostRA(MachineLoop *CurLoop);

void HoistPostRA(MachineInstr *MI, Register Def, MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader);
void HoistPostRA(MachineInstr *MI, Register Def, MachineLoop *CurLoop);

void ProcessMI(MachineInstr *MI, BitVector &RUDefs, BitVector &RUClobbers,
SmallDenseSet<int> &StoredFIs,
Expand Down Expand Up @@ -259,8 +257,7 @@ namespace {
DenseMap<MachineDomTreeNode *, unsigned> &OpenChildren,
const DenseMap<MachineDomTreeNode *, MachineDomTreeNode *> &ParentMap);

void HoistOutOfLoop(MachineDomTreeNode *HeaderN, MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader);
void HoistOutOfLoop(MachineDomTreeNode *HeaderN, MachineLoop *CurLoop);

void InitRegPressure(MachineBasicBlock *BB);

Expand Down Expand Up @@ -291,8 +288,7 @@ namespace {

bool isTgtHotterThanSrc(MachineBasicBlock *SrcBlock,
MachineBasicBlock *TgtBlock);
MachineBasicBlock *getCurPreheader(MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader);
MachineBasicBlock *getOrCreatePreheader(MachineLoop *CurLoop);
};

class MachineLICMBase : public MachineFunctionPass {
Expand Down Expand Up @@ -417,16 +413,15 @@ bool MachineLICMImpl::run(MachineFunction &MF) {
SmallVector<MachineLoop *, 8> Worklist(MLI->begin(), MLI->end());
while (!Worklist.empty()) {
MachineLoop *CurLoop = Worklist.pop_back_val();
MachineBasicBlock *CurPreheader = nullptr;

if (!PreRegAlloc)
HoistRegionPostRA(CurLoop, CurPreheader);
else {
if (!PreRegAlloc) {
HoistRegionPostRA(CurLoop);
} else {
// CSEMap is initialized for loop header when the first instruction is
// being hoisted.
MachineDomTreeNode *N = MDTU->getDomTree().getNode(CurLoop->getHeader());
FirstInLoop = true;
HoistOutOfLoop(N, CurLoop, CurPreheader);
HoistOutOfLoop(N, CurLoop);
CSEMap.clear();
}
}
Expand Down Expand Up @@ -606,9 +601,8 @@ void MachineLICMImpl::ProcessMI(MachineInstr *MI, BitVector &RUDefs,

/// Walk the specified region of the CFG and hoist loop invariants out to the
/// preheader.
void MachineLICMImpl::HoistRegionPostRA(MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader) {
MachineBasicBlock *Preheader = getCurPreheader(CurLoop, CurPreheader);
void MachineLICMImpl::HoistRegionPostRA(MachineLoop *CurLoop) {
MachineBasicBlock *Preheader = getOrCreatePreheader(CurLoop);
if (!Preheader)
return;

Expand Down Expand Up @@ -702,7 +696,7 @@ void MachineLICMImpl::HoistRegionPostRA(MachineLoop *CurLoop,
}

if (Safe)
HoistPostRA(MI, Candidate.Def, CurLoop, CurPreheader);
HoistPostRA(MI, Candidate.Def, CurLoop);
}
}

Expand All @@ -726,9 +720,8 @@ void MachineLICMImpl::AddToLiveIns(MCRegister Reg, MachineLoop *CurLoop) {
/// When an instruction is found to only use loop invariant operands that is
/// safe to hoist, this instruction is called to do the dirty work.
void MachineLICMImpl::HoistPostRA(MachineInstr *MI, Register Def,
MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader) {
MachineBasicBlock *Preheader = getCurPreheader(CurLoop, CurPreheader);
MachineLoop *CurLoop) {
MachineBasicBlock *Preheader = CurLoop->getLoopPreheader();

// Now move the instructions to the predecessor, inserting it before any
// terminator instructions.
Expand Down Expand Up @@ -831,9 +824,8 @@ void MachineLICMImpl::ExitScopeIfDone(
/// order w.r.t the DominatorTree. This allows us to visit definitions before
/// uses, allowing us to hoist a loop body in one pass without iteration.
void MachineLICMImpl::HoistOutOfLoop(MachineDomTreeNode *HeaderN,
MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader) {
MachineBasicBlock *Preheader = getCurPreheader(CurLoop, CurPreheader);
MachineLoop *CurLoop) {
MachineBasicBlock *Preheader = getOrCreatePreheader(CurLoop);
if (!Preheader)
return;

Expand Down Expand Up @@ -1715,34 +1707,23 @@ unsigned MachineLICMImpl::Hoist(MachineInstr *MI, MachineBasicBlock *Preheader,
}

/// Get the preheader for the current loop, splitting a critical edge if needed.
MachineBasicBlock *
MachineLICMImpl::getCurPreheader(MachineLoop *CurLoop,
MachineBasicBlock *CurPreheader) {
MachineBasicBlock *MachineLICMImpl::getOrCreatePreheader(MachineLoop *CurLoop) {
// Determine the block to which to hoist instructions. If we can't find a
// suitable loop predecessor, we can't do any hoisting.

// If we've tried to get a preheader and failed, don't try again.
if (CurPreheader == reinterpret_cast<MachineBasicBlock *>(-1))
return nullptr;

if (!CurPreheader) {
CurPreheader = CurLoop->getLoopPreheader();
if (!CurPreheader) {
MachineBasicBlock *Pred = CurLoop->getLoopPredecessor();
if (!Pred) {
CurPreheader = reinterpret_cast<MachineBasicBlock *>(-1);
return nullptr;
}

CurPreheader = Pred->SplitCriticalEdge(CurLoop->getHeader(), LegacyPass,
MFAM, nullptr, MDTU);
if (!CurPreheader) {
CurPreheader = reinterpret_cast<MachineBasicBlock *>(-1);
return nullptr;
}
}
if (MachineBasicBlock *Preheader = CurLoop->getLoopPreheader())
return Preheader;

// Try forming a preheader by splitting the critical edge between the single
// predecessor and the loop header.
if (MachineBasicBlock *Pred = CurLoop->getLoopPredecessor()) {
MachineBasicBlock *NewPreheader = Pred->SplitCriticalEdge(
CurLoop->getHeader(), LegacyPass, MFAM, nullptr, MDTU);
if (NewPreheader)
Changed = true;
return NewPreheader;
}
return CurPreheader;

return nullptr;
}

/// Is the target basic block at least "BlockFrequencyRatioThreshold"
Expand Down