[llvm-commits] [llvm] r41287 - /llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp
Devang Patel
dpatel at apple.com
Wed Aug 22 12:33:29 PDT 2007
Author: dpatel
Date: Wed Aug 22 14:33:29 2007
New Revision: 41287
URL: http://llvm.org/viewvc/llvm-project?rev=41287&view=rev
Log:
Cosmetic change
"True Loop" and "False Loop" naming terminology to refer two loops
after loop cloning is confusing. Instead just use A_Loop and B_Loop.
Modified:
llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp
Modified: llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp?rev=41287&r1=41286&r2=41287&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/LoopIndexSplit.cpp Wed Aug 22 14:33:29 2007
@@ -757,60 +757,73 @@
if (!safeSplitCondition(SD))
return false;
- // True loop is original loop. False loop is cloned loop.
- BasicBlock *TL_SplitCondBlock = SD.SplitCondition->getParent();
- BasicBlock *TL_Preheader = L->getLoopPreheader();
-
- bool SignedPredicate = ExitCondition->isSignedPredicate();
- //[*] Calculate True loop's new Exit Value in loop preheader.
- // TL_ExitValue = min(SplitValue, ExitValue)
- //[*] Calculate False loop's new Start Value in loop preheader.
- // FL_StartValue = max(SplitValue, TrueLoop.StartValue)
- Value *TL_ExitValue = NULL;
- Value *FL_StartValue = NULL;
+ // After loop is cloned there are two loops.
+ //
+ // First loop, referred as ALoop, executes first part of loop's iteration
+ // space split. Second loop, referred as BLoop, executes remaining
+ // part of loop's iteration space.
+ //
+ // ALoop's exit edge enters BLoop's header through a forwarding block which
+ // acts as a BLoop's preheader.
+
+ //[*] Calculate ALoop induction variable's new exiting value and
+ // BLoop induction variable's new starting value. Calculuate these
+ // values in original loop's preheader.
+ // A_ExitValue = min(SplitValue, OrignalLoopExitValue)
+ // B_StartValue = max(SplitValue, OriginalLoopStartValue)
+ Value *A_ExitValue = NULL;
+ Value *B_StartValue = NULL;
if (isa<ConstantInt>(SD.SplitValue)) {
- TL_ExitValue = SD.SplitValue;
- FL_StartValue = SD.SplitValue;
+ A_ExitValue = SD.SplitValue;
+ B_StartValue = SD.SplitValue;
}
else {
- Instruction *TL_PHTerminator = TL_Preheader->getTerminator();
+ BasicBlock *Preheader = L->getLoopPreheader();
+ Instruction *PHTerminator = Preheader->getTerminator();
+ bool SignedPredicate = ExitCondition->isSignedPredicate();
Value *C1 = new ICmpInst(SignedPredicate ?
ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,
SD.SplitValue,
ExitCondition->getOperand(ExitValueNum),
- "lsplit.ev", TL_PHTerminator);
- TL_ExitValue = new SelectInst(C1, SD.SplitValue,
+ "lsplit.ev", PHTerminator);
+ A_ExitValue = new SelectInst(C1, SD.SplitValue,
ExitCondition->getOperand(ExitValueNum),
- "lsplit.ev", TL_PHTerminator);
+ "lsplit.ev", PHTerminator);
Value *C2 = new ICmpInst(SignedPredicate ?
ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,
SD.SplitValue, StartValue, "lsplit.sv",
- TL_PHTerminator);
- FL_StartValue = new SelectInst(C2, StartValue, SD.SplitValue,
- "lsplit.sv", TL_PHTerminator);
+ PHTerminator);
+ B_StartValue = new SelectInst(C2, StartValue, SD.SplitValue,
+ "lsplit.sv", PHTerminator);
}
- //[*] Clone loop. Avoid true destination of split condition and
- // the blocks dominated by true destination.
+ //[*] Clone loop.
DenseMap<const Value *, Value *> ValueMap;
- Loop *FalseLoop = CloneLoop(L, LPM, LI, ValueMap, this);
- BasicBlock *FL_Header = FalseLoop->getHeader();
+ Loop *BLoop = CloneLoop(L, LPM, LI, ValueMap, this);
+ BasicBlock *B_Header = BLoop->getHeader();
- //[*] True loop's exit edge enters False loop.
- PHINode *FL_IndVar = cast<PHINode>(ValueMap[IndVar]);
- BasicBlock *TL_ExitingBlock = ExitCondition->getParent();
- BranchInst *TL_ExitInsn =
- dyn_cast<BranchInst>(TL_ExitingBlock->getTerminator());
- assert (TL_ExitInsn && "Unable to find suitable loop exit branch");
- BasicBlock *TL_ExitDest = TL_ExitInsn->getSuccessor(1);
-
- if (L->contains(TL_ExitDest)) {
- TL_ExitDest = TL_ExitInsn->getSuccessor(0);
- TL_ExitInsn->setSuccessor(0, FL_Header);
+ //[*] ALoop's exiting edge BLoop's header.
+ // ALoop's original exit block becomes BLoop's exit block.
+ PHINode *B_IndVar = cast<PHINode>(ValueMap[IndVar]);
+ BasicBlock *A_ExitingBlock = ExitCondition->getParent();
+ BranchInst *A_ExitInsn =
+ dyn_cast<BranchInst>(A_ExitingBlock->getTerminator());
+ assert (A_ExitInsn && "Unable to find suitable loop exit branch");
+ BasicBlock *B_ExitBlock = A_ExitInsn->getSuccessor(1);
+ if (L->contains(B_ExitBlock)) {
+ B_ExitBlock = A_ExitInsn->getSuccessor(0);
+ A_ExitInsn->setSuccessor(0, B_Header);
} else
- TL_ExitInsn->setSuccessor(1, FL_Header);
+ A_ExitInsn->setSuccessor(1, B_Header);
+
+ //[*] Update ALoop's exit value using new exit value.
+ ExitCondition->setOperand(ExitValueNum, A_ExitValue);
+ // [*] Update BLoop's header phi nodes. Remove incoming PHINode's from
+ // original loop's preheader. Add incoming PHINode values from
+ // ALoop's exiting block. Update BLoop header's domiantor info.
+
// Collect inverse map of Header PHINodes.
DenseMap<Value *, Value *> InverseMap;
for (BasicBlock::iterator BI = L->getHeader()->begin(),
@@ -821,76 +834,81 @@
} else
break;
}
-
- // Update False loop's header
- for (BasicBlock::iterator BI = FL_Header->begin(), BE = FL_Header->end();
+ BasicBlock *Preheader = L->getLoopPreheader();
+ for (BasicBlock::iterator BI = B_Header->begin(), BE = B_Header->end();
BI != BE; ++BI) {
if (PHINode *PN = dyn_cast<PHINode>(BI)) {
- PN->removeIncomingValue(TL_Preheader);
- if (PN == FL_IndVar)
- PN->addIncoming(FL_StartValue, TL_ExitingBlock);
+ // Remove incoming value from original preheader.
+ PN->removeIncomingValue(Preheader);
+
+ // Add incoming value from A_ExitingBlock.
+ if (PN == B_IndVar)
+ PN->addIncoming(B_StartValue, A_ExitingBlock);
else {
PHINode *OrigPN = cast<PHINode>(InverseMap[PN]);
- Value *V2 = OrigPN->getIncomingValueForBlock(TL_ExitingBlock);
- PN->addIncoming(V2, TL_ExitingBlock);
+ Value *V2 = OrigPN->getIncomingValueForBlock(A_ExitingBlock);
+ PN->addIncoming(V2, A_ExitingBlock);
}
} else
break;
}
+ DT->changeImmediateDominator(B_Header, A_ExitingBlock);
+ DF->changeImmediateDominator(B_Header, A_ExitingBlock, DT);
- // Update TL_ExitDest. Now it's predecessor is False loop's exit block.
- BasicBlock *FL_ExitingBlock = cast<BasicBlock>(ValueMap[TL_ExitingBlock]);
- for (BasicBlock::iterator BI = TL_ExitDest->begin(), BE = TL_ExitDest->end();
+ // [*] Update BLoop's exit block. Its new predecessor is BLoop's exit
+ // block. Remove incoming PHINode values from ALoop's exiting block.
+ // Add new incoming values from BLoop's incoming exiting value.
+ // Update BLoop exit block's dominator info..
+ BasicBlock *B_ExitingBlock = cast<BasicBlock>(ValueMap[A_ExitingBlock]);
+ for (BasicBlock::iterator BI = B_ExitBlock->begin(), BE = B_ExitBlock->end();
BI != BE; ++BI) {
if (PHINode *PN = dyn_cast<PHINode>(BI)) {
- PN->addIncoming(ValueMap[PN->getIncomingValueForBlock(TL_ExitingBlock)],
- FL_ExitingBlock);
- PN->removeIncomingValue(TL_ExitingBlock);
+ PN->addIncoming(ValueMap[PN->getIncomingValueForBlock(A_ExitingBlock)],
+ B_ExitingBlock);
+ PN->removeIncomingValue(A_ExitingBlock);
} else
break;
}
- if (DT) {
- DT->changeImmediateDominator(FL_Header, TL_ExitingBlock);
- DT->changeImmediateDominator(TL_ExitDest,
- cast<BasicBlock>(ValueMap[TL_ExitingBlock]));
- }
-
- assert (!L->contains(TL_ExitDest) && " Unable to find exit edge destination");
-
- //[*] Split Exit Edge.
- BasicBlock *TL_ExitBlock = SplitEdge(TL_ExitingBlock, FL_Header, this);
-
- //[*] Eliminate split condition's false branch from True loop.
- BranchInst *TL_BR = cast<BranchInst>(TL_SplitCondBlock->getTerminator());
- BasicBlock *TL_FalseBlock = TL_BR->getSuccessor(1);
- TL_BR->setUnconditionalDest(TL_BR->getSuccessor(0));
- removeBlocks(TL_FalseBlock, L, TL_BR->getSuccessor(0));
-
- //[*] Update True loop's exit value using new exit value.
- ExitCondition->setOperand(ExitValueNum, TL_ExitValue);
-
- //[*] Eliminate split condition's true branch in False loop CFG.
- BasicBlock *FL_SplitCondBlock = cast<BasicBlock>(ValueMap[TL_SplitCondBlock]);
- BranchInst *FL_BR = cast<BranchInst>(FL_SplitCondBlock->getTerminator());
- BasicBlock *FL_TrueBlock = FL_BR->getSuccessor(0);
- FL_BR->setUnconditionalDest(FL_BR->getSuccessor(1));
- removeBlocks(FL_TrueBlock, FalseLoop,
- cast<BasicBlock>(FL_BR->getSuccessor(0)));
+ DT->changeImmediateDominator(B_ExitBlock, B_ExitingBlock);
+ DF->changeImmediateDominator(B_ExitBlock, B_ExitingBlock, DT);
- //[*] Preserve LCSSA
- for(BasicBlock::iterator BI = FL_Header->begin(), BE = FL_Header->end();
+ //[*] Split ALoop's exit edge. This creates a new block which
+ // serves two purposes. First one is to hold PHINode defnitions
+ // to ensure that ALoop's LCSSA form. Second use it to act
+ // as a preheader for BLoop.
+ BasicBlock *A_ExitBlock = SplitEdge(A_ExitingBlock, B_Header, this);
+
+ //[*] Preserve ALoop's LCSSA form. Create new forwarding PHINodes
+ // in A_ExitBlock to redefine outgoing PHI definitions from ALoop.
+ for(BasicBlock::iterator BI = B_Header->begin(), BE = B_Header->end();
BI != BE; ++BI) {
if (PHINode *PN = dyn_cast<PHINode>(BI)) {
- Value *V1 = PN->getIncomingValueForBlock(TL_ExitBlock);
+ Value *V1 = PN->getIncomingValueForBlock(A_ExitBlock);
PHINode *newPHI = new PHINode(PN->getType(), PN->getName());
- newPHI->addIncoming(V1, TL_ExitingBlock);
- TL_ExitBlock->getInstList().push_front(newPHI);
- PN->removeIncomingValue(TL_ExitBlock);
- PN->addIncoming(newPHI, TL_ExitBlock);
+ newPHI->addIncoming(V1, A_ExitingBlock);
+ A_ExitBlock->getInstList().push_front(newPHI);
+ PN->removeIncomingValue(A_ExitBlock);
+ PN->addIncoming(newPHI, A_ExitBlock);
} else
break;
}
+ //[*] Eliminate split condition's inactive branch from ALoop.
+ BasicBlock *A_SplitCondBlock = SD.SplitCondition->getParent();
+ BranchInst *A_BR = cast<BranchInst>(A_SplitCondBlock->getTerminator());
+ BasicBlock *A_InactiveBranch = A_BR->getSuccessor(1);
+ BasicBlock *A_ActiveBranch = A_BR->getSuccessor(1);
+ A_BR->setUnconditionalDest(A_BR->getSuccessor(0));
+ removeBlocks(A_InactiveBranch, L, A_ActiveBranch);
+
+ //[*] Eliminate split condition's inactive branch in from BLoop.
+ BasicBlock *B_SplitCondBlock = cast<BasicBlock>(ValueMap[A_SplitCondBlock]);
+ BranchInst *B_BR = cast<BranchInst>(B_SplitCondBlock->getTerminator());
+ BasicBlock *B_InactiveBranch = B_BR->getSuccessor(0);
+ BasicBlock *B_ActiveBranch = B_BR->getSuccessor(1);
+ B_BR->setUnconditionalDest(B_BR->getSuccessor(1));
+ removeBlocks(B_InactiveBranch, BLoop, B_ActiveBranch);
+
return true;
}
More information about the llvm-commits
mailing list