From 05c1dc64936c196d7242567e85710b26e8696336 Mon Sep 17 00:00:00 2001 From: Devang Patel Date: Fri, 6 Jul 2007 22:03:47 +0000 Subject: [PATCH] These rountines are now available as part of basic block utilities. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37955 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/LoopUnswitch.cpp | 71 ++------------------------ 1 file changed, 5 insertions(+), 66 deletions(-) diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp index 498d3785f97..f57c0450083 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -106,8 +106,6 @@ namespace { void UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val, BasicBlock *ExitBlock); void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L); - BasicBlock *SplitEdge(BasicBlock *From, BasicBlock *To); - BasicBlock *SplitBlock(BasicBlock *Old, Instruction *SplitPt); void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC, Constant *Val, bool isEqual); @@ -399,65 +397,6 @@ bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val,Loop *L){ return true; } -/// SplitBlock - Split the specified block at the specified instruction - every -/// thing before SplitPt stays in Old and everything starting with SplitPt moves -/// to a new block. The two blocks are joined by an unconditional branch and -/// the loop info is updated. -/// -BasicBlock *LoopUnswitch::SplitBlock(BasicBlock *Old, Instruction *SplitPt) { - BasicBlock::iterator SplitIt = SplitPt; - while (isa(SplitIt)) - ++SplitIt; - BasicBlock *New = Old->splitBasicBlock(SplitIt, Old->getName()+".split"); - - // The new block lives in whichever loop the old one did. - if (Loop *L = LI->getLoopFor(Old)) - L->addBasicBlockToLoop(New, *LI); - - if (DominatorTree *DT = getAnalysisToUpdate()) - DT->addNewBlock(New, Old); - - if (DominanceFrontier *DF = getAnalysisToUpdate()) - DF->splitBlock(Old); - - return New; -} - - -BasicBlock *LoopUnswitch::SplitEdge(BasicBlock *BB, BasicBlock *Succ) { - TerminatorInst *LatchTerm = BB->getTerminator(); - unsigned SuccNum = 0; - for (unsigned i = 0, e = LatchTerm->getNumSuccessors(); ; ++i) { - assert(i != e && "Didn't find edge?"); - if (LatchTerm->getSuccessor(i) == Succ) { - SuccNum = i; - break; - } - } - - // If this is a critical edge, let SplitCriticalEdge do it. - if (SplitCriticalEdge(BB->getTerminator(), SuccNum, this)) - return LatchTerm->getSuccessor(SuccNum); - - // If the edge isn't critical, then BB has a single successor or Succ has a - // single pred. Split the block. - BasicBlock::iterator SplitPoint; - if (BasicBlock *SP = Succ->getSinglePredecessor()) { - // If the successor only has a single pred, split the top of the successor - // block. - assert(SP == BB && "CFG broken"); - return SplitBlock(Succ, Succ->begin()); - } else { - // Otherwise, if BB has a single successor, split it at the bottom of the - // block. - assert(BB->getTerminator()->getNumSuccessors() == 1 && - "Should have a single succ!"); - return SplitBlock(BB, BB->getTerminator()); - } -} - - - // RemapInstruction - Convert the instruction operands from referencing the // current values into those specified by ValueMap. // @@ -581,7 +520,7 @@ void LoopUnswitch::UnswitchTrivialCondition(Loop *L, Value *Cond, // to insert the conditional branch. We will change 'OrigPH' to have a // conditional branch on Cond. BasicBlock *OrigPH = L->getLoopPreheader(); - BasicBlock *NewPH = SplitEdge(OrigPH, L->getHeader()); + BasicBlock *NewPH = SplitEdge(OrigPH, L->getHeader(), this); // Now that we have a place to insert the conditional branch, create a place // to branch to: this is the exit block out of the loop that we should @@ -592,7 +531,7 @@ void LoopUnswitch::UnswitchTrivialCondition(Loop *L, Value *Cond, // without actually branching to it (the exit block should be dominated by the // loop header, not the preheader). assert(!L->contains(ExitBlock) && "Exit block is in the loop?"); - BasicBlock *NewExit = SplitBlock(ExitBlock, ExitBlock->begin()); + BasicBlock *NewExit = SplitBlock(ExitBlock, ExitBlock->begin(), this); // Okay, now we have a position to branch from and a position to branch to, // insert the new conditional branch. @@ -629,7 +568,7 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val, // First step, split the preheader and exit blocks, and add these blocks to // the LoopBlocks list. BasicBlock *OrigPreheader = L->getLoopPreheader(); - LoopBlocks.push_back(SplitEdge(OrigPreheader, L->getHeader())); + LoopBlocks.push_back(SplitEdge(OrigPreheader, L->getHeader(), this)); // We want the loop to come after the preheader, but before the exit blocks. LoopBlocks.insert(LoopBlocks.end(), L->block_begin(), L->block_end()); @@ -644,7 +583,7 @@ void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val, std::vector Preds(pred_begin(ExitBlock), pred_end(ExitBlock)); for (unsigned j = 0, e = Preds.size(); j != e; ++j) { - BasicBlock* MiddleBlock = SplitEdge(Preds[j], ExitBlock); + BasicBlock* MiddleBlock = SplitEdge(Preds[j], ExitBlock, this); BasicBlock* StartBlock = Preds[j]; BasicBlock* EndBlock; if (MiddleBlock->getSinglePredecessor() == ExitBlock) { @@ -985,7 +924,7 @@ void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC, // loop structure and put the block on an dead code path. BasicBlock* Old = SI->getParent(); - BasicBlock* Split = SplitBlock(Old, SI); + BasicBlock* Split = SplitBlock(Old, SI, this); Instruction* OldTerm = Old->getTerminator(); new BranchInst(Split, SI->getSuccessor(i),