lib/Analysis/InductionVariable.cpp

   1 //===- llvm/Analysis/InductionVariable.h - Induction variable ----*- C++ -*--=//
   2 //
   3 // This interface is used to identify and classify induction variables that
   4 // exist in the program.  Induction variables must contain a PHI node that
   5 // exists in a loop header.  Because of this, they are identified an managed by
   6 // this PHI node.
   7 //
   8 // Induction variables are classified into a type.  Knowing that an induction
   9 // variable is of a specific type can constrain the values of the start and
  10 // step.  For example, a SimpleLinear induction variable must have a start and
  11 // step values that are constants.
  12 //
  13 // Induction variables can be created with or without loop information.  If no
  14 // loop information is available, induction variables cannot be recognized to be
  15 // more than SimpleLinear variables.
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/Analysis/InductionVariable.h"
  20 #include "llvm/Analysis/LoopInfo.h"
  21 #include "llvm/Analysis/Expressions.h"
  22 #include "llvm/iOther.h"
  23 #include "llvm/Type.h"
  24 #include "llvm/ConstPoolVals.h"
  25
  26 using analysis::ExprType;
  27
  28
  29 static bool isLoopInvariant(const Value *V, const cfg::Loop *L) {
  30   if (isa<ConstPoolVal>(V) || isa<MethodArgument>(V) || isa<GlobalValue>(V))
  31     return true;
  32
  33   const Instruction *I = cast<Instruction>(V);
  34   const BasicBlock *BB = I->getParent();
  35
  36   return !L->contains(BB);
  37 }
  38
  39 enum InductionVariable::iType
  40 InductionVariable::Classify(const Value *Start, const Value *Step,
  41                             const cfg::Loop *L = 0) {
  42   // Check for cannonical and simple linear expressions now...
  43   if (ConstPoolInt *CStart = dyn_cast<ConstPoolInt>(Start))
  44     if (ConstPoolInt *CStep = dyn_cast<ConstPoolInt>(Step)) {
  45       if (CStart->equalsInt(0) && CStep->equalsInt(1))
  46         return Cannonical;
  47       else
  48         return SimpleLinear;
  49     }
  50
  51   // Without loop information, we cannot do any better, so bail now...
  52   if (L == 0) return Unknown;
  53
  54   if (isLoopInvariant(Start, L) && isLoopInvariant(Step, L))
  55     return Linear;
  56   return Unknown;
  57 }
  58
  59 // Create an induction variable for the specified value.  If it is a PHI, and
  60 // if it's recognizable, classify it and fill in instance variables.
  61 //
  62 InductionVariable::InductionVariable(Instruction *V, cfg::LoopInfo *LoopInfo) {
  63   InductionType = Unknown;     // Assume the worst
  64
  65   // If this instruction is not a PHINode, it can't be an induction variable.
  66   // Also, if the PHI node has more than two predecessors, we don't know how to
  67   // handle it.
  68   //
  69   Phi = dyn_cast<PHINode>(V);
  70   if (!Phi || Phi->getNumIncomingValues() != 2) return;
  71
  72   // If we have loop information, make sure that this PHI node is in the header
  73   // of a loop...
  74   //
  75   const cfg::Loop *L = LoopInfo ? LoopInfo->getLoopFor(Phi->getParent()) : 0;
  76   if (L && L->getHeader() != Phi->getParent())
  77     return;
  78
  79   Value *V1 = Phi->getIncomingValue(0);
  80   Value *V2 = Phi->getIncomingValue(1);
  81
  82   if (L == 0) {  // No loop information?  Base everything on expression analysis
  83     ExprType E1 = analysis::ClassifyExpression(V1);
  84     ExprType E2 = analysis::ClassifyExpression(V2);
  85
  86     if (E1.ExprTy > E2.ExprTy)        // Make E1 be the simpler expression
  87       swap(E1, E2);
  88
  89     // E1 must be a constant incoming value, and E2 must be a linear expression
  90     // with respect to the PHI node.
  91     //
  92     if (E1.ExprTy > ExprType::Constant || E2.ExprTy != ExprType::Linear ||
  93         E2.Var != Phi)
  94       return;
  95
  96     // Okay, we have found an induction variable. Save the start and step values
  97     const Type *ETy = Phi->getType();
  98     if (ETy->isPointerType()) ETy = Type::ULongTy;
  99
 100     Start = (Value*)(E1.Offset ? E1.Offset : ConstPoolInt::get(ETy, 0));
 101     Step  = (Value*)(E2.Offset ? E2.Offset : ConstPoolInt::get(ETy, 0));
 102   } else {
 103     // Okay, at this point, we know that we have loop information...
 104
 105     // Make sure that V1 is the incoming value, and V2 is from the backedge of
 106     // the loop.
 107     if (L->contains(Phi->getIncomingBlock(0)))     // Wrong order.  Swap now.
 108       swap(V1, V2);
 109
 110     Start = V1;     // We know that Start has to be loop invariant...
 111     Step = 0;
 112
 113     if (V2 == Phi) {  // referencing the PHI directly?  Must have zero step
 114       Step = ConstPoolVal::getNullConstant(Phi->getType());
 115     } else if (BinaryOperator *I = dyn_cast<BinaryOperator>(V2)) {
 116       // TODO: This could be much better...
 117       if (I->getOpcode() == Instruction::Add) {
 118         if (I->getOperand(0) == Phi)
 119           Step = I->getOperand(1);
 120         else if (I->getOperand(1) == Phi)
 121           Step = I->getOperand(0);
 122       }
 123     }
 124
 125     if (Step == 0) {                  // Unrecognized step value...
 126       ExprType StepE = analysis::ClassifyExpression(V2);
 127       if (StepE.ExprTy != ExprType::Linear ||
 128           StepE.Var != Phi) return;
 129
 130       const Type *ETy = Phi->getType();
 131       if (ETy->isPointerType()) ETy = Type::ULongTy;
 132       Step  = (Value*)(StepE.Offset ? StepE.Offset : ConstPoolInt::get(ETy, 0));
 133     }
 134   }
 135
 136   // Classify the induction variable type now...
 137   InductionType = InductionVariable::Classify(Start, Step, L);
 138 }