#include "llvm/Instructions.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/LoopPass.h"
+#include "llvm/Analysis/Dominators.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"),
cl::init(10), cl::Hidden);
- class VISIBILITY_HIDDEN LoopUnswitch : public FunctionPass {
+ class VISIBILITY_HIDDEN LoopUnswitch : public LoopPass {
LoopInfo *LI; // Loop information
+ LPPassManager *LPM;
- // LoopProcessWorklist - List of loops we need to process.
+ // LoopProcessWorklist - Used to check if second loop needs processing
+ // after RewriteLoopBodyWithConditionConstant rewrites first loop.
std::vector<Loop*> LoopProcessWorklist;
SmallPtrSet<Value *,8> UnswitchedVals;
-
+
+ bool OptimizeForSize;
public:
- virtual bool runOnFunction(Function &F);
- bool visitLoop(Loop *L);
+ static char ID; // Pass ID, replacement for typeid
+ LoopUnswitch(bool Os = false) :
+ LoopPass((intptr_t)&ID), OptimizeForSize(Os) {}
+
+ bool runOnLoop(Loop *L, LPPassManager &LPM);
/// This transformation requires natural loop information & requires that
/// loop preheaders be inserted into the CFG...
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequiredID(LoopSimplifyID);
AU.addPreservedID(LoopSimplifyID);
+ AU.addPreserved<DominatorTree>();
AU.addRequired<LoopInfo>();
AU.addPreserved<LoopInfo>();
AU.addRequiredID(LCSSAID);
void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
Constant *Val, bool isEqual);
-
+
+ void EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
+ BasicBlock *TrueDest,
+ BasicBlock *FalseDest,
+ Instruction *InsertPt);
+
void SimplifyCode(std::vector<Instruction*> &Worklist);
void RemoveBlockIfDead(BasicBlock *BB,
std::vector<Instruction*> &Worklist);
void RemoveLoopFromHierarchy(Loop *L);
};
+ char LoopUnswitch::ID = 0;
RegisterPass<LoopUnswitch> X("loop-unswitch", "Unswitch loops");
}
-FunctionPass *llvm::createLoopUnswitchPass() { return new LoopUnswitch(); }
-
-bool LoopUnswitch::runOnFunction(Function &F) {
- bool Changed = false;
- LI = &getAnalysis<LoopInfo>();
-
- // Populate the worklist of loops to process in post-order.
- for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
- for (po_iterator<Loop*> LI = po_begin(*I), E = po_end(*I); LI != E; ++LI)
- LoopProcessWorklist.push_back(*LI);
-
- // Process the loops in worklist order, this is a post-order visitation of
- // the loops. We use a worklist of loops so that loops can be removed at any
- // time if they are deleted (e.g. the backedge of a loop is removed).
- while (!LoopProcessWorklist.empty()) {
- Loop *L = LoopProcessWorklist.back();
- LoopProcessWorklist.pop_back();
- Changed |= visitLoop(L);
- }
-
- UnswitchedVals.clear();
- return Changed;
+LoopPass *llvm::createLoopUnswitchPass(bool Os) {
+ return new LoopUnswitch(Os);
}
/// FindLIVLoopCondition - Cond is a condition that occurs in L. If it is
static Value *FindLIVLoopCondition(Value *Cond, Loop *L, bool &Changed) {
// Constants should be folded, not unswitched on!
if (isa<Constant>(Cond)) return false;
-
+
// TODO: Handle: br (VARIANT|INVARIANT).
// TODO: Hoist simple expressions out of loops.
if (L->isLoopInvariant(Cond)) return Cond;
return 0;
}
-bool LoopUnswitch::visitLoop(Loop *L) {
+bool LoopUnswitch::runOnLoop(Loop *L, LPPassManager &LPM_Ref) {
assert(L->isLCSSAForm());
-
+ LI = &getAnalysis<LoopInfo>();
+ LPM = &LPM_Ref;
bool Changed = false;
// Loop over all of the basic blocks in the loop. If we find an interior
// loop.
for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
I != E; ++I) {
+ if (*I == L->getHeader())
+ continue;
TerminatorInst *TI = (*I)->getTerminator();
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
// If this isn't branching on an invariant condition, we can't unswitch
bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val,Loop *L){
// Check to see if it would be profitable to unswitch this loop.
unsigned Cost = getLoopUnswitchCost(L, LoopCond);
+
+ // Do not do non-trivial unswitch while optimizing for size.
+ if (Cost && OptimizeForSize)
+ return false;
+
if (Cost > Threshold) {
// FIXME: this should estimate growth by the amount of code shared by the
// resultant unswitched loops.
// 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<DominatorTree>())
+ DT->addNewBlock(New, Old);
+
return New;
}
}
}
+// CloneDomInfo - NewBB is cloned from Orig basic block. Now clone Dominator Info.
+// If Orig is in Loop then find and use Orig dominator's cloned block as NewBB
+// dominator.
+void CloneDomInfo(BasicBlock *NewBB, BasicBlock *Orig, Loop *L,
+ DominatorTree *DT,
+ DenseMap<const Value*, Value*> &VM) {
+
+ DomTreeNode *OrigNode = DT->getNode(Orig);
+ if (!OrigNode)
+ return;
+ BasicBlock *OrigIDom = OrigNode->getBlock();
+ BasicBlock *NewIDom = OrigIDom;
+ if (L->contains(OrigIDom)) {
+ if (!DT->getNode(OrigIDom))
+ CloneDomInfo(NewIDom, OrigIDom, L, DT, VM);
+ NewIDom = cast<BasicBlock>(VM[OrigIDom]);
+ }
+ if (NewBB == NewIDom) {
+ DT->addNewBlock(NewBB, OrigIDom);
+ DT->changeImmediateDominator(NewBB, NewIDom);
+ } else
+ DT->addNewBlock(NewBB, NewIDom);
+}
+
/// CloneLoop - Recursively clone the specified loop and all of its children,
/// mapping the blocks with the specified map.
static Loop *CloneLoop(Loop *L, Loop *PL, DenseMap<const Value*, Value*> &VM,
- LoopInfo *LI) {
+ LoopInfo *LI, LPPassManager *LPM) {
Loop *New = new Loop();
- if (PL)
- PL->addChildLoop(New);
- else
- LI->addTopLevelLoop(New);
+ LPM->insertLoop(New, PL);
// Add all of the blocks in L to the new loop.
for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
// Add all of the subloops to the new loop.
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
- CloneLoop(*I, New, VM, LI);
+ CloneLoop(*I, New, VM, LI, LPM);
return New;
}
/// EmitPreheaderBranchOnCondition - Emit a conditional branch on two values
/// if LIC == Val, branch to TrueDst, otherwise branch to FalseDest. Insert the
/// code immediately before InsertPt.
-static void EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
- BasicBlock *TrueDest,
- BasicBlock *FalseDest,
- Instruction *InsertPt) {
+void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
+ BasicBlock *TrueDest,
+ BasicBlock *FalseDest,
+ Instruction *InsertPt) {
// Insert a conditional branch on LIC to the two preheaders. The original
// code is the true version and the new code is the false version.
Value *BranchVal = LIC;
std::swap(TrueDest, FalseDest);
// Insert the new branch.
- new BranchInst(TrueDest, FalseDest, BranchVal, InsertPt);
+ BranchInst *BRI = new BranchInst(TrueDest, FalseDest, BranchVal, InsertPt);
+
+ // Update dominator info.
+ if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>()) {
+ // BranchVal is a new preheader so it dominates true and false destination
+ // loop headers.
+ DT->changeImmediateDominator(TrueDest, BRI->getParent());
+ DT->changeImmediateDominator(FalseDest, BRI->getParent());
+ }
}
OrigPH->getTerminator()->eraseFromParent();
// We need to reprocess this loop, it could be unswitched again.
- LoopProcessWorklist.push_back(L);
+ LPM->redoLoop(L);
// Now that we know that the loop is never entered when this condition is a
// particular value, rewrite the loop with this info. We know that this will
++NumTrivial;
}
-
/// VersionLoop - We determined that the loop is profitable to unswitch when LIC
/// equal Val. Split it into loop versions and test the condition outside of
/// either loop. Return the loops created as Out1/Out2.
std::vector<BasicBlock*> Preds(pred_begin(ExitBlock), pred_end(ExitBlock));
for (unsigned j = 0, e = Preds.size(); j != e; ++j) {
- assert(L->contains(Preds[j]) &&
- "All preds of loop exit blocks must be the same loop!");
BasicBlock* MiddleBlock = SplitEdge(Preds[j], ExitBlock);
BasicBlock* StartBlock = Preds[j];
BasicBlock* EndBlock;
ValueMap[LoopBlocks[i]] = New; // Keep the BB mapping.
}
+ // Update dominator info
+ if (DominatorTree *DT = getAnalysisToUpdate<DominatorTree>())
+ for (unsigned i = 0, e = LoopBlocks.size(); i != e; ++i) {
+ BasicBlock *LBB = LoopBlocks[i];
+ BasicBlock *NBB = NewBlocks[i];
+ CloneDomInfo(NBB, LBB, L, DT, ValueMap);
+ }
+
// Splice the newly inserted blocks into the function right before the
// original preheader.
F->getBasicBlockList().splice(LoopBlocks[0], F->getBasicBlockList(),
NewBlocks[0], F->end());
// Now we create the new Loop object for the versioned loop.
- Loop *NewLoop = CloneLoop(L, L->getParentLoop(), ValueMap, LI);
+ Loop *NewLoop = CloneLoop(L, L->getParentLoop(), ValueMap, LI, LPM);
Loop *ParentLoop = L->getParentLoop();
if (ParentLoop) {
// Make sure to add the cloned preheader and exit blocks to the parent loop
EmitPreheaderBranchOnCondition(LIC, Val, NewBlocks[0], LoopBlocks[0], OldBR);
OldBR->eraseFromParent();
- LoopProcessWorklist.push_back(L);
LoopProcessWorklist.push_back(NewLoop);
+ LPM->redoLoop(L);
// Now we rewrite the original code to know that the condition is true and the
// new code to know that the condition is false.
/// so they just reparent loops. If the loops are actually dead, they will be
/// removed later.
void LoopUnswitch::RemoveLoopFromHierarchy(Loop *L) {
- if (Loop *ParentLoop = L->getParentLoop()) { // Not a top-level loop.
- // Reparent all of the blocks in this loop. Since BBLoop had a parent,
- // they are now all in it.
- for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
- I != E; ++I)
- if (LI->getLoopFor(*I) == L) // Don't change blocks in subloops.
- LI->changeLoopFor(*I, ParentLoop);
-
- // Remove the loop from its parent loop.
- for (Loop::iterator I = ParentLoop->begin(), E = ParentLoop->end();;
- ++I) {
- assert(I != E && "Couldn't find loop");
- if (*I == L) {
- ParentLoop->removeChildLoop(I);
- break;
- }
- }
-
- // Move all subloops into the parent loop.
- while (L->begin() != L->end())
- ParentLoop->addChildLoop(L->removeChildLoop(L->end()-1));
- } else {
- // Reparent all of the blocks in this loop. Since BBLoop had no parent,
- // they no longer in a loop at all.
-
- for (unsigned i = 0; i != L->getBlocks().size(); ++i) {
- // Don't change blocks in subloops.
- if (LI->getLoopFor(L->getBlocks()[i]) == L) {
- LI->removeBlock(L->getBlocks()[i]);
- --i;
- }
- }
-
- // Remove the loop from the top-level LoopInfo object.
- for (LoopInfo::iterator I = LI->begin(), E = LI->end();; ++I) {
- assert(I != E && "Couldn't find loop");
- if (*I == L) {
- LI->removeLoop(I);
- break;
- }
- }
-
- // Move all of the subloops to the top-level.
- while (L->begin() != L->end())
- LI->addTopLevelLoop(L->removeChildLoop(L->end()-1));
- }
-
- delete L;
+ LPM->deleteLoopFromQueue(L);
RemoveLoopFromWorklist(L);
}
projects / oota-llvm.git / blobdiff