llvm-project/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp

//===- LoopStrengthReduce.cpp - Strength Reduce GEPs in Loops -------------===//
// 
//                     The LLVM Compiler Infrastructure
//
// This file was developed by Nate Begeman and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This pass performs a strength reduction on array references inside loops that
// have as one or more of their components the loop induction variable.  This is
// accomplished by creating a new Value to hold the initial value of the array
// access for the first iteration, and then creating a new GEP instruction in
// the loop to increment the value by the appropriate amount.
//
// There are currently several deficiencies in the implementation, marked with
// FIXME in the code.
//
//===----------------------------------------------------------------------===//

#include "llvm/Transforms/Scalar.h"
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/CFG.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/ADT/Statistic.h"
#include <set>
using namespace llvm;

namespace {
  Statistic<> NumReduced ("loop-reduce", "Number of GEPs strength reduced");

  class LoopStrengthReduce : public FunctionPass {
    LoopInfo *LI;
    DominatorSet *DS;
    bool Changed;
  public:
    virtual bool runOnFunction(Function &) {
      LI = &getAnalysis<LoopInfo>();
      DS = &getAnalysis<DominatorSet>();
      Changed = false;

      for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
        runOnLoop(*I);
      return Changed;
    }

    virtual void getAnalysisUsage(AnalysisUsage &AU) const {
      AU.setPreservesCFG();
      AU.addRequired<LoopInfo>();
      AU.addRequired<DominatorSet>();
    }
  private:
    void runOnLoop(Loop *L);
    void strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L,
                           Instruction *InsertBefore,
                           std::set<Instruction*> &DeadInsts);
    void DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts);
  };
  RegisterOpt<LoopStrengthReduce> X("loop-reduce", 
                                    "Strength Reduce GEP Uses of Ind. Vars");
}

FunctionPass *llvm::createLoopStrengthReducePass() {
  return new LoopStrengthReduce();
}

/// DeleteTriviallyDeadInstructions - If any of the instructions is the
/// specified set are trivially dead, delete them and see if this makes any of
/// their operands subsequently dead.
void LoopStrengthReduce::
DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts) {
  while (!Insts.empty()) {
    Instruction *I = *Insts.begin();
    Insts.erase(Insts.begin());
    if (isInstructionTriviallyDead(I)) {
      for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
        if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
          Insts.insert(U);
      I->getParent()->getInstList().erase(I);
      Changed = true;
    }
  }
}

void LoopStrengthReduce::strengthReduceGEP(GetElementPtrInst *GEPI, Loop *L,
                                           Instruction *InsertBefore,
                                           std::set<Instruction*> &DeadInsts) {
  // We will strength reduce the GEP by splitting it into two parts.  The first
  // is a GEP to hold the initial value of the non-strength-reduced GEP upon
  // entering the loop, which we will insert at the end of the loop preheader.
  // The second is a GEP to hold the incremented value of the initial GEP.
  // The LoopIndVarSimplify pass guarantees that loop counts start at zero, so
  // we will replace the indvar with a constant zero value to create the first
  // GEP.
  //
  // We currently only handle GEP instructions that consist of zero or more
  // constants and one instance of the canonical induction variable.
  bool foundIndvar = false;
  bool indvarLast = false;
  std::vector<Value *> pre_op_vector;
  std::vector<Value *> inc_op_vector;
  Value *CanonicalIndVar = L->getCanonicalInductionVariable();
  for (unsigned op = 1, e = GEPI->getNumOperands(); op != e; ++op) {
    Value *operand = GEPI->getOperand(op);
    if (operand == CanonicalIndVar) {
      // FIXME: We currently only support strength reducing GEP instructions
      // with one instance of the canonical induction variable.  This means that 
      // we can't deal with statements of the form A[i][i].
      if (foundIndvar == true)
        return;
        
      // FIXME: use getCanonicalInductionVariableIncrement to choose between
      // one and neg one maybe?  We need to support int *foo = GEP base, -1
      const Type *Ty = CanonicalIndVar->getType();
      pre_op_vector.push_back(Constant::getNullValue(Ty));
      inc_op_vector.push_back(ConstantInt::get(Ty, 1));
      foundIndvar = true;
      indvarLast = true;
    } else if (isa<Constant>(operand)) {
      pre_op_vector.push_back(operand);
      if (indvarLast == true) indvarLast = false;
    } else
      return;
  }
  // FIXME: handle GEPs where the indvar is not the last element of the index
  // array.
  if (indvarLast == false)
    return;
  assert(true == foundIndvar && "Indvar used by GEP not found in operand list");
  
  // FIXME: Being able to hoist the definition of the initial pointer value
  // would allow us to strength reduce more loops.  For example, %tmp.32 in the
  // following loop:
  // entry:
  //   br label %no_exit.0
  // no_exit.0:		; preds = %entry, %no_exit.0
  //   %init.1.0 = phi uint [ 0, %entry ], [ %indvar.next, %no_exit.0 ]
  //   %tmp.32 = load uint** %CROSSING
  //   %tmp.35 = getelementptr uint* %tmp.32, uint %init.1.0
  //   br label %no_exit.0
  BasicBlock *Header = L->getHeader();
  if (Instruction *GepPtrOp = dyn_cast<Instruction>(GEPI->getOperand(0)))
    if (!DS->dominates(GepPtrOp, Header->begin()))
      return;
  
  // If all operands of the GEP we are going to insert into the preheader
  // are constants, generate a GEP ConstantExpr instead. 
  //
  // If there is only one operand after the initial non-constant one, we know
  // that it was the induction variable, and has been replaced by a constant
  // null value.  In this case, replace the GEP with a use of pointer directly.
  //
  // 
  BasicBlock *Preheader = L->getLoopPreheader();
  Value *PreGEP;
  if (isa<Constant>(GEPI->getOperand(0))) {
    Constant *C = dyn_cast<Constant>(GEPI->getOperand(0));
    PreGEP = ConstantExpr::getGetElementPtr(C, pre_op_vector);
  } else if (pre_op_vector.size() == 1) {
    PreGEP = GEPI->getOperand(0);
  } else {
    PreGEP = new GetElementPtrInst(GEPI->getOperand(0),
                                   pre_op_vector, GEPI->getName(), 
                                   Preheader->getTerminator());
  }

  // The next step of the strength reduction is to create a PHI that will choose
  // between the initial GEP we created and inserted into the preheader, and 
  // the incremented GEP that we will create below and insert into the loop body
  PHINode *NewPHI = new PHINode(PreGEP->getType(), 
                                GEPI->getName()+".str", InsertBefore);
  NewPHI->addIncoming(PreGEP, Preheader);
  
  // Now, create the GEP instruction to increment the value selected by the PHI
  // instruction we just created above by one, and add it as the second incoming
  // Value and BasicBlock pair to the PHINode.
  Instruction *IncrInst = 
    const_cast<Instruction*>(L->getCanonicalInductionVariableIncrement());
  GetElementPtrInst *StrGEP = new GetElementPtrInst(NewPHI, inc_op_vector,
                                                    GEPI->getName()+".inc",
                                                    IncrInst);
  NewPHI->addIncoming(StrGEP, IncrInst->getParent());
  
  // Replace all uses of the old GEP instructions with the new PHI
  GEPI->replaceAllUsesWith(NewPHI);
  
  // The old GEP is now dead.
  DeadInsts.insert(GEPI);
  ++NumReduced;
}

void LoopStrengthReduce::runOnLoop(Loop *L) {
  // First step, transform all loops nesting inside of this loop.
  for (LoopInfo::iterator I = L->begin(), E = L->end(); I != E; ++I)
    runOnLoop(*I);

  // Next, get the first PHINode since it is guaranteed to be the canonical
  // induction variable for the loop by the preceding IndVarSimplify pass.
  PHINode *PN = L->getCanonicalInductionVariable();
  if (0 == PN)
    return;

  // Insert secondary PHI nodes after the canonical induction variable's PHI
  // for the strength reduced pointers that we will be creating.
  Instruction *InsertBefore = PN->getNext();

  // FIXME: Need to use SCEV to detect GEP uses of the indvar, since indvars
  // pass creates code like this, which we can't currently detect:
  //  %tmp.1 = sub uint 2000, %indvar
  //  %tmp.8 = getelementptr int* %y, uint %tmp.1
  
  // Strength reduce all GEPs in the Loop
  std::set<Instruction*> DeadInsts;
  for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end();
       UI != UE; ++UI)
    if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*UI))
      strengthReduceGEP(GEPI, L, InsertBefore, DeadInsts);

  // Clean up after ourselves
  if (!DeadInsts.empty()) {
    DeleteTriviallyDeadInstructions(DeadInsts);

    // At this point, we know that we have killed one or more GEP instructions.
    // It is worth checking to see if the cann indvar is also dead, so that we
    // can remove it as well.  The requirements for the cann indvar to be
    // considered dead are:
    // 1. the cann indvar has one use
    // 2. the use is an add instruction
    // 3. the add has one use
    // 4. the add is used by the cann indvar
    // If all four cases above are true, then we can remove both the add and
    // the cann indvar.
    if (PN->hasOneUse()) {
      BinaryOperator *BO = dyn_cast<BinaryOperator>(*(PN->use_begin()));
      if (BO && BO->getOpcode() == Instruction::Add)
        if (BO->hasOneUse()) {
          PHINode *PotentialIndvar = dyn_cast<PHINode>(*(BO->use_begin()));
          if (PotentialIndvar && PN == PotentialIndvar) {
            PN->dropAllReferences();
            DeadInsts.insert(BO);
            DeadInsts.insert(PN);
            DeleteTriviallyDeadInstructions(DeadInsts);
          }
        }
    }
  }
}