Transforms/Scalar/LICM.cpp

//===-- 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;
}