From: Roman Lebedev Date: Sun, 5 May 2019 18:59:39 +0000 (+0000) Subject: [NFC] BasicBlock: refactor changePhiUses() out of replacePhiUsesWith(), use it X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=fb75d5732914931c91c250c96ec0d357ecb97fef;p=llvm [NFC] BasicBlock: refactor changePhiUses() out of replacePhiUsesWith(), use it Summary: It is a common thing to loop over every `PHINode` in some `BasicBlock` and change old `BasicBlock` incoming block to a new `BasicBlock` incoming block. `replaceSuccessorsPhiUsesWith()` already had code to do that, it just wasn't a function. So outline it into a new function, and use it. Reviewers: chandlerc, craig.topper, spatel, danielcdh Reviewed By: craig.topper Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D61013 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@359996 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/IR/BasicBlock.h b/include/llvm/IR/BasicBlock.h index fd9efb8417e..c88b1b51014 100644 --- a/include/llvm/IR/BasicBlock.h +++ b/include/llvm/IR/BasicBlock.h @@ -390,6 +390,10 @@ public: /// direct branches, switches, etc. to it. bool hasAddressTaken() const { return getSubclassDataFromValue() != 0; } + /// Update all phi nodes in this basic block to refer to basic block \p New + /// instead of basic block \p Old. + void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New); + /// Update all phi nodes in this basic block's successors to refer to basic /// block \p New instead of to it. void replaceSuccessorsPhiUsesWith(BasicBlock *New); diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp index aa57748ffa7..355455a6146 100644 --- a/lib/CodeGen/CodeGenPrepare.cpp +++ b/lib/CodeGen/CodeGenPrepare.cpp @@ -7221,8 +7221,7 @@ bool CodeGenPrepare::splitBranchCondition(Function &F, bool &ModifiedDT) { std::swap(TBB, FBB); // Replace the old BB with the new BB. - for (PHINode &PN : TBB->phis()) - PN.replaceIncomingBlockWith(&BB, TmpBB); + TBB->replacePhiUsesWith(&BB, TmpBB); // Add another incoming edge form the new BB. for (PHINode &PN : FBB->phis()) { diff --git a/lib/IR/BasicBlock.cpp b/lib/IR/BasicBlock.cpp index 8dde864385a..b3980cf9c31 100644 --- a/lib/IR/BasicBlock.cpp +++ b/lib/IR/BasicBlock.cpp @@ -427,32 +427,32 @@ BasicBlock *BasicBlock::splitBasicBlock(iterator I, const Twine &BBName) { // successors. If there were PHI nodes in the successors, then they need to // know that incoming branches will be from New, not from Old. // - for (succ_iterator I = succ_begin(New), E = succ_end(New); I != E; ++I) { - // Loop over any phi nodes in the basic block, updating the BB field of - // incoming values... - BasicBlock *Successor = *I; - for (auto &PN : Successor->phis()) - PN.replaceIncomingBlockWith(this, New); - } + llvm::for_each(successors(New), [this, New](BasicBlock *Succ) { + Succ->replacePhiUsesWith(this, New); + }); return New; } +void BasicBlock::replacePhiUsesWith(BasicBlock *Old, BasicBlock *New) { + // N.B. This might not be a complete BasicBlock, so don't assume + // that it ends with a non-phi instruction. + for (iterator II = begin(), IE = end(); II != IE; ++II) { + PHINode *PN = dyn_cast(II); + if (!PN) + break; + PN->replaceIncomingBlockWith(Old, New); + } +} + void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *New) { Instruction *TI = getTerminator(); if (!TI) // Cope with being called on a BasicBlock that doesn't have a terminator // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this. return; - for (BasicBlock *Succ : successors(TI)) { - // N.B. Succ might not be a complete BasicBlock, so don't assume - // that it ends with a non-phi instruction. - for (iterator II = Succ->begin(), IE = Succ->end(); II != IE; ++II) { - PHINode *PN = dyn_cast(II); - if (!PN) - break; - PN->replaceIncomingBlockWith(this, New); - } - } + llvm::for_each(successors(TI), [this, New](BasicBlock *Succ) { + Succ->replacePhiUsesWith(this, New); + }); } /// Return true if this basic block is a landing pad. I.e., it's diff --git a/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp b/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp index 92e3e9a0496..64a97f86a21 100644 --- a/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp +++ b/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp @@ -1325,8 +1325,7 @@ LoopConstrainer::RewrittenRangeInfo LoopConstrainer::changeIterationSpaceEnd( // The latch exit now has a branch from `RRI.ExitSelector' instead of // `LS.Latch'. The PHI nodes need to be updated to reflect that. - for (PHINode &PN : LS.LatchExit->phis()) - PN.replaceIncomingBlockWith(LS.Latch, RRI.ExitSelector); + LS.LatchExit->replacePhiUsesWith(LS.Latch, RRI.ExitSelector); return RRI; } @@ -1349,8 +1348,7 @@ BasicBlock *LoopConstrainer::createPreheader(const LoopStructure &LS, BasicBlock *Preheader = BasicBlock::Create(Ctx, Tag, &F, LS.Header); BranchInst::Create(LS.Header, Preheader); - for (PHINode &PN : LS.Header->phis()) - PN.replaceIncomingBlockWith(OldPreheader, Preheader); + LS.Header->replacePhiUsesWith(OldPreheader, Preheader); return Preheader; } diff --git a/lib/Transforms/Scalar/LoopInterchange.cpp b/lib/Transforms/Scalar/LoopInterchange.cpp index 8347dbe4598..bde4ecaaa6c 100644 --- a/lib/Transforms/Scalar/LoopInterchange.cpp +++ b/lib/Transforms/Scalar/LoopInterchange.cpp @@ -1279,12 +1279,6 @@ static void moveBBContents(BasicBlock *FromBB, Instruction *InsertBefore) { FromBB->getTerminator()->getIterator()); } -static void updateIncomingBlock(BasicBlock *CurrBlock, BasicBlock *OldPred, - BasicBlock *NewPred) { - for (PHINode &PHI : CurrBlock->phis()) - PHI.replaceIncomingBlockWith(OldPred, NewPred); -} - /// Update BI to jump to NewBB instead of OldBB. Records updates to /// the dominator tree in DTUpdates, if DT should be preserved. static void updateSuccessor(BranchInst *BI, BasicBlock *OldBB, @@ -1349,7 +1343,7 @@ static void moveLCSSAPhis(BasicBlock *InnerExit, BasicBlock *InnerLatch, // Now adjust the incoming blocks for the LCSSA PHIs. // For PHIs moved from Inner's exit block, we need to replace Inner's latch // with the new latch. - updateIncomingBlock(InnerLatch, InnerLatch, OuterLatch); + InnerLatch->replacePhiUsesWith(InnerLatch, OuterLatch); } bool LoopInterchangeTransform::adjustLoopBranches() { @@ -1416,8 +1410,8 @@ bool LoopInterchangeTransform::adjustLoopBranches() { InnerLoopHeaderSuccessor, DTUpdates); // Adjust reduction PHI's now that the incoming block has changed. - updateIncomingBlock(InnerLoopHeaderSuccessor, InnerLoopHeader, - OuterLoopHeader); + InnerLoopHeaderSuccessor->replacePhiUsesWith(InnerLoopHeader, + OuterLoopHeader); updateSuccessor(InnerLoopHeaderBI, InnerLoopHeaderSuccessor, OuterLoopPreHeader, DTUpdates); @@ -1449,7 +1443,7 @@ bool LoopInterchangeTransform::adjustLoopBranches() { moveLCSSAPhis(InnerLoopLatchSuccessor, InnerLoopLatch, OuterLoopLatch); // For PHIs in the exit block of the outer loop, outer's latch has been // replaced by Inners'. - updateIncomingBlock(OuterLoopLatchSuccessor, OuterLoopLatch, InnerLoopLatch); + OuterLoopLatchSuccessor->replacePhiUsesWith(OuterLoopLatch, InnerLoopLatch); // Now update the reduction PHIs in the inner and outer loop headers. SmallVector InnerLoopPHIs, OuterLoopPHIs; @@ -1476,10 +1470,10 @@ bool LoopInterchangeTransform::adjustLoopBranches() { } // Update the incoming blocks for moved PHI nodes. - updateIncomingBlock(OuterLoopHeader, InnerLoopPreHeader, OuterLoopPreHeader); - updateIncomingBlock(OuterLoopHeader, InnerLoopLatch, OuterLoopLatch); - updateIncomingBlock(InnerLoopHeader, OuterLoopPreHeader, InnerLoopPreHeader); - updateIncomingBlock(InnerLoopHeader, OuterLoopLatch, InnerLoopLatch); + OuterLoopHeader->replacePhiUsesWith(InnerLoopPreHeader, OuterLoopPreHeader); + OuterLoopHeader->replacePhiUsesWith(InnerLoopLatch, OuterLoopLatch); + InnerLoopHeader->replacePhiUsesWith(OuterLoopPreHeader, InnerLoopPreHeader); + InnerLoopHeader->replacePhiUsesWith(OuterLoopLatch, InnerLoopLatch); return true; }