summaryrefslogtreecommitdiffstats
path: root/llvm/lib/Transforms
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/Transforms')
-rw-r--r--llvm/lib/Transforms/Scalar/LICM.cpp262
1 files changed, 262 insertions, 0 deletions
diff --git a/llvm/lib/Transforms/Scalar/LICM.cpp b/llvm/lib/Transforms/Scalar/LICM.cpp
new file mode 100644
index 00000000000..3be163ce412
--- /dev/null
+++ b/llvm/lib/Transforms/Scalar/LICM.cpp
@@ -0,0 +1,262 @@
+//===-- LICM.cpp - Loop Invariant Code Motion Pass ------------------------===//
+//
+// This pass is a simple loop invariant code motion pass.
+//
+// Note that this pass does NOT require pre-headers to exist on loops in the
+// CFG, but if there is not distinct preheader for a loop, the hoisted code will
+// be *DUPLICATED* in every basic block, outside of the loop, that preceeds the
+// loop header. Additionally, any use of one of these hoisted expressions
+// cannot be loop invariant itself, because the expression hoisted gets a PHI
+// node that is loop variant.
+//
+// For these reasons, and many more, it makes sense to run a pass before this
+// that ensures that there are preheaders on all loops. That said, we don't
+// REQUIRE it. :)
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/iOperators.h"
+#include "llvm/iPHINode.h"
+#include "llvm/Support/InstVisitor.h"
+#include "llvm/Support/CFG.h"
+#include "Support/STLExtras.h"
+#include "Support/StatisticReporter.h"
+#include <algorithm>
+
+static Statistic<> NumHoistedNPH("licm\t\t- Number of insts hoisted to multiple"
+ " loop preds (bad, no loop pre-header)");
+static Statistic<> NumHoistedPH("licm\t\t- Number of insts hoisted to a loop "
+ "pre-header");
+
+namespace {
+ struct LICM : public FunctionPass, public InstVisitor<LICM> {
+ const char *getPassName() const { return "Loop Invariant Code Motion"; }
+
+ virtual bool runOnFunction(Function *F);
+
+ // This transformation requires natural loop information...
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.preservesCFG();
+ AU.addRequired(LoopInfo::ID);
+ }
+
+ private:
+ // List of predecessor blocks for the current loop - These blocks are where
+ // we hoist loop invariants to for the current loop.
+ //
+ std::vector<BasicBlock*> LoopPreds, LoopBackEdges;
+
+ Loop *CurLoop; // The current loop we are working on...
+ bool Changed; // Set to true when we change anything.
+
+ // visitLoop - Hoist expressions out of the specified loop...
+ void visitLoop(Loop *L);
+
+ // notInCurrentLoop - Little predicate that returns true if the specified
+ // basic block is in a subloop of the current one, not the current one
+ // itself.
+ //
+ bool notInCurrentLoop(BasicBlock *BB) {
+ for (unsigned i = 0, e = CurLoop->getSubLoops().size(); i != e; ++i)
+ if (CurLoop->getSubLoops()[i]->contains(BB))
+ return true; // A subloop actually contains this block!
+ return false;
+ }
+
+ // hoist - 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 hoist(Instruction *I);
+
+ // isLoopInvariant - Return true if the specified value is loop invariant
+ inline bool isLoopInvariant(Value *V) {
+ if (Instruction *I = dyn_cast<Instruction>(V))
+ return !CurLoop->contains(I->getParent());
+ return true; // All non-instructions are loop invariant
+ }
+
+ // visitBasicBlock - Run LICM on a particular block.
+ void visitBasicBlock(BasicBlock *BB);
+
+ // Instruction visitation handlers... these basically control whether or not
+ // the specified instruction types are hoisted.
+ //
+ friend class InstVisitor<LICM>;
+ void visitUnaryOperator(Instruction *I) {
+ if (isLoopInvariant(I->getOperand(0))) hoist(I);
+ }
+ void visitBinaryOperator(Instruction *I) {
+ if (isLoopInvariant(I->getOperand(0)) &&isLoopInvariant(I->getOperand(1)))
+ hoist(I);
+ }
+
+ void visitCastInst(CastInst *I) { visitUnaryOperator((Instruction*)I); }
+ void visitShiftInst(ShiftInst *I) { visitBinaryOperator((Instruction*)I); }
+
+ void visitGetElementPtrInst(GetElementPtrInst *GEPI) {
+ Instruction *I = (Instruction*)GEPI;
+ for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
+ if (!isLoopInvariant(I->getOperand(i))) return;
+ hoist(I);
+ }
+ };
+}
+
+Pass *createLICMPass() { return new LICM(); }
+
+bool LICM::runOnFunction(Function *F) {
+ // get our loop information...
+ const std::vector<Loop*> &TopLevelLoops =
+ getAnalysis<LoopInfo>().getTopLevelLoops();
+
+ // Traverse loops in postorder, hoisting expressions out of the deepest loops
+ // first.
+ //
+ Changed = false;
+ std::for_each(TopLevelLoops.begin(), TopLevelLoops.end(),
+ bind_obj(this, &LICM::visitLoop));
+ return Changed;
+}
+
+void LICM::visitLoop(Loop *L) {
+ // Recurse through all subloops before we process this loop...
+ std::for_each(L->getSubLoops().begin(), L->getSubLoops().end(),
+ bind_obj(this, &LICM::visitLoop));
+ CurLoop = L;
+
+ // Calculate the set of predecessors for this loop. The predecessors for this
+ // loop are equal to the predecessors for the header node of the loop that are
+ // not themselves in the loop.
+ //
+ BasicBlock *Header = L->getHeader();
+
+ // Calculate the sets of predecessors and backedges of the loop...
+ LoopBackEdges.insert(LoopBackEdges.end(),pred_begin(Header),pred_end(Header));
+
+ std::vector<BasicBlock*>::iterator LPI =
+ std::partition(LoopBackEdges.begin(), LoopBackEdges.end(),
+ bind_obj(CurLoop, &Loop::contains));
+
+ // Move all predecessors to the LoopPreds vector...
+ LoopPreds.insert(LoopPreds.end(), LPI, LoopBackEdges.end());
+
+ // Remove predecessors from backedges list...
+ LoopBackEdges.erase(LPI, LoopBackEdges.end());
+
+
+ // The only way that there could be no predecessors to a loop is if the loop
+ // is not reachable. Since we don't care about optimizing dead loops,
+ // summarily ignore them.
+ //
+ if (LoopPreds.empty()) return;
+
+ // We want to visit all of the instructions in this loop... that are not parts
+ // of our subloops (they have already had their invariants hoisted out of
+ // their loop, into this loop, so there is no need to process the BODIES of
+ // the subloops).
+ //
+ std::vector<BasicBlock*> BBs(L->getBlocks().begin(), L->getBlocks().end());
+
+ // Remove blocks that are actually in subloops...
+ BBs.erase(std::remove_if(BBs.begin(), BBs.end(),
+ bind_obj(this, &LICM::notInCurrentLoop)), BBs.end());
+
+ // Visit all of the basic blocks we have chosen, hoisting out the instructions
+ // as neccesary. This leaves dead copies of the instruction in the loop
+ // unfortunately...
+ //
+ for_each(BBs.begin(), BBs.end(), bind_obj(this, &LICM::visitBasicBlock));
+
+ // Clear out loops state information for the next iteration
+ CurLoop = 0;
+ LoopPreds.clear();
+ LoopBackEdges.clear();
+}
+
+void LICM::visitBasicBlock(BasicBlock *BB) {
+ // This cannot use an iterator, because it might get invalidated when PHI
+ // nodes are inserted!
+ //
+ for (unsigned i = 0; i < BB->size(); ) {
+ visit(BB->begin()[i]);
+
+ BasicBlock::iterator It = BB->begin()+i;
+ if (dceInstruction(BB->getInstList(), It))
+ Changed = true;
+ else
+ ++i;
+ }
+}
+
+
+void LICM::hoist(Instruction *Inst) {
+ if (Inst->use_empty()) return; // Don't (re) hoist dead instructions!
+ //cerr << "Hoisting " << Inst;
+
+ BasicBlock *Header = CurLoop->getHeader();
+
+ // Old instruction will be removed, so take it's name...
+ string InstName = Inst->getName();
+ Inst->setName("");
+
+ // The common case is that we have a pre-header. Generate special case code
+ // that is faster if that is the case.
+ //
+ if (LoopPreds.size() == 1) {
+ BasicBlock *Pred = LoopPreds[0];
+
+ // Create a new copy of the instruction, for insertion into Pred.
+ Instruction *New = Inst->clone();
+ New->setName(InstName);
+
+ // Insert the new node in Pred, before the terminator.
+ Pred->getInstList().insert(Pred->end()-1, New);
+
+ // Kill the old instruction.
+ Inst->replaceAllUsesWith(New);
+ ++NumHoistedPH;
+
+ } else {
+ // No loop pre-header, insert a PHI node into header to capture all of the
+ // incoming versions of the value.
+ //
+ PHINode *LoopVal = new PHINode(Inst->getType(), InstName+".phi");
+
+ // Insert the new PHI node into the loop header...
+ Header->getInstList().push_front(LoopVal);
+
+ // Insert cloned versions of the instruction into all of the loop preds.
+ for (unsigned i = 0, e = LoopPreds.size(); i != e; ++i) {
+ BasicBlock *Pred = LoopPreds[i];
+
+ // Create a new copy of the instruction, for insertion into Pred.
+ Instruction *New = Inst->clone();
+ New->setName(InstName);
+
+ // Insert the new node in Pred, before the terminator.
+ Pred->getInstList().insert(Pred->end()-1, New);
+
+ // Add the incoming value to the PHI node.
+ LoopVal->addIncoming(New, Pred);
+ }
+
+ // Add incoming values to the PHI node for all backedges in the loop...
+ for (unsigned i = 0, e = LoopBackEdges.size(); i != e; ++i)
+ LoopVal->addIncoming(LoopVal, LoopBackEdges[i]);
+
+ // Replace all uses of the old version of the instruction in the loop with
+ // the new version that is out of the loop. We know that this is ok,
+ // because the new definition is in the loop header, which dominates the
+ // entire loop body. The old definition was defined _inside_ of the loop,
+ // so the scope cannot extend outside of the loop, so we're ok.
+ //
+ Inst->replaceAllUsesWith(LoopVal);
+ ++NumHoistedNPH;
+ }
+
+ Changed = true;
+}
+
OpenPOWER on IntegriCloud