lib/Analysis/ScalarEvolution.cpp

   1 //===- ScalarEvolution.cpp - Scalar Evolution Analysis ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the implementation of the scalar evolution analysis
  11 // engine, which is used primarily to analyze expressions involving induction
  12 // variables in loops.
  13 //
  14 // There are several aspects to this library.  First is the representation of
  15 // scalar expressions, which are represented as subclasses of the SCEV class.
  16 // These classes are used to represent certain types of subexpressions that we
  17 // can handle. We only create one SCEV of a particular shape, so
  18 // pointer-comparisons for equality are legal.
  19 //
  20 // One important aspect of the SCEV objects is that they are never cyclic, even
  21 // if there is a cycle in the dataflow for an expression (ie, a PHI node).  If
  22 // the PHI node is one of the idioms that we can represent (e.g., a polynomial
  23 // recurrence) then we represent it directly as a recurrence node, otherwise we
  24 // represent it as a SCEVUnknown node.
  25 //
  26 // In addition to being able to represent expressions of various types, we also
  27 // have folders that are used to build the *canonical* representation for a
  28 // particular expression.  These folders are capable of using a variety of
  29 // rewrite rules to simplify the expressions.
  30 //
  31 // Once the folders are defined, we can implement the more interesting
  32 // higher-level code, such as the code that recognizes PHI nodes of various
  33 // types, computes the execution count of a loop, etc.
  34 //
  35 // TODO: We should use these routines and value representations to implement
  36 // dependence analysis!
  37 //
  38 //===----------------------------------------------------------------------===//
  39 //
  40 // There are several good references for the techniques used in this analysis.
  41 //
  42 //  Chains of recurrences -- a method to expedite the evaluation
  43 //  of closed-form functions
  44 //  Olaf Bachmann, Paul S. Wang, Eugene V. Zima
  45 //
  46 //  On computational properties of chains of recurrences
  47 //  Eugene V. Zima
  48 //
  49 //  Symbolic Evaluation of Chains of Recurrences for Loop Optimization
  50 //  Robert A. van Engelen
  51 //
  52 //  Efficient Symbolic Analysis for Optimizing Compilers
  53 //  Robert A. van Engelen
  54 //
  55 //  Using the chains of recurrences algebra for data dependence testing and
  56 //  induction variable substitution
  57 //  MS Thesis, Johnie Birch
  58 //
  59 //===----------------------------------------------------------------------===//
  60
  61 #define DEBUG_TYPE "scalar-evolution"
  62 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
  63 #include "llvm/Constants.h"
  64 #include "llvm/DerivedTypes.h"
  65 #include "llvm/GlobalVariable.h"
  66 #include "llvm/GlobalAlias.h"
  67 #include "llvm/Instructions.h"
  68 #include "llvm/LLVMContext.h"
  69 #include "llvm/Operator.h"
  70 #include "llvm/Analysis/ConstantFolding.h"
  71 #include "llvm/Analysis/Dominators.h"
  72 #include "llvm/Analysis/LoopInfo.h"
  73 #include "llvm/Analysis/ValueTracking.h"
  74 #include "llvm/Assembly/Writer.h"
  75 #include "llvm/Target/TargetData.h"
  76 #include "llvm/Support/CommandLine.h"
  77 #include "llvm/Support/ConstantRange.h"
  78 #include "llvm/Support/Debug.h"
  79 #include "llvm/Support/ErrorHandling.h"
  80 #include "llvm/Support/GetElementPtrTypeIterator.h"
  81 #include "llvm/Support/InstIterator.h"
  82 #include "llvm/Support/MathExtras.h"
  83 #include "llvm/Support/raw_ostream.h"
  84 #include "llvm/ADT/Statistic.h"
  85 #include "llvm/ADT/STLExtras.h"
  86 #include "llvm/ADT/SmallPtrSet.h"
  87 #include <algorithm>
  88 using namespace llvm;
  89
  90 STATISTIC(NumArrayLenItCounts,
  91           "Number of trip counts computed with array length");
  92 STATISTIC(NumTripCountsComputed,
  93           "Number of loops with predictable loop counts");
  94 STATISTIC(NumTripCountsNotComputed,
  95           "Number of loops without predictable loop counts");
  96 STATISTIC(NumBruteForceTripCountsComputed,
  97           "Number of loops with trip counts computed by force");
  98
  99 static cl::opt<unsigned>
 100 MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden,
 101                         cl::desc("Maximum number of iterations SCEV will "
 102                                  "symbolically execute a constant "
 103                                  "derived loop"),
 104                         cl::init(100));
 105
 106 INITIALIZE_PASS(ScalarEvolution, "scalar-evolution",
 107                 "Scalar Evolution Analysis", false, true);
 108 char ScalarEvolution::ID = 0;
 109
 110 //===----------------------------------------------------------------------===//
 111 //                           SCEV class definitions
 112 //===----------------------------------------------------------------------===//
 113
 114 //===----------------------------------------------------------------------===//
 115 // Implementation of the SCEV class.
 116 //
 117
 118 SCEV::~SCEV() {}
 119
 120 void SCEV::dump() const {
 121   print(dbgs());
 122   dbgs() << '\n';
 123 }
 124
 125 bool SCEV::isZero() const {
 126   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 127     return SC->getValue()->isZero();
 128   return false;
 129 }
 130
 131 bool SCEV::isOne() const {
 132   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 133     return SC->getValue()->isOne();
 134   return false;
 135 }
 136
 137 bool SCEV::isAllOnesValue() const {
 138   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 139     return SC->getValue()->isAllOnesValue();
 140   return false;
 141 }
 142
 143 SCEVCouldNotCompute::SCEVCouldNotCompute() :
 144   SCEV(FoldingSetNodeIDRef(), scCouldNotCompute) {}
 145
 146 bool SCEVCouldNotCompute::isLoopInvariant(const Loop *L) const {
 147   llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 148   return false;
 149 }
 150
 151 const Type *SCEVCouldNotCompute::getType() const {
 152   llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 153   return 0;
 154 }
 155
 156 bool SCEVCouldNotCompute::hasComputableLoopEvolution(const Loop *L) const {
 157   llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 158   return false;
 159 }
 160
 161 bool SCEVCouldNotCompute::hasOperand(const SCEV *) const {
 162   llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 163   return false;
 164 }
 165
 166 void SCEVCouldNotCompute::print(raw_ostream &OS) const {
 167   OS << "***COULDNOTCOMPUTE***";
 168 }
 169
 170 bool SCEVCouldNotCompute::classof(const SCEV *S) {
 171   return S->getSCEVType() == scCouldNotCompute;
 172 }
 173
 174 const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
 175   FoldingSetNodeID ID;
 176   ID.AddInteger(scConstant);
 177   ID.AddPointer(V);
 178   void *IP = 0;
 179   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
 180   SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
 181   UniqueSCEVs.InsertNode(S, IP);
 182   return S;
 183 }
 184
 185 const SCEV *ScalarEvolution::getConstant(const APInt& Val) {
 186   return getConstant(ConstantInt::get(getContext(), Val));
 187 }
 188
 189 const SCEV *
 190 ScalarEvolution::getConstant(const Type *Ty, uint64_t V, bool isSigned) {
 191   const IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
 192   return getConstant(ConstantInt::get(ITy, V, isSigned));
 193 }
 194
 195 const Type *SCEVConstant::getType() const { return V->getType(); }
 196
 197 void SCEVConstant::print(raw_ostream &OS) const {
 198   WriteAsOperand(OS, V, false);
 199 }
 200
 201 SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID,
 202                            unsigned SCEVTy, const SCEV *op, const Type *ty)
 203   : SCEV(ID, SCEVTy), Op(op), Ty(ty) {}
 204
 205 bool SCEVCastExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
 206   return Op->dominates(BB, DT);
 207 }
 208
 209 bool SCEVCastExpr::properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
 210   return Op->properlyDominates(BB, DT);
 211 }
 212
 213 SCEVTruncateExpr::SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
 214                                    const SCEV *op, const Type *ty)
 215   : SCEVCastExpr(ID, scTruncate, op, ty) {
 216   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 217          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 218          "Cannot truncate non-integer value!");
 219 }
 220
 221 void SCEVTruncateExpr::print(raw_ostream &OS) const {
 222   OS << "(trunc " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
 223 }
 224
 225 SCEVZeroExtendExpr::SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
 226                                        const SCEV *op, const Type *ty)
 227   : SCEVCastExpr(ID, scZeroExtend, op, ty) {
 228   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 229          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 230          "Cannot zero extend non-integer value!");
 231 }
 232
 233 void SCEVZeroExtendExpr::print(raw_ostream &OS) const {
 234   OS << "(zext " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
 235 }
 236
 237 SCEVSignExtendExpr::SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
 238                                        const SCEV *op, const Type *ty)
 239   : SCEVCastExpr(ID, scSignExtend, op, ty) {
 240   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 241          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 242          "Cannot sign extend non-integer value!");
 243 }
 244
 245 void SCEVSignExtendExpr::print(raw_ostream &OS) const {
 246   OS << "(sext " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
 247 }
 248
 249 void SCEVCommutativeExpr::print(raw_ostream &OS) const {
 250   const char *OpStr = getOperationStr();
 251   OS << "(";
 252   for (op_iterator I = op_begin(), E = op_end(); I != E; ++I) {
 253     OS << **I;
 254     if (llvm::next(I) != E)
 255       OS << OpStr;
 256   }
 257   OS << ")";
 258 }
 259
 260 bool SCEVNAryExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
 261   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 262     if (!getOperand(i)->dominates(BB, DT))
 263       return false;
 264   }
 265   return true;
 266 }
 267
 268 bool SCEVNAryExpr::properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
 269   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
 270     if (!getOperand(i)->properlyDominates(BB, DT))
 271       return false;
 272   }
 273   return true;
 274 }
 275
 276 bool SCEVUDivExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
 277   return LHS->dominates(BB, DT) && RHS->dominates(BB, DT);
 278 }
 279
 280 bool SCEVUDivExpr::properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
 281   return LHS->properlyDominates(BB, DT) && RHS->properlyDominates(BB, DT);
 282 }
 283
 284 void SCEVUDivExpr::print(raw_ostream &OS) const {
 285   OS << "(" << *LHS << " /u " << *RHS << ")";
 286 }
 287
 288 const Type *SCEVUDivExpr::getType() const {
 289   // In most cases the types of LHS and RHS will be the same, but in some
 290   // crazy cases one or the other may be a pointer. ScalarEvolution doesn't
 291   // depend on the type for correctness, but handling types carefully can
 292   // avoid extra casts in the SCEVExpander. The LHS is more likely to be
 293   // a pointer type than the RHS, so use the RHS' type here.
 294   return RHS->getType();
 295 }
 296
 297 bool SCEVAddRecExpr::isLoopInvariant(const Loop *QueryLoop) const {
 298   // Add recurrences are never invariant in the function-body (null loop).
 299   if (!QueryLoop)
 300     return false;
 301
 302   // This recurrence is variant w.r.t. QueryLoop if QueryLoop contains L.
 303   if (QueryLoop->contains(L))
 304     return false;
 305
 306   // This recurrence is invariant w.r.t. QueryLoop if L contains QueryLoop.
 307   if (L->contains(QueryLoop))
 308     return true;
 309
 310   // This recurrence is variant w.r.t. QueryLoop if any of its operands
 311   // are variant.
 312   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
 313     if (!getOperand(i)->isLoopInvariant(QueryLoop))
 314       return false;
 315
 316   // Otherwise it's loop-invariant.
 317   return true;
 318 }
 319
 320 bool
 321 SCEVAddRecExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
 322   return DT->dominates(L->getHeader(), BB) &&
 323          SCEVNAryExpr::dominates(BB, DT);
 324 }
 325
 326 bool
 327 SCEVAddRecExpr::properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
 328   // This uses a "dominates" query instead of "properly dominates" query because
 329   // the instruction which produces the addrec's value is a PHI, and a PHI
 330   // effectively properly dominates its entire containing block.
 331   return DT->dominates(L->getHeader(), BB) &&
 332          SCEVNAryExpr::properlyDominates(BB, DT);
 333 }
 334
 335 void SCEVAddRecExpr::print(raw_ostream &OS) const {
 336   OS << "{" << *Operands[0];
 337   for (unsigned i = 1, e = NumOperands; i != e; ++i)
 338     OS << ",+," << *Operands[i];
 339   OS << "}<";
 340   WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
 341   OS << ">";
 342 }
 343
 344 void SCEVUnknown::deleted() {
 345   // Clear this SCEVUnknown from ValuesAtScopes.
 346   SE->ValuesAtScopes.erase(this);
 347
 348   // Remove this SCEVUnknown from the uniquing map.
 349   SE->UniqueSCEVs.RemoveNode(this);
 350
 351   // Release the value.
 352   setValPtr(0);
 353 }
 354
 355 void SCEVUnknown::allUsesReplacedWith(Value *New) {
 356   // Clear this SCEVUnknown from ValuesAtScopes.
 357   SE->ValuesAtScopes.erase(this);
 358
 359   // Remove this SCEVUnknown from the uniquing map.
 360   SE->UniqueSCEVs.RemoveNode(this);
 361
 362   // Update this SCEVUnknown to point to the new value. This is needed
 363   // because there may still be outstanding SCEVs which still point to
 364   // this SCEVUnknown.
 365   setValPtr(New);
 366 }
 367
 368 bool SCEVUnknown::isLoopInvariant(const Loop *L) const {
 369   // All non-instruction values are loop invariant.  All instructions are loop
 370   // invariant if they are not contained in the specified loop.
 371   // Instructions are never considered invariant in the function body
 372   // (null loop) because they are defined within the "loop".
 373   if (Instruction *I = dyn_cast<Instruction>(getValue()))
 374     return L && !L->contains(I);
 375   return true;
 376 }
 377
 378 bool SCEVUnknown::dominates(BasicBlock *BB, DominatorTree *DT) const {
 379   if (Instruction *I = dyn_cast<Instruction>(getValue()))
 380     return DT->dominates(I->getParent(), BB);
 381   return true;
 382 }
 383
 384 bool SCEVUnknown::properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
 385   if (Instruction *I = dyn_cast<Instruction>(getValue()))
 386     return DT->properlyDominates(I->getParent(), BB);
 387   return true;
 388 }
 389
 390 const Type *SCEVUnknown::getType() const {
 391   return getValue()->getType();
 392 }
 393
 394 bool SCEVUnknown::isSizeOf(const Type *&AllocTy) const {
 395   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 396     if (VCE->getOpcode() == Instruction::PtrToInt)
 397       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 398         if (CE->getOpcode() == Instruction::GetElementPtr &&
 399             CE->getOperand(0)->isNullValue() &&
 400             CE->getNumOperands() == 2)
 401           if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
 402             if (CI->isOne()) {
 403               AllocTy = cast<PointerType>(CE->getOperand(0)->getType())
 404                                  ->getElementType();
 405               return true;
 406             }
 407
 408   return false;
 409 }
 410
 411 bool SCEVUnknown::isAlignOf(const Type *&AllocTy) const {
 412   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 413     if (VCE->getOpcode() == Instruction::PtrToInt)
 414       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 415         if (CE->getOpcode() == Instruction::GetElementPtr &&
 416             CE->getOperand(0)->isNullValue()) {
 417           const Type *Ty =
 418             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
 419           if (const StructType *STy = dyn_cast<StructType>(Ty))
 420             if (!STy->isPacked() &&
 421                 CE->getNumOperands() == 3 &&
 422                 CE->getOperand(1)->isNullValue()) {
 423               if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
 424                 if (CI->isOne() &&
 425                     STy->getNumElements() == 2 &&
 426                     STy->getElementType(0)->isIntegerTy(1)) {
 427                   AllocTy = STy->getElementType(1);
 428                   return true;
 429                 }
 430             }
 431         }
 432
 433   return false;
 434 }
 435
 436 bool SCEVUnknown::isOffsetOf(const Type *&CTy, Constant *&FieldNo) const {
 437   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 438     if (VCE->getOpcode() == Instruction::PtrToInt)
 439       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 440         if (CE->getOpcode() == Instruction::GetElementPtr &&
 441             CE->getNumOperands() == 3 &&
 442             CE->getOperand(0)->isNullValue() &&
 443             CE->getOperand(1)->isNullValue()) {
 444           const Type *Ty =
 445             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
 446           // Ignore vector types here so that ScalarEvolutionExpander doesn't
 447           // emit getelementptrs that index into vectors.
 448           if (Ty->isStructTy() || Ty->isArrayTy()) {
 449             CTy = Ty;
 450             FieldNo = CE->getOperand(2);
 451             return true;
 452           }
 453         }
 454
 455   return false;
 456 }
 457
 458 void SCEVUnknown::print(raw_ostream &OS) const {
 459   const Type *AllocTy;
 460   if (isSizeOf(AllocTy)) {
 461     OS << "sizeof(" << *AllocTy << ")";
 462     return;
 463   }
 464   if (isAlignOf(AllocTy)) {
 465     OS << "alignof(" << *AllocTy << ")";
 466     return;
 467   }
 468
 469   const Type *CTy;
 470   Constant *FieldNo;
 471   if (isOffsetOf(CTy, FieldNo)) {
 472     OS << "offsetof(" << *CTy << ", ";
 473     WriteAsOperand(OS, FieldNo, false);
 474     OS << ")";
 475     return;
 476   }
 477
 478   // Otherwise just print it normally.
 479   WriteAsOperand(OS, getValue(), false);
 480 }
 481
 482 //===----------------------------------------------------------------------===//
 483 //                               SCEV Utilities
 484 //===----------------------------------------------------------------------===//
 485
 486 static bool CompareTypes(const Type *A, const Type *B) {
 487   if (A->getTypeID() != B->getTypeID())
 488     return A->getTypeID() < B->getTypeID();
 489   if (const IntegerType *AI = dyn_cast<IntegerType>(A)) {
 490     const IntegerType *BI = cast<IntegerType>(B);
 491     return AI->getBitWidth() < BI->getBitWidth();
 492   }
 493   if (const PointerType *AI = dyn_cast<PointerType>(A)) {
 494     const PointerType *BI = cast<PointerType>(B);
 495     return CompareTypes(AI->getElementType(), BI->getElementType());
 496   }
 497   if (const ArrayType *AI = dyn_cast<ArrayType>(A)) {
 498     const ArrayType *BI = cast<ArrayType>(B);
 499     if (AI->getNumElements() != BI->getNumElements())
 500       return AI->getNumElements() < BI->getNumElements();
 501     return CompareTypes(AI->getElementType(), BI->getElementType());
 502   }
 503   if (const VectorType *AI = dyn_cast<VectorType>(A)) {
 504     const VectorType *BI = cast<VectorType>(B);
 505     if (AI->getNumElements() != BI->getNumElements())
 506       return AI->getNumElements() < BI->getNumElements();
 507     return CompareTypes(AI->getElementType(), BI->getElementType());
 508   }
 509   if (const StructType *AI = dyn_cast<StructType>(A)) {
 510     const StructType *BI = cast<StructType>(B);
 511     if (AI->getNumElements() != BI->getNumElements())
 512       return AI->getNumElements() < BI->getNumElements();
 513     for (unsigned i = 0, e = AI->getNumElements(); i != e; ++i)
 514       if (CompareTypes(AI->getElementType(i), BI->getElementType(i)) ||
 515           CompareTypes(BI->getElementType(i), AI->getElementType(i)))
 516         return CompareTypes(AI->getElementType(i), BI->getElementType(i));
 517   }
 518   return false;
 519 }
 520
 521 namespace {
 522   /// SCEVComplexityCompare - Return true if the complexity of the LHS is less
 523   /// than the complexity of the RHS.  This comparator is used to canonicalize
 524   /// expressions.
 525   class SCEVComplexityCompare {
 526     const LoopInfo *const LI;
 527   public:
 528     explicit SCEVComplexityCompare(const LoopInfo *li) : LI(li) {}
 529
 530     bool operator()(const SCEV *LHS, const SCEV *RHS) const {
 531       // Fast-path: SCEVs are uniqued so we can do a quick equality check.
 532       if (LHS == RHS)
 533         return false;
 534
 535       // Primarily, sort the SCEVs by their getSCEVType().
 536       unsigned LType = LHS->getSCEVType(), RType = RHS->getSCEVType();
 537       if (LType != RType)
 538         return LType < RType;
 539
 540       // Aside from the getSCEVType() ordering, the particular ordering
 541       // isn't very important except that it's beneficial to be consistent,
 542       // so that (a + b) and (b + a) don't end up as different expressions.
 543
 544       // Sort SCEVUnknown values with some loose heuristics. TODO: This is
 545       // not as complete as it could be.
 546       if (const SCEVUnknown *LU = dyn_cast<SCEVUnknown>(LHS)) {
 547         const SCEVUnknown *RU = cast<SCEVUnknown>(RHS);
 548
 549         // Order pointer values after integer values. This helps SCEVExpander
 550         // form GEPs.
 551         bool LIsPointer = LU->getType()->isPointerTy(),
 552              RIsPointer = RU->getType()->isPointerTy();
 553         if (LIsPointer != RIsPointer)
 554           return RIsPointer;
 555
 556         // Compare getValueID values.
 557         unsigned LID = LU->getValue()->getValueID(),
 558                  RID = RU->getValue()->getValueID();
 559         if (LID != RID)
 560           return LID < RID;
 561
 562         // Sort arguments by their position.
 563         if (const Argument *LA = dyn_cast<Argument>(LU->getValue())) {
 564           const Argument *RA = cast<Argument>(RU->getValue());
 565           return LA->getArgNo() < RA->getArgNo();
 566         }
 567
 568         // For instructions, compare their loop depth, and their opcode.
 569         // This is pretty loose.
 570         if (const Instruction *LV = dyn_cast<Instruction>(LU->getValue())) {
 571           const Instruction *RV = cast<Instruction>(RU->getValue());
 572
 573           // Compare loop depths.
 574           unsigned LDepth = LI->getLoopDepth(LV->getParent()),
 575                    RDepth = LI->getLoopDepth(RV->getParent());
 576           if (LDepth != RDepth)
 577             return LDepth < RDepth;
 578
 579           // Compare the number of operands.
 580           unsigned LNumOps = LV->getNumOperands(),
 581                    RNumOps = RV->getNumOperands();
 582           if (LNumOps != RNumOps)
 583             return LNumOps < RNumOps;
 584         }
 585
 586         return false;
 587       }
 588
 589       // Compare constant values.
 590       if (const SCEVConstant *LC = dyn_cast<SCEVConstant>(LHS)) {
 591         const SCEVConstant *RC = cast<SCEVConstant>(RHS);
 592         const ConstantInt *LCC = LC->getValue();
 593         const ConstantInt *RCC = RC->getValue();
 594         unsigned LBitWidth = LCC->getBitWidth(), RBitWidth = RCC->getBitWidth();
 595         if (LBitWidth != RBitWidth)
 596           return LBitWidth < RBitWidth;
 597         return LCC->getValue().ult(RCC->getValue());
 598       }
 599
 600       // Compare addrec loop depths.
 601       if (const SCEVAddRecExpr *LA = dyn_cast<SCEVAddRecExpr>(LHS)) {
 602         const SCEVAddRecExpr *RA = cast<SCEVAddRecExpr>(RHS);
 603         unsigned LDepth = LA->getLoop()->getLoopDepth(),
 604                  RDepth = RA->getLoop()->getLoopDepth();
 605         if (LDepth != RDepth)
 606           return LDepth < RDepth;
 607       }
 608
 609       // Lexicographically compare n-ary expressions.
 610       if (const SCEVNAryExpr *LC = dyn_cast<SCEVNAryExpr>(LHS)) {
 611         const SCEVNAryExpr *RC = cast<SCEVNAryExpr>(RHS);
 612         unsigned LNumOps = LC->getNumOperands(), RNumOps = RC->getNumOperands();
 613         for (unsigned i = 0; i != LNumOps; ++i) {
 614           if (i >= RNumOps)
 615             return false;
 616           const SCEV *LOp = LC->getOperand(i), *ROp = RC->getOperand(i);
 617           if (operator()(LOp, ROp))
 618             return true;
 619           if (operator()(ROp, LOp))
 620             return false;
 621         }
 622         return LNumOps < RNumOps;
 623       }
 624
 625       // Lexicographically compare udiv expressions.
 626       if (const SCEVUDivExpr *LC = dyn_cast<SCEVUDivExpr>(LHS)) {
 627         const SCEVUDivExpr *RC = cast<SCEVUDivExpr>(RHS);
 628         const SCEV *LL = LC->getLHS(), *LR = LC->getRHS(),
 629                    *RL = RC->getLHS(), *RR = RC->getRHS();
 630         if (operator()(LL, RL))
 631           return true;
 632         if (operator()(RL, LL))
 633           return false;
 634         if (operator()(LR, RR))
 635           return true;
 636         if (operator()(RR, LR))
 637           return false;
 638         return false;
 639       }
 640
 641       // Compare cast expressions by operand.
 642       if (const SCEVCastExpr *LC = dyn_cast<SCEVCastExpr>(LHS)) {
 643         const SCEVCastExpr *RC = cast<SCEVCastExpr>(RHS);
 644         return operator()(LC->getOperand(), RC->getOperand());
 645       }
 646
 647       llvm_unreachable("Unknown SCEV kind!");
 648       return false;
 649     }
 650   };
 651 }
 652
 653 /// GroupByComplexity - Given a list of SCEV objects, order them by their
 654 /// complexity, and group objects of the same complexity together by value.
 655 /// When this routine is finished, we know that any duplicates in the vector are
 656 /// consecutive and that complexity is monotonically increasing.
 657 ///
 658 /// Note that we go take special precautions to ensure that we get deterministic
 659 /// results from this routine.  In other words, we don't want the results of
 660 /// this to depend on where the addresses of various SCEV objects happened to
 661 /// land in memory.
 662 ///
 663 static void GroupByComplexity(SmallVectorImpl<const SCEV *> &Ops,
 664                               LoopInfo *LI) {
 665   if (Ops.size() < 2) return;  // Noop
 666   if (Ops.size() == 2) {
 667     // This is the common case, which also happens to be trivially simple.
 668     // Special case it.
 669     if (SCEVComplexityCompare(LI)(Ops[1], Ops[0]))
 670       std::swap(Ops[0], Ops[1]);
 671     return;
 672   }
 673
 674   // Do the rough sort by complexity.
 675   std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
 676
 677   // Now that we are sorted by complexity, group elements of the same
 678   // complexity.  Note that this is, at worst, N^2, but the vector is likely to
 679   // be extremely short in practice.  Note that we take this approach because we
 680   // do not want to depend on the addresses of the objects we are grouping.
 681   for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
 682     const SCEV *S = Ops[i];
 683     unsigned Complexity = S->getSCEVType();
 684
 685     // If there are any objects of the same complexity and same value as this
 686     // one, group them.
 687     for (unsigned j = i+1; j != e && Ops[j]->getSCEVType() == Complexity; ++j) {
 688       if (Ops[j] == S) { // Found a duplicate.
 689         // Move it to immediately after i'th element.
 690         std::swap(Ops[i+1], Ops[j]);
 691         ++i;   // no need to rescan it.
 692         if (i == e-2) return;  // Done!
 693       }
 694     }
 695   }
 696 }
 697
 698
 699
 700 //===----------------------------------------------------------------------===//
 701 //                      Simple SCEV method implementations
 702 //===----------------------------------------------------------------------===//
 703
 704 /// BinomialCoefficient - Compute BC(It, K).  The result has width W.
 705 /// Assume, K > 0.
 706 static const SCEV *BinomialCoefficient(const SCEV *It, unsigned K,
 707                                        ScalarEvolution &SE,
 708                                        const Type* ResultTy) {
 709   // Handle the simplest case efficiently.
 710   if (K == 1)
 711     return SE.getTruncateOrZeroExtend(It, ResultTy);
 712
 713   // We are using the following formula for BC(It, K):
 714   //
 715   //   BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / K!
 716   //
 717   // Suppose, W is the bitwidth of the return value.  We must be prepared for
 718   // overflow.  Hence, we must assure that the result of our computation is
 719   // equal to the accurate one modulo 2^W.  Unfortunately, division isn't
 720   // safe in modular arithmetic.
 721   //
 722   // However, this code doesn't use exactly that formula; the formula it uses
 723   // is something like the following, where T is the number of factors of 2 in
 724   // K! (i.e. trailing zeros in the binary representation of K!), and ^ is
 725   // exponentiation:
 726   //
 727   //   BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / 2^T / (K! / 2^T)
 728   //
 729   // This formula is trivially equivalent to the previous formula.  However,
 730   // this formula can be implemented much more efficiently.  The trick is that
 731   // K! / 2^T is odd, and exact division by an odd number *is* safe in modular
 732   // arithmetic.  To do exact division in modular arithmetic, all we have
 733   // to do is multiply by the inverse.  Therefore, this step can be done at
 734   // width W.
 735   //
 736   // The next issue is how to safely do the division by 2^T.  The way this
 737   // is done is by doing the multiplication step at a width of at least W + T
 738   // bits.  This way, the bottom W+T bits of the product are accurate. Then,
 739   // when we perform the division by 2^T (which is equivalent to a right shift
 740   // by T), the bottom W bits are accurate.  Extra bits are okay; they'll get
 741   // truncated out after the division by 2^T.
 742   //
 743   // In comparison to just directly using the first formula, this technique
 744   // is much more efficient; using the first formula requires W * K bits,
 745   // but this formula less than W + K bits. Also, the first formula requires
 746   // a division step, whereas this formula only requires multiplies and shifts.
 747   //
 748   // It doesn't matter whether the subtraction step is done in the calculation
 749   // width or the input iteration count's width; if the subtraction overflows,
 750   // the result must be zero anyway.  We prefer here to do it in the width of
 751   // the induction variable because it helps a lot for certain cases; CodeGen
 752   // isn't smart enough to ignore the overflow, which leads to much less
 753   // efficient code if the width of the subtraction is wider than the native
 754   // register width.
 755   //
 756   // (It's possible to not widen at all by pulling out factors of 2 before
 757   // the multiplication; for example, K=2 can be calculated as
 758   // It/2*(It+(It*INT_MIN/INT_MIN)+-1). However, it requires
 759   // extra arithmetic, so it's not an obvious win, and it gets
 760   // much more complicated for K > 3.)
 761
 762   // Protection from insane SCEVs; this bound is conservative,
 763   // but it probably doesn't matter.
 764   if (K > 1000)
 765     return SE.getCouldNotCompute();
 766
 767   unsigned W = SE.getTypeSizeInBits(ResultTy);
 768
 769   // Calculate K! / 2^T and T; we divide out the factors of two before
 770   // multiplying for calculating K! / 2^T to avoid overflow.
 771   // Other overflow doesn't matter because we only care about the bottom
 772   // W bits of the result.
 773   APInt OddFactorial(W, 1);
 774   unsigned T = 1;
 775   for (unsigned i = 3; i <= K; ++i) {
 776     APInt Mult(W, i);
 777     unsigned TwoFactors = Mult.countTrailingZeros();
 778     T += TwoFactors;
 779     Mult = Mult.lshr(TwoFactors);
 780     OddFactorial *= Mult;
 781   }
 782
 783   // We need at least W + T bits for the multiplication step
 784   unsigned CalculationBits = W + T;
 785
 786   // Calculate 2^T, at width T+W.
 787   APInt DivFactor = APInt(CalculationBits, 1).shl(T);
 788
 789   // Calculate the multiplicative inverse of K! / 2^T;
 790   // this multiplication factor will perform the exact division by
 791   // K! / 2^T.
 792   APInt Mod = APInt::getSignedMinValue(W+1);
 793   APInt MultiplyFactor = OddFactorial.zext(W+1);
 794   MultiplyFactor = MultiplyFactor.multiplicativeInverse(Mod);
 795   MultiplyFactor = MultiplyFactor.trunc(W);
 796
 797   // Calculate the product, at width T+W
 798   const IntegerType *CalculationTy = IntegerType::get(SE.getContext(),
 799                                                       CalculationBits);
 800   const SCEV *Dividend = SE.getTruncateOrZeroExtend(It, CalculationTy);
 801   for (unsigned i = 1; i != K; ++i) {
 802     const SCEV *S = SE.getMinusSCEV(It, SE.getConstant(It->getType(), i));
 803     Dividend = SE.getMulExpr(Dividend,
 804                              SE.getTruncateOrZeroExtend(S, CalculationTy));
 805   }
 806
 807   // Divide by 2^T
 808   const SCEV *DivResult = SE.getUDivExpr(Dividend, SE.getConstant(DivFactor));
 809
 810   // Truncate the result, and divide by K! / 2^T.
 811
 812   return SE.getMulExpr(SE.getConstant(MultiplyFactor),
 813                        SE.getTruncateOrZeroExtend(DivResult, ResultTy));
 814 }
 815
 816 /// evaluateAtIteration - Return the value of this chain of recurrences at
 817 /// the specified iteration number.  We can evaluate this recurrence by
 818 /// multiplying each element in the chain by the binomial coefficient
 819 /// corresponding to it.  In other words, we can evaluate {A,+,B,+,C,+,D} as:
 820 ///
 821 ///   A*BC(It, 0) + B*BC(It, 1) + C*BC(It, 2) + D*BC(It, 3)
 822 ///
 823 /// where BC(It, k) stands for binomial coefficient.
 824 ///
 825 const SCEV *SCEVAddRecExpr::evaluateAtIteration(const SCEV *It,
 826                                                 ScalarEvolution &SE) const {
 827   const SCEV *Result = getStart();
 828   for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
 829     // The computation is correct in the face of overflow provided that the
 830     // multiplication is performed _after_ the evaluation of the binomial
 831     // coefficient.
 832     const SCEV *Coeff = BinomialCoefficient(It, i, SE, getType());
 833     if (isa<SCEVCouldNotCompute>(Coeff))
 834       return Coeff;
 835
 836     Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
 837   }
 838   return Result;
 839 }
 840
 841 //===----------------------------------------------------------------------===//
 842 //                    SCEV Expression folder implementations
 843 //===----------------------------------------------------------------------===//
 844
 845 const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op,
 846                                              const Type *Ty) {
 847   assert(getTypeSizeInBits(Op->getType()) > getTypeSizeInBits(Ty) &&
 848          "This is not a truncating conversion!");
 849   assert(isSCEVable(Ty) &&
 850          "This is not a conversion to a SCEVable type!");
 851   Ty = getEffectiveSCEVType(Ty);
 852
 853   FoldingSetNodeID ID;
 854   ID.AddInteger(scTruncate);
 855   ID.AddPointer(Op);
 856   ID.AddPointer(Ty);
 857   void *IP = 0;
 858   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
 859
 860   // Fold if the operand is constant.
 861   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
 862     return getConstant(
 863       cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(),
 864                                                getEffectiveSCEVType(Ty))));
 865
 866   // trunc(trunc(x)) --> trunc(x)
 867   if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op))
 868     return getTruncateExpr(ST->getOperand(), Ty);
 869
 870   // trunc(sext(x)) --> sext(x) if widening or trunc(x) if narrowing
 871   if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
 872     return getTruncateOrSignExtend(SS->getOperand(), Ty);
 873
 874   // trunc(zext(x)) --> zext(x) if widening or trunc(x) if narrowing
 875   if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
 876     return getTruncateOrZeroExtend(SZ->getOperand(), Ty);
 877
 878   // If the input value is a chrec scev, truncate the chrec's operands.
 879   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Op)) {
 880     SmallVector<const SCEV *, 4> Operands;
 881     for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
 882       Operands.push_back(getTruncateExpr(AddRec->getOperand(i), Ty));
 883     return getAddRecExpr(Operands, AddRec->getLoop());
 884   }
 885
 886   // As a special case, fold trunc(undef) to undef. We don't want to
 887   // know too much about SCEVUnknowns, but this special case is handy
 888   // and harmless.
 889   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Op))
 890     if (isa<UndefValue>(U->getValue()))
 891       return getSCEV(UndefValue::get(Ty));
 892
 893   // The cast wasn't folded; create an explicit cast node. We can reuse
 894   // the existing insert position since if we get here, we won't have
 895   // made any changes which would invalidate it.
 896   SCEV *S = new (SCEVAllocator) SCEVTruncateExpr(ID.Intern(SCEVAllocator),
 897                                                  Op, Ty);
 898   UniqueSCEVs.InsertNode(S, IP);
 899   return S;
 900 }
 901
 902 const SCEV *ScalarEvolution::getZeroExtendExpr(const SCEV *Op,
 903                                                const Type *Ty) {
 904   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
 905          "This is not an extending conversion!");
 906   assert(isSCEVable(Ty) &&
 907          "This is not a conversion to a SCEVable type!");
 908   Ty = getEffectiveSCEVType(Ty);
 909
 910   // Fold if the operand is constant.
 911   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
 912     return getConstant(
 913       cast<ConstantInt>(ConstantExpr::getZExt(SC->getValue(),
 914                                               getEffectiveSCEVType(Ty))));
 915
 916   // zext(zext(x)) --> zext(x)
 917   if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
 918     return getZeroExtendExpr(SZ->getOperand(), Ty);
 919
 920   // Before doing any expensive analysis, check to see if we've already
 921   // computed a SCEV for this Op and Ty.
 922   FoldingSetNodeID ID;
 923   ID.AddInteger(scZeroExtend);
 924   ID.AddPointer(Op);
 925   ID.AddPointer(Ty);
 926   void *IP = 0;
 927   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
 928
 929   // If the input value is a chrec scev, and we can prove that the value
 930   // did not overflow the old, smaller, value, we can zero extend all of the
 931   // operands (often constants).  This allows analysis of something like
 932   // this:  for (unsigned char X = 0; X < 100; ++X) { int Y = X; }
 933   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
 934     if (AR->isAffine()) {
 935       const SCEV *Start = AR->getStart();
 936       const SCEV *Step = AR->getStepRecurrence(*this);
 937       unsigned BitWidth = getTypeSizeInBits(AR->getType());
 938       const Loop *L = AR->getLoop();
 939
 940       // If we have special knowledge that this addrec won't overflow,
 941       // we don't need to do any further analysis.
 942       if (AR->hasNoUnsignedWrap())
 943         return getAddRecExpr(getZeroExtendExpr(Start, Ty),
 944                              getZeroExtendExpr(Step, Ty),
 945                              L);
 946
 947       // Check whether the backedge-taken count is SCEVCouldNotCompute.
 948       // Note that this serves two purposes: It filters out loops that are
 949       // simply not analyzable, and it covers the case where this code is
 950       // being called from within backedge-taken count analysis, such that
 951       // attempting to ask for the backedge-taken count would likely result
 952       // in infinite recursion. In the later case, the analysis code will
 953       // cope with a conservative value, and it will take care to purge
 954       // that value once it has finished.
 955       const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
 956       if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
 957         // Manually compute the final value for AR, checking for
 958         // overflow.
 959
 960         // Check whether the backedge-taken count can be losslessly casted to
 961         // the addrec's type. The count is always unsigned.
 962         const SCEV *CastedMaxBECount =
 963           getTruncateOrZeroExtend(MaxBECount, Start->getType());
 964         const SCEV *RecastedMaxBECount =
 965           getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
 966         if (MaxBECount == RecastedMaxBECount) {
 967           const Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
 968           // Check whether Start+Step*MaxBECount has no unsigned overflow.
 969           const SCEV *ZMul = getMulExpr(CastedMaxBECount, Step);
 970           const SCEV *Add = getAddExpr(Start, ZMul);
 971           const SCEV *OperandExtendedAdd =
 972             getAddExpr(getZeroExtendExpr(Start, WideTy),
 973                        getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
 974                                   getZeroExtendExpr(Step, WideTy)));
 975           if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd)
 976             // Return the expression with the addrec on the outside.
 977             return getAddRecExpr(getZeroExtendExpr(Start, Ty),
 978                                  getZeroExtendExpr(Step, Ty),
 979                                  L);
 980
 981           // Similar to above, only this time treat the step value as signed.
 982           // This covers loops that count down.
 983           const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
 984           Add = getAddExpr(Start, SMul);
 985           OperandExtendedAdd =
 986             getAddExpr(getZeroExtendExpr(Start, WideTy),
 987                        getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
 988                                   getSignExtendExpr(Step, WideTy)));
 989           if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd)
 990             // Return the expression with the addrec on the outside.
 991             return getAddRecExpr(getZeroExtendExpr(Start, Ty),
 992                                  getSignExtendExpr(Step, Ty),
 993                                  L);
 994         }
 995
 996         // If the backedge is guarded by a comparison with the pre-inc value
 997         // the addrec is safe. Also, if the entry is guarded by a comparison
 998         // with the start value and the backedge is guarded by a comparison
 999         // with the post-inc value, the addrec is safe.
1000         if (isKnownPositive(Step)) {
1001           const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
1002                                       getUnsignedRange(Step).getUnsignedMax());
1003           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT, AR, N) ||
1004               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
1005                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT,
1006                                            AR->getPostIncExpr(*this), N)))
1007             // Return the expression with the addrec on the outside.
1008             return getAddRecExpr(getZeroExtendExpr(Start, Ty),
1009                                  getZeroExtendExpr(Step, Ty),
1010                                  L);
1011         } else if (isKnownNegative(Step)) {
1012           const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
1013                                       getSignedRange(Step).getSignedMin());
1014           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT, AR, N) ||
1015               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) &&
1016                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT,
1017                                            AR->getPostIncExpr(*this), N)))
1018             // Return the expression with the addrec on the outside.
1019             return getAddRecExpr(getZeroExtendExpr(Start, Ty),
1020                                  getSignExtendExpr(Step, Ty),
1021                                  L);
1022         }
1023       }
1024     }
1025
1026   // The cast wasn't folded; create an explicit cast node.
1027   // Recompute the insert position, as it may have been invalidated.
1028   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1029   SCEV *S = new (SCEVAllocator) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
1030                                                    Op, Ty);
1031   UniqueSCEVs.InsertNode(S, IP);
1032   return S;
1033 }
1034
1035 const SCEV *ScalarEvolution::getSignExtendExpr(const SCEV *Op,
1036                                                const Type *Ty) {
1037   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1038          "This is not an extending conversion!");
1039   assert(isSCEVable(Ty) &&
1040          "This is not a conversion to a SCEVable type!");
1041   Ty = getEffectiveSCEVType(Ty);
1042
1043   // Fold if the operand is constant.
1044   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1045     return getConstant(
1046       cast<ConstantInt>(ConstantExpr::getSExt(SC->getValue(),
1047                                               getEffectiveSCEVType(Ty))));
1048
1049   // sext(sext(x)) --> sext(x)
1050   if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
1051     return getSignExtendExpr(SS->getOperand(), Ty);
1052
1053   // Before doing any expensive analysis, check to see if we've already
1054   // computed a SCEV for this Op and Ty.
1055   FoldingSetNodeID ID;
1056   ID.AddInteger(scSignExtend);
1057   ID.AddPointer(Op);
1058   ID.AddPointer(Ty);
1059   void *IP = 0;
1060   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1061
1062   // If the input value is a chrec scev, and we can prove that the value
1063   // did not overflow the old, smaller, value, we can sign extend all of the
1064   // operands (often constants).  This allows analysis of something like
1065   // this:  for (signed char X = 0; X < 100; ++X) { int Y = X; }
1066   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
1067     if (AR->isAffine()) {
1068       const SCEV *Start = AR->getStart();
1069       const SCEV *Step = AR->getStepRecurrence(*this);
1070       unsigned BitWidth = getTypeSizeInBits(AR->getType());
1071       const Loop *L = AR->getLoop();
1072
1073       // If we have special knowledge that this addrec won't overflow,
1074       // we don't need to do any further analysis.
1075       if (AR->hasNoSignedWrap())
1076         return getAddRecExpr(getSignExtendExpr(Start, Ty),
1077                              getSignExtendExpr(Step, Ty),
1078                              L);
1079
1080       // Check whether the backedge-taken count is SCEVCouldNotCompute.
1081       // Note that this serves two purposes: It filters out loops that are
1082       // simply not analyzable, and it covers the case where this code is
1083       // being called from within backedge-taken count analysis, such that
1084       // attempting to ask for the backedge-taken count would likely result
1085       // in infinite recursion. In the later case, the analysis code will
1086       // cope with a conservative value, and it will take care to purge
1087       // that value once it has finished.
1088       const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
1089       if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
1090         // Manually compute the final value for AR, checking for
1091         // overflow.
1092
1093         // Check whether the backedge-taken count can be losslessly casted to
1094         // the addrec's type. The count is always unsigned.
1095         const SCEV *CastedMaxBECount =
1096           getTruncateOrZeroExtend(MaxBECount, Start->getType());
1097         const SCEV *RecastedMaxBECount =
1098           getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
1099         if (MaxBECount == RecastedMaxBECount) {
1100           const Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1101           // Check whether Start+Step*MaxBECount has no signed overflow.
1102           const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
1103           const SCEV *Add = getAddExpr(Start, SMul);
1104           const SCEV *OperandExtendedAdd =
1105             getAddExpr(getSignExtendExpr(Start, WideTy),
1106                        getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
1107                                   getSignExtendExpr(Step, WideTy)));
1108           if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd)
1109             // Return the expression with the addrec on the outside.
1110             return getAddRecExpr(getSignExtendExpr(Start, Ty),
1111                                  getSignExtendExpr(Step, Ty),
1112                                  L);
1113
1114           // Similar to above, only this time treat the step value as unsigned.
1115           // This covers loops that count up with an unsigned step.
1116           const SCEV *UMul = getMulExpr(CastedMaxBECount, Step);
1117           Add = getAddExpr(Start, UMul);
1118           OperandExtendedAdd =
1119             getAddExpr(getSignExtendExpr(Start, WideTy),
1120                        getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
1121                                   getZeroExtendExpr(Step, WideTy)));
1122           if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd)
1123             // Return the expression with the addrec on the outside.
1124             return getAddRecExpr(getSignExtendExpr(Start, Ty),
1125                                  getZeroExtendExpr(Step, Ty),
1126                                  L);
1127         }
1128
1129         // If the backedge is guarded by a comparison with the pre-inc value
1130         // the addrec is safe. Also, if the entry is guarded by a comparison
1131         // with the start value and the backedge is guarded by a comparison
1132         // with the post-inc value, the addrec is safe.
1133         if (isKnownPositive(Step)) {
1134           const SCEV *N = getConstant(APInt::getSignedMinValue(BitWidth) -
1135                                       getSignedRange(Step).getSignedMax());
1136           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SLT, AR, N) ||
1137               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_SLT, Start, N) &&
1138                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SLT,
1139                                            AR->getPostIncExpr(*this), N)))
1140             // Return the expression with the addrec on the outside.
1141             return getAddRecExpr(getSignExtendExpr(Start, Ty),
1142                                  getSignExtendExpr(Step, Ty),
1143                                  L);
1144         } else if (isKnownNegative(Step)) {
1145           const SCEV *N = getConstant(APInt::getSignedMaxValue(BitWidth) -
1146                                       getSignedRange(Step).getSignedMin());
1147           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT, AR, N) ||
1148               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_SGT, Start, N) &&
1149                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT,
1150                                            AR->getPostIncExpr(*this), N)))
1151             // Return the expression with the addrec on the outside.
1152             return getAddRecExpr(getSignExtendExpr(Start, Ty),
1153                                  getSignExtendExpr(Step, Ty),
1154                                  L);
1155         }
1156       }
1157     }
1158
1159   // The cast wasn't folded; create an explicit cast node.
1160   // Recompute the insert position, as it may have been invalidated.
1161   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1162   SCEV *S = new (SCEVAllocator) SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
1163                                                    Op, Ty);
1164   UniqueSCEVs.InsertNode(S, IP);
1165   return S;
1166 }
1167
1168 /// getAnyExtendExpr - Return a SCEV for the given operand extended with
1169 /// unspecified bits out to the given type.
1170 ///
1171 const SCEV *ScalarEvolution::getAnyExtendExpr(const SCEV *Op,
1172                                               const Type *Ty) {
1173   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1174          "This is not an extending conversion!");
1175   assert(isSCEVable(Ty) &&
1176          "This is not a conversion to a SCEVable type!");
1177   Ty = getEffectiveSCEVType(Ty);
1178
1179   // Sign-extend negative constants.
1180   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1181     if (SC->getValue()->getValue().isNegative())
1182       return getSignExtendExpr(Op, Ty);
1183
1184   // Peel off a truncate cast.
1185   if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Op)) {
1186     const SCEV *NewOp = T->getOperand();
1187     if (getTypeSizeInBits(NewOp->getType()) < getTypeSizeInBits(Ty))
1188       return getAnyExtendExpr(NewOp, Ty);
1189     return getTruncateOrNoop(NewOp, Ty);
1190   }
1191
1192   // Next try a zext cast. If the cast is folded, use it.
1193   const SCEV *ZExt = getZeroExtendExpr(Op, Ty);
1194   if (!isa<SCEVZeroExtendExpr>(ZExt))
1195     return ZExt;
1196
1197   // Next try a sext cast. If the cast is folded, use it.
1198   const SCEV *SExt = getSignExtendExpr(Op, Ty);
1199   if (!isa<SCEVSignExtendExpr>(SExt))
1200     return SExt;
1201
1202   // Force the cast to be folded into the operands of an addrec.
1203   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op)) {
1204     SmallVector<const SCEV *, 4> Ops;
1205     for (SCEVAddRecExpr::op_iterator I = AR->op_begin(), E = AR->op_end();
1206          I != E; ++I)
1207       Ops.push_back(getAnyExtendExpr(*I, Ty));
1208     return getAddRecExpr(Ops, AR->getLoop());
1209   }
1210
1211   // As a special case, fold anyext(undef) to undef. We don't want to
1212   // know too much about SCEVUnknowns, but this special case is handy
1213   // and harmless.
1214   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Op))
1215     if (isa<UndefValue>(U->getValue()))
1216       return getSCEV(UndefValue::get(Ty));
1217
1218   // If the expression is obviously signed, use the sext cast value.
1219   if (isa<SCEVSMaxExpr>(Op))
1220     return SExt;
1221
1222   // Absent any other information, use the zext cast value.
1223   return ZExt;
1224 }
1225
1226 /// CollectAddOperandsWithScales - Process the given Ops list, which is
1227 /// a list of operands to be added under the given scale, update the given
1228 /// map. This is a helper function for getAddRecExpr. As an example of
1229 /// what it does, given a sequence of operands that would form an add
1230 /// expression like this:
1231 ///
1232 ///    m + n + 13 + (A * (o + p + (B * q + m + 29))) + r + (-1 * r)
1233 ///
1234 /// where A and B are constants, update the map with these values:
1235 ///
1236 ///    (m, 1+A*B), (n, 1), (o, A), (p, A), (q, A*B), (r, 0)
1237 ///
1238 /// and add 13 + A*B*29 to AccumulatedConstant.
1239 /// This will allow getAddRecExpr to produce this:
1240 ///
1241 ///    13+A*B*29 + n + (m * (1+A*B)) + ((o + p) * A) + (q * A*B)
1242 ///
1243 /// This form often exposes folding opportunities that are hidden in
1244 /// the original operand list.
1245 ///
1246 /// Return true iff it appears that any interesting folding opportunities
1247 /// may be exposed. This helps getAddRecExpr short-circuit extra work in
1248 /// the common case where no interesting opportunities are present, and
1249 /// is also used as a check to avoid infinite recursion.
1250 ///
1251 static bool
1252 CollectAddOperandsWithScales(DenseMap<const SCEV *, APInt> &M,
1253                              SmallVector<const SCEV *, 8> &NewOps,
1254                              APInt &AccumulatedConstant,
1255                              const SCEV *const *Ops, size_t NumOperands,
1256                              const APInt &Scale,
1257                              ScalarEvolution &SE) {
1258   bool Interesting = false;
1259
1260   // Iterate over the add operands. They are sorted, with constants first.
1261   unsigned i = 0;
1262   while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1263     ++i;
1264     // Pull a buried constant out to the outside.
1265     if (Scale != 1 || AccumulatedConstant != 0 || C->getValue()->isZero())
1266       Interesting = true;
1267     AccumulatedConstant += Scale * C->getValue()->getValue();
1268   }
1269
1270   // Next comes everything else. We're especially interested in multiplies
1271   // here, but they're in the middle, so just visit the rest with one loop.
1272   for (; i != NumOperands; ++i) {
1273     const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[i]);
1274     if (Mul && isa<SCEVConstant>(Mul->getOperand(0))) {
1275       APInt NewScale =
1276         Scale * cast<SCEVConstant>(Mul->getOperand(0))->getValue()->getValue();
1277       if (Mul->getNumOperands() == 2 && isa<SCEVAddExpr>(Mul->getOperand(1))) {
1278         // A multiplication of a constant with another add; recurse.
1279         const SCEVAddExpr *Add = cast<SCEVAddExpr>(Mul->getOperand(1));
1280         Interesting |=
1281           CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
1282                                        Add->op_begin(), Add->getNumOperands(),
1283                                        NewScale, SE);
1284       } else {
1285         // A multiplication of a constant with some other value. Update
1286         // the map.
1287         SmallVector<const SCEV *, 4> MulOps(Mul->op_begin()+1, Mul->op_end());
1288         const SCEV *Key = SE.getMulExpr(MulOps);
1289         std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
1290           M.insert(std::make_pair(Key, NewScale));
1291         if (Pair.second) {
1292           NewOps.push_back(Pair.first->first);
1293         } else {
1294           Pair.first->second += NewScale;
1295           // The map already had an entry for this value, which may indicate
1296           // a folding opportunity.
1297           Interesting = true;
1298         }
1299       }
1300     } else {
1301       // An ordinary operand. Update the map.
1302       std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
1303         M.insert(std::make_pair(Ops[i], Scale));
1304       if (Pair.second) {
1305         NewOps.push_back(Pair.first->first);
1306       } else {
1307         Pair.first->second += Scale;
1308         // The map already had an entry for this value, which may indicate
1309         // a folding opportunity.
1310         Interesting = true;
1311       }
1312     }
1313   }
1314
1315   return Interesting;
1316 }
1317
1318 namespace {
1319   struct APIntCompare {
1320     bool operator()(const APInt &LHS, const APInt &RHS) const {
1321       return LHS.ult(RHS);
1322     }
1323   };
1324 }
1325
1326 /// getAddExpr - Get a canonical add expression, or something simpler if
1327 /// possible.
1328 const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
1329                                         bool HasNUW, bool HasNSW) {
1330   assert(!Ops.empty() && "Cannot get empty add!");
1331   if (Ops.size() == 1) return Ops[0];
1332 #ifndef NDEBUG
1333   const Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
1334   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
1335     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
1336            "SCEVAddExpr operand types don't match!");
1337 #endif
1338
1339   // If HasNSW is true and all the operands are non-negative, infer HasNUW.
1340   if (!HasNUW && HasNSW) {
1341     bool All = true;
1342     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1343       if (!isKnownNonNegative(Ops[i])) {
1344         All = false;
1345         break;
1346       }
1347     if (All) HasNUW = true;
1348   }
1349
1350   // Sort by complexity, this groups all similar expression types together.
1351   GroupByComplexity(Ops, LI);
1352
1353   // If there are any constants, fold them together.
1354   unsigned Idx = 0;
1355   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
1356     ++Idx;
1357     assert(Idx < Ops.size());
1358     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
1359       // We found two constants, fold them together!
1360       Ops[0] = getConstant(LHSC->getValue()->getValue() +
1361                            RHSC->getValue()->getValue());
1362       if (Ops.size() == 2) return Ops[0];
1363       Ops.erase(Ops.begin()+1);  // Erase the folded element
1364       LHSC = cast<SCEVConstant>(Ops[0]);
1365     }
1366
1367     // If we are left with a constant zero being added, strip it off.
1368     if (LHSC->getValue()->isZero()) {
1369       Ops.erase(Ops.begin());
1370       --Idx;
1371     }
1372
1373     if (Ops.size() == 1) return Ops[0];
1374   }
1375
1376   // Okay, check to see if the same value occurs in the operand list twice.  If
1377   // so, merge them together into an multiply expression.  Since we sorted the
1378   // list, these values are required to be adjacent.
1379   const Type *Ty = Ops[0]->getType();
1380   bool FoundMatch = false;
1381   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
1382     if (Ops[i] == Ops[i+1]) {      //  X + Y + Y  -->  X + Y*2
1383       // Found a match, merge the two values into a multiply, and add any
1384       // remaining values to the result.
1385       const SCEV *Two = getConstant(Ty, 2);
1386       const SCEV *Mul = getMulExpr(Two, Ops[i]);
1387       if (Ops.size() == 2)
1388         return Mul;
1389       Ops[i] = Mul;
1390       Ops.erase(Ops.begin()+i+1);
1391       --i; --e;
1392       FoundMatch = true;
1393     }
1394   if (FoundMatch)
1395     return getAddExpr(Ops, HasNUW, HasNSW);
1396
1397   // Check for truncates. If all the operands are truncated from the same
1398   // type, see if factoring out the truncate would permit the result to be
1399   // folded. eg., trunc(x) + m*trunc(n) --> trunc(x + trunc(m)*n)
1400   // if the contents of the resulting outer trunc fold to something simple.
1401   for (; Idx < Ops.size() && isa<SCEVTruncateExpr>(Ops[Idx]); ++Idx) {
1402     const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(Ops[Idx]);
1403     const Type *DstType = Trunc->getType();
1404     const Type *SrcType = Trunc->getOperand()->getType();
1405     SmallVector<const SCEV *, 8> LargeOps;
1406     bool Ok = true;
1407     // Check all the operands to see if they can be represented in the
1408     // source type of the truncate.
1409     for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
1410       if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Ops[i])) {
1411         if (T->getOperand()->getType() != SrcType) {
1412           Ok = false;
1413           break;
1414         }
1415         LargeOps.push_back(T->getOperand());
1416       } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1417         LargeOps.push_back(getAnyExtendExpr(C, SrcType));
1418       } else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Ops[i])) {
1419         SmallVector<const SCEV *, 8> LargeMulOps;
1420         for (unsigned j = 0, f = M->getNumOperands(); j != f && Ok; ++j) {
1421           if (const SCEVTruncateExpr *T =
1422                 dyn_cast<SCEVTruncateExpr>(M->getOperand(j))) {
1423             if (T->getOperand()->getType() != SrcType) {
1424               Ok = false;
1425               break;
1426             }
1427             LargeMulOps.push_back(T->getOperand());
1428           } else if (const SCEVConstant *C =
1429                        dyn_cast<SCEVConstant>(M->getOperand(j))) {
1430             LargeMulOps.push_back(getAnyExtendExpr(C, SrcType));
1431           } else {
1432             Ok = false;
1433             break;
1434           }
1435         }
1436         if (Ok)
1437           LargeOps.push_back(getMulExpr(LargeMulOps));
1438       } else {
1439         Ok = false;
1440         break;
1441       }
1442     }
1443     if (Ok) {
1444       // Evaluate the expression in the larger type.
1445       const SCEV *Fold = getAddExpr(LargeOps, HasNUW, HasNSW);
1446       // If it folds to something simple, use it. Otherwise, don't.
1447       if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
1448         return getTruncateExpr(Fold, DstType);
1449     }
1450   }
1451
1452   // Skip past any other cast SCEVs.
1453   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
1454     ++Idx;
1455
1456   // If there are add operands they would be next.
1457   if (Idx < Ops.size()) {
1458     bool DeletedAdd = false;
1459     while (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[Idx])) {
1460       // If we have an add, expand the add operands onto the end of the operands
1461       // list.
1462       Ops.erase(Ops.begin()+Idx);
1463       Ops.append(Add->op_begin(), Add->op_end());
1464       DeletedAdd = true;
1465     }
1466
1467     // If we deleted at least one add, we added operands to the end of the list,
1468     // and they are not necessarily sorted.  Recurse to resort and resimplify
1469     // any operands we just acquired.
1470     if (DeletedAdd)
1471       return getAddExpr(Ops);
1472   }
1473
1474   // Skip over the add expression until we get to a multiply.
1475   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
1476     ++Idx;
1477
1478   // Check to see if there are any folding opportunities present with
1479   // operands multiplied by constant values.
1480   if (Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx])) {
1481     uint64_t BitWidth = getTypeSizeInBits(Ty);
1482     DenseMap<const SCEV *, APInt> M;
1483     SmallVector<const SCEV *, 8> NewOps;
1484     APInt AccumulatedConstant(BitWidth, 0);
1485     if (CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
1486                                      Ops.data(), Ops.size(),
1487                                      APInt(BitWidth, 1), *this)) {
1488       // Some interesting folding opportunity is present, so its worthwhile to
1489       // re-generate the operands list. Group the operands by constant scale,
1490       // to avoid multiplying by the same constant scale multiple times.
1491       std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare> MulOpLists;
1492       for (SmallVector<const SCEV *, 8>::iterator I = NewOps.begin(),
1493            E = NewOps.end(); I != E; ++I)
1494         MulOpLists[M.find(*I)->second].push_back(*I);
1495       // Re-generate the operands list.
1496       Ops.clear();
1497       if (AccumulatedConstant != 0)
1498         Ops.push_back(getConstant(AccumulatedConstant));
1499       for (std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare>::iterator
1500            I = MulOpLists.begin(), E = MulOpLists.end(); I != E; ++I)
1501         if (I->first != 0)
1502           Ops.push_back(getMulExpr(getConstant(I->first),
1503                                    getAddExpr(I->second)));
1504       if (Ops.empty())
1505         return getConstant(Ty, 0);
1506       if (Ops.size() == 1)
1507         return Ops[0];
1508       return getAddExpr(Ops);
1509     }
1510   }
1511
1512   // If we are adding something to a multiply expression, make sure the
1513   // something is not already an operand of the multiply.  If so, merge it into
1514   // the multiply.
1515   for (; Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx]); ++Idx) {
1516     const SCEVMulExpr *Mul = cast<SCEVMulExpr>(Ops[Idx]);
1517     for (unsigned MulOp = 0, e = Mul->getNumOperands(); MulOp != e; ++MulOp) {
1518       const SCEV *MulOpSCEV = Mul->getOperand(MulOp);
1519       if (isa<SCEVConstant>(MulOpSCEV))
1520         continue;
1521       for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
1522         if (MulOpSCEV == Ops[AddOp]) {
1523           // Fold W + X + (X * Y * Z)  -->  W + (X * ((Y*Z)+1))
1524           const SCEV *InnerMul = Mul->getOperand(MulOp == 0);
1525           if (Mul->getNumOperands() != 2) {
1526             // If the multiply has more than two operands, we must get the
1527             // Y*Z term.
1528             SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(), Mul->op_end());
1529             MulOps.erase(MulOps.begin()+MulOp);
1530             InnerMul = getMulExpr(MulOps);
1531           }
1532           const SCEV *One = getConstant(Ty, 1);
1533           const SCEV *AddOne = getAddExpr(One, InnerMul);
1534           const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
1535           if (Ops.size() == 2) return OuterMul;
1536           if (AddOp < Idx) {
1537             Ops.erase(Ops.begin()+AddOp);
1538             Ops.erase(Ops.begin()+Idx-1);
1539           } else {
1540             Ops.erase(Ops.begin()+Idx);
1541             Ops.erase(Ops.begin()+AddOp-1);
1542           }
1543           Ops.push_back(OuterMul);
1544           return getAddExpr(Ops);
1545         }
1546
1547       // Check this multiply against other multiplies being added together.
1548       bool AnyFold = false;
1549       for (unsigned OtherMulIdx = Idx+1;
1550            OtherMulIdx < Ops.size() && isa<SCEVMulExpr>(Ops[OtherMulIdx]);
1551            ++OtherMulIdx) {
1552         const SCEVMulExpr *OtherMul = cast<SCEVMulExpr>(Ops[OtherMulIdx]);
1553         // If MulOp occurs in OtherMul, we can fold the two multiplies
1554         // together.
1555         for (unsigned OMulOp = 0, e = OtherMul->getNumOperands();
1556              OMulOp != e; ++OMulOp)
1557           if (OtherMul->getOperand(OMulOp) == MulOpSCEV) {
1558             // Fold X + (A*B*C) + (A*D*E) --> X + (A*(B*C+D*E))
1559             const SCEV *InnerMul1 = Mul->getOperand(MulOp == 0);
1560             if (Mul->getNumOperands() != 2) {
1561               SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
1562                                                   Mul->op_end());
1563               MulOps.erase(MulOps.begin()+MulOp);
1564               InnerMul1 = getMulExpr(MulOps);
1565             }
1566             const SCEV *InnerMul2 = OtherMul->getOperand(OMulOp == 0);
1567             if (OtherMul->getNumOperands() != 2) {
1568               SmallVector<const SCEV *, 4> MulOps(OtherMul->op_begin(),
1569                                                   OtherMul->op_end());
1570               MulOps.erase(MulOps.begin()+OMulOp);
1571               InnerMul2 = getMulExpr(MulOps);
1572             }
1573             const SCEV *InnerMulSum = getAddExpr(InnerMul1,InnerMul2);
1574             const SCEV *OuterMul = getMulExpr(MulOpSCEV, InnerMulSum);
1575             if (Ops.size() == 2) return OuterMul;
1576             Ops[Idx] = OuterMul;
1577             Ops.erase(Ops.begin()+OtherMulIdx);
1578             OtherMulIdx = Idx;
1579             AnyFold = true;
1580           }
1581       }
1582       if (AnyFold)
1583         return getAddExpr(Ops);
1584     }
1585   }
1586
1587   // If there are any add recurrences in the operands list, see if any other
1588   // added values are loop invariant.  If so, we can fold them into the
1589   // recurrence.
1590   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
1591     ++Idx;
1592
1593   // Scan over all recurrences, trying to fold loop invariants into them.
1594   for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
1595     // Scan all of the other operands to this add and add them to the vector if
1596     // they are loop invariant w.r.t. the recurrence.
1597     SmallVector<const SCEV *, 8> LIOps;
1598     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
1599     const Loop *AddRecLoop = AddRec->getLoop();
1600     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1601       if (Ops[i]->isLoopInvariant(AddRecLoop)) {
1602         LIOps.push_back(Ops[i]);
1603         Ops.erase(Ops.begin()+i);
1604         --i; --e;
1605       }
1606
1607     // If we found some loop invariants, fold them into the recurrence.
1608     if (!LIOps.empty()) {
1609       //  NLI + LI + {Start,+,Step}  -->  NLI + {LI+Start,+,Step}
1610       LIOps.push_back(AddRec->getStart());
1611
1612       SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
1613                                              AddRec->op_end());
1614       AddRecOps[0] = getAddExpr(LIOps);
1615
1616       // Build the new addrec. Propagate the NUW and NSW flags if both the
1617       // outer add and the inner addrec are guaranteed to have no overflow.
1618       const SCEV *NewRec = getAddRecExpr(AddRecOps, AddRecLoop,
1619                                          HasNUW && AddRec->hasNoUnsignedWrap(),
1620                                          HasNSW && AddRec->hasNoSignedWrap());
1621
1622       // If all of the other operands were loop invariant, we are done.
1623       if (Ops.size() == 1) return NewRec;
1624
1625       // Otherwise, add the folded AddRec by the non-liv parts.
1626       for (unsigned i = 0;; ++i)
1627         if (Ops[i] == AddRec) {
1628           Ops[i] = NewRec;
1629           break;
1630         }
1631       return getAddExpr(Ops);
1632     }
1633
1634     // Okay, if there weren't any loop invariants to be folded, check to see if
1635     // there are multiple AddRec's with the same loop induction variable being
1636     // added together.  If so, we can fold them.
1637     for (unsigned OtherIdx = Idx+1;
1638          OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);++OtherIdx)
1639       if (OtherIdx != Idx) {
1640         const SCEVAddRecExpr *OtherAddRec = cast<SCEVAddRecExpr>(Ops[OtherIdx]);
1641         if (AddRecLoop == OtherAddRec->getLoop()) {
1642           // Other + {A,+,B} + {C,+,D}  -->  Other + {A+C,+,B+D}
1643           SmallVector<const SCEV *, 4> NewOps(AddRec->op_begin(),
1644                                               AddRec->op_end());
1645           for (unsigned i = 0, e = OtherAddRec->getNumOperands(); i != e; ++i) {
1646             if (i >= NewOps.size()) {
1647               NewOps.append(OtherAddRec->op_begin()+i,
1648                             OtherAddRec->op_end());
1649               break;
1650             }
1651             NewOps[i] = getAddExpr(NewOps[i], OtherAddRec->getOperand(i));
1652           }
1653           const SCEV *NewAddRec = getAddRecExpr(NewOps, AddRecLoop);
1654
1655           if (Ops.size() == 2) return NewAddRec;
1656
1657           Ops.erase(Ops.begin()+Idx);
1658           Ops.erase(Ops.begin()+OtherIdx-1);
1659           Ops.push_back(NewAddRec);
1660           return getAddExpr(Ops);
1661         }
1662       }
1663
1664     // Otherwise couldn't fold anything into this recurrence.  Move onto the
1665     // next one.
1666   }
1667
1668   // Okay, it looks like we really DO need an add expr.  Check to see if we
1669   // already have one, otherwise create a new one.
1670   FoldingSetNodeID ID;
1671   ID.AddInteger(scAddExpr);
1672   ID.AddInteger(Ops.size());
1673   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1674     ID.AddPointer(Ops[i]);
1675   void *IP = 0;
1676   SCEVAddExpr *S =
1677     static_cast<SCEVAddExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
1678   if (!S) {
1679     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
1680     std::uninitialized_copy(Ops.begin(), Ops.end(), O);
1681     S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
1682                                         O, Ops.size());
1683     UniqueSCEVs.InsertNode(S, IP);
1684   }
1685   if (HasNUW) S->setHasNoUnsignedWrap(true);
1686   if (HasNSW) S->setHasNoSignedWrap(true);
1687   return S;
1688 }
1689
1690 /// getMulExpr - Get a canonical multiply expression, or something simpler if
1691 /// possible.
1692 const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
1693                                         bool HasNUW, bool HasNSW) {
1694   assert(!Ops.empty() && "Cannot get empty mul!");
1695   if (Ops.size() == 1) return Ops[0];
1696 #ifndef NDEBUG
1697   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
1698     assert(getEffectiveSCEVType(Ops[i]->getType()) ==
1699            getEffectiveSCEVType(Ops[0]->getType()) &&
1700            "SCEVMulExpr operand types don't match!");
1701 #endif
1702
1703   // If HasNSW is true and all the operands are non-negative, infer HasNUW.
1704   if (!HasNUW && HasNSW) {
1705     bool All = true;
1706     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1707       if (!isKnownNonNegative(Ops[i])) {
1708         All = false;
1709         break;
1710       }
1711     if (All) HasNUW = true;
1712   }
1713
1714   // Sort by complexity, this groups all similar expression types together.
1715   GroupByComplexity(Ops, LI);
1716
1717   // If there are any constants, fold them together.
1718   unsigned Idx = 0;
1719   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
1720
1721     // C1*(C2+V) -> C1*C2 + C1*V
1722     if (Ops.size() == 2)
1723       if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1]))
1724         if (Add->getNumOperands() == 2 &&
1725             isa<SCEVConstant>(Add->getOperand(0)))
1726           return getAddExpr(getMulExpr(LHSC, Add->getOperand(0)),
1727                             getMulExpr(LHSC, Add->getOperand(1)));
1728
1729     ++Idx;
1730     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
1731       // We found two constants, fold them together!
1732       ConstantInt *Fold = ConstantInt::get(getContext(),
1733                                            LHSC->getValue()->getValue() *
1734                                            RHSC->getValue()->getValue());
1735       Ops[0] = getConstant(Fold);
1736       Ops.erase(Ops.begin()+1);  // Erase the folded element
1737       if (Ops.size() == 1) return Ops[0];
1738       LHSC = cast<SCEVConstant>(Ops[0]);
1739     }
1740
1741     // If we are left with a constant one being multiplied, strip it off.
1742     if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
1743       Ops.erase(Ops.begin());
1744       --Idx;
1745     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
1746       // If we have a multiply of zero, it will always be zero.
1747       return Ops[0];
1748     } else if (Ops[0]->isAllOnesValue()) {
1749       // If we have a mul by -1 of an add, try distributing the -1 among the
1750       // add operands.
1751       if (Ops.size() == 2)
1752         if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1])) {
1753           SmallVector<const SCEV *, 4> NewOps;
1754           bool AnyFolded = false;
1755           for (SCEVAddRecExpr::op_iterator I = Add->op_begin(), E = Add->op_end();
1756                I != E; ++I) {
1757             const SCEV *Mul = getMulExpr(Ops[0], *I);
1758             if (!isa<SCEVMulExpr>(Mul)) AnyFolded = true;
1759             NewOps.push_back(Mul);
1760           }
1761           if (AnyFolded)
1762             return getAddExpr(NewOps);
1763         }
1764     }
1765
1766     if (Ops.size() == 1)
1767       return Ops[0];
1768   }
1769
1770   // Skip over the add expression until we get to a multiply.
1771   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
1772     ++Idx;
1773
1774   // If there are mul operands inline them all into this expression.
1775   if (Idx < Ops.size()) {
1776     bool DeletedMul = false;
1777     while (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[Idx])) {
1778       // If we have an mul, expand the mul operands onto the end of the operands
1779       // list.
1780       Ops.erase(Ops.begin()+Idx);
1781       Ops.append(Mul->op_begin(), Mul->op_end());
1782       DeletedMul = true;
1783     }
1784
1785     // If we deleted at least one mul, we added operands to the end of the list,
1786     // and they are not necessarily sorted.  Recurse to resort and resimplify
1787     // any operands we just acquired.
1788     if (DeletedMul)
1789       return getMulExpr(Ops);
1790   }
1791
1792   // If there are any add recurrences in the operands list, see if any other
1793   // added values are loop invariant.  If so, we can fold them into the
1794   // recurrence.
1795   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
1796     ++Idx;
1797
1798   // Scan over all recurrences, trying to fold loop invariants into them.
1799   for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
1800     // Scan all of the other operands to this mul and add them to the vector if
1801     // they are loop invariant w.r.t. the recurrence.
1802     SmallVector<const SCEV *, 8> LIOps;
1803     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
1804     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1805       if (Ops[i]->isLoopInvariant(AddRec->getLoop())) {
1806         LIOps.push_back(Ops[i]);
1807         Ops.erase(Ops.begin()+i);
1808         --i; --e;
1809       }
1810
1811     // If we found some loop invariants, fold them into the recurrence.
1812     if (!LIOps.empty()) {
1813       //  NLI * LI * {Start,+,Step}  -->  NLI * {LI*Start,+,LI*Step}
1814       SmallVector<const SCEV *, 4> NewOps;
1815       NewOps.reserve(AddRec->getNumOperands());
1816       const SCEV *Scale = getMulExpr(LIOps);
1817       for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
1818         NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i)));
1819
1820       // Build the new addrec. Propagate the NUW and NSW flags if both the
1821       // outer mul and the inner addrec are guaranteed to have no overflow.
1822       const SCEV *NewRec = getAddRecExpr(NewOps, AddRec->getLoop(),
1823                                          HasNUW && AddRec->hasNoUnsignedWrap(),
1824                                          HasNSW && AddRec->hasNoSignedWrap());
1825
1826       // If all of the other operands were loop invariant, we are done.
1827       if (Ops.size() == 1) return NewRec;
1828
1829       // Otherwise, multiply the folded AddRec by the non-liv parts.
1830       for (unsigned i = 0;; ++i)
1831         if (Ops[i] == AddRec) {
1832           Ops[i] = NewRec;
1833           break;
1834         }
1835       return getMulExpr(Ops);
1836     }
1837
1838     // Okay, if there weren't any loop invariants to be folded, check to see if
1839     // there are multiple AddRec's with the same loop induction variable being
1840     // multiplied together.  If so, we can fold them.
1841     for (unsigned OtherIdx = Idx+1;
1842          OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);++OtherIdx)
1843       if (OtherIdx != Idx) {
1844         const SCEVAddRecExpr *OtherAddRec = cast<SCEVAddRecExpr>(Ops[OtherIdx]);
1845         if (AddRec->getLoop() == OtherAddRec->getLoop()) {
1846           // F * G  -->  {A,+,B} * {C,+,D}  -->  {A*C,+,F*D + G*B + B*D}
1847           const SCEVAddRecExpr *F = AddRec, *G = OtherAddRec;
1848           const SCEV *NewStart = getMulExpr(F->getStart(),
1849                                                  G->getStart());
1850           const SCEV *B = F->getStepRecurrence(*this);
1851           const SCEV *D = G->getStepRecurrence(*this);
1852           const SCEV *NewStep = getAddExpr(getMulExpr(F, D),
1853                                           getMulExpr(G, B),
1854                                           getMulExpr(B, D));
1855           const SCEV *NewAddRec = getAddRecExpr(NewStart, NewStep,
1856                                                F->getLoop());
1857           if (Ops.size() == 2) return NewAddRec;
1858
1859           Ops.erase(Ops.begin()+Idx);
1860           Ops.erase(Ops.begin()+OtherIdx-1);
1861           Ops.push_back(NewAddRec);
1862           return getMulExpr(Ops);
1863         }
1864       }
1865
1866     // Otherwise couldn't fold anything into this recurrence.  Move onto the
1867     // next one.
1868   }
1869
1870   // Okay, it looks like we really DO need an mul expr.  Check to see if we
1871   // already have one, otherwise create a new one.
1872   FoldingSetNodeID ID;
1873   ID.AddInteger(scMulExpr);
1874   ID.AddInteger(Ops.size());
1875   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
1876     ID.AddPointer(Ops[i]);
1877   void *IP = 0;
1878   SCEVMulExpr *S =
1879     static_cast<SCEVMulExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
1880   if (!S) {
1881     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
1882     std::uninitialized_copy(Ops.begin(), Ops.end(), O);
1883     S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
1884                                         O, Ops.size());
1885     UniqueSCEVs.InsertNode(S, IP);
1886   }
1887   if (HasNUW) S->setHasNoUnsignedWrap(true);
1888   if (HasNSW) S->setHasNoSignedWrap(true);
1889   return S;
1890 }
1891
1892 /// getUDivExpr - Get a canonical unsigned division expression, or something
1893 /// simpler if possible.
1894 const SCEV *ScalarEvolution::getUDivExpr(const SCEV *LHS,
1895                                          const SCEV *RHS) {
1896   assert(getEffectiveSCEVType(LHS->getType()) ==
1897          getEffectiveSCEVType(RHS->getType()) &&
1898          "SCEVUDivExpr operand types don't match!");
1899
1900   if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
1901     if (RHSC->getValue()->equalsInt(1))
1902       return LHS;                               // X udiv 1 --> x
1903     // If the denominator is zero, the result of the udiv is undefined. Don't
1904     // try to analyze it, because the resolution chosen here may differ from
1905     // the resolution chosen in other parts of the compiler.
1906     if (!RHSC->getValue()->isZero()) {
1907       // Determine if the division can be folded into the operands of
1908       // its operands.
1909       // TODO: Generalize this to non-constants by using known-bits information.
1910       const Type *Ty = LHS->getType();
1911       unsigned LZ = RHSC->getValue()->getValue().countLeadingZeros();
1912       unsigned MaxShiftAmt = getTypeSizeInBits(Ty) - LZ - 1;
1913       // For non-power-of-two values, effectively round the value up to the
1914       // nearest power of two.
1915       if (!RHSC->getValue()->getValue().isPowerOf2())
1916         ++MaxShiftAmt;
1917       const IntegerType *ExtTy =
1918         IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
1919       // {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
1920       if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
1921         if (const SCEVConstant *Step =
1922               dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this)))
1923           if (!Step->getValue()->getValue()
1924                 .urem(RHSC->getValue()->getValue()) &&
1925               getZeroExtendExpr(AR, ExtTy) ==
1926               getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
1927                             getZeroExtendExpr(Step, ExtTy),
1928                             AR->getLoop())) {
1929             SmallVector<const SCEV *, 4> Operands;
1930             for (unsigned i = 0, e = AR->getNumOperands(); i != e; ++i)
1931               Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
1932             return getAddRecExpr(Operands, AR->getLoop());
1933           }
1934       // (A*B)/C --> A*(B/C) if safe and B/C can be folded.
1935       if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
1936         SmallVector<const SCEV *, 4> Operands;
1937         for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i)
1938           Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
1939         if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
1940           // Find an operand that's safely divisible.
1941           for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
1942             const SCEV *Op = M->getOperand(i);
1943             const SCEV *Div = getUDivExpr(Op, RHSC);
1944             if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
1945               Operands = SmallVector<const SCEV *, 4>(M->op_begin(),
1946                                                       M->op_end());
1947               Operands[i] = Div;
1948               return getMulExpr(Operands);
1949             }
1950           }
1951       }
1952       // (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
1953       if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(LHS)) {
1954         SmallVector<const SCEV *, 4> Operands;
1955         for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i)
1956           Operands.push_back(getZeroExtendExpr(A->getOperand(i), ExtTy));
1957         if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
1958           Operands.clear();
1959           for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
1960             const SCEV *Op = getUDivExpr(A->getOperand(i), RHS);
1961             if (isa<SCEVUDivExpr>(Op) ||
1962                 getMulExpr(Op, RHS) != A->getOperand(i))
1963               break;
1964             Operands.push_back(Op);
1965           }
1966           if (Operands.size() == A->getNumOperands())
1967             return getAddExpr(Operands);
1968         }
1969       }
1970
1971       // Fold if both operands are constant.
1972       if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
1973         Constant *LHSCV = LHSC->getValue();
1974         Constant *RHSCV = RHSC->getValue();
1975         return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
1976                                                                    RHSCV)));
1977       }
1978     }
1979   }
1980
1981   FoldingSetNodeID ID;
1982   ID.AddInteger(scUDivExpr);
1983   ID.AddPointer(LHS);
1984   ID.AddPointer(RHS);
1985   void *IP = 0;
1986   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1987   SCEV *S = new (SCEVAllocator) SCEVUDivExpr(ID.Intern(SCEVAllocator),
1988                                              LHS, RHS);
1989   UniqueSCEVs.InsertNode(S, IP);
1990   return S;
1991 }
1992
1993
1994 /// getAddRecExpr - Get an add recurrence expression for the specified loop.
1995 /// Simplify the expression as much as possible.
1996 const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start,
1997                                            const SCEV *Step, const Loop *L,
1998                                            bool HasNUW, bool HasNSW) {
1999   SmallVector<const SCEV *, 4> Operands;
2000   Operands.push_back(Start);
2001   if (const SCEVAddRecExpr *StepChrec = dyn_cast<SCEVAddRecExpr>(Step))
2002     if (StepChrec->getLoop() == L) {
2003       Operands.append(StepChrec->op_begin(), StepChrec->op_end());
2004       return getAddRecExpr(Operands, L);
2005     }
2006
2007   Operands.push_back(Step);
2008   return getAddRecExpr(Operands, L, HasNUW, HasNSW);
2009 }
2010
2011 /// getAddRecExpr - Get an add recurrence expression for the specified loop.
2012 /// Simplify the expression as much as possible.
2013 const SCEV *
2014 ScalarEvolution::getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
2015                                const Loop *L,
2016                                bool HasNUW, bool HasNSW) {
2017   if (Operands.size() == 1) return Operands[0];
2018 #ifndef NDEBUG
2019   for (unsigned i = 1, e = Operands.size(); i != e; ++i)
2020     assert(getEffectiveSCEVType(Operands[i]->getType()) ==
2021            getEffectiveSCEVType(Operands[0]->getType()) &&
2022            "SCEVAddRecExpr operand types don't match!");
2023 #endif
2024
2025   if (Operands.back()->isZero()) {
2026     Operands.pop_back();
2027     return getAddRecExpr(Operands, L, HasNUW, HasNSW); // {X,+,0}  -->  X
2028   }
2029
2030   // It's tempting to want to call getMaxBackedgeTakenCount count here and
2031   // use that information to infer NUW and NSW flags. However, computing a
2032   // BE count requires calling getAddRecExpr, so we may not yet have a
2033   // meaningful BE count at this point (and if we don't, we'd be stuck
2034   // with a SCEVCouldNotCompute as the cached BE count).
2035
2036   // If HasNSW is true and all the operands are non-negative, infer HasNUW.
2037   if (!HasNUW && HasNSW) {
2038     bool All = true;
2039     for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2040       if (!isKnownNonNegative(Operands[i])) {
2041         All = false;
2042         break;
2043       }
2044     if (All) HasNUW = true;
2045   }
2046
2047   // Canonicalize nested AddRecs in by nesting them in order of loop depth.
2048   if (const SCEVAddRecExpr *NestedAR = dyn_cast<SCEVAddRecExpr>(Operands[0])) {
2049     const Loop *NestedLoop = NestedAR->getLoop();
2050     if (L->contains(NestedLoop->getHeader()) ?
2051         (L->getLoopDepth() < NestedLoop->getLoopDepth()) :
2052         (!NestedLoop->contains(L->getHeader()) &&
2053          DT->dominates(L->getHeader(), NestedLoop->getHeader()))) {
2054       SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
2055                                                   NestedAR->op_end());
2056       Operands[0] = NestedAR->getStart();
2057       // AddRecs require their operands be loop-invariant with respect to their
2058       // loops. Don't perform this transformation if it would break this
2059       // requirement.
2060       bool AllInvariant = true;
2061       for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2062         if (!Operands[i]->isLoopInvariant(L)) {
2063           AllInvariant = false;
2064           break;
2065         }
2066       if (AllInvariant) {
2067         NestedOperands[0] = getAddRecExpr(Operands, L);
2068         AllInvariant = true;
2069         for (unsigned i = 0, e = NestedOperands.size(); i != e; ++i)
2070           if (!NestedOperands[i]->isLoopInvariant(NestedLoop)) {
2071             AllInvariant = false;
2072             break;
2073           }
2074         if (AllInvariant)
2075           // Ok, both add recurrences are valid after the transformation.
2076           return getAddRecExpr(NestedOperands, NestedLoop, HasNUW, HasNSW);
2077       }
2078       // Reset Operands to its original state.
2079       Operands[0] = NestedAR;
2080     }
2081   }
2082
2083   // Okay, it looks like we really DO need an addrec expr.  Check to see if we
2084   // already have one, otherwise create a new one.
2085   FoldingSetNodeID ID;
2086   ID.AddInteger(scAddRecExpr);
2087   ID.AddInteger(Operands.size());
2088   for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2089     ID.AddPointer(Operands[i]);
2090   ID.AddPointer(L);
2091   void *IP = 0;
2092   SCEVAddRecExpr *S =
2093     static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2094   if (!S) {
2095     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
2096     std::uninitialized_copy(Operands.begin(), Operands.end(), O);
2097     S = new (SCEVAllocator) SCEVAddRecExpr(ID.Intern(SCEVAllocator),
2098                                            O, Operands.size(), L);
2099     UniqueSCEVs.InsertNode(S, IP);
2100   }
2101   if (HasNUW) S->setHasNoUnsignedWrap(true);
2102   if (HasNSW) S->setHasNoSignedWrap(true);
2103   return S;
2104 }
2105
2106 const SCEV *ScalarEvolution::getSMaxExpr(const SCEV *LHS,
2107                                          const SCEV *RHS) {
2108   SmallVector<const SCEV *, 2> Ops;
2109   Ops.push_back(LHS);
2110   Ops.push_back(RHS);
2111   return getSMaxExpr(Ops);
2112 }
2113
2114 const SCEV *
2115 ScalarEvolution::getSMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
2116   assert(!Ops.empty() && "Cannot get empty smax!");
2117   if (Ops.size() == 1) return Ops[0];
2118 #ifndef NDEBUG
2119   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2120     assert(getEffectiveSCEVType(Ops[i]->getType()) ==
2121            getEffectiveSCEVType(Ops[0]->getType()) &&
2122            "SCEVSMaxExpr operand types don't match!");
2123 #endif
2124
2125   // Sort by complexity, this groups all similar expression types together.
2126   GroupByComplexity(Ops, LI);
2127
2128   // If there are any constants, fold them together.
2129   unsigned Idx = 0;
2130   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2131     ++Idx;
2132     assert(Idx < Ops.size());
2133     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2134       // We found two constants, fold them together!
2135       ConstantInt *Fold = ConstantInt::get(getContext(),
2136                               APIntOps::smax(LHSC->getValue()->getValue(),
2137                                              RHSC->getValue()->getValue()));
2138       Ops[0] = getConstant(Fold);
2139       Ops.erase(Ops.begin()+1);  // Erase the folded element
2140       if (Ops.size() == 1) return Ops[0];
2141       LHSC = cast<SCEVConstant>(Ops[0]);
2142     }
2143
2144     // If we are left with a constant minimum-int, strip it off.
2145     if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(true)) {
2146       Ops.erase(Ops.begin());
2147       --Idx;
2148     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(true)) {
2149       // If we have an smax with a constant maximum-int, it will always be
2150       // maximum-int.
2151       return Ops[0];
2152     }
2153
2154     if (Ops.size() == 1) return Ops[0];
2155   }
2156
2157   // Find the first SMax
2158   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scSMaxExpr)
2159     ++Idx;
2160
2161   // Check to see if one of the operands is an SMax. If so, expand its operands
2162   // onto our operand list, and recurse to simplify.
2163   if (Idx < Ops.size()) {
2164     bool DeletedSMax = false;
2165     while (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(Ops[Idx])) {
2166       Ops.erase(Ops.begin()+Idx);
2167       Ops.append(SMax->op_begin(), SMax->op_end());
2168       DeletedSMax = true;
2169     }
2170
2171     if (DeletedSMax)
2172       return getSMaxExpr(Ops);
2173   }
2174
2175   // Okay, check to see if the same value occurs in the operand list twice.  If
2176   // so, delete one.  Since we sorted the list, these values are required to
2177   // be adjacent.
2178   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
2179     //  X smax Y smax Y  -->  X smax Y
2180     //  X smax Y         -->  X, if X is always greater than Y
2181     if (Ops[i] == Ops[i+1] ||
2182         isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
2183       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
2184       --i; --e;
2185     } else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
2186       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
2187       --i; --e;
2188     }
2189
2190   if (Ops.size() == 1) return Ops[0];
2191
2192   assert(!Ops.empty() && "Reduced smax down to nothing!");
2193
2194   // Okay, it looks like we really DO need an smax expr.  Check to see if we
2195   // already have one, otherwise create a new one.
2196   FoldingSetNodeID ID;
2197   ID.AddInteger(scSMaxExpr);
2198   ID.AddInteger(Ops.size());
2199   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2200     ID.AddPointer(Ops[i]);
2201   void *IP = 0;
2202   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
2203   const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2204   std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2205   SCEV *S = new (SCEVAllocator) SCEVSMaxExpr(ID.Intern(SCEVAllocator),
2206                                              O, Ops.size());
2207   UniqueSCEVs.InsertNode(S, IP);
2208   return S;
2209 }
2210
2211 const SCEV *ScalarEvolution::getUMaxExpr(const SCEV *LHS,
2212                                          const SCEV *RHS) {
2213   SmallVector<const SCEV *, 2> Ops;
2214   Ops.push_back(LHS);
2215   Ops.push_back(RHS);
2216   return getUMaxExpr(Ops);
2217 }
2218
2219 const SCEV *
2220 ScalarEvolution::getUMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
2221   assert(!Ops.empty() && "Cannot get empty umax!");
2222   if (Ops.size() == 1) return Ops[0];
2223 #ifndef NDEBUG
2224   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2225     assert(getEffectiveSCEVType(Ops[i]->getType()) ==
2226            getEffectiveSCEVType(Ops[0]->getType()) &&
2227            "SCEVUMaxExpr operand types don't match!");
2228 #endif
2229
2230   // Sort by complexity, this groups all similar expression types together.
2231   GroupByComplexity(Ops, LI);
2232
2233   // If there are any constants, fold them together.
2234   unsigned Idx = 0;
2235   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2236     ++Idx;
2237     assert(Idx < Ops.size());
2238     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2239       // We found two constants, fold them together!
2240       ConstantInt *Fold = ConstantInt::get(getContext(),
2241                               APIntOps::umax(LHSC->getValue()->getValue(),
2242                                              RHSC->getValue()->getValue()));
2243       Ops[0] = getConstant(Fold);
2244       Ops.erase(Ops.begin()+1);  // Erase the folded element
2245       if (Ops.size() == 1) return Ops[0];
2246       LHSC = cast<SCEVConstant>(Ops[0]);
2247     }
2248
2249     // If we are left with a constant minimum-int, strip it off.
2250     if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(false)) {
2251       Ops.erase(Ops.begin());
2252       --Idx;
2253     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(false)) {
2254       // If we have an umax with a constant maximum-int, it will always be
2255       // maximum-int.
2256       return Ops[0];
2257     }
2258
2259     if (Ops.size() == 1) return Ops[0];
2260   }
2261
2262   // Find the first UMax
2263   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scUMaxExpr)
2264     ++Idx;
2265
2266   // Check to see if one of the operands is a UMax. If so, expand its operands
2267   // onto our operand list, and recurse to simplify.
2268   if (Idx < Ops.size()) {
2269     bool DeletedUMax = false;
2270     while (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(Ops[Idx])) {
2271       Ops.erase(Ops.begin()+Idx);
2272       Ops.append(UMax->op_begin(), UMax->op_end());
2273       DeletedUMax = true;
2274     }
2275
2276     if (DeletedUMax)
2277       return getUMaxExpr(Ops);
2278   }
2279
2280   // Okay, check to see if the same value occurs in the operand list twice.  If
2281   // so, delete one.  Since we sorted the list, these values are required to
2282   // be adjacent.
2283   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
2284     //  X umax Y umax Y  -->  X umax Y
2285     //  X umax Y         -->  X, if X is always greater than Y
2286     if (Ops[i] == Ops[i+1] ||
2287         isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
2288       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
2289       --i; --e;
2290     } else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
2291       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
2292       --i; --e;
2293     }
2294
2295   if (Ops.size() == 1) return Ops[0];
2296
2297   assert(!Ops.empty() && "Reduced umax down to nothing!");
2298
2299   // Okay, it looks like we really DO need a umax expr.  Check to see if we
2300   // already have one, otherwise create a new one.
2301   FoldingSetNodeID ID;
2302   ID.AddInteger(scUMaxExpr);
2303   ID.AddInteger(Ops.size());
2304   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2305     ID.AddPointer(Ops[i]);
2306   void *IP = 0;
2307   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
2308   const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2309   std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2310   SCEV *S = new (SCEVAllocator) SCEVUMaxExpr(ID.Intern(SCEVAllocator),
2311                                              O, Ops.size());
2312   UniqueSCEVs.InsertNode(S, IP);
2313   return S;
2314 }
2315
2316 const SCEV *ScalarEvolution::getSMinExpr(const SCEV *LHS,
2317                                          const SCEV *RHS) {
2318   // ~smax(~x, ~y) == smin(x, y).
2319   return getNotSCEV(getSMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
2320 }
2321
2322 const SCEV *ScalarEvolution::getUMinExpr(const SCEV *LHS,
2323                                          const SCEV *RHS) {
2324   // ~umax(~x, ~y) == umin(x, y)
2325   return getNotSCEV(getUMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
2326 }
2327
2328 const SCEV *ScalarEvolution::getSizeOfExpr(const Type *AllocTy) {
2329   // If we have TargetData, we can bypass creating a target-independent
2330   // constant expression and then folding it back into a ConstantInt.
2331   // This is just a compile-time optimization.
2332   if (TD)
2333     return getConstant(TD->getIntPtrType(getContext()),
2334                        TD->getTypeAllocSize(AllocTy));
2335
2336   Constant *C = ConstantExpr::getSizeOf(AllocTy);
2337   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
2338     if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
2339       C = Folded;
2340   const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(AllocTy));
2341   return getTruncateOrZeroExtend(getSCEV(C), Ty);
2342 }
2343
2344 const SCEV *ScalarEvolution::getAlignOfExpr(const Type *AllocTy) {
2345   Constant *C = ConstantExpr::getAlignOf(AllocTy);
2346   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
2347     if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
2348       C = Folded;
2349   const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(AllocTy));
2350   return getTruncateOrZeroExtend(getSCEV(C), Ty);
2351 }
2352
2353 const SCEV *ScalarEvolution::getOffsetOfExpr(const StructType *STy,
2354                                              unsigned FieldNo) {
2355   // If we have TargetData, we can bypass creating a target-independent
2356   // constant expression and then folding it back into a ConstantInt.
2357   // This is just a compile-time optimization.
2358   if (TD)
2359     return getConstant(TD->getIntPtrType(getContext()),
2360                        TD->getStructLayout(STy)->getElementOffset(FieldNo));
2361
2362   Constant *C = ConstantExpr::getOffsetOf(STy, FieldNo);
2363   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
2364     if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
2365       C = Folded;
2366   const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(STy));
2367   return getTruncateOrZeroExtend(getSCEV(C), Ty);
2368 }
2369
2370 const SCEV *ScalarEvolution::getOffsetOfExpr(const Type *CTy,
2371                                              Constant *FieldNo) {
2372   Constant *C = ConstantExpr::getOffsetOf(CTy, FieldNo);
2373   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
2374     if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
2375       C = Folded;
2376   const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(CTy));
2377   return getTruncateOrZeroExtend(getSCEV(C), Ty);
2378 }
2379
2380 const SCEV *ScalarEvolution::getUnknown(Value *V) {
2381   // Don't attempt to do anything other than create a SCEVUnknown object
2382   // here.  createSCEV only calls getUnknown after checking for all other
2383   // interesting possibilities, and any other code that calls getUnknown
2384   // is doing so in order to hide a value from SCEV canonicalization.
2385
2386   FoldingSetNodeID ID;
2387   ID.AddInteger(scUnknown);
2388   ID.AddPointer(V);
2389   void *IP = 0;
2390   if (SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) {
2391     assert(cast<SCEVUnknown>(S)->getValue() == V &&
2392            "Stale SCEVUnknown in uniquing map!");
2393     return S;
2394   }
2395   SCEV *S = new (SCEVAllocator) SCEVUnknown(ID.Intern(SCEVAllocator), V, this,
2396                                             FirstUnknown);
2397   FirstUnknown = cast<SCEVUnknown>(S);
2398   UniqueSCEVs.InsertNode(S, IP);
2399   return S;
2400 }
2401
2402 //===----------------------------------------------------------------------===//
2403 //            Basic SCEV Analysis and PHI Idiom Recognition Code
2404 //
2405
2406 /// isSCEVable - Test if values of the given type are analyzable within
2407 /// the SCEV framework. This primarily includes integer types, and it
2408 /// can optionally include pointer types if the ScalarEvolution class
2409 /// has access to target-specific information.
2410 bool ScalarEvolution::isSCEVable(const Type *Ty) const {
2411   // Integers and pointers are always SCEVable.
2412   return Ty->isIntegerTy() || Ty->isPointerTy();
2413 }
2414
2415 /// getTypeSizeInBits - Return the size in bits of the specified type,
2416 /// for which isSCEVable must return true.
2417 uint64_t ScalarEvolution::getTypeSizeInBits(const Type *Ty) const {
2418   assert(isSCEVable(Ty) && "Type is not SCEVable!");
2419
2420   // If we have a TargetData, use it!
2421   if (TD)
2422     return TD->getTypeSizeInBits(Ty);
2423
2424   // Integer types have fixed sizes.
2425   if (Ty->isIntegerTy())
2426     return Ty->getPrimitiveSizeInBits();
2427
2428   // The only other support type is pointer. Without TargetData, conservatively
2429   // assume pointers are 64-bit.
2430   assert(Ty->isPointerTy() && "isSCEVable permitted a non-SCEVable type!");
2431   return 64;
2432 }
2433
2434 /// getEffectiveSCEVType - Return a type with the same bitwidth as
2435 /// the given type and which represents how SCEV will treat the given
2436 /// type, for which isSCEVable must return true. For pointer types,
2437 /// this is the pointer-sized integer type.
2438 const Type *ScalarEvolution::getEffectiveSCEVType(const Type *Ty) const {
2439   assert(isSCEVable(Ty) && "Type is not SCEVable!");
2440
2441   if (Ty->isIntegerTy())
2442     return Ty;
2443
2444   // The only other support type is pointer.
2445   assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
2446   if (TD) return TD->getIntPtrType(getContext());
2447
2448   // Without TargetData, conservatively assume pointers are 64-bit.
2449   return Type::getInt64Ty(getContext());
2450 }
2451
2452 const SCEV *ScalarEvolution::getCouldNotCompute() {
2453   return &CouldNotCompute;
2454 }
2455
2456 /// getSCEV - Return an existing SCEV if it exists, otherwise analyze the
2457 /// expression and create a new one.
2458 const SCEV *ScalarEvolution::getSCEV(Value *V) {
2459   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
2460
2461   std::map<SCEVCallbackVH, const SCEV *>::iterator I = Scalars.find(V);
2462   if (I != Scalars.end()) return I->second;
2463   const SCEV *S = createSCEV(V);
2464   Scalars.insert(std::make_pair(SCEVCallbackVH(V, this), S));
2465   return S;
2466 }
2467
2468 /// getNegativeSCEV - Return a SCEV corresponding to -V = -1*V
2469 ///
2470 const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V) {
2471   if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
2472     return getConstant(
2473                cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
2474
2475   const Type *Ty = V->getType();
2476   Ty = getEffectiveSCEVType(Ty);
2477   return getMulExpr(V,
2478                   getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty))));
2479 }
2480
2481 /// getNotSCEV - Return a SCEV corresponding to ~V = -1-V
2482 const SCEV *ScalarEvolution::getNotSCEV(const SCEV *V) {
2483   if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
2484     return getConstant(
2485                 cast<ConstantInt>(ConstantExpr::getNot(VC->getValue())));
2486
2487   const Type *Ty = V->getType();
2488   Ty = getEffectiveSCEVType(Ty);
2489   const SCEV *AllOnes =
2490                    getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty)));
2491   return getMinusSCEV(AllOnes, V);
2492 }
2493
2494 /// getMinusSCEV - Return a SCEV corresponding to LHS - RHS.
2495 ///
2496 const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS,
2497                                           const SCEV *RHS) {
2498   // Fast path: X - X --> 0.
2499   if (LHS == RHS)
2500     return getConstant(LHS->getType(), 0);
2501
2502   // X - Y --> X + -Y
2503   return getAddExpr(LHS, getNegativeSCEV(RHS));
2504 }
2505
2506 /// getTruncateOrZeroExtend - Return a SCEV corresponding to a conversion of the
2507 /// input value to the specified type.  If the type must be extended, it is zero
2508 /// extended.
2509 const SCEV *
2510 ScalarEvolution::getTruncateOrZeroExtend(const SCEV *V,
2511                                          const Type *Ty) {
2512   const Type *SrcTy = V->getType();
2513   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2514          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2515          "Cannot truncate or zero extend with non-integer arguments!");
2516   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2517     return V;  // No conversion
2518   if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
2519     return getTruncateExpr(V, Ty);
2520   return getZeroExtendExpr(V, Ty);
2521 }
2522
2523 /// getTruncateOrSignExtend - Return a SCEV corresponding to a conversion of the
2524 /// input value to the specified type.  If the type must be extended, it is sign
2525 /// extended.
2526 const SCEV *
2527 ScalarEvolution::getTruncateOrSignExtend(const SCEV *V,
2528                                          const Type *Ty) {
2529   const Type *SrcTy = V->getType();
2530   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2531          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2532          "Cannot truncate or zero extend with non-integer arguments!");
2533   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2534     return V;  // No conversion
2535   if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
2536     return getTruncateExpr(V, Ty);
2537   return getSignExtendExpr(V, Ty);
2538 }
2539
2540 /// getNoopOrZeroExtend - Return a SCEV corresponding to a conversion of the
2541 /// input value to the specified type.  If the type must be extended, it is zero
2542 /// extended.  The conversion must not be narrowing.
2543 const SCEV *
2544 ScalarEvolution::getNoopOrZeroExtend(const SCEV *V, const Type *Ty) {
2545   const Type *SrcTy = V->getType();
2546   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2547          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2548          "Cannot noop or zero extend with non-integer arguments!");
2549   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
2550          "getNoopOrZeroExtend cannot truncate!");
2551   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2552     return V;  // No conversion
2553   return getZeroExtendExpr(V, Ty);
2554 }
2555
2556 /// getNoopOrSignExtend - Return a SCEV corresponding to a conversion of the
2557 /// input value to the specified type.  If the type must be extended, it is sign
2558 /// extended.  The conversion must not be narrowing.
2559 const SCEV *
2560 ScalarEvolution::getNoopOrSignExtend(const SCEV *V, const Type *Ty) {
2561   const Type *SrcTy = V->getType();
2562   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2563          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2564          "Cannot noop or sign extend with non-integer arguments!");
2565   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
2566          "getNoopOrSignExtend cannot truncate!");
2567   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2568     return V;  // No conversion
2569   return getSignExtendExpr(V, Ty);
2570 }
2571
2572 /// getNoopOrAnyExtend - Return a SCEV corresponding to a conversion of
2573 /// the input value to the specified type. If the type must be extended,
2574 /// it is extended with unspecified bits. The conversion must not be
2575 /// narrowing.
2576 const SCEV *
2577 ScalarEvolution::getNoopOrAnyExtend(const SCEV *V, const Type *Ty) {
2578   const Type *SrcTy = V->getType();
2579   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2580          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2581          "Cannot noop or any extend with non-integer arguments!");
2582   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
2583          "getNoopOrAnyExtend cannot truncate!");
2584   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2585     return V;  // No conversion
2586   return getAnyExtendExpr(V, Ty);
2587 }
2588
2589 /// getTruncateOrNoop - Return a SCEV corresponding to a conversion of the
2590 /// input value to the specified type.  The conversion must not be widening.
2591 const SCEV *
2592 ScalarEvolution::getTruncateOrNoop(const SCEV *V, const Type *Ty) {
2593   const Type *SrcTy = V->getType();
2594   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
2595          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
2596          "Cannot truncate or noop with non-integer arguments!");
2597   assert(getTypeSizeInBits(SrcTy) >= getTypeSizeInBits(Ty) &&
2598          "getTruncateOrNoop cannot extend!");
2599   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
2600     return V;  // No conversion
2601   return getTruncateExpr(V, Ty);
2602 }
2603
2604 /// getUMaxFromMismatchedTypes - Promote the operands to the wider of
2605 /// the types using zero-extension, and then perform a umax operation
2606 /// with them.
2607 const SCEV *ScalarEvolution::getUMaxFromMismatchedTypes(const SCEV *LHS,
2608                                                         const SCEV *RHS) {
2609   const SCEV *PromotedLHS = LHS;
2610   const SCEV *PromotedRHS = RHS;
2611
2612   if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
2613     PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
2614   else
2615     PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
2616
2617   return getUMaxExpr(PromotedLHS, PromotedRHS);
2618 }
2619
2620 /// getUMinFromMismatchedTypes - Promote the operands to the wider of
2621 /// the types using zero-extension, and then perform a umin operation
2622 /// with them.
2623 const SCEV *ScalarEvolution::getUMinFromMismatchedTypes(const SCEV *LHS,
2624                                                         const SCEV *RHS) {
2625   const SCEV *PromotedLHS = LHS;
2626   const SCEV *PromotedRHS = RHS;
2627
2628   if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
2629     PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
2630   else
2631     PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
2632
2633   return getUMinExpr(PromotedLHS, PromotedRHS);
2634 }
2635
2636 /// PushDefUseChildren - Push users of the given Instruction
2637 /// onto the given Worklist.
2638 static void
2639 PushDefUseChildren(Instruction *I,
2640                    SmallVectorImpl<Instruction *> &Worklist) {
2641   // Push the def-use children onto the Worklist stack.
2642   for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
2643        UI != UE; ++UI)
2644     Worklist.push_back(cast<Instruction>(*UI));
2645 }
2646
2647 /// ForgetSymbolicValue - This looks up computed SCEV values for all
2648 /// instructions that depend on the given instruction and removes them from
2649 /// the Scalars map if they reference SymName. This is used during PHI
2650 /// resolution.
2651 void
2652 ScalarEvolution::ForgetSymbolicName(Instruction *PN, const SCEV *SymName) {
2653   SmallVector<Instruction *, 16> Worklist;
2654   PushDefUseChildren(PN, Worklist);
2655
2656   SmallPtrSet<Instruction *, 8> Visited;
2657   Visited.insert(PN);
2658   while (!Worklist.empty()) {
2659     Instruction *I = Worklist.pop_back_val();
2660     if (!Visited.insert(I)) continue;
2661
2662     std::map<SCEVCallbackVH, const SCEV *>::iterator It =
2663       Scalars.find(static_cast<Value *>(I));
2664     if (It != Scalars.end()) {
2665       // Short-circuit the def-use traversal if the symbolic name
2666       // ceases to appear in expressions.
2667       if (It->second != SymName && !It->second->hasOperand(SymName))
2668         continue;
2669
2670       // SCEVUnknown for a PHI either means that it has an unrecognized
2671       // structure, it's a PHI that's in the progress of being computed
2672       // by createNodeForPHI, or it's a single-value PHI. In the first case,
2673       // additional loop trip count information isn't going to change anything.
2674       // In the second case, createNodeForPHI will perform the necessary
2675       // updates on its own when it gets to that point. In the third, we do
2676       // want to forget the SCEVUnknown.
2677       if (!isa<PHINode>(I) ||
2678           !isa<SCEVUnknown>(It->second) ||
2679           (I != PN && It->second == SymName)) {
2680         ValuesAtScopes.erase(It->second);
2681         Scalars.erase(It);
2682       }
2683     }
2684
2685     PushDefUseChildren(I, Worklist);
2686   }
2687 }
2688
2689 /// createNodeForPHI - PHI nodes have two cases.  Either the PHI node exists in
2690 /// a loop header, making it a potential recurrence, or it doesn't.
2691 ///
2692 const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
2693   if (const Loop *L = LI->getLoopFor(PN->getParent()))
2694     if (L->getHeader() == PN->getParent()) {
2695       // The loop may have multiple entrances or multiple exits; we can analyze
2696       // this phi as an addrec if it has a unique entry value and a unique
2697       // backedge value.
2698       Value *BEValueV = 0, *StartValueV = 0;
2699       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
2700         Value *V = PN->getIncomingValue(i);
2701         if (L->contains(PN->getIncomingBlock(i))) {
2702           if (!BEValueV) {
2703             BEValueV = V;
2704           } else if (BEValueV != V) {
2705             BEValueV = 0;
2706             break;
2707           }
2708         } else if (!StartValueV) {
2709           StartValueV = V;
2710         } else if (StartValueV != V) {
2711           StartValueV = 0;
2712           break;
2713         }
2714       }
2715       if (BEValueV && StartValueV) {
2716         // While we are analyzing this PHI node, handle its value symbolically.
2717         const SCEV *SymbolicName = getUnknown(PN);
2718         assert(Scalars.find(PN) == Scalars.end() &&
2719                "PHI node already processed?");
2720         Scalars.insert(std::make_pair(SCEVCallbackVH(PN, this), SymbolicName));
2721
2722         // Using this symbolic name for the PHI, analyze the value coming around
2723         // the back-edge.
2724         const SCEV *BEValue = getSCEV(BEValueV);
2725
2726         // NOTE: If BEValue is loop invariant, we know that the PHI node just
2727         // has a special value for the first iteration of the loop.
2728
2729         // If the value coming around the backedge is an add with the symbolic
2730         // value we just inserted, then we found a simple induction variable!
2731         if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(BEValue)) {
2732           // If there is a single occurrence of the symbolic value, replace it
2733           // with a recurrence.
2734           unsigned FoundIndex = Add->getNumOperands();
2735           for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
2736             if (Add->getOperand(i) == SymbolicName)
2737               if (FoundIndex == e) {
2738                 FoundIndex = i;
2739                 break;
2740               }
2741
2742           if (FoundIndex != Add->getNumOperands()) {
2743             // Create an add with everything but the specified operand.
2744             SmallVector<const SCEV *, 8> Ops;
2745             for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
2746               if (i != FoundIndex)
2747                 Ops.push_back(Add->getOperand(i));
2748             const SCEV *Accum = getAddExpr(Ops);
2749
2750             // This is not a valid addrec if the step amount is varying each
2751             // loop iteration, but is not itself an addrec in this loop.
2752             if (Accum->isLoopInvariant(L) ||
2753                 (isa<SCEVAddRecExpr>(Accum) &&
2754                  cast<SCEVAddRecExpr>(Accum)->getLoop() == L)) {
2755               bool HasNUW = false;
2756               bool HasNSW = false;
2757
2758               // If the increment doesn't overflow, then neither the addrec nor
2759               // the post-increment will overflow.
2760               if (const AddOperator *OBO = dyn_cast<AddOperator>(BEValueV)) {
2761                 if (OBO->hasNoUnsignedWrap())
2762                   HasNUW = true;
2763                 if (OBO->hasNoSignedWrap())
2764                   HasNSW = true;
2765               }
2766
2767               const SCEV *StartVal = getSCEV(StartValueV);
2768               const SCEV *PHISCEV =
2769                 getAddRecExpr(StartVal, Accum, L, HasNUW, HasNSW);
2770
2771               // Since the no-wrap flags are on the increment, they apply to the
2772               // post-incremented value as well.
2773               if (Accum->isLoopInvariant(L))
2774                 (void)getAddRecExpr(getAddExpr(StartVal, Accum),
2775                                     Accum, L, HasNUW, HasNSW);
2776
2777               // Okay, for the entire analysis of this edge we assumed the PHI
2778               // to be symbolic.  We now need to go back and purge all of the
2779               // entries for the scalars that use the symbolic expression.
2780               ForgetSymbolicName(PN, SymbolicName);
2781               Scalars[SCEVCallbackVH(PN, this)] = PHISCEV;
2782               return PHISCEV;
2783             }
2784           }
2785         } else if (const SCEVAddRecExpr *AddRec =
2786                      dyn_cast<SCEVAddRecExpr>(BEValue)) {
2787           // Otherwise, this could be a loop like this:
2788           //     i = 0;  for (j = 1; ..; ++j) { ....  i = j; }
2789           // In this case, j = {1,+,1}  and BEValue is j.
2790           // Because the other in-value of i (0) fits the evolution of BEValue
2791           // i really is an addrec evolution.
2792           if (AddRec->getLoop() == L && AddRec->isAffine()) {
2793             const SCEV *StartVal = getSCEV(StartValueV);
2794
2795             // If StartVal = j.start - j.stride, we can use StartVal as the
2796             // initial step of the addrec evolution.
2797             if (StartVal == getMinusSCEV(AddRec->getOperand(0),
2798                                          AddRec->getOperand(1))) {
2799               const SCEV *PHISCEV =
2800                  getAddRecExpr(StartVal, AddRec->getOperand(1), L);
2801
2802               // Okay, for the entire analysis of this edge we assumed the PHI
2803               // to be symbolic.  We now need to go back and purge all of the
2804               // entries for the scalars that use the symbolic expression.
2805               ForgetSymbolicName(PN, SymbolicName);
2806               Scalars[SCEVCallbackVH(PN, this)] = PHISCEV;
2807               return PHISCEV;
2808             }
2809           }
2810         }
2811       }
2812     }
2813
2814   // If the PHI has a single incoming value, follow that value, unless the
2815   // PHI's incoming blocks are in a different loop, in which case doing so
2816   // risks breaking LCSSA form. Instcombine would normally zap these, but
2817   // it doesn't have DominatorTree information, so it may miss cases.
2818   if (Value *V = PN->hasConstantValue(DT)) {
2819     bool AllSameLoop = true;
2820     Loop *PNLoop = LI->getLoopFor(PN->getParent());
2821     for (size_t i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
2822       if (LI->getLoopFor(PN->getIncomingBlock(i)) != PNLoop) {
2823         AllSameLoop = false;
2824         break;
2825       }
2826     if (AllSameLoop)
2827       return getSCEV(V);
2828   }
2829
2830   // If it's not a loop phi, we can't handle it yet.
2831   return getUnknown(PN);
2832 }
2833
2834 /// createNodeForGEP - Expand GEP instructions into add and multiply
2835 /// operations. This allows them to be analyzed by regular SCEV code.
2836 ///
2837 const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
2838
2839   // Don't blindly transfer the inbounds flag from the GEP instruction to the
2840   // Add expression, because the Instruction may be guarded by control flow
2841   // and the no-overflow bits may not be valid for the expression in any
2842   // context.
2843
2844   const Type *IntPtrTy = getEffectiveSCEVType(GEP->getType());
2845   Value *Base = GEP->getOperand(0);
2846   // Don't attempt to analyze GEPs over unsized objects.
2847   if (!cast<PointerType>(Base->getType())->getElementType()->isSized())
2848     return getUnknown(GEP);
2849   const SCEV *TotalOffset = getConstant(IntPtrTy, 0);
2850   gep_type_iterator GTI = gep_type_begin(GEP);
2851   for (GetElementPtrInst::op_iterator I = llvm::next(GEP->op_begin()),
2852                                       E = GEP->op_end();
2853        I != E; ++I) {
2854     Value *Index = *I;
2855     // Compute the (potentially symbolic) offset in bytes for this index.
2856     if (const StructType *STy = dyn_cast<StructType>(*GTI++)) {
2857       // For a struct, add the member offset.
2858       unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue();
2859       const SCEV *FieldOffset = getOffsetOfExpr(STy, FieldNo);
2860
2861       // Add the field offset to the running total offset.
2862       TotalOffset = getAddExpr(TotalOffset, FieldOffset);
2863     } else {
2864       // For an array, add the element offset, explicitly scaled.
2865       const SCEV *ElementSize = getSizeOfExpr(*GTI);
2866       const SCEV *IndexS = getSCEV(Index);
2867       // Getelementptr indices are signed.
2868       IndexS = getTruncateOrSignExtend(IndexS, IntPtrTy);
2869
2870       // Multiply the index by the element size to compute the element offset.
2871       const SCEV *LocalOffset = getMulExpr(IndexS, ElementSize);
2872
2873       // Add the element offset to the running total offset.
2874       TotalOffset = getAddExpr(TotalOffset, LocalOffset);
2875     }
2876   }
2877
2878   // Get the SCEV for the GEP base.
2879   const SCEV *BaseS = getSCEV(Base);
2880
2881   // Add the total offset from all the GEP indices to the base.
2882   return getAddExpr(BaseS, TotalOffset);
2883 }
2884
2885 /// GetMinTrailingZeros - Determine the minimum number of zero bits that S is
2886 /// guaranteed to end in (at every loop iteration).  It is, at the same time,
2887 /// the minimum number of times S is divisible by 2.  For example, given {4,+,8}
2888 /// it returns 2.  If S is guaranteed to be 0, it returns the bitwidth of S.
2889 uint32_t
2890 ScalarEvolution::GetMinTrailingZeros(const SCEV *S) {
2891   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
2892     return C->getValue()->getValue().countTrailingZeros();
2893
2894   if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(S))
2895     return std::min(GetMinTrailingZeros(T->getOperand()),
2896                     (uint32_t)getTypeSizeInBits(T->getType()));
2897
2898   if (const SCEVZeroExtendExpr *E = dyn_cast<SCEVZeroExtendExpr>(S)) {
2899     uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
2900     return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
2901              getTypeSizeInBits(E->getType()) : OpRes;
2902   }
2903
2904   if (const SCEVSignExtendExpr *E = dyn_cast<SCEVSignExtendExpr>(S)) {
2905     uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
2906     return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
2907              getTypeSizeInBits(E->getType()) : OpRes;
2908   }
2909
2910   if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(S)) {
2911     // The result is the min of all operands results.
2912     uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
2913     for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
2914       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
2915     return MinOpRes;
2916   }
2917
2918   if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
2919     // The result is the sum of all operands results.
2920     uint32_t SumOpRes = GetMinTrailingZeros(M->getOperand(0));
2921     uint32_t BitWidth = getTypeSizeInBits(M->getType());
2922     for (unsigned i = 1, e = M->getNumOperands();
2923          SumOpRes != BitWidth && i != e; ++i)
2924       SumOpRes = std::min(SumOpRes + GetMinTrailingZeros(M->getOperand(i)),
2925                           BitWidth);
2926     return SumOpRes;
2927   }
2928
2929   if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(S)) {
2930     // The result is the min of all operands results.
2931     uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
2932     for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
2933       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
2934     return MinOpRes;
2935   }
2936
2937   if (const SCEVSMaxExpr *M = dyn_cast<SCEVSMaxExpr>(S)) {
2938     // The result is the min of all operands results.
2939     uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
2940     for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
2941       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
2942     return MinOpRes;
2943   }
2944
2945   if (const SCEVUMaxExpr *M = dyn_cast<SCEVUMaxExpr>(S)) {
2946     // The result is the min of all operands results.
2947     uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
2948     for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
2949       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
2950     return MinOpRes;
2951   }
2952
2953   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
2954     // For a SCEVUnknown, ask ValueTracking.
2955     unsigned BitWidth = getTypeSizeInBits(U->getType());
2956     APInt Mask = APInt::getAllOnesValue(BitWidth);
2957     APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
2958     ComputeMaskedBits(U->getValue(), Mask, Zeros, Ones);
2959     return Zeros.countTrailingOnes();
2960   }
2961
2962   // SCEVUDivExpr
2963   return 0;
2964 }
2965
2966 /// getUnsignedRange - Determine the unsigned range for a particular SCEV.
2967 ///
2968 ConstantRange
2969 ScalarEvolution::getUnsignedRange(const SCEV *S) {
2970
2971   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
2972     return ConstantRange(C->getValue()->getValue());
2973
2974   unsigned BitWidth = getTypeSizeInBits(S->getType());
2975   ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
2976
2977   // If the value has known zeros, the maximum unsigned value will have those
2978   // known zeros as well.
2979   uint32_t TZ = GetMinTrailingZeros(S);
2980   if (TZ != 0)
2981     ConservativeResult =
2982       ConstantRange(APInt::getMinValue(BitWidth),
2983                     APInt::getMaxValue(BitWidth).lshr(TZ).shl(TZ) + 1);
2984
2985   if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
2986     ConstantRange X = getUnsignedRange(Add->getOperand(0));
2987     for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
2988       X = X.add(getUnsignedRange(Add->getOperand(i)));
2989     return ConservativeResult.intersectWith(X);
2990   }
2991
2992   if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
2993     ConstantRange X = getUnsignedRange(Mul->getOperand(0));
2994     for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
2995       X = X.multiply(getUnsignedRange(Mul->getOperand(i)));
2996     return ConservativeResult.intersectWith(X);
2997   }
2998
2999   if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
3000     ConstantRange X = getUnsignedRange(SMax->getOperand(0));
3001     for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
3002       X = X.smax(getUnsignedRange(SMax->getOperand(i)));
3003     return ConservativeResult.intersectWith(X);
3004   }
3005
3006   if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
3007     ConstantRange X = getUnsignedRange(UMax->getOperand(0));
3008     for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
3009       X = X.umax(getUnsignedRange(UMax->getOperand(i)));
3010     return ConservativeResult.intersectWith(X);
3011   }
3012
3013   if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
3014     ConstantRange X = getUnsignedRange(UDiv->getLHS());
3015     ConstantRange Y = getUnsignedRange(UDiv->getRHS());
3016     return ConservativeResult.intersectWith(X.udiv(Y));
3017   }
3018
3019   if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
3020     ConstantRange X = getUnsignedRange(ZExt->getOperand());
3021     return ConservativeResult.intersectWith(X.zeroExtend(BitWidth));
3022   }
3023
3024   if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
3025     ConstantRange X = getUnsignedRange(SExt->getOperand());
3026     return ConservativeResult.intersectWith(X.signExtend(BitWidth));
3027   }
3028
3029   if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
3030     ConstantRange X = getUnsignedRange(Trunc->getOperand());
3031     return ConservativeResult.intersectWith(X.truncate(BitWidth));
3032   }
3033
3034   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
3035     // If there's no unsigned wrap, the value will never be less than its
3036     // initial value.
3037     if (AddRec->hasNoUnsignedWrap())
3038       if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
3039         if (!C->getValue()->isZero())
3040           ConservativeResult =
3041             ConservativeResult.intersectWith(
3042               ConstantRange(C->getValue()->getValue(), APInt(BitWidth, 0)));
3043
3044     // TODO: non-affine addrec
3045     if (AddRec->isAffine()) {
3046       const Type *Ty = AddRec->getType();
3047       const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
3048       if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
3049           getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
3050         MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
3051
3052         const SCEV *Start = AddRec->getStart();
3053         const SCEV *Step = AddRec->getStepRecurrence(*this);
3054
3055         ConstantRange StartRange = getUnsignedRange(Start);
3056         ConstantRange StepRange = getSignedRange(Step);
3057         ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
3058         ConstantRange EndRange =
3059           StartRange.add(MaxBECountRange.multiply(StepRange));
3060
3061         // Check for overflow. This must be done with ConstantRange arithmetic
3062         // because we could be called from within the ScalarEvolution overflow
3063         // checking code.
3064         ConstantRange ExtStartRange = StartRange.zextOrTrunc(BitWidth*2+1);
3065         ConstantRange ExtStepRange = StepRange.sextOrTrunc(BitWidth*2+1);
3066         ConstantRange ExtMaxBECountRange =
3067           MaxBECountRange.zextOrTrunc(BitWidth*2+1);
3068         ConstantRange ExtEndRange = EndRange.zextOrTrunc(BitWidth*2+1);
3069         if (ExtStartRange.add(ExtMaxBECountRange.multiply(ExtStepRange)) !=
3070             ExtEndRange)
3071           return ConservativeResult;
3072
3073         APInt Min = APIntOps::umin(StartRange.getUnsignedMin(),
3074                                    EndRange.getUnsignedMin());
3075         APInt Max = APIntOps::umax(StartRange.getUnsignedMax(),
3076                                    EndRange.getUnsignedMax());
3077         if (Min.isMinValue() && Max.isMaxValue())
3078           return ConservativeResult;
3079         return ConservativeResult.intersectWith(ConstantRange(Min, Max+1));
3080       }
3081     }
3082
3083     return ConservativeResult;
3084   }
3085
3086   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
3087     // For a SCEVUnknown, ask ValueTracking.
3088     APInt Mask = APInt::getAllOnesValue(BitWidth);
3089     APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
3090     ComputeMaskedBits(U->getValue(), Mask, Zeros, Ones, TD);
3091     if (Ones == ~Zeros + 1)
3092       return ConservativeResult;
3093     return ConservativeResult.intersectWith(ConstantRange(Ones, ~Zeros + 1));
3094   }
3095
3096   return ConservativeResult;
3097 }
3098
3099 /// getSignedRange - Determine the signed range for a particular SCEV.
3100 ///
3101 ConstantRange
3102 ScalarEvolution::getSignedRange(const SCEV *S) {
3103
3104   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
3105     return ConstantRange(C->getValue()->getValue());
3106
3107   unsigned BitWidth = getTypeSizeInBits(S->getType());
3108   ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
3109
3110   // If the value has known zeros, the maximum signed value will have those
3111   // known zeros as well.
3112   uint32_t TZ = GetMinTrailingZeros(S);
3113   if (TZ != 0)
3114     ConservativeResult =
3115       ConstantRange(APInt::getSignedMinValue(BitWidth),
3116                     APInt::getSignedMaxValue(BitWidth).ashr(TZ).shl(TZ) + 1);
3117
3118   if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
3119     ConstantRange X = getSignedRange(Add->getOperand(0));
3120     for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
3121       X = X.add(getSignedRange(Add->getOperand(i)));
3122     return ConservativeResult.intersectWith(X);
3123   }
3124
3125   if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
3126     ConstantRange X = getSignedRange(Mul->getOperand(0));
3127     for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
3128       X = X.multiply(getSignedRange(Mul->getOperand(i)));
3129     return ConservativeResult.intersectWith(X);
3130   }
3131
3132   if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
3133     ConstantRange X = getSignedRange(SMax->getOperand(0));
3134     for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
3135       X = X.smax(getSignedRange(SMax->getOperand(i)));
3136     return ConservativeResult.intersectWith(X);
3137   }
3138
3139   if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
3140     ConstantRange X = getSignedRange(UMax->getOperand(0));
3141     for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
3142       X = X.umax(getSignedRange(UMax->getOperand(i)));
3143     return ConservativeResult.intersectWith(X);
3144   }
3145
3146   if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
3147     ConstantRange X = getSignedRange(UDiv->getLHS());
3148     ConstantRange Y = getSignedRange(UDiv->getRHS());
3149     return ConservativeResult.intersectWith(X.udiv(Y));
3150   }
3151
3152   if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
3153     ConstantRange X = getSignedRange(ZExt->getOperand());
3154     return ConservativeResult.intersectWith(X.zeroExtend(BitWidth));
3155   }
3156
3157   if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
3158     ConstantRange X = getSignedRange(SExt->getOperand());
3159     return ConservativeResult.intersectWith(X.signExtend(BitWidth));
3160   }
3161
3162   if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
3163     ConstantRange X = getSignedRange(Trunc->getOperand());
3164     return ConservativeResult.intersectWith(X.truncate(BitWidth));
3165   }
3166
3167   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
3168     // If there's no signed wrap, and all the operands have the same sign or
3169     // zero, the value won't ever change sign.
3170     if (AddRec->hasNoSignedWrap()) {
3171       bool AllNonNeg = true;
3172       bool AllNonPos = true;
3173       for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
3174         if (!isKnownNonNegative(AddRec->getOperand(i))) AllNonNeg = false;
3175         if (!isKnownNonPositive(AddRec->getOperand(i))) AllNonPos = false;
3176       }
3177       if (AllNonNeg)
3178         ConservativeResult = ConservativeResult.intersectWith(
3179           ConstantRange(APInt(BitWidth, 0),
3180                         APInt::getSignedMinValue(BitWidth)));
3181       else if (AllNonPos)
3182         ConservativeResult = ConservativeResult.intersectWith(
3183           ConstantRange(APInt::getSignedMinValue(BitWidth),
3184                         APInt(BitWidth, 1)));
3185     }
3186
3187     // TODO: non-affine addrec
3188     if (AddRec->isAffine()) {
3189       const Type *Ty = AddRec->getType();
3190       const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
3191       if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
3192           getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
3193         MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
3194
3195         const SCEV *Start = AddRec->getStart();
3196         const SCEV *Step = AddRec->getStepRecurrence(*this);
3197
3198         ConstantRange StartRange = getSignedRange(Start);
3199         ConstantRange StepRange = getSignedRange(Step);
3200         ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
3201         ConstantRange EndRange =
3202           StartRange.add(MaxBECountRange.multiply(StepRange));
3203
3204         // Check for overflow. This must be done with ConstantRange arithmetic
3205         // because we could be called from within the ScalarEvolution overflow
3206         // checking code.
3207         ConstantRange ExtStartRange = StartRange.sextOrTrunc(BitWidth*2+1);
3208         ConstantRange ExtStepRange = StepRange.sextOrTrunc(BitWidth*2+1);
3209         ConstantRange ExtMaxBECountRange =
3210           MaxBECountRange.zextOrTrunc(BitWidth*2+1);
3211         ConstantRange ExtEndRange = EndRange.sextOrTrunc(BitWidth*2+1);
3212         if (ExtStartRange.add(ExtMaxBECountRange.multiply(ExtStepRange)) !=
3213             ExtEndRange)
3214           return ConservativeResult;
3215
3216         APInt Min = APIntOps::smin(StartRange.getSignedMin(),
3217                                    EndRange.getSignedMin());
3218         APInt Max = APIntOps::smax(StartRange.getSignedMax(),
3219                                    EndRange.getSignedMax());
3220         if (Min.isMinSignedValue() && Max.isMaxSignedValue())
3221           return ConservativeResult;
3222         return ConservativeResult.intersectWith(ConstantRange(Min, Max+1));
3223       }
3224     }
3225
3226     return ConservativeResult;
3227   }
3228
3229   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
3230     // For a SCEVUnknown, ask ValueTracking.
3231     if (!U->getValue()->getType()->isIntegerTy() && !TD)
3232       return ConservativeResult;
3233     unsigned NS = ComputeNumSignBits(U->getValue(), TD);
3234     if (NS == 1)
3235       return ConservativeResult;
3236     return ConservativeResult.intersectWith(
3237       ConstantRange(APInt::getSignedMinValue(BitWidth).ashr(NS - 1),
3238                     APInt::getSignedMaxValue(BitWidth).ashr(NS - 1)+1));
3239   }
3240
3241   return ConservativeResult;
3242 }
3243
3244 /// createSCEV - We know that there is no SCEV for the specified value.
3245 /// Analyze the expression.
3246 ///
3247 const SCEV *ScalarEvolution::createSCEV(Value *V) {
3248   if (!isSCEVable(V->getType()))
3249     return getUnknown(V);
3250
3251   unsigned Opcode = Instruction::UserOp1;
3252   if (Instruction *I = dyn_cast<Instruction>(V)) {
3253     Opcode = I->getOpcode();
3254
3255     // Don't attempt to analyze instructions in blocks that aren't
3256     // reachable. Such instructions don't matter, and they aren't required
3257     // to obey basic rules for definitions dominating uses which this
3258     // analysis depends on.
3259     if (!DT->isReachableFromEntry(I->getParent()))
3260       return getUnknown(V);
3261   } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
3262     Opcode = CE->getOpcode();
3263   else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
3264     return getConstant(CI);
3265   else if (isa<ConstantPointerNull>(V))
3266     return getConstant(V->getType(), 0);
3267   else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
3268     return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
3269   else
3270     return getUnknown(V);
3271
3272   Operator *U = cast<Operator>(V);
3273   switch (Opcode) {
3274   case Instruction::Add:
3275     return getAddExpr(getSCEV(U->getOperand(0)),
3276                       getSCEV(U->getOperand(1)));
3277   case Instruction::Mul:
3278     return getMulExpr(getSCEV(U->getOperand(0)),
3279                       getSCEV(U->getOperand(1)));
3280   case Instruction::UDiv:
3281     return getUDivExpr(getSCEV(U->getOperand(0)),
3282                        getSCEV(U->getOperand(1)));
3283   case Instruction::Sub:
3284     return getMinusSCEV(getSCEV(U->getOperand(0)),
3285                         getSCEV(U->getOperand(1)));
3286   case Instruction::And:
3287     // For an expression like x&255 that merely masks off the high bits,
3288     // use zext(trunc(x)) as the SCEV expression.
3289     if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
3290       if (CI->isNullValue())
3291         return getSCEV(U->getOperand(1));
3292       if (CI->isAllOnesValue())
3293         return getSCEV(U->getOperand(0));
3294       const APInt &A = CI->getValue();
3295
3296       // Instcombine's ShrinkDemandedConstant may strip bits out of
3297       // constants, obscuring what would otherwise be a low-bits mask.
3298       // Use ComputeMaskedBits to compute what ShrinkDemandedConstant
3299       // knew about to reconstruct a low-bits mask value.
3300       unsigned LZ = A.countLeadingZeros();
3301       unsigned BitWidth = A.getBitWidth();
3302       APInt AllOnes = APInt::getAllOnesValue(BitWidth);
3303       APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
3304       ComputeMaskedBits(U->getOperand(0), AllOnes, KnownZero, KnownOne, TD);
3305
3306       APInt EffectiveMask = APInt::getLowBitsSet(BitWidth, BitWidth - LZ);
3307
3308       if (LZ != 0 && !((~A & ~KnownZero) & EffectiveMask))
3309         return
3310           getZeroExtendExpr(getTruncateExpr(getSCEV(U->getOperand(0)),
3311                                 IntegerType::get(getContext(), BitWidth - LZ)),
3312                             U->getType());
3313     }
3314     break;
3315
3316   case Instruction::Or:
3317     // If the RHS of the Or is a constant, we may have something like:
3318     // X*4+1 which got turned into X*4|1.  Handle this as an Add so loop
3319     // optimizations will transparently handle this case.
3320     //
3321     // In order for this transformation to be safe, the LHS must be of the
3322     // form X*(2^n) and the Or constant must be less than 2^n.
3323     if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
3324       const SCEV *LHS = getSCEV(U->getOperand(0));
3325       const APInt &CIVal = CI->getValue();
3326       if (GetMinTrailingZeros(LHS) >=
3327           (CIVal.getBitWidth() - CIVal.countLeadingZeros())) {
3328         // Build a plain add SCEV.
3329         const SCEV *S = getAddExpr(LHS, getSCEV(CI));
3330         // If the LHS of the add was an addrec and it has no-wrap flags,
3331         // transfer the no-wrap flags, since an or won't introduce a wrap.
3332         if (const SCEVAddRecExpr *NewAR = dyn_cast<SCEVAddRecExpr>(S)) {
3333           const SCEVAddRecExpr *OldAR = cast<SCEVAddRecExpr>(LHS);
3334           if (OldAR->hasNoUnsignedWrap())
3335             const_cast<SCEVAddRecExpr *>(NewAR)->setHasNoUnsignedWrap(true);
3336           if (OldAR->hasNoSignedWrap())
3337             const_cast<SCEVAddRecExpr *>(NewAR)->setHasNoSignedWrap(true);
3338         }
3339         return S;
3340       }
3341     }
3342     break;
3343   case Instruction::Xor:
3344     if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
3345       // If the RHS of the xor is a signbit, then this is just an add.
3346       // Instcombine turns add of signbit into xor as a strength reduction step.
3347       if (CI->getValue().isSignBit())
3348         return getAddExpr(getSCEV(U->getOperand(0)),
3349                           getSCEV(U->getOperand(1)));
3350
3351       // If the RHS of xor is -1, then this is a not operation.
3352       if (CI->isAllOnesValue())
3353         return getNotSCEV(getSCEV(U->getOperand(0)));
3354
3355       // Model xor(and(x, C), C) as and(~x, C), if C is a low-bits mask.
3356       // This is a variant of the check for xor with -1, and it handles
3357       // the case where instcombine has trimmed non-demanded bits out
3358       // of an xor with -1.
3359       if (BinaryOperator *BO = dyn_cast<BinaryOperator>(U->getOperand(0)))
3360         if (ConstantInt *LCI = dyn_cast<ConstantInt>(BO->getOperand(1)))
3361           if (BO->getOpcode() == Instruction::And &&
3362               LCI->getValue() == CI->getValue())
3363             if (const SCEVZeroExtendExpr *Z =
3364                   dyn_cast<SCEVZeroExtendExpr>(getSCEV(U->getOperand(0)))) {
3365               const Type *UTy = U->getType();
3366               const SCEV *Z0 = Z->getOperand();
3367               const Type *Z0Ty = Z0->getType();
3368               unsigned Z0TySize = getTypeSizeInBits(Z0Ty);
3369
3370               // If C is a low-bits mask, the zero extend is serving to
3371               // mask off the high bits. Complement the operand and
3372               // re-apply the zext.
3373               if (APIntOps::isMask(Z0TySize, CI->getValue()))
3374                 return getZeroExtendExpr(getNotSCEV(Z0), UTy);
3375
3376               // If C is a single bit, it may be in the sign-bit position
3377               // before the zero-extend. In this case, represent the xor
3378               // using an add, which is equivalent, and re-apply the zext.
3379               APInt Trunc = APInt(CI->getValue()).trunc(Z0TySize);
3380               if (APInt(Trunc).zext(getTypeSizeInBits(UTy)) == CI->getValue() &&
3381                   Trunc.isSignBit())
3382                 return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
3383                                          UTy);
3384             }
3385     }
3386     break;
3387
3388   case Instruction::Shl:
3389     // Turn shift left of a constant amount into a multiply.
3390     if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
3391       uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
3392
3393       // If the shift count is not less than the bitwidth, the result of
3394       // the shift is undefined. Don't try to analyze it, because the
3395       // resolution chosen here may differ from the resolution chosen in
3396       // other parts of the compiler.
3397       if (SA->getValue().uge(BitWidth))
3398         break;
3399
3400       Constant *X = ConstantInt::get(getContext(),
3401         APInt(BitWidth, 1).shl(SA->getZExtValue()));
3402       return getMulExpr(getSCEV(U->getOperand(0)), getSCEV(X));
3403     }
3404     break;
3405
3406   case Instruction::LShr:
3407     // Turn logical shift right of a constant into a unsigned divide.
3408     if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
3409       uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
3410
3411       // If the shift count is not less than the bitwidth, the result of
3412       // the shift is undefined. Don't try to analyze it, because the
3413       // resolution chosen here may differ from the resolution chosen in
3414       // other parts of the compiler.
3415       if (SA->getValue().uge(BitWidth))
3416         break;
3417
3418       Constant *X = ConstantInt::get(getContext(),
3419         APInt(BitWidth, 1).shl(SA->getZExtValue()));
3420       return getUDivExpr(getSCEV(U->getOperand(0)), getSCEV(X));
3421     }
3422     break;
3423
3424   case Instruction::AShr:
3425     // For a two-shift sext-inreg, use sext(trunc(x)) as the SCEV expression.
3426     if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1)))
3427       if (Operator *L = dyn_cast<Operator>(U->getOperand(0)))
3428         if (L->getOpcode() == Instruction::Shl &&
3429             L->getOperand(1) == U->getOperand(1)) {
3430           uint64_t BitWidth = getTypeSizeInBits(U->getType());
3431
3432           // If the shift count is not less than the bitwidth, the result of
3433           // the shift is undefined. Don't try to analyze it, because the
3434           // resolution chosen here may differ from the resolution chosen in
3435           // other parts of the compiler.
3436           if (CI->getValue().uge(BitWidth))
3437             break;
3438
3439           uint64_t Amt = BitWidth - CI->getZExtValue();
3440           if (Amt == BitWidth)
3441             return getSCEV(L->getOperand(0));       // shift by zero --> noop
3442           return
3443             getSignExtendExpr(getTruncateExpr(getSCEV(L->getOperand(0)),
3444                                               IntegerType::get(getContext(),
3445                                                                Amt)),
3446                               U->getType());
3447         }
3448     break;
3449
3450   case Instruction::Trunc:
3451     return getTruncateExpr(getSCEV(U->getOperand(0)), U->getType());
3452
3453   case Instruction::ZExt:
3454     return getZeroExtendExpr(getSCEV(U->getOperand(0)), U->getType());
3455
3456   case Instruction::SExt:
3457     return getSignExtendExpr(getSCEV(U->getOperand(0)), U->getType());
3458
3459   case Instruction::BitCast:
3460     // BitCasts are no-op casts so we just eliminate the cast.
3461     if (isSCEVable(U->getType()) && isSCEVable(U->getOperand(0)->getType()))
3462       return getSCEV(U->getOperand(0));
3463     break;
3464
3465   // It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
3466   // lead to pointer expressions which cannot safely be expanded to GEPs,
3467   // because ScalarEvolution doesn't respect the GEP aliasing rules when
3468   // simplifying integer expressions.
3469
3470   case Instruction::GetElementPtr:
3471     return createNodeForGEP(cast<GEPOperator>(U));
3472
3473   case Instruction::PHI:
3474     return createNodeForPHI(cast<PHINode>(U));
3475
3476   case Instruction::Select:
3477     // This could be a smax or umax that was lowered earlier.
3478     // Try to recover it.
3479     if (ICmpInst *ICI = dyn_cast<ICmpInst>(U->getOperand(0))) {
3480       Value *LHS = ICI->getOperand(0);
3481       Value *RHS = ICI->getOperand(1);
3482       switch (ICI->getPredicate()) {
3483       case ICmpInst::ICMP_SLT:
3484       case ICmpInst::ICMP_SLE:
3485         std::swap(LHS, RHS);
3486         // fall through
3487       case ICmpInst::ICMP_SGT:
3488       case ICmpInst::ICMP_SGE:
3489         // a >s b ? a+x : b+x  ->  smax(a, b)+x
3490         // a >s b ? b+x : a+x  ->  smin(a, b)+x
3491         if (LHS->getType() == U->getType()) {
3492           const SCEV *LS = getSCEV(LHS);
3493           const SCEV *RS = getSCEV(RHS);
3494           const SCEV *LA = getSCEV(U->getOperand(1));
3495           const SCEV *RA = getSCEV(U->getOperand(2));
3496           const SCEV *LDiff = getMinusSCEV(LA, LS);
3497           const SCEV *RDiff = getMinusSCEV(RA, RS);
3498           if (LDiff == RDiff)
3499             return getAddExpr(getSMaxExpr(LS, RS), LDiff);
3500           LDiff = getMinusSCEV(LA, RS);
3501           RDiff = getMinusSCEV(RA, LS);
3502           if (LDiff == RDiff)
3503             return getAddExpr(getSMinExpr(LS, RS), LDiff);
3504         }
3505         break;
3506       case ICmpInst::ICMP_ULT:
3507       case ICmpInst::ICMP_ULE:
3508         std::swap(LHS, RHS);
3509         // fall through
3510       case ICmpInst::ICMP_UGT:
3511       case ICmpInst::ICMP_UGE:
3512         // a >u b ? a+x : b+x  ->  umax(a, b)+x
3513         // a >u b ? b+x : a+x  ->  umin(a, b)+x
3514         if (LHS->getType() == U->getType()) {
3515           const SCEV *LS = getSCEV(LHS);
3516           const SCEV *RS = getSCEV(RHS);
3517           const SCEV *LA = getSCEV(U->getOperand(1));
3518           const SCEV *RA = getSCEV(U->getOperand(2));
3519           const SCEV *LDiff = getMinusSCEV(LA, LS);
3520           const SCEV *RDiff = getMinusSCEV(RA, RS);
3521           if (LDiff == RDiff)
3522             return getAddExpr(getUMaxExpr(LS, RS), LDiff);
3523           LDiff = getMinusSCEV(LA, RS);
3524           RDiff = getMinusSCEV(RA, LS);
3525           if (LDiff == RDiff)
3526             return getAddExpr(getUMinExpr(LS, RS), LDiff);
3527         }
3528         break;
3529       case ICmpInst::ICMP_NE:
3530         // n != 0 ? n+x : 1+x  ->  umax(n, 1)+x
3531         if (LHS->getType() == U->getType() &&
3532             isa<ConstantInt>(RHS) &&
3533             cast<ConstantInt>(RHS)->isZero()) {
3534           const SCEV *One = getConstant(LHS->getType(), 1);
3535           const SCEV *LS = getSCEV(LHS);
3536           const SCEV *LA = getSCEV(U->getOperand(1));
3537           const SCEV *RA = getSCEV(U->getOperand(2));
3538           const SCEV *LDiff = getMinusSCEV(LA, LS);
3539           const SCEV *RDiff = getMinusSCEV(RA, One);
3540           if (LDiff == RDiff)
3541             return getAddExpr(getUMaxExpr(One, LS), LDiff);
3542         }
3543         break;
3544       case ICmpInst::ICMP_EQ:
3545         // n == 0 ? 1+x : n+x  ->  umax(n, 1)+x
3546         if (LHS->getType() == U->getType() &&
3547             isa<ConstantInt>(RHS) &&
3548             cast<ConstantInt>(RHS)->isZero()) {
3549           const SCEV *One = getConstant(LHS->getType(), 1);
3550           const SCEV *LS = getSCEV(LHS);
3551           const SCEV *LA = getSCEV(U->getOperand(1));
3552           const SCEV *RA = getSCEV(U->getOperand(2));
3553           const SCEV *LDiff = getMinusSCEV(LA, One);
3554           const SCEV *RDiff = getMinusSCEV(RA, LS);
3555           if (LDiff == RDiff)
3556             return getAddExpr(getUMaxExpr(One, LS), LDiff);
3557         }
3558         break;
3559       default:
3560         break;
3561       }
3562     }
3563
3564   default: // We cannot analyze this expression.
3565     break;
3566   }
3567
3568   return getUnknown(V);
3569 }
3570
3571
3572
3573 //===----------------------------------------------------------------------===//
3574 //                   Iteration Count Computation Code
3575 //
3576
3577 /// getBackedgeTakenCount - If the specified loop has a predictable
3578 /// backedge-taken count, return it, otherwise return a SCEVCouldNotCompute
3579 /// object. The backedge-taken count is the number of times the loop header
3580 /// will be branched to from within the loop. This is one less than the
3581 /// trip count of the loop, since it doesn't count the first iteration,
3582 /// when the header is branched to from outside the loop.
3583 ///
3584 /// Note that it is not valid to call this method on a loop without a
3585 /// loop-invariant backedge-taken count (see
3586 /// hasLoopInvariantBackedgeTakenCount).
3587 ///
3588 const SCEV *ScalarEvolution::getBackedgeTakenCount(const Loop *L) {
3589   return getBackedgeTakenInfo(L).Exact;
3590 }
3591
3592 /// getMaxBackedgeTakenCount - Similar to getBackedgeTakenCount, except
3593 /// return the least SCEV value that is known never to be less than the
3594 /// actual backedge taken count.
3595 const SCEV *ScalarEvolution::getMaxBackedgeTakenCount(const Loop *L) {
3596   return getBackedgeTakenInfo(L).Max;
3597 }
3598
3599 /// PushLoopPHIs - Push PHI nodes in the header of the given loop
3600 /// onto the given Worklist.
3601 static void
3602 PushLoopPHIs(const Loop *L, SmallVectorImpl<Instruction *> &Worklist) {
3603   BasicBlock *Header = L->getHeader();
3604
3605   // Push all Loop-header PHIs onto the Worklist stack.
3606   for (BasicBlock::iterator I = Header->begin();
3607        PHINode *PN = dyn_cast<PHINode>(I); ++I)
3608     Worklist.push_back(PN);
3609 }
3610
3611 const ScalarEvolution::BackedgeTakenInfo &
3612 ScalarEvolution::getBackedgeTakenInfo(const Loop *L) {
3613   // Initially insert a CouldNotCompute for this loop. If the insertion
3614   // succeeds, proceed to actually compute a backedge-taken count and
3615   // update the value. The temporary CouldNotCompute value tells SCEV
3616   // code elsewhere that it shouldn't attempt to request a new
3617   // backedge-taken count, which could result in infinite recursion.
3618   std::pair<std::map<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
3619     BackedgeTakenCounts.insert(std::make_pair(L, getCouldNotCompute()));
3620   if (Pair.second) {
3621     BackedgeTakenInfo BECount = ComputeBackedgeTakenCount(L);
3622     if (BECount.Exact != getCouldNotCompute()) {
3623       assert(BECount.Exact->isLoopInvariant(L) &&
3624              BECount.Max->isLoopInvariant(L) &&
3625              "Computed backedge-taken count isn't loop invariant for loop!");
3626       ++NumTripCountsComputed;
3627
3628       // Update the value in the map.
3629       Pair.first->second = BECount;
3630     } else {
3631       if (BECount.Max != getCouldNotCompute())
3632         // Update the value in the map.
3633         Pair.first->second = BECount;
3634       if (isa<PHINode>(L->getHeader()->begin()))
3635         // Only count loops that have phi nodes as not being computable.
3636         ++NumTripCountsNotComputed;
3637     }
3638
3639     // Now that we know more about the trip count for this loop, forget any
3640     // existing SCEV values for PHI nodes in this loop since they are only
3641     // conservative estimates made without the benefit of trip count
3642     // information. This is similar to the code in forgetLoop, except that
3643     // it handles SCEVUnknown PHI nodes specially.
3644     if (BECount.hasAnyInfo()) {
3645       SmallVector<Instruction *, 16> Worklist;
3646       PushLoopPHIs(L, Worklist);
3647
3648       SmallPtrSet<Instruction *, 8> Visited;
3649       while (!Worklist.empty()) {
3650         Instruction *I = Worklist.pop_back_val();
3651         if (!Visited.insert(I)) continue;
3652
3653         std::map<SCEVCallbackVH, const SCEV *>::iterator It =
3654           Scalars.find(static_cast<Value *>(I));
3655         if (It != Scalars.end()) {
3656           // SCEVUnknown for a PHI either means that it has an unrecognized
3657           // structure, or it's a PHI that's in the progress of being computed
3658           // by createNodeForPHI.  In the former case, additional loop trip
3659           // count information isn't going to change anything. In the later
3660           // case, createNodeForPHI will perform the necessary updates on its
3661           // own when it gets to that point.
3662           if (!isa<PHINode>(I) || !isa<SCEVUnknown>(It->second)) {
3663             ValuesAtScopes.erase(It->second);
3664             Scalars.erase(It);
3665           }
3666           if (PHINode *PN = dyn_cast<PHINode>(I))
3667             ConstantEvolutionLoopExitValue.erase(PN);
3668         }
3669
3670         PushDefUseChildren(I, Worklist);
3671       }
3672     }
3673   }
3674   return Pair.first->second;
3675 }
3676
3677 /// forgetLoop - This method should be called by the client when it has
3678 /// changed a loop in a way that may effect ScalarEvolution's ability to
3679 /// compute a trip count, or if the loop is deleted.
3680 void ScalarEvolution::forgetLoop(const Loop *L) {
3681   // Drop any stored trip count value.
3682   BackedgeTakenCounts.erase(L);
3683
3684   // Drop information about expressions based on loop-header PHIs.
3685   SmallVector<Instruction *, 16> Worklist;
3686   PushLoopPHIs(L, Worklist);
3687
3688   SmallPtrSet<Instruction *, 8> Visited;
3689   while (!Worklist.empty()) {
3690     Instruction *I = Worklist.pop_back_val();
3691     if (!Visited.insert(I)) continue;
3692
3693     std::map<SCEVCallbackVH, const SCEV *>::iterator It =
3694       Scalars.find(static_cast<Value *>(I));
3695     if (It != Scalars.end()) {
3696       ValuesAtScopes.erase(It->second);
3697       Scalars.erase(It);
3698       if (PHINode *PN = dyn_cast<PHINode>(I))
3699         ConstantEvolutionLoopExitValue.erase(PN);
3700     }
3701
3702     PushDefUseChildren(I, Worklist);
3703   }
3704 }
3705
3706 /// forgetValue - This method should be called by the client when it has
3707 /// changed a value in a way that may effect its value, or which may
3708 /// disconnect it from a def-use chain linking it to a loop.
3709 void ScalarEvolution::forgetValue(Value *V) {
3710   Instruction *I = dyn_cast<Instruction>(V);
3711   if (!I) return;
3712
3713   // Drop information about expressions based on loop-header PHIs.
3714   SmallVector<Instruction *, 16> Worklist;
3715   Worklist.push_back(I);
3716
3717   SmallPtrSet<Instruction *, 8> Visited;
3718   while (!Worklist.empty()) {
3719     I = Worklist.pop_back_val();
3720     if (!Visited.insert(I)) continue;
3721
3722     std::map<SCEVCallbackVH, const SCEV *>::iterator It =
3723       Scalars.find(static_cast<Value *>(I));
3724     if (It != Scalars.end()) {
3725       ValuesAtScopes.erase(It->second);
3726       Scalars.erase(It);
3727       if (PHINode *PN = dyn_cast<PHINode>(I))
3728         ConstantEvolutionLoopExitValue.erase(PN);
3729     }
3730
3731     PushDefUseChildren(I, Worklist);
3732   }
3733 }
3734
3735 /// ComputeBackedgeTakenCount - Compute the number of times the backedge
3736 /// of the specified loop will execute.
3737 ScalarEvolution::BackedgeTakenInfo
3738 ScalarEvolution::ComputeBackedgeTakenCount(const Loop *L) {
3739   SmallVector<BasicBlock *, 8> ExitingBlocks;
3740   L->getExitingBlocks(ExitingBlocks);
3741
3742   // Examine all exits and pick the most conservative values.
3743   const SCEV *BECount = getCouldNotCompute();
3744   const SCEV *MaxBECount = getCouldNotCompute();
3745   bool CouldNotComputeBECount = false;
3746   for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
3747     BackedgeTakenInfo NewBTI =
3748       ComputeBackedgeTakenCountFromExit(L, ExitingBlocks[i]);
3749
3750     if (NewBTI.Exact == getCouldNotCompute()) {
3751       // We couldn't compute an exact value for this exit, so
3752       // we won't be able to compute an exact value for the loop.
3753       CouldNotComputeBECount = true;
3754       BECount = getCouldNotCompute();
3755     } else if (!CouldNotComputeBECount) {
3756       if (BECount == getCouldNotCompute())
3757         BECount = NewBTI.Exact;
3758       else
3759         BECount = getUMinFromMismatchedTypes(BECount, NewBTI.Exact);
3760     }
3761     if (MaxBECount == getCouldNotCompute())
3762       MaxBECount = NewBTI.Max;
3763     else if (NewBTI.Max != getCouldNotCompute())
3764       MaxBECount = getUMinFromMismatchedTypes(MaxBECount, NewBTI.Max);
3765   }
3766
3767   return BackedgeTakenInfo(BECount, MaxBECount);
3768 }
3769
3770 /// ComputeBackedgeTakenCountFromExit - Compute the number of times the backedge
3771 /// of the specified loop will execute if it exits via the specified block.
3772 ScalarEvolution::BackedgeTakenInfo
3773 ScalarEvolution::ComputeBackedgeTakenCountFromExit(const Loop *L,
3774                                                    BasicBlock *ExitingBlock) {
3775
3776   // Okay, we've chosen an exiting block.  See what condition causes us to
3777   // exit at this block.
3778   //
3779   // FIXME: we should be able to handle switch instructions (with a single exit)
3780   BranchInst *ExitBr = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
3781   if (ExitBr == 0) return getCouldNotCompute();
3782   assert(ExitBr->isConditional() && "If unconditional, it can't be in loop!");
3783
3784   // At this point, we know we have a conditional branch that determines whether
3785   // the loop is exited.  However, we don't know if the branch is executed each
3786   // time through the loop.  If not, then the execution count of the branch will
3787   // not be equal to the trip count of the loop.
3788   //
3789   // Currently we check for this by checking to see if the Exit branch goes to
3790   // the loop header.  If so, we know it will always execute the same number of
3791   // times as the loop.  We also handle the case where the exit block *is* the
3792   // loop header.  This is common for un-rotated loops.
3793   //
3794   // If both of those tests fail, walk up the unique predecessor chain to the
3795   // header, stopping if there is an edge that doesn't exit the loop. If the
3796   // header is reached, the execution count of the branch will be equal to the
3797   // trip count of the loop.
3798   //
3799   //  More extensive analysis could be done to handle more cases here.
3800   //
3801   if (ExitBr->getSuccessor(0) != L->getHeader() &&
3802       ExitBr->getSuccessor(1) != L->getHeader() &&
3803       ExitBr->getParent() != L->getHeader()) {
3804     // The simple checks failed, try climbing the unique predecessor chain
3805     // up to the header.
3806     bool Ok = false;
3807     for (BasicBlock *BB = ExitBr->getParent(); BB; ) {
3808       BasicBlock *Pred = BB->getUniquePredecessor();
3809       if (!Pred)
3810         return getCouldNotCompute();
3811       TerminatorInst *PredTerm = Pred->getTerminator();
3812       for (unsigned i = 0, e = PredTerm->getNumSuccessors(); i != e; ++i) {
3813         BasicBlock *PredSucc = PredTerm->getSuccessor(i);
3814         if (PredSucc == BB)
3815           continue;
3816         // If the predecessor has a successor that isn't BB and isn't
3817         // outside the loop, assume the worst.
3818         if (L->contains(PredSucc))
3819           return getCouldNotCompute();
3820       }
3821       if (Pred == L->getHeader()) {
3822         Ok = true;
3823         break;
3824       }
3825       BB = Pred;
3826     }
3827     if (!Ok)
3828       return getCouldNotCompute();
3829   }
3830
3831   // Proceed to the next level to examine the exit condition expression.
3832   return ComputeBackedgeTakenCountFromExitCond(L, ExitBr->getCondition(),
3833                                                ExitBr->getSuccessor(0),
3834                                                ExitBr->getSuccessor(1));
3835 }
3836
3837 /// ComputeBackedgeTakenCountFromExitCond - Compute the number of times the
3838 /// backedge of the specified loop will execute if its exit condition
3839 /// were a conditional branch of ExitCond, TBB, and FBB.
3840 ScalarEvolution::BackedgeTakenInfo
3841 ScalarEvolution::ComputeBackedgeTakenCountFromExitCond(const Loop *L,
3842                                                        Value *ExitCond,
3843                                                        BasicBlock *TBB,
3844                                                        BasicBlock *FBB) {
3845   // Check if the controlling expression for this loop is an And or Or.
3846   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(ExitCond)) {
3847     if (BO->getOpcode() == Instruction::And) {
3848       // Recurse on the operands of the and.
3849       BackedgeTakenInfo BTI0 =
3850         ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(0), TBB, FBB);
3851       BackedgeTakenInfo BTI1 =
3852         ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(1), TBB, FBB);
3853       const SCEV *BECount = getCouldNotCompute();
3854       const SCEV *MaxBECount = getCouldNotCompute();
3855       if (L->contains(TBB)) {
3856         // Both conditions must be true for the loop to continue executing.
3857         // Choose the less conservative count.
3858         if (BTI0.Exact == getCouldNotCompute() ||
3859             BTI1.Exact == getCouldNotCompute())
3860           BECount = getCouldNotCompute();
3861         else
3862           BECount = getUMinFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
3863         if (BTI0.Max == getCouldNotCompute())
3864           MaxBECount = BTI1.Max;
3865         else if (BTI1.Max == getCouldNotCompute())
3866           MaxBECount = BTI0.Max;
3867         else
3868           MaxBECount = getUMinFromMismatchedTypes(BTI0.Max, BTI1.Max);
3869       } else {
3870         // Both conditions must be true at the same time for the loop to exit.
3871         // For now, be conservative.
3872         assert(L->contains(FBB) && "Loop block has no successor in loop!");
3873         if (BTI0.Max == BTI1.Max)
3874           MaxBECount = BTI0.Max;
3875         if (BTI0.Exact == BTI1.Exact)
3876           BECount = BTI0.Exact;
3877       }
3878
3879       return BackedgeTakenInfo(BECount, MaxBECount);
3880     }
3881     if (BO->getOpcode() == Instruction::Or) {
3882       // Recurse on the operands of the or.
3883       BackedgeTakenInfo BTI0 =
3884         ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(0), TBB, FBB);
3885       BackedgeTakenInfo BTI1 =
3886         ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(1), TBB, FBB);
3887       const SCEV *BECount = getCouldNotCompute();
3888       const SCEV *MaxBECount = getCouldNotCompute();
3889       if (L->contains(FBB)) {
3890         // Both conditions must be false for the loop to continue executing.
3891         // Choose the less conservative count.
3892         if (BTI0.Exact == getCouldNotCompute() ||
3893             BTI1.Exact == getCouldNotCompute())
3894           BECount = getCouldNotCompute();
3895         else
3896           BECount = getUMinFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
3897         if (BTI0.Max == getCouldNotCompute())
3898           MaxBECount = BTI1.Max;
3899         else if (BTI1.Max == getCouldNotCompute())
3900           MaxBECount = BTI0.Max;
3901         else
3902           MaxBECount = getUMinFromMismatchedTypes(BTI0.Max, BTI1.Max);
3903       } else {
3904         // Both conditions must be false at the same time for the loop to exit.
3905         // For now, be conservative.
3906         assert(L->contains(TBB) && "Loop block has no successor in loop!");
3907         if (BTI0.Max == BTI1.Max)
3908           MaxBECount = BTI0.Max;
3909         if (BTI0.Exact == BTI1.Exact)
3910           BECount = BTI0.Exact;
3911       }
3912
3913       return BackedgeTakenInfo(BECount, MaxBECount);
3914     }
3915   }
3916
3917   // With an icmp, it may be feasible to compute an exact backedge-taken count.
3918   // Proceed to the next level to examine the icmp.
3919   if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond))
3920     return ComputeBackedgeTakenCountFromExitCondICmp(L, ExitCondICmp, TBB, FBB);
3921
3922   // Check for a constant condition. These are normally stripped out by
3923   // SimplifyCFG, but ScalarEvolution may be used by a pass which wishes to
3924   // preserve the CFG and is temporarily leaving constant conditions
3925   // in place.
3926   if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
3927     if (L->contains(FBB) == !CI->getZExtValue())
3928       // The backedge is always taken.
3929       return getCouldNotCompute();
3930     else
3931       // The backedge is never taken.
3932       return getConstant(CI->getType(), 0);
3933   }
3934
3935   // If it's not an integer or pointer comparison then compute it the hard way.
3936   return ComputeBackedgeTakenCountExhaustively(L, ExitCond, !L->contains(TBB));
3937 }
3938
3939 /// ComputeBackedgeTakenCountFromExitCondICmp - Compute the number of times the
3940 /// backedge of the specified loop will execute if its exit condition
3941 /// were a conditional branch of the ICmpInst ExitCond, TBB, and FBB.
3942 ScalarEvolution::BackedgeTakenInfo
3943 ScalarEvolution::ComputeBackedgeTakenCountFromExitCondICmp(const Loop *L,
3944                                                            ICmpInst *ExitCond,
3945                                                            BasicBlock *TBB,
3946                                                            BasicBlock *FBB) {
3947
3948   // If the condition was exit on true, convert the condition to exit on false
3949   ICmpInst::Predicate Cond;
3950   if (!L->contains(FBB))
3951     Cond = ExitCond->getPredicate();
3952   else
3953     Cond = ExitCond->getInversePredicate();
3954
3955   // Handle common loops like: for (X = "string"; *X; ++X)
3956   if (LoadInst *LI = dyn_cast<LoadInst>(ExitCond->getOperand(0)))
3957     if (Constant *RHS = dyn_cast<Constant>(ExitCond->getOperand(1))) {
3958       BackedgeTakenInfo ItCnt =
3959         ComputeLoadConstantCompareBackedgeTakenCount(LI, RHS, L, Cond);
3960       if (ItCnt.hasAnyInfo())
3961         return ItCnt;
3962     }
3963
3964   const SCEV *LHS = getSCEV(ExitCond->getOperand(0));
3965   const SCEV *RHS = getSCEV(ExitCond->getOperand(1));
3966
3967   // Try to evaluate any dependencies out of the loop.
3968   LHS = getSCEVAtScope(LHS, L);
3969   RHS = getSCEVAtScope(RHS, L);
3970
3971   // At this point, we would like to compute how many iterations of the
3972   // loop the predicate will return true for these inputs.
3973   if (LHS->isLoopInvariant(L) && !RHS->isLoopInvariant(L)) {
3974     // If there is a loop-invariant, force it into the RHS.
3975     std::swap(LHS, RHS);
3976     Cond = ICmpInst::getSwappedPredicate(Cond);
3977   }
3978
3979   // Simplify the operands before analyzing them.
3980   (void)SimplifyICmpOperands(Cond, LHS, RHS);
3981
3982   // If we have a comparison of a chrec against a constant, try to use value
3983   // ranges to answer this query.
3984   if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
3985     if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS))
3986       if (AddRec->getLoop() == L) {
3987         // Form the constant range.
3988         ConstantRange CompRange(
3989             ICmpInst::makeConstantRange(Cond, RHSC->getValue()->getValue()));
3990
3991         const SCEV *Ret = AddRec->getNumIterationsInRange(CompRange, *this);
3992         if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
3993       }
3994
3995   switch (Cond) {
3996   case ICmpInst::ICMP_NE: {                     // while (X != Y)
3997     // Convert to: while (X-Y != 0)
3998     BackedgeTakenInfo BTI = HowFarToZero(getMinusSCEV(LHS, RHS), L);
3999     if (BTI.hasAnyInfo()) return BTI;
4000     break;
4001   }
4002   case ICmpInst::ICMP_EQ: {                     // while (X == Y)
4003     // Convert to: while (X-Y == 0)
4004     BackedgeTakenInfo BTI = HowFarToNonZero(getMinusSCEV(LHS, RHS), L);
4005     if (BTI.hasAnyInfo()) return BTI;
4006     break;
4007   }
4008   case ICmpInst::ICMP_SLT: {
4009     BackedgeTakenInfo BTI = HowManyLessThans(LHS, RHS, L, true);
4010     if (BTI.hasAnyInfo()) return BTI;
4011     break;
4012   }
4013   case ICmpInst::ICMP_SGT: {
4014     BackedgeTakenInfo BTI = HowManyLessThans(getNotSCEV(LHS),
4015                                              getNotSCEV(RHS), L, true);
4016     if (BTI.hasAnyInfo()) return BTI;
4017     break;
4018   }
4019   case ICmpInst::ICMP_ULT: {
4020     BackedgeTakenInfo BTI = HowManyLessThans(LHS, RHS, L, false);
4021     if (BTI.hasAnyInfo()) return BTI;
4022     break;
4023   }
4024   case ICmpInst::ICMP_UGT: {
4025     BackedgeTakenInfo BTI = HowManyLessThans(getNotSCEV(LHS),
4026                                              getNotSCEV(RHS), L, false);
4027     if (BTI.hasAnyInfo()) return BTI;
4028     break;
4029   }
4030   default:
4031 #if 0
4032     dbgs() << "ComputeBackedgeTakenCount ";
4033     if (ExitCond->getOperand(0)->getType()->isUnsigned())
4034       dbgs() << "[unsigned] ";
4035     dbgs() << *LHS << "   "
4036          << Instruction::getOpcodeName(Instruction::ICmp)
4037          << "   " << *RHS << "\n";
4038 #endif
4039     break;
4040   }
4041   return
4042     ComputeBackedgeTakenCountExhaustively(L, ExitCond, !L->contains(TBB));
4043 }
4044
4045 static ConstantInt *
4046 EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C,
4047                                 ScalarEvolution &SE) {
4048   const SCEV *InVal = SE.getConstant(C);
4049   const SCEV *Val = AddRec->evaluateAtIteration(InVal, SE);
4050   assert(isa<SCEVConstant>(Val) &&
4051          "Evaluation of SCEV at constant didn't fold correctly?");
4052   return cast<SCEVConstant>(Val)->getValue();
4053 }
4054
4055 /// GetAddressedElementFromGlobal - Given a global variable with an initializer
4056 /// and a GEP expression (missing the pointer index) indexing into it, return
4057 /// the addressed element of the initializer or null if the index expression is
4058 /// invalid.
4059 static Constant *
4060 GetAddressedElementFromGlobal(GlobalVariable *GV,
4061                               const std::vector<ConstantInt*> &Indices) {
4062   Constant *Init = GV->getInitializer();
4063   for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
4064     uint64_t Idx = Indices[i]->getZExtValue();
4065     if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Init)) {
4066       assert(Idx < CS->getNumOperands() && "Bad struct index!");
4067       Init = cast<Constant>(CS->getOperand(Idx));
4068     } else if (ConstantArray *CA = dyn_cast<ConstantArray>(Init)) {
4069       if (Idx >= CA->getNumOperands()) return 0;  // Bogus program
4070       Init = cast<Constant>(CA->getOperand(Idx));
4071     } else if (isa<ConstantAggregateZero>(Init)) {
4072       if (const StructType *STy = dyn_cast<StructType>(Init->getType())) {
4073         assert(Idx < STy->getNumElements() && "Bad struct index!");
4074         Init = Constant::getNullValue(STy->getElementType(Idx));
4075       } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Init->getType())) {
4076         if (Idx >= ATy->getNumElements()) return 0;  // Bogus program
4077         Init = Constant::getNullValue(ATy->getElementType());
4078       } else {
4079         llvm_unreachable("Unknown constant aggregate type!");
4080       }
4081       return 0;
4082     } else {
4083       return 0; // Unknown initializer type
4084     }
4085   }
4086   return Init;
4087 }
4088
4089 /// ComputeLoadConstantCompareBackedgeTakenCount - Given an exit condition of
4090 /// 'icmp op load X, cst', try to see if we can compute the backedge
4091 /// execution count.
4092 ScalarEvolution::BackedgeTakenInfo
4093 ScalarEvolution::ComputeLoadConstantCompareBackedgeTakenCount(
4094                                                 LoadInst *LI,
4095                                                 Constant *RHS,
4096                                                 const Loop *L,
4097                                                 ICmpInst::Predicate predicate) {
4098   if (LI->isVolatile()) return getCouldNotCompute();
4099
4100   // Check to see if the loaded pointer is a getelementptr of a global.
4101   // TODO: Use SCEV instead of manually grubbing with GEPs.
4102   GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getOperand(0));
4103   if (!GEP) return getCouldNotCompute();
4104
4105   // Make sure that it is really a constant global we are gepping, with an
4106   // initializer, and make sure the first IDX is really 0.
4107   GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0));
4108   if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer() ||
4109       GEP->getNumOperands() < 3 || !isa<Constant>(GEP->getOperand(1)) ||
4110       !cast<Constant>(GEP->getOperand(1))->isNullValue())
4111     return getCouldNotCompute();
4112
4113   // Okay, we allow one non-constant index into the GEP instruction.
4114   Value *VarIdx = 0;
4115   std::vector<ConstantInt*> Indexes;
4116   unsigned VarIdxNum = 0;
4117   for (unsigned i = 2, e = GEP->getNumOperands(); i != e; ++i)
4118     if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
4119       Indexes.push_back(CI);
4120     } else if (!isa<ConstantInt>(GEP->getOperand(i))) {
4121       if (VarIdx) return getCouldNotCompute();  // Multiple non-constant idx's.
4122       VarIdx = GEP->getOperand(i);
4123       VarIdxNum = i-2;
4124       Indexes.push_back(0);
4125     }
4126
4127   // Okay, we know we have a (load (gep GV, 0, X)) comparison with a constant.
4128   // Check to see if X is a loop variant variable value now.
4129   const SCEV *Idx = getSCEV(VarIdx);
4130   Idx = getSCEVAtScope(Idx, L);
4131
4132   // We can only recognize very limited forms of loop index expressions, in
4133   // particular, only affine AddRec's like {C1,+,C2}.
4134   const SCEVAddRecExpr *IdxExpr = dyn_cast<SCEVAddRecExpr>(Idx);
4135   if (!IdxExpr || !IdxExpr->isAffine() || IdxExpr->isLoopInvariant(L) ||
4136       !isa<SCEVConstant>(IdxExpr->getOperand(0)) ||
4137       !isa<SCEVConstant>(IdxExpr->getOperand(1)))
4138     return getCouldNotCompute();
4139
4140   unsigned MaxSteps = MaxBruteForceIterations;
4141   for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
4142     ConstantInt *ItCst = ConstantInt::get(
4143                            cast<IntegerType>(IdxExpr->getType()), IterationNum);
4144     ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst, *this);
4145
4146     // Form the GEP offset.
4147     Indexes[VarIdxNum] = Val;
4148
4149     Constant *Result = GetAddressedElementFromGlobal(GV, Indexes);
4150     if (Result == 0) break;  // Cannot compute!
4151
4152     // Evaluate the condition for this iteration.
4153     Result = ConstantExpr::getICmp(predicate, Result, RHS);
4154     if (!isa<ConstantInt>(Result)) break;  // Couldn't decide for sure
4155     if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
4156 #if 0
4157       dbgs() << "\n***\n*** Computed loop count " << *ItCst
4158              << "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
4159              << "***\n";
4160 #endif
4161       ++NumArrayLenItCounts;
4162       return getConstant(ItCst);   // Found terminating iteration!
4163     }
4164   }
4165   return getCouldNotCompute();
4166 }
4167
4168
4169 /// CanConstantFold - Return true if we can constant fold an instruction of the
4170 /// specified type, assuming that all operands were constants.
4171 static bool CanConstantFold(const Instruction *I) {
4172   if (isa<BinaryOperator>(I) || isa<CmpInst>(I) ||
4173       isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I))
4174     return true;
4175
4176   if (const CallInst *CI = dyn_cast<CallInst>(I))
4177     if (const Function *F = CI->getCalledFunction())
4178       return canConstantFoldCallTo(F);
4179   return false;
4180 }
4181
4182 /// getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node
4183 /// in the loop that V is derived from.  We allow arbitrary operations along the
4184 /// way, but the operands of an operation must either be constants or a value
4185 /// derived from a constant PHI.  If this expression does not fit with these
4186 /// constraints, return null.
4187 static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
4188   // If this is not an instruction, or if this is an instruction outside of the
4189   // loop, it can't be derived from a loop PHI.
4190   Instruction *I = dyn_cast<Instruction>(V);
4191   if (I == 0 || !L->contains(I)) return 0;
4192
4193   if (PHINode *PN = dyn_cast<PHINode>(I)) {
4194     if (L->getHeader() == I->getParent())
4195       return PN;
4196     else
4197       // We don't currently keep track of the control flow needed to evaluate
4198       // PHIs, so we cannot handle PHIs inside of loops.
4199       return 0;
4200   }
4201
4202   // If we won't be able to constant fold this expression even if the operands
4203   // are constants, return early.
4204   if (!CanConstantFold(I)) return 0;
4205
4206   // Otherwise, we can evaluate this instruction if all of its operands are
4207   // constant or derived from a PHI node themselves.
4208   PHINode *PHI = 0;
4209   for (unsigned Op = 0, e = I->getNumOperands(); Op != e; ++Op)
4210     if (!isa<Constant>(I->getOperand(Op))) {
4211       PHINode *P = getConstantEvolvingPHI(I->getOperand(Op), L);
4212       if (P == 0) return 0;  // Not evolving from PHI
4213       if (PHI == 0)
4214         PHI = P;
4215       else if (PHI != P)
4216         return 0;  // Evolving from multiple different PHIs.
4217     }
4218
4219   // This is a expression evolving from a constant PHI!
4220   return PHI;
4221 }
4222
4223 /// EvaluateExpression - Given an expression that passes the
4224 /// getConstantEvolvingPHI predicate, evaluate its value assuming the PHI node
4225 /// in the loop has the value PHIVal.  If we can't fold this expression for some
4226 /// reason, return null.
4227 static Constant *EvaluateExpression(Value *V, Constant *PHIVal,
4228                                     const TargetData *TD) {
4229   if (isa<PHINode>(V)) return PHIVal;
4230   if (Constant *C = dyn_cast<Constant>(V)) return C;
4231   Instruction *I = cast<Instruction>(V);
4232
4233   std::vector<Constant*> Operands(I->getNumOperands());
4234
4235   for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
4236     Operands[i] = EvaluateExpression(I->getOperand(i), PHIVal, TD);
4237     if (Operands[i] == 0) return 0;
4238   }
4239
4240   if (const CmpInst *CI = dyn_cast<CmpInst>(I))
4241     return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
4242                                            Operands[1], TD);
4243   return ConstantFoldInstOperands(I->getOpcode(), I->getType(),
4244                                   &Operands[0], Operands.size(), TD);
4245 }
4246
4247 /// getConstantEvolutionLoopExitValue - If we know that the specified Phi is
4248 /// in the header of its containing loop, we know the loop executes a
4249 /// constant number of times, and the PHI node is just a recurrence
4250 /// involving constants, fold it.
4251 Constant *
4252 ScalarEvolution::getConstantEvolutionLoopExitValue(PHINode *PN,
4253                                                    const APInt &BEs,
4254                                                    const Loop *L) {
4255   std::map<PHINode*, Constant*>::iterator I =
4256     ConstantEvolutionLoopExitValue.find(PN);
4257   if (I != ConstantEvolutionLoopExitValue.end())
4258     return I->second;
4259
4260   if (BEs.ugt(MaxBruteForceIterations))
4261     return ConstantEvolutionLoopExitValue[PN] = 0;  // Not going to evaluate it.
4262
4263   Constant *&RetVal = ConstantEvolutionLoopExitValue[PN];
4264
4265   // Since the loop is canonicalized, the PHI node must have two entries.  One
4266   // entry must be a constant (coming in from outside of the loop), and the
4267   // second must be derived from the same PHI.
4268   bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
4269   Constant *StartCST =
4270     dyn_cast<Constant>(PN->getIncomingValue(!SecondIsBackedge));
4271   if (StartCST == 0)
4272     return RetVal = 0;  // Must be a constant.
4273
4274   Value *BEValue = PN->getIncomingValue(SecondIsBackedge);
4275   if (getConstantEvolvingPHI(BEValue, L) != PN &&
4276       !isa<Constant>(BEValue))
4277     return RetVal = 0;  // Not derived from same PHI.
4278
4279   // Execute the loop symbolically to determine the exit value.
4280   if (BEs.getActiveBits() >= 32)
4281     return RetVal = 0; // More than 2^32-1 iterations?? Not doing it!
4282
4283   unsigned NumIterations = BEs.getZExtValue(); // must be in range
4284   unsigned IterationNum = 0;
4285   for (Constant *PHIVal = StartCST; ; ++IterationNum) {
4286     if (IterationNum == NumIterations)
4287       return RetVal = PHIVal;  // Got exit value!
4288
4289     // Compute the value of the PHI node for the next iteration.
4290     Constant *NextPHI = EvaluateExpression(BEValue, PHIVal, TD);
4291     if (NextPHI == PHIVal)
4292       return RetVal = NextPHI;  // Stopped evolving!
4293     if (NextPHI == 0)
4294       return 0;        // Couldn't evaluate!
4295     PHIVal = NextPHI;
4296   }
4297 }
4298
4299 /// ComputeBackedgeTakenCountExhaustively - If the loop is known to execute a
4300 /// constant number of times (the condition evolves only from constants),
4301 /// try to evaluate a few iterations of the loop until we get the exit
4302 /// condition gets a value of ExitWhen (true or false).  If we cannot
4303 /// evaluate the trip count of the loop, return getCouldNotCompute().
4304 const SCEV *
4305 ScalarEvolution::ComputeBackedgeTakenCountExhaustively(const Loop *L,
4306                                                        Value *Cond,
4307                                                        bool ExitWhen) {
4308   PHINode *PN = getConstantEvolvingPHI(Cond, L);
4309   if (PN == 0) return getCouldNotCompute();
4310
4311   // If the loop is canonicalized, the PHI will have exactly two entries.
4312   // That's the only form we support here.
4313   if (PN->getNumIncomingValues() != 2) return getCouldNotCompute();
4314
4315   // One entry must be a constant (coming in from outside of the loop), and the
4316   // second must be derived from the same PHI.
4317   bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
4318   Constant *StartCST =
4319     dyn_cast<Constant>(PN->getIncomingValue(!SecondIsBackedge));
4320   if (StartCST == 0) return getCouldNotCompute();  // Must be a constant.
4321
4322   Value *BEValue = PN->getIncomingValue(SecondIsBackedge);
4323   if (getConstantEvolvingPHI(BEValue, L) != PN &&
4324       !isa<Constant>(BEValue))
4325     return getCouldNotCompute();  // Not derived from same PHI.
4326
4327   // Okay, we find a PHI node that defines the trip count of this loop.  Execute
4328   // the loop symbolically to determine when the condition gets a value of
4329   // "ExitWhen".
4330   unsigned IterationNum = 0;
4331   unsigned MaxIterations = MaxBruteForceIterations;   // Limit analysis.
4332   for (Constant *PHIVal = StartCST;
4333        IterationNum != MaxIterations; ++IterationNum) {
4334     ConstantInt *CondVal =
4335       dyn_cast_or_null<ConstantInt>(EvaluateExpression(Cond, PHIVal, TD));
4336
4337     // Couldn't symbolically evaluate.
4338     if (!CondVal) return getCouldNotCompute();
4339
4340     if (CondVal->getValue() == uint64_t(ExitWhen)) {
4341       ++NumBruteForceTripCountsComputed;
4342       return getConstant(Type::getInt32Ty(getContext()), IterationNum);
4343     }
4344
4345     // Compute the value of the PHI node for the next iteration.
4346     Constant *NextPHI = EvaluateExpression(BEValue, PHIVal, TD);
4347     if (NextPHI == 0 || NextPHI == PHIVal)
4348       return getCouldNotCompute();// Couldn't evaluate or not making progress...
4349     PHIVal = NextPHI;
4350   }
4351
4352   // Too many iterations were needed to evaluate.
4353   return getCouldNotCompute();
4354 }
4355
4356 /// getSCEVAtScope - Return a SCEV expression for the specified value
4357 /// at the specified scope in the program.  The L value specifies a loop
4358 /// nest to evaluate the expression at, where null is the top-level or a
4359 /// specified loop is immediately inside of the loop.
4360 ///
4361 /// This method can be used to compute the exit value for a variable defined
4362 /// in a loop by querying what the value will hold in the parent loop.
4363 ///
4364 /// In the case that a relevant loop exit value cannot be computed, the
4365 /// original value V is returned.
4366 const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
4367   // Check to see if we've folded this expression at this loop before.
4368   std::map<const Loop *, const SCEV *> &Values = ValuesAtScopes[V];
4369   std::pair<std::map<const Loop *, const SCEV *>::iterator, bool> Pair =
4370     Values.insert(std::make_pair(L, static_cast<const SCEV *>(0)));
4371   if (!Pair.second)
4372     return Pair.first->second ? Pair.first->second : V;
4373
4374   // Otherwise compute it.
4375   const SCEV *C = computeSCEVAtScope(V, L);
4376   ValuesAtScopes[V][L] = C;
4377   return C;
4378 }
4379
4380 const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
4381   if (isa<SCEVConstant>(V)) return V;
4382
4383   // If this instruction is evolved from a constant-evolving PHI, compute the
4384   // exit value from the loop without using SCEVs.
4385   if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V)) {
4386     if (Instruction *I = dyn_cast<Instruction>(SU->getValue())) {
4387       const Loop *LI = (*this->LI)[I->getParent()];
4388       if (LI && LI->getParentLoop() == L)  // Looking for loop exit value.
4389         if (PHINode *PN = dyn_cast<PHINode>(I))
4390           if (PN->getParent() == LI->getHeader()) {
4391             // Okay, there is no closed form solution for the PHI node.  Check
4392             // to see if the loop that contains it has a known backedge-taken
4393             // count.  If so, we may be able to force computation of the exit
4394             // value.
4395             const SCEV *BackedgeTakenCount = getBackedgeTakenCount(LI);
4396             if (const SCEVConstant *BTCC =
4397                   dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
4398               // Okay, we know how many times the containing loop executes.  If
4399               // this is a constant evolving PHI node, get the final value at
4400               // the specified iteration number.
4401               Constant *RV = getConstantEvolutionLoopExitValue(PN,
4402                                                    BTCC->getValue()->getValue(),
4403                                                                LI);
4404               if (RV) return getSCEV(RV);
4405             }
4406           }
4407
4408       // Okay, this is an expression that we cannot symbolically evaluate
4409       // into a SCEV.  Check to see if it's possible to symbolically evaluate
4410       // the arguments into constants, and if so, try to constant propagate the
4411       // result.  This is particularly useful for computing loop exit values.
4412       if (CanConstantFold(I)) {
4413         SmallVector<Constant *, 4> Operands;
4414         bool MadeImprovement = false;
4415         for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
4416           Value *Op = I->getOperand(i);
4417           if (Constant *C = dyn_cast<Constant>(Op)) {
4418             Operands.push_back(C);
4419             continue;
4420           }
4421
4422           // If any of the operands is non-constant and if they are
4423           // non-integer and non-pointer, don't even try to analyze them
4424           // with scev techniques.
4425           if (!isSCEVable(Op->getType()))
4426             return V;
4427
4428           const SCEV *OrigV = getSCEV(Op);
4429           const SCEV *OpV = getSCEVAtScope(OrigV, L);
4430           MadeImprovement |= OrigV != OpV;
4431
4432           Constant *C = 0;
4433           if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(OpV))
4434             C = SC->getValue();
4435           if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(OpV))
4436             C = dyn_cast<Constant>(SU->getValue());
4437           if (!C) return V;
4438           if (C->getType() != Op->getType())
4439             C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
4440                                                               Op->getType(),
4441                                                               false),
4442                                       C, Op->getType());
4443           Operands.push_back(C);
4444         }
4445
4446         // Check to see if getSCEVAtScope actually made an improvement.
4447         if (MadeImprovement) {
4448           Constant *C = 0;
4449           if (const CmpInst *CI = dyn_cast<CmpInst>(I))
4450             C = ConstantFoldCompareInstOperands(CI->getPredicate(),
4451                                                 Operands[0], Operands[1], TD);
4452           else
4453             C = ConstantFoldInstOperands(I->getOpcode(), I->getType(),
4454                                          &Operands[0], Operands.size(), TD);
4455           if (!C) return V;
4456           return getSCEV(C);
4457         }
4458       }
4459     }
4460
4461     // This is some other type of SCEVUnknown, just return it.
4462     return V;
4463   }
4464
4465   if (const SCEVCommutativeExpr *Comm = dyn_cast<SCEVCommutativeExpr>(V)) {
4466     // Avoid performing the look-up in the common case where the specified
4467     // expression has no loop-variant portions.
4468     for (unsigned i = 0, e = Comm->getNumOperands(); i != e; ++i) {
4469       const SCEV *OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
4470       if (OpAtScope != Comm->getOperand(i)) {
4471         // Okay, at least one of these operands is loop variant but might be
4472         // foldable.  Build a new instance of the folded commutative expression.
4473         SmallVector<const SCEV *, 8> NewOps(Comm->op_begin(),
4474                                             Comm->op_begin()+i);
4475         NewOps.push_back(OpAtScope);
4476
4477         for (++i; i != e; ++i) {
4478           OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
4479           NewOps.push_back(OpAtScope);
4480         }
4481         if (isa<SCEVAddExpr>(Comm))
4482           return getAddExpr(NewOps);
4483         if (isa<SCEVMulExpr>(Comm))
4484           return getMulExpr(NewOps);
4485         if (isa<SCEVSMaxExpr>(Comm))
4486           return getSMaxExpr(NewOps);
4487         if (isa<SCEVUMaxExpr>(Comm))
4488           return getUMaxExpr(NewOps);
4489         llvm_unreachable("Unknown commutative SCEV type!");
4490       }
4491     }
4492     // If we got here, all operands are loop invariant.
4493     return Comm;
4494   }
4495
4496   if (const SCEVUDivExpr *Div = dyn_cast<SCEVUDivExpr>(V)) {
4497     const SCEV *LHS = getSCEVAtScope(Div->getLHS(), L);
4498     const SCEV *RHS = getSCEVAtScope(Div->getRHS(), L);
4499     if (LHS == Div->getLHS() && RHS == Div->getRHS())
4500       return Div;   // must be loop invariant
4501     return getUDivExpr(LHS, RHS);
4502   }
4503
4504   // If this is a loop recurrence for a loop that does not contain L, then we
4505   // are dealing with the final value computed by the loop.
4506   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V)) {
4507     // First, attempt to evaluate each operand.
4508     // Avoid performing the look-up in the common case where the specified
4509     // expression has no loop-variant portions.
4510     for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
4511       const SCEV *OpAtScope = getSCEVAtScope(AddRec->getOperand(i), L);
4512       if (OpAtScope == AddRec->getOperand(i))
4513         continue;
4514
4515       // Okay, at least one of these operands is loop variant but might be
4516       // foldable.  Build a new instance of the folded commutative expression.
4517       SmallVector<const SCEV *, 8> NewOps(AddRec->op_begin(),
4518                                           AddRec->op_begin()+i);
4519       NewOps.push_back(OpAtScope);
4520       for (++i; i != e; ++i)
4521         NewOps.push_back(getSCEVAtScope(AddRec->getOperand(i), L));
4522
4523       AddRec = cast<SCEVAddRecExpr>(getAddRecExpr(NewOps, AddRec->getLoop()));
4524       break;
4525     }
4526
4527     // If the scope is outside the addrec's loop, evaluate it by using the
4528     // loop exit value of the addrec.
4529     if (!AddRec->getLoop()->contains(L)) {
4530       // To evaluate this recurrence, we need to know how many times the AddRec
4531       // loop iterates.  Compute this now.
4532       const SCEV *BackedgeTakenCount = getBackedgeTakenCount(AddRec->getLoop());
4533       if (BackedgeTakenCount == getCouldNotCompute()) return AddRec;
4534
4535       // Then, evaluate the AddRec.
4536       return AddRec->evaluateAtIteration(BackedgeTakenCount, *this);
4537     }
4538
4539     return AddRec;
4540   }
4541
4542   if (const SCEVZeroExtendExpr *Cast = dyn_cast<SCEVZeroExtendExpr>(V)) {
4543     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
4544     if (Op == Cast->getOperand())
4545       return Cast;  // must be loop invariant
4546     return getZeroExtendExpr(Op, Cast->getType());
4547   }
4548
4549   if (const SCEVSignExtendExpr *Cast = dyn_cast<SCEVSignExtendExpr>(V)) {
4550     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
4551     if (Op == Cast->getOperand())
4552       return Cast;  // must be loop invariant
4553     return getSignExtendExpr(Op, Cast->getType());
4554   }
4555
4556   if (const SCEVTruncateExpr *Cast = dyn_cast<SCEVTruncateExpr>(V)) {
4557     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
4558     if (Op == Cast->getOperand())
4559       return Cast;  // must be loop invariant
4560     return getTruncateExpr(Op, Cast->getType());
4561   }
4562
4563   llvm_unreachable("Unknown SCEV type!");
4564   return 0;
4565 }
4566
4567 /// getSCEVAtScope - This is a convenience function which does
4568 /// getSCEVAtScope(getSCEV(V), L).
4569 const SCEV *ScalarEvolution::getSCEVAtScope(Value *V, const Loop *L) {
4570   return getSCEVAtScope(getSCEV(V), L);
4571 }
4572
4573 /// SolveLinEquationWithOverflow - Finds the minimum unsigned root of the
4574 /// following equation:
4575 ///
4576 ///     A * X = B (mod N)
4577 ///
4578 /// where N = 2^BW and BW is the common bit width of A and B. The signedness of
4579 /// A and B isn't important.
4580 ///
4581 /// If the equation does not have a solution, SCEVCouldNotCompute is returned.
4582 static const SCEV *SolveLinEquationWithOverflow(const APInt &A, const APInt &B,
4583                                                ScalarEvolution &SE) {
4584   uint32_t BW = A.getBitWidth();
4585   assert(BW == B.getBitWidth() && "Bit widths must be the same.");
4586   assert(A != 0 && "A must be non-zero.");
4587
4588   // 1. D = gcd(A, N)
4589   //
4590   // The gcd of A and N may have only one prime factor: 2. The number of
4591   // trailing zeros in A is its multiplicity
4592   uint32_t Mult2 = A.countTrailingZeros();
4593   // D = 2^Mult2
4594
4595   // 2. Check if B is divisible by D.
4596   //
4597   // B is divisible by D if and only if the multiplicity of prime factor 2 for B
4598   // is not less than multiplicity of this prime factor for D.
4599   if (B.countTrailingZeros() < Mult2)
4600     return SE.getCouldNotCompute();
4601
4602   // 3. Compute I: the multiplicative inverse of (A / D) in arithmetic
4603   // modulo (N / D).
4604   //
4605   // (N / D) may need BW+1 bits in its representation.  Hence, we'll use this
4606   // bit width during computations.
4607   APInt AD = A.lshr(Mult2).zext(BW + 1);  // AD = A / D
4608   APInt Mod(BW + 1, 0);
4609   Mod.set(BW - Mult2);  // Mod = N / D
4610   APInt I = AD.multiplicativeInverse(Mod);
4611
4612   // 4. Compute the minimum unsigned root of the equation:
4613   // I * (B / D) mod (N / D)
4614   APInt Result = (I * B.lshr(Mult2).zext(BW + 1)).urem(Mod);
4615
4616   // The result is guaranteed to be less than 2^BW so we may truncate it to BW
4617   // bits.
4618   return SE.getConstant(Result.trunc(BW));
4619 }
4620
4621 /// SolveQuadraticEquation - Find the roots of the quadratic equation for the
4622 /// given quadratic chrec {L,+,M,+,N}.  This returns either the two roots (which
4623 /// might be the same) or two SCEVCouldNotCompute objects.
4624 ///
4625 static std::pair<const SCEV *,const SCEV *>
4626 SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
4627   assert(AddRec->getNumOperands() == 3 && "This is not a quadratic chrec!");
4628   const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
4629   const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
4630   const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
4631
4632   // We currently can only solve this if the coefficients are constants.
4633   if (!LC || !MC || !NC) {
4634     const SCEV *CNC = SE.getCouldNotCompute();
4635     return std::make_pair(CNC, CNC);
4636   }
4637
4638   uint32_t BitWidth = LC->getValue()->getValue().getBitWidth();
4639   const APInt &L = LC->getValue()->getValue();
4640   const APInt &M = MC->getValue()->getValue();
4641   const APInt &N = NC->getValue()->getValue();
4642   APInt Two(BitWidth, 2);
4643   APInt Four(BitWidth, 4);
4644
4645   {
4646     using namespace APIntOps;
4647     const APInt& C = L;
4648     // Convert from chrec coefficients to polynomial coefficients AX^2+BX+C
4649     // The B coefficient is M-N/2
4650     APInt B(M);
4651     B -= sdiv(N,Two);
4652
4653     // The A coefficient is N/2
4654     APInt A(N.sdiv(Two));
4655
4656     // Compute the B^2-4ac term.
4657     APInt SqrtTerm(B);
4658     SqrtTerm *= B;
4659     SqrtTerm -= Four * (A * C);
4660
4661     // Compute sqrt(B^2-4ac). This is guaranteed to be the nearest
4662     // integer value or else APInt::sqrt() will assert.
4663     APInt SqrtVal(SqrtTerm.sqrt());
4664
4665     // Compute the two solutions for the quadratic formula.
4666     // The divisions must be performed as signed divisions.
4667     APInt NegB(-B);
4668     APInt TwoA( A << 1 );
4669     if (TwoA.isMinValue()) {
4670       const SCEV *CNC = SE.getCouldNotCompute();
4671       return std::make_pair(CNC, CNC);
4672     }
4673
4674     LLVMContext &Context = SE.getContext();
4675
4676     ConstantInt *Solution1 =
4677       ConstantInt::get(Context, (NegB + SqrtVal).sdiv(TwoA));
4678     ConstantInt *Solution2 =
4679       ConstantInt::get(Context, (NegB - SqrtVal).sdiv(TwoA));
4680
4681     return std::make_pair(SE.getConstant(Solution1),
4682                           SE.getConstant(Solution2));
4683     } // end APIntOps namespace
4684 }
4685
4686 /// HowFarToZero - Return the number of times a backedge comparing the specified
4687 /// value to zero will execute.  If not computable, return CouldNotCompute.
4688 ScalarEvolution::BackedgeTakenInfo
4689 ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
4690   // If the value is a constant
4691   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
4692     // If the value is already zero, the branch will execute zero times.
4693     if (C->getValue()->isZero()) return C;
4694     return getCouldNotCompute();  // Otherwise it will loop infinitely.
4695   }
4696
4697   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V);
4698   if (!AddRec || AddRec->getLoop() != L)
4699     return getCouldNotCompute();
4700
4701   if (AddRec->isAffine()) {
4702     // If this is an affine expression, the execution count of this branch is
4703     // the minimum unsigned root of the following equation:
4704     //
4705     //     Start + Step*N = 0 (mod 2^BW)
4706     //
4707     // equivalent to:
4708     //
4709     //             Step*N = -Start (mod 2^BW)
4710     //
4711     // where BW is the common bit width of Start and Step.
4712
4713     // Get the initial value for the loop.
4714     const SCEV *Start = getSCEVAtScope(AddRec->getStart(),
4715                                        L->getParentLoop());
4716     const SCEV *Step = getSCEVAtScope(AddRec->getOperand(1),
4717                                       L->getParentLoop());
4718
4719     if (const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step)) {
4720       // For now we handle only constant steps.
4721
4722       // First, handle unitary steps.
4723       if (StepC->getValue()->equalsInt(1))      // 1*N = -Start (mod 2^BW), so:
4724         return getNegativeSCEV(Start);          //   N = -Start (as unsigned)
4725       if (StepC->getValue()->isAllOnesValue())  // -1*N = -Start (mod 2^BW), so:
4726         return Start;                           //    N = Start (as unsigned)
4727
4728       // Then, try to solve the above equation provided that Start is constant.
4729       if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start))
4730         return SolveLinEquationWithOverflow(StepC->getValue()->getValue(),
4731                                             -StartC->getValue()->getValue(),
4732                                             *this);
4733     }
4734   } else if (AddRec->isQuadratic() && AddRec->getType()->isIntegerTy()) {
4735     // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
4736     // the quadratic equation to solve it.
4737     std::pair<const SCEV *,const SCEV *> Roots = SolveQuadraticEquation(AddRec,
4738                                                                     *this);
4739     const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
4740     const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
4741     if (R1) {
4742 #if 0
4743       dbgs() << "HFTZ: " << *V << " - sol#1: " << *R1
4744              << "  sol#2: " << *R2 << "\n";
4745 #endif
4746       // Pick the smallest positive root value.
4747       if (ConstantInt *CB =
4748           dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
4749                                    R1->getValue(), R2->getValue()))) {
4750         if (CB->getZExtValue() == false)
4751           std::swap(R1, R2);   // R1 is the minimum root now.
4752
4753         // We can only use this value if the chrec ends up with an exact zero
4754         // value at this index.  When solving for "X*X != 5", for example, we
4755         // should not accept a root of 2.
4756         const SCEV *Val = AddRec->evaluateAtIteration(R1, *this);
4757         if (Val->isZero())
4758           return R1;  // We found a quadratic root!
4759       }
4760     }
4761   }
4762
4763   return getCouldNotCompute();
4764 }
4765
4766 /// HowFarToNonZero - Return the number of times a backedge checking the
4767 /// specified value for nonzero will execute.  If not computable, return
4768 /// CouldNotCompute
4769 ScalarEvolution::BackedgeTakenInfo
4770 ScalarEvolution::HowFarToNonZero(const SCEV *V, const Loop *L) {
4771   // Loops that look like: while (X == 0) are very strange indeed.  We don't
4772   // handle them yet except for the trivial case.  This could be expanded in the
4773   // future as needed.
4774
4775   // If the value is a constant, check to see if it is known to be non-zero
4776   // already.  If so, the backedge will execute zero times.
4777   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
4778     if (!C->getValue()->isNullValue())
4779       return getConstant(C->getType(), 0);
4780     return getCouldNotCompute();  // Otherwise it will loop infinitely.
4781   }
4782
4783   // We could implement others, but I really doubt anyone writes loops like
4784   // this, and if they did, they would already be constant folded.
4785   return getCouldNotCompute();
4786 }
4787
4788 /// getPredecessorWithUniqueSuccessorForBB - Return a predecessor of BB
4789 /// (which may not be an immediate predecessor) which has exactly one
4790 /// successor from which BB is reachable, or null if no such block is
4791 /// found.
4792 ///
4793 std::pair<BasicBlock *, BasicBlock *>
4794 ScalarEvolution::getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB) {
4795   // If the block has a unique predecessor, then there is no path from the
4796   // predecessor to the block that does not go through the direct edge
4797   // from the predecessor to the block.
4798   if (BasicBlock *Pred = BB->getSinglePredecessor())
4799     return std::make_pair(Pred, BB);
4800
4801   // A loop's header is defined to be a block that dominates the loop.
4802   // If the header has a unique predecessor outside the loop, it must be
4803   // a block that has exactly one successor that can reach the loop.
4804   if (Loop *L = LI->getLoopFor(BB))
4805     return std::make_pair(L->getLoopPredecessor(), L->getHeader());
4806
4807   return std::pair<BasicBlock *, BasicBlock *>();
4808 }
4809
4810 /// HasSameValue - SCEV structural equivalence is usually sufficient for
4811 /// testing whether two expressions are equal, however for the purposes of
4812 /// looking for a condition guarding a loop, it can be useful to be a little
4813 /// more general, since a front-end may have replicated the controlling
4814 /// expression.
4815 ///
4816 static bool HasSameValue(const SCEV *A, const SCEV *B) {
4817   // Quick check to see if they are the same SCEV.
4818   if (A == B) return true;
4819
4820   // Otherwise, if they're both SCEVUnknown, it's possible that they hold
4821   // two different instructions with the same value. Check for this case.
4822   if (const SCEVUnknown *AU = dyn_cast<SCEVUnknown>(A))
4823     if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
4824       if (const Instruction *AI = dyn_cast<Instruction>(AU->getValue()))
4825         if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))
4826           if (AI->isIdenticalTo(BI) && !AI->mayReadFromMemory())
4827             return true;
4828
4829   // Otherwise assume they may have a different value.
4830   return false;
4831 }
4832
4833 /// SimplifyICmpOperands - Simplify LHS and RHS in a comparison with
4834 /// predicate Pred. Return true iff any changes were made.
4835 ///
4836 bool ScalarEvolution::SimplifyICmpOperands(ICmpInst::Predicate &Pred,
4837                                            const SCEV *&LHS, const SCEV *&RHS) {
4838   bool Changed = false;
4839
4840   // Canonicalize a constant to the right side.
4841   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
4842     // Check for both operands constant.
4843     if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
4844       if (ConstantExpr::getICmp(Pred,
4845                                 LHSC->getValue(),
4846                                 RHSC->getValue())->isNullValue())
4847         goto trivially_false;
4848       else
4849         goto trivially_true;
4850     }
4851     // Otherwise swap the operands to put the constant on the right.
4852     std::swap(LHS, RHS);
4853     Pred = ICmpInst::getSwappedPredicate(Pred);
4854     Changed = true;
4855   }
4856
4857   // If we're comparing an addrec with a value which is loop-invariant in the
4858   // addrec's loop, put the addrec on the left. Also make a dominance check,
4859   // as both operands could be addrecs loop-invariant in each other's loop.
4860   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS)) {
4861     const Loop *L = AR->getLoop();
4862     if (LHS->isLoopInvariant(L) && LHS->properlyDominates(L->getHeader(), DT)) {
4863       std::swap(LHS, RHS);
4864       Pred = ICmpInst::getSwappedPredicate(Pred);
4865       Changed = true;
4866     }
4867   }
4868
4869   // If there's a constant operand, canonicalize comparisons with boundary
4870   // cases, and canonicalize *-or-equal comparisons to regular comparisons.
4871   if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
4872     const APInt &RA = RC->getValue()->getValue();
4873     switch (Pred) {
4874     default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
4875     case ICmpInst::ICMP_EQ:
4876     case ICmpInst::ICMP_NE:
4877       break;
4878     case ICmpInst::ICMP_UGE:
4879       if ((RA - 1).isMinValue()) {
4880         Pred = ICmpInst::ICMP_NE;
4881         RHS = getConstant(RA - 1);
4882         Changed = true;
4883         break;
4884       }
4885       if (RA.isMaxValue()) {
4886         Pred = ICmpInst::ICMP_EQ;
4887         Changed = true;
4888         break;
4889       }
4890       if (RA.isMinValue()) goto trivially_true;
4891
4892       Pred = ICmpInst::ICMP_UGT;
4893       RHS = getConstant(RA - 1);
4894       Changed = true;
4895       break;
4896     case ICmpInst::ICMP_ULE:
4897       if ((RA + 1).isMaxValue()) {
4898         Pred = ICmpInst::ICMP_NE;
4899         RHS = getConstant(RA + 1);
4900         Changed = true;
4901         break;
4902       }
4903       if (RA.isMinValue()) {
4904         Pred = ICmpInst::ICMP_EQ;
4905         Changed = true;
4906         break;
4907       }
4908       if (RA.isMaxValue()) goto trivially_true;
4909
4910       Pred = ICmpInst::ICMP_ULT;
4911       RHS = getConstant(RA + 1);
4912       Changed = true;
4913       break;
4914     case ICmpInst::ICMP_SGE:
4915       if ((RA - 1).isMinSignedValue()) {
4916         Pred = ICmpInst::ICMP_NE;
4917         RHS = getConstant(RA - 1);
4918         Changed = true;
4919         break;
4920       }
4921       if (RA.isMaxSignedValue()) {
4922         Pred = ICmpInst::ICMP_EQ;
4923         Changed = true;
4924         break;
4925       }
4926       if (RA.isMinSignedValue()) goto trivially_true;
4927
4928       Pred = ICmpInst::ICMP_SGT;
4929       RHS = getConstant(RA - 1);
4930       Changed = true;
4931       break;
4932     case ICmpInst::ICMP_SLE:
4933       if ((RA + 1).isMaxSignedValue()) {
4934         Pred = ICmpInst::ICMP_NE;
4935         RHS = getConstant(RA + 1);
4936         Changed = true;
4937         break;
4938       }
4939       if (RA.isMinSignedValue()) {
4940         Pred = ICmpInst::ICMP_EQ;
4941         Changed = true;
4942         break;
4943       }
4944       if (RA.isMaxSignedValue()) goto trivially_true;
4945
4946       Pred = ICmpInst::ICMP_SLT;
4947       RHS = getConstant(RA + 1);
4948       Changed = true;
4949       break;
4950     case ICmpInst::ICMP_UGT:
4951       if (RA.isMinValue()) {
4952         Pred = ICmpInst::ICMP_NE;
4953         Changed = true;
4954         break;
4955       }
4956       if ((RA + 1).isMaxValue()) {
4957         Pred = ICmpInst::ICMP_EQ;
4958         RHS = getConstant(RA + 1);
4959         Changed = true;
4960         break;
4961       }
4962       if (RA.isMaxValue()) goto trivially_false;
4963       break;
4964     case ICmpInst::ICMP_ULT:
4965       if (RA.isMaxValue()) {
4966         Pred = ICmpInst::ICMP_NE;
4967         Changed = true;
4968         break;
4969       }
4970       if ((RA - 1).isMinValue()) {
4971         Pred = ICmpInst::ICMP_EQ;
4972         RHS = getConstant(RA - 1);
4973         Changed = true;
4974         break;
4975       }
4976       if (RA.isMinValue()) goto trivially_false;
4977       break;
4978     case ICmpInst::ICMP_SGT:
4979       if (RA.isMinSignedValue()) {
4980         Pred = ICmpInst::ICMP_NE;
4981         Changed = true;
4982         break;
4983       }
4984       if ((RA + 1).isMaxSignedValue()) {
4985         Pred = ICmpInst::ICMP_EQ;
4986         RHS = getConstant(RA + 1);
4987         Changed = true;
4988         break;
4989       }
4990       if (RA.isMaxSignedValue()) goto trivially_false;
4991       break;
4992     case ICmpInst::ICMP_SLT:
4993       if (RA.isMaxSignedValue()) {
4994         Pred = ICmpInst::ICMP_NE;
4995         Changed = true;
4996         break;
4997       }
4998       if ((RA - 1).isMinSignedValue()) {
4999        Pred = ICmpInst::ICMP_EQ;
5000        RHS = getConstant(RA - 1);
5001         Changed = true;
5002        break;
5003       }
5004       if (RA.isMinSignedValue()) goto trivially_false;
5005       break;
5006     }
5007   }
5008
5009   // Check for obvious equality.
5010   if (HasSameValue(LHS, RHS)) {
5011     if (ICmpInst::isTrueWhenEqual(Pred))
5012       goto trivially_true;
5013     if (ICmpInst::isFalseWhenEqual(Pred))
5014       goto trivially_false;
5015   }
5016
5017   // If possible, canonicalize GE/LE comparisons to GT/LT comparisons, by
5018   // adding or subtracting 1 from one of the operands.
5019   switch (Pred) {
5020   case ICmpInst::ICMP_SLE:
5021     if (!getSignedRange(RHS).getSignedMax().isMaxSignedValue()) {
5022       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
5023                        /*HasNUW=*/false, /*HasNSW=*/true);
5024       Pred = ICmpInst::ICMP_SLT;
5025       Changed = true;
5026     } else if (!getSignedRange(LHS).getSignedMin().isMinSignedValue()) {
5027       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
5028                        /*HasNUW=*/false, /*HasNSW=*/true);
5029       Pred = ICmpInst::ICMP_SLT;
5030       Changed = true;
5031     }
5032     break;
5033   case ICmpInst::ICMP_SGE:
5034     if (!getSignedRange(RHS).getSignedMin().isMinSignedValue()) {
5035       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
5036                        /*HasNUW=*/false, /*HasNSW=*/true);
5037       Pred = ICmpInst::ICMP_SGT;
5038       Changed = true;
5039     } else if (!getSignedRange(LHS).getSignedMax().isMaxSignedValue()) {
5040       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
5041                        /*HasNUW=*/false, /*HasNSW=*/true);
5042       Pred = ICmpInst::ICMP_SGT;
5043       Changed = true;
5044     }
5045     break;
5046   case ICmpInst::ICMP_ULE:
5047     if (!getUnsignedRange(RHS).getUnsignedMax().isMaxValue()) {
5048       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
5049                        /*HasNUW=*/true, /*HasNSW=*/false);
5050       Pred = ICmpInst::ICMP_ULT;
5051       Changed = true;
5052     } else if (!getUnsignedRange(LHS).getUnsignedMin().isMinValue()) {
5053       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
5054                        /*HasNUW=*/true, /*HasNSW=*/false);
5055       Pred = ICmpInst::ICMP_ULT;
5056       Changed = true;
5057     }
5058     break;
5059   case ICmpInst::ICMP_UGE:
5060     if (!getUnsignedRange(RHS).getUnsignedMin().isMinValue()) {
5061       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
5062                        /*HasNUW=*/true, /*HasNSW=*/false);
5063       Pred = ICmpInst::ICMP_UGT;
5064       Changed = true;
5065     } else if (!getUnsignedRange(LHS).getUnsignedMax().isMaxValue()) {
5066       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
5067                        /*HasNUW=*/true, /*HasNSW=*/false);
5068       Pred = ICmpInst::ICMP_UGT;
5069       Changed = true;
5070     }
5071     break;
5072   default:
5073     break;
5074   }
5075
5076   // TODO: More simplifications are possible here.
5077
5078   return Changed;
5079
5080 trivially_true:
5081   // Return 0 == 0.
5082   LHS = RHS = getConstant(Type::getInt1Ty(getContext()), 0);
5083   Pred = ICmpInst::ICMP_EQ;
5084   return true;
5085
5086 trivially_false:
5087   // Return 0 != 0.
5088   LHS = RHS = getConstant(Type::getInt1Ty(getContext()), 0);
5089   Pred = ICmpInst::ICMP_NE;
5090   return true;
5091 }
5092
5093 bool ScalarEvolution::isKnownNegative(const SCEV *S) {
5094   return getSignedRange(S).getSignedMax().isNegative();
5095 }
5096
5097 bool ScalarEvolution::isKnownPositive(const SCEV *S) {
5098   return getSignedRange(S).getSignedMin().isStrictlyPositive();
5099 }
5100
5101 bool ScalarEvolution::isKnownNonNegative(const SCEV *S) {
5102   return !getSignedRange(S).getSignedMin().isNegative();
5103 }
5104
5105 bool ScalarEvolution::isKnownNonPositive(const SCEV *S) {
5106   return !getSignedRange(S).getSignedMax().isStrictlyPositive();
5107 }
5108
5109 bool ScalarEvolution::isKnownNonZero(const SCEV *S) {
5110   return isKnownNegative(S) || isKnownPositive(S);
5111 }
5112
5113 bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
5114                                        const SCEV *LHS, const SCEV *RHS) {
5115   // Canonicalize the inputs first.
5116   (void)SimplifyICmpOperands(Pred, LHS, RHS);
5117
5118   // If LHS or RHS is an addrec, check to see if the condition is true in
5119   // every iteration of the loop.
5120   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
5121     if (isLoopEntryGuardedByCond(
5122           AR->getLoop(), Pred, AR->getStart(), RHS) &&
5123         isLoopBackedgeGuardedByCond(
5124           AR->getLoop(), Pred, AR->getPostIncExpr(*this), RHS))
5125       return true;
5126   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS))
5127     if (isLoopEntryGuardedByCond(
5128           AR->getLoop(), Pred, LHS, AR->getStart()) &&
5129         isLoopBackedgeGuardedByCond(
5130           AR->getLoop(), Pred, LHS, AR->getPostIncExpr(*this)))
5131       return true;
5132
5133   // Otherwise see what can be done with known constant ranges.
5134   return isKnownPredicateWithRanges(Pred, LHS, RHS);
5135 }
5136
5137 bool
5138 ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
5139                                             const SCEV *LHS, const SCEV *RHS) {
5140   if (HasSameValue(LHS, RHS))
5141     return ICmpInst::isTrueWhenEqual(Pred);
5142
5143   // This code is split out from isKnownPredicate because it is called from
5144   // within isLoopEntryGuardedByCond.
5145   switch (Pred) {
5146   default:
5147     llvm_unreachable("Unexpected ICmpInst::Predicate value!");
5148     break;
5149   case ICmpInst::ICMP_SGT:
5150     Pred = ICmpInst::ICMP_SLT;
5151     std::swap(LHS, RHS);
5152   case ICmpInst::ICMP_SLT: {
5153     ConstantRange LHSRange = getSignedRange(LHS);
5154     ConstantRange RHSRange = getSignedRange(RHS);
5155     if (LHSRange.getSignedMax().slt(RHSRange.getSignedMin()))
5156       return true;
5157     if (LHSRange.getSignedMin().sge(RHSRange.getSignedMax()))
5158       return false;
5159     break;
5160   }
5161   case ICmpInst::ICMP_SGE:
5162     Pred = ICmpInst::ICMP_SLE;
5163     std::swap(LHS, RHS);
5164   case ICmpInst::ICMP_SLE: {
5165     ConstantRange LHSRange = getSignedRange(LHS);
5166     ConstantRange RHSRange = getSignedRange(RHS);
5167     if (LHSRange.getSignedMax().sle(RHSRange.getSignedMin()))
5168       return true;
5169     if (LHSRange.getSignedMin().sgt(RHSRange.getSignedMax()))
5170       return false;
5171     break;
5172   }
5173   case ICmpInst::ICMP_UGT:
5174     Pred = ICmpInst::ICMP_ULT;
5175     std::swap(LHS, RHS);
5176   case ICmpInst::ICMP_ULT: {
5177     ConstantRange LHSRange = getUnsignedRange(LHS);
5178     ConstantRange RHSRange = getUnsignedRange(RHS);
5179     if (LHSRange.getUnsignedMax().ult(RHSRange.getUnsignedMin()))
5180       return true;
5181     if (LHSRange.getUnsignedMin().uge(RHSRange.getUnsignedMax()))
5182       return false;
5183     break;
5184   }
5185   case ICmpInst::ICMP_UGE:
5186     Pred = ICmpInst::ICMP_ULE;
5187     std::swap(LHS, RHS);
5188   case ICmpInst::ICMP_ULE: {
5189     ConstantRange LHSRange = getUnsignedRange(LHS);
5190     ConstantRange RHSRange = getUnsignedRange(RHS);
5191     if (LHSRange.getUnsignedMax().ule(RHSRange.getUnsignedMin()))
5192       return true;
5193     if (LHSRange.getUnsignedMin().ugt(RHSRange.getUnsignedMax()))
5194       return false;
5195     break;
5196   }
5197   case ICmpInst::ICMP_NE: {
5198     if (getUnsignedRange(LHS).intersectWith(getUnsignedRange(RHS)).isEmptySet())
5199       return true;
5200     if (getSignedRange(LHS).intersectWith(getSignedRange(RHS)).isEmptySet())
5201       return true;
5202
5203     const SCEV *Diff = getMinusSCEV(LHS, RHS);
5204     if (isKnownNonZero(Diff))
5205       return true;
5206     break;
5207   }
5208   case ICmpInst::ICMP_EQ:
5209     // The check at the top of the function catches the case where
5210     // the values are known to be equal.
5211     break;
5212   }
5213   return false;
5214 }
5215
5216 /// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is
5217 /// protected by a conditional between LHS and RHS.  This is used to
5218 /// to eliminate casts.
5219 bool
5220 ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
5221                                              ICmpInst::Predicate Pred,
5222                                              const SCEV *LHS, const SCEV *RHS) {
5223   // Interpret a null as meaning no loop, where there is obviously no guard
5224   // (interprocedural conditions notwithstanding).
5225   if (!L) return true;
5226
5227   BasicBlock *Latch = L->getLoopLatch();
5228   if (!Latch)
5229     return false;
5230
5231   BranchInst *LoopContinuePredicate =
5232     dyn_cast<BranchInst>(Latch->getTerminator());
5233   if (!LoopContinuePredicate ||
5234       LoopContinuePredicate->isUnconditional())
5235     return false;
5236
5237   return isImpliedCond(Pred, LHS, RHS,
5238                        LoopContinuePredicate->getCondition(),
5239                        LoopContinuePredicate->getSuccessor(0) != L->getHeader());
5240 }
5241
5242 /// isLoopEntryGuardedByCond - Test whether entry to the loop is protected
5243 /// by a conditional between LHS and RHS.  This is used to help avoid max
5244 /// expressions in loop trip counts, and to eliminate casts.
5245 bool
5246 ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
5247                                           ICmpInst::Predicate Pred,
5248                                           const SCEV *LHS, const SCEV *RHS) {
5249   // Interpret a null as meaning no loop, where there is obviously no guard
5250   // (interprocedural conditions notwithstanding).
5251   if (!L) return false;
5252
5253   // Starting at the loop predecessor, climb up the predecessor chain, as long
5254   // as there are predecessors that can be found that have unique successors
5255   // leading to the original header.
5256   for (std::pair<BasicBlock *, BasicBlock *>
5257          Pair(L->getLoopPredecessor(), L->getHeader());
5258        Pair.first;
5259        Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
5260
5261     BranchInst *LoopEntryPredicate =
5262       dyn_cast<BranchInst>(Pair.first->getTerminator());
5263     if (!LoopEntryPredicate ||
5264         LoopEntryPredicate->isUnconditional())
5265       continue;
5266
5267     if (isImpliedCond(Pred, LHS, RHS,
5268                       LoopEntryPredicate->getCondition(),
5269                       LoopEntryPredicate->getSuccessor(0) != Pair.second))
5270       return true;
5271   }
5272
5273   return false;
5274 }
5275
5276 /// isImpliedCond - Test whether the condition described by Pred, LHS,
5277 /// and RHS is true whenever the given Cond value evaluates to true.
5278 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
5279                                     const SCEV *LHS, const SCEV *RHS,
5280                                     Value *FoundCondValue,
5281                                     bool Inverse) {
5282   // Recursively handle And and Or conditions.
5283   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FoundCondValue)) {
5284     if (BO->getOpcode() == Instruction::And) {
5285       if (!Inverse)
5286         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
5287                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
5288     } else if (BO->getOpcode() == Instruction::Or) {
5289       if (Inverse)
5290         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
5291                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
5292     }
5293   }
5294
5295   ICmpInst *ICI = dyn_cast<ICmpInst>(FoundCondValue);
5296   if (!ICI) return false;
5297
5298   // Bail if the ICmp's operands' types are wider than the needed type
5299   // before attempting to call getSCEV on them. This avoids infinite
5300   // recursion, since the analysis of widening casts can require loop
5301   // exit condition information for overflow checking, which would
5302   // lead back here.
5303   if (getTypeSizeInBits(LHS->getType()) <
5304       getTypeSizeInBits(ICI->getOperand(0)->getType()))
5305     return false;
5306
5307   // Now that we found a conditional branch that dominates the loop, check to
5308   // see if it is the comparison we are looking for.
5309   ICmpInst::Predicate FoundPred;
5310   if (Inverse)
5311     FoundPred = ICI->getInversePredicate();
5312   else
5313     FoundPred = ICI->getPredicate();
5314
5315   const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
5316   const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
5317
5318   // Balance the types. The case where FoundLHS' type is wider than
5319   // LHS' type is checked for above.
5320   if (getTypeSizeInBits(LHS->getType()) >
5321       getTypeSizeInBits(FoundLHS->getType())) {
5322     if (CmpInst::isSigned(Pred)) {
5323       FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
5324       FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
5325     } else {
5326       FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
5327       FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
5328     }
5329   }
5330
5331   // Canonicalize the query to match the way instcombine will have
5332   // canonicalized the comparison.
5333   if (SimplifyICmpOperands(Pred, LHS, RHS))
5334     if (LHS == RHS)
5335       return CmpInst::isTrueWhenEqual(Pred);
5336   if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
5337     if (FoundLHS == FoundRHS)
5338       return CmpInst::isFalseWhenEqual(Pred);
5339
5340   // Check to see if we can make the LHS or RHS match.
5341   if (LHS == FoundRHS || RHS == FoundLHS) {
5342     if (isa<SCEVConstant>(RHS)) {
5343       std::swap(FoundLHS, FoundRHS);
5344       FoundPred = ICmpInst::getSwappedPredicate(FoundPred);
5345     } else {
5346       std::swap(LHS, RHS);
5347       Pred = ICmpInst::getSwappedPredicate(Pred);
5348     }
5349   }
5350
5351   // Check whether the found predicate is the same as the desired predicate.
5352   if (FoundPred == Pred)
5353     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
5354
5355   // Check whether swapping the found predicate makes it the same as the
5356   // desired predicate.
5357   if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
5358     if (isa<SCEVConstant>(RHS))
5359       return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
5360     else
5361       return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
5362                                    RHS, LHS, FoundLHS, FoundRHS);
5363   }
5364
5365   // Check whether the actual condition is beyond sufficient.
5366   if (FoundPred == ICmpInst::ICMP_EQ)
5367     if (ICmpInst::isTrueWhenEqual(Pred))
5368       if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
5369         return true;
5370   if (Pred == ICmpInst::ICMP_NE)
5371     if (!ICmpInst::isTrueWhenEqual(FoundPred))
5372       if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
5373         return true;
5374
5375   // Otherwise assume the worst.
5376   return false;
5377 }
5378
5379 /// isImpliedCondOperands - Test whether the condition described by Pred,
5380 /// LHS, and RHS is true whenever the condition described by Pred, FoundLHS,
5381 /// and FoundRHS is true.
5382 bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
5383                                             const SCEV *LHS, const SCEV *RHS,
5384                                             const SCEV *FoundLHS,
5385                                             const SCEV *FoundRHS) {
5386   return isImpliedCondOperandsHelper(Pred, LHS, RHS,
5387                                      FoundLHS, FoundRHS) ||
5388          // ~x < ~y --> x > y
5389          isImpliedCondOperandsHelper(Pred, LHS, RHS,
5390                                      getNotSCEV(FoundRHS),
5391                                      getNotSCEV(FoundLHS));
5392 }
5393
5394 /// isImpliedCondOperandsHelper - Test whether the condition described by
5395 /// Pred, LHS, and RHS is true whenever the condition described by Pred,
5396 /// FoundLHS, and FoundRHS is true.
5397 bool
5398 ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
5399                                              const SCEV *LHS, const SCEV *RHS,
5400                                              const SCEV *FoundLHS,
5401                                              const SCEV *FoundRHS) {
5402   switch (Pred) {
5403   default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
5404   case ICmpInst::ICMP_EQ:
5405   case ICmpInst::ICMP_NE:
5406     if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
5407       return true;
5408     break;
5409   case ICmpInst::ICMP_SLT:
5410   case ICmpInst::ICMP_SLE:
5411     if (isKnownPredicateWithRanges(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
5412         isKnownPredicateWithRanges(ICmpInst::ICMP_SGE, RHS, FoundRHS))
5413       return true;
5414     break;
5415   case ICmpInst::ICMP_SGT:
5416   case ICmpInst::ICMP_SGE:
5417     if (isKnownPredicateWithRanges(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
5418         isKnownPredicateWithRanges(ICmpInst::ICMP_SLE, RHS, FoundRHS))
5419       return true;
5420     break;
5421   case ICmpInst::ICMP_ULT:
5422   case ICmpInst::ICMP_ULE:
5423     if (isKnownPredicateWithRanges(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
5424         isKnownPredicateWithRanges(ICmpInst::ICMP_UGE, RHS, FoundRHS))
5425       return true;
5426     break;
5427   case ICmpInst::ICMP_UGT:
5428   case ICmpInst::ICMP_UGE:
5429     if (isKnownPredicateWithRanges(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
5430         isKnownPredicateWithRanges(ICmpInst::ICMP_ULE, RHS, FoundRHS))
5431       return true;
5432     break;
5433   }
5434
5435   return false;
5436 }
5437
5438 /// getBECount - Subtract the end and start values and divide by the step,
5439 /// rounding up, to get the number of times the backedge is executed. Return
5440 /// CouldNotCompute if an intermediate computation overflows.
5441 const SCEV *ScalarEvolution::getBECount(const SCEV *Start,
5442                                         const SCEV *End,
5443                                         const SCEV *Step,
5444                                         bool NoWrap) {
5445   assert(!isKnownNegative(Step) &&
5446          "This code doesn't handle negative strides yet!");
5447
5448   const Type *Ty = Start->getType();
5449   const SCEV *NegOne = getConstant(Ty, (uint64_t)-1);
5450   const SCEV *Diff = getMinusSCEV(End, Start);
5451   const SCEV *RoundUp = getAddExpr(Step, NegOne);
5452
5453   // Add an adjustment to the difference between End and Start so that
5454   // the division will effectively round up.
5455   const SCEV *Add = getAddExpr(Diff, RoundUp);
5456
5457   if (!NoWrap) {
5458     // Check Add for unsigned overflow.
5459     // TODO: More sophisticated things could be done here.
5460     const Type *WideTy = IntegerType::get(getContext(),
5461                                           getTypeSizeInBits(Ty) + 1);
5462     const SCEV *EDiff = getZeroExtendExpr(Diff, WideTy);
5463     const SCEV *ERoundUp = getZeroExtendExpr(RoundUp, WideTy);
5464     const SCEV *OperandExtendedAdd = getAddExpr(EDiff, ERoundUp);
5465     if (getZeroExtendExpr(Add, WideTy) != OperandExtendedAdd)
5466       return getCouldNotCompute();
5467   }
5468
5469   return getUDivExpr(Add, Step);
5470 }
5471
5472 /// HowManyLessThans - Return the number of times a backedge containing the
5473 /// specified less-than comparison will execute.  If not computable, return
5474 /// CouldNotCompute.
5475 ScalarEvolution::BackedgeTakenInfo
5476 ScalarEvolution::HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
5477                                   const Loop *L, bool isSigned) {
5478   // Only handle:  "ADDREC < LoopInvariant".
5479   if (!RHS->isLoopInvariant(L)) return getCouldNotCompute();
5480
5481   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS);
5482   if (!AddRec || AddRec->getLoop() != L)
5483     return getCouldNotCompute();
5484
5485   // Check to see if we have a flag which makes analysis easy.
5486   bool NoWrap = isSigned ? AddRec->hasNoSignedWrap() :
5487                            AddRec->hasNoUnsignedWrap();
5488
5489   if (AddRec->isAffine()) {
5490     unsigned BitWidth = getTypeSizeInBits(AddRec->getType());
5491     const SCEV *Step = AddRec->getStepRecurrence(*this);
5492
5493     if (Step->isZero())
5494       return getCouldNotCompute();
5495     if (Step->isOne()) {
5496       // With unit stride, the iteration never steps past the limit value.
5497     } else if (isKnownPositive(Step)) {
5498       // Test whether a positive iteration can step past the limit
5499       // value and past the maximum value for its type in a single step.
5500       // Note that it's not sufficient to check NoWrap here, because even
5501       // though the value after a wrap is undefined, it's not undefined
5502       // behavior, so if wrap does occur, the loop could either terminate or
5503       // loop infinitely, but in either case, the loop is guaranteed to
5504       // iterate at least until the iteration where the wrapping occurs.
5505       const SCEV *One = getConstant(Step->getType(), 1);
5506       if (isSigned) {
5507         APInt Max = APInt::getSignedMaxValue(BitWidth);
5508         if ((Max - getSignedRange(getMinusSCEV(Step, One)).getSignedMax())
5509               .slt(getSignedRange(RHS).getSignedMax()))
5510           return getCouldNotCompute();
5511       } else {
5512         APInt Max = APInt::getMaxValue(BitWidth);
5513         if ((Max - getUnsignedRange(getMinusSCEV(Step, One)).getUnsignedMax())
5514               .ult(getUnsignedRange(RHS).getUnsignedMax()))
5515           return getCouldNotCompute();
5516       }
5517     } else
5518       // TODO: Handle negative strides here and below.
5519       return getCouldNotCompute();
5520
5521     // We know the LHS is of the form {n,+,s} and the RHS is some loop-invariant
5522     // m.  So, we count the number of iterations in which {n,+,s} < m is true.
5523     // Note that we cannot simply return max(m-n,0)/s because it's not safe to
5524     // treat m-n as signed nor unsigned due to overflow possibility.
5525
5526     // First, we get the value of the LHS in the first iteration: n
5527     const SCEV *Start = AddRec->getOperand(0);
5528
5529     // Determine the minimum constant start value.
5530     const SCEV *MinStart = getConstant(isSigned ?
5531       getSignedRange(Start).getSignedMin() :
5532       getUnsignedRange(Start).getUnsignedMin());
5533
5534     // If we know that the condition is true in order to enter the loop,
5535     // then we know that it will run exactly (m-n)/s times. Otherwise, we
5536     // only know that it will execute (max(m,n)-n)/s times. In both cases,
5537     // the division must round up.
5538     const SCEV *End = RHS;
5539     if (!isLoopEntryGuardedByCond(L,
5540                                   isSigned ? ICmpInst::ICMP_SLT :
5541                                              ICmpInst::ICMP_ULT,
5542                                   getMinusSCEV(Start, Step), RHS))
5543       End = isSigned ? getSMaxExpr(RHS, Start)
5544                      : getUMaxExpr(RHS, Start);
5545
5546     // Determine the maximum constant end value.
5547     const SCEV *MaxEnd = getConstant(isSigned ?
5548       getSignedRange(End).getSignedMax() :
5549       getUnsignedRange(End).getUnsignedMax());
5550
5551     // If MaxEnd is within a step of the maximum integer value in its type,
5552     // adjust it down to the minimum value which would produce the same effect.
5553     // This allows the subsequent ceiling division of (N+(step-1))/step to
5554     // compute the correct value.
5555     const SCEV *StepMinusOne = getMinusSCEV(Step,
5556                                             getConstant(Step->getType(), 1));
5557     MaxEnd = isSigned ?
5558       getSMinExpr(MaxEnd,
5559                   getMinusSCEV(getConstant(APInt::getSignedMaxValue(BitWidth)),
5560                                StepMinusOne)) :
5561       getUMinExpr(MaxEnd,
5562                   getMinusSCEV(getConstant(APInt::getMaxValue(BitWidth)),
5563                                StepMinusOne));
5564
5565     // Finally, we subtract these two values and divide, rounding up, to get
5566     // the number of times the backedge is executed.
5567     const SCEV *BECount = getBECount(Start, End, Step, NoWrap);
5568
5569     // The maximum backedge count is similar, except using the minimum start
5570     // value and the maximum end value.
5571     const SCEV *MaxBECount = getBECount(MinStart, MaxEnd, Step, NoWrap);
5572
5573     return BackedgeTakenInfo(BECount, MaxBECount);
5574   }
5575
5576   return getCouldNotCompute();
5577 }
5578
5579 /// getNumIterationsInRange - Return the number of iterations of this loop that
5580 /// produce values in the specified constant range.  Another way of looking at
5581 /// this is that it returns the first iteration number where the value is not in
5582 /// the condition, thus computing the exit count. If the iteration count can't
5583 /// be computed, an instance of SCEVCouldNotCompute is returned.
5584 const SCEV *SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
5585                                                     ScalarEvolution &SE) const {
5586   if (Range.isFullSet())  // Infinite loop.
5587     return SE.getCouldNotCompute();
5588
5589   // If the start is a non-zero constant, shift the range to simplify things.
5590   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
5591     if (!SC->getValue()->isZero()) {
5592       SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
5593       Operands[0] = SE.getConstant(SC->getType(), 0);
5594       const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop());
5595       if (const SCEVAddRecExpr *ShiftedAddRec =
5596             dyn_cast<SCEVAddRecExpr>(Shifted))
5597         return ShiftedAddRec->getNumIterationsInRange(
5598                            Range.subtract(SC->getValue()->getValue()), SE);
5599       // This is strange and shouldn't happen.
5600       return SE.getCouldNotCompute();
5601     }
5602
5603   // The only time we can solve this is when we have all constant indices.
5604   // Otherwise, we cannot determine the overflow conditions.
5605   for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
5606     if (!isa<SCEVConstant>(getOperand(i)))
5607       return SE.getCouldNotCompute();
5608
5609
5610   // Okay at this point we know that all elements of the chrec are constants and
5611   // that the start element is zero.
5612
5613   // First check to see if the range contains zero.  If not, the first
5614   // iteration exits.
5615   unsigned BitWidth = SE.getTypeSizeInBits(getType());
5616   if (!Range.contains(APInt(BitWidth, 0)))
5617     return SE.getConstant(getType(), 0);
5618
5619   if (isAffine()) {
5620     // If this is an affine expression then we have this situation:
5621     //   Solve {0,+,A} in Range  ===  Ax in Range
5622
5623     // We know that zero is in the range.  If A is positive then we know that
5624     // the upper value of the range must be the first possible exit value.
5625     // If A is negative then the lower of the range is the last possible loop
5626     // value.  Also note that we already checked for a full range.
5627     APInt One(BitWidth,1);
5628     APInt A     = cast<SCEVConstant>(getOperand(1))->getValue()->getValue();
5629     APInt End = A.sge(One) ? (Range.getUpper() - One) : Range.getLower();
5630
5631     // The exit value should be (End+A)/A.
5632     APInt ExitVal = (End + A).udiv(A);
5633     ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
5634
5635     // Evaluate at the exit value.  If we really did fall out of the valid
5636     // range, then we computed our trip count, otherwise wrap around or other
5637     // things must have happened.
5638     ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue, SE);
5639     if (Range.contains(Val->getValue()))
5640       return SE.getCouldNotCompute();  // Something strange happened
5641
5642     // Ensure that the previous value is in the range.  This is a sanity check.
5643     assert(Range.contains(
5644            EvaluateConstantChrecAtConstant(this,
5645            ConstantInt::get(SE.getContext(), ExitVal - One), SE)->getValue()) &&
5646            "Linear scev computation is off in a bad way!");
5647     return SE.getConstant(ExitValue);
5648   } else if (isQuadratic()) {
5649     // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of the
5650     // quadratic equation to solve it.  To do this, we must frame our problem in
5651     // terms of figuring out when zero is crossed, instead of when
5652     // Range.getUpper() is crossed.
5653     SmallVector<const SCEV *, 4> NewOps(op_begin(), op_end());
5654     NewOps[0] = SE.getNegativeSCEV(SE.getConstant(Range.getUpper()));
5655     const SCEV *NewAddRec = SE.getAddRecExpr(NewOps, getLoop());
5656
5657     // Next, solve the constructed addrec
5658     std::pair<const SCEV *,const SCEV *> Roots =
5659       SolveQuadraticEquation(cast<SCEVAddRecExpr>(NewAddRec), SE);
5660     const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
5661     const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
5662     if (R1) {
5663       // Pick the smallest positive root value.
5664       if (ConstantInt *CB =
5665           dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
5666                          R1->getValue(), R2->getValue()))) {
5667         if (CB->getZExtValue() == false)
5668           std::swap(R1, R2);   // R1 is the minimum root now.
5669
5670         // Make sure the root is not off by one.  The returned iteration should
5671         // not be in the range, but the previous one should be.  When solving
5672         // for "X*X < 5", for example, we should not return a root of 2.
5673         ConstantInt *R1Val = EvaluateConstantChrecAtConstant(this,
5674                                                              R1->getValue(),
5675                                                              SE);
5676         if (Range.contains(R1Val->getValue())) {
5677           // The next iteration must be out of the range...
5678           ConstantInt *NextVal =
5679                 ConstantInt::get(SE.getContext(), R1->getValue()->getValue()+1);
5680
5681           R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
5682           if (!Range.contains(R1Val->getValue()))
5683             return SE.getConstant(NextVal);
5684           return SE.getCouldNotCompute();  // Something strange happened
5685         }
5686
5687         // If R1 was not in the range, then it is a good return value.  Make
5688         // sure that R1-1 WAS in the range though, just in case.
5689         ConstantInt *NextVal =
5690                ConstantInt::get(SE.getContext(), R1->getValue()->getValue()-1);
5691         R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
5692         if (Range.contains(R1Val->getValue()))
5693           return R1;
5694         return SE.getCouldNotCompute();  // Something strange happened
5695       }
5696     }
5697   }
5698
5699   return SE.getCouldNotCompute();
5700 }
5701
5702
5703
5704 //===----------------------------------------------------------------------===//
5705 //                   SCEVCallbackVH Class Implementation
5706 //===----------------------------------------------------------------------===//
5707
5708 void ScalarEvolution::SCEVCallbackVH::deleted() {
5709   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
5710   if (PHINode *PN = dyn_cast<PHINode>(getValPtr()))
5711     SE->ConstantEvolutionLoopExitValue.erase(PN);
5712   SE->Scalars.erase(getValPtr());
5713   // this now dangles!
5714 }
5715
5716 void ScalarEvolution::SCEVCallbackVH::allUsesReplacedWith(Value *V) {
5717   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
5718
5719   // Forget all the expressions associated with users of the old value,
5720   // so that future queries will recompute the expressions using the new
5721   // value.
5722   Value *Old = getValPtr();
5723   SmallVector<User *, 16> Worklist;
5724   SmallPtrSet<User *, 8> Visited;
5725   for (Value::use_iterator UI = Old->use_begin(), UE = Old->use_end();
5726        UI != UE; ++UI)
5727     Worklist.push_back(*UI);
5728   while (!Worklist.empty()) {
5729     User *U = Worklist.pop_back_val();
5730     // Deleting the Old value will cause this to dangle. Postpone
5731     // that until everything else is done.
5732     if (U == Old)
5733       continue;
5734     if (!Visited.insert(U))
5735       continue;
5736     if (PHINode *PN = dyn_cast<PHINode>(U))
5737       SE->ConstantEvolutionLoopExitValue.erase(PN);
5738     SE->Scalars.erase(U);
5739     for (Value::use_iterator UI = U->use_begin(), UE = U->use_end();
5740          UI != UE; ++UI)
5741       Worklist.push_back(*UI);
5742   }
5743   // Delete the Old value.
5744   if (PHINode *PN = dyn_cast<PHINode>(Old))
5745     SE->ConstantEvolutionLoopExitValue.erase(PN);
5746   SE->Scalars.erase(Old);
5747   // this now dangles!
5748 }
5749
5750 ScalarEvolution::SCEVCallbackVH::SCEVCallbackVH(Value *V, ScalarEvolution *se)
5751   : CallbackVH(V), SE(se) {}
5752
5753 //===----------------------------------------------------------------------===//
5754 //                   ScalarEvolution Class Implementation
5755 //===----------------------------------------------------------------------===//
5756
5757 ScalarEvolution::ScalarEvolution()
5758   : FunctionPass(ID), FirstUnknown(0) {
5759 }
5760
5761 bool ScalarEvolution::runOnFunction(Function &F) {
5762   this->F = &F;
5763   LI = &getAnalysis<LoopInfo>();
5764   TD = getAnalysisIfAvailable<TargetData>();
5765   DT = &getAnalysis<DominatorTree>();
5766   return false;
5767 }
5768
5769 void ScalarEvolution::releaseMemory() {
5770   // Iterate through all the SCEVUnknown instances and call their
5771   // destructors, so that they release their references to their values.
5772   for (SCEVUnknown *U = FirstUnknown; U; U = U->Next)
5773     U->~SCEVUnknown();
5774   FirstUnknown = 0;
5775
5776   Scalars.clear();
5777   BackedgeTakenCounts.clear();
5778   ConstantEvolutionLoopExitValue.clear();
5779   ValuesAtScopes.clear();
5780   UniqueSCEVs.clear();
5781   SCEVAllocator.Reset();
5782 }
5783
5784 void ScalarEvolution::getAnalysisUsage(AnalysisUsage &AU) const {
5785   AU.setPreservesAll();
5786   AU.addRequiredTransitive<LoopInfo>();
5787   AU.addRequiredTransitive<DominatorTree>();
5788 }
5789
5790 bool ScalarEvolution::hasLoopInvariantBackedgeTakenCount(const Loop *L) {
5791   return !isa<SCEVCouldNotCompute>(getBackedgeTakenCount(L));
5792 }
5793
5794 static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
5795                           const Loop *L) {
5796   // Print all inner loops first
5797   for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
5798     PrintLoopInfo(OS, SE, *I);
5799
5800   OS << "Loop ";
5801   WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
5802   OS << ": ";
5803
5804   SmallVector<BasicBlock *, 8> ExitBlocks;
5805   L->getExitBlocks(ExitBlocks);
5806   if (ExitBlocks.size() != 1)
5807     OS << "<multiple exits> ";
5808
5809   if (SE->hasLoopInvariantBackedgeTakenCount(L)) {
5810     OS << "backedge-taken count is " << *SE->getBackedgeTakenCount(L);
5811   } else {
5812     OS << "Unpredictable backedge-taken count. ";
5813   }
5814
5815   OS << "\n"
5816         "Loop ";
5817   WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
5818   OS << ": ";
5819
5820   if (!isa<SCEVCouldNotCompute>(SE->getMaxBackedgeTakenCount(L))) {
5821     OS << "max backedge-taken count is " << *SE->getMaxBackedgeTakenCount(L);
5822   } else {
5823     OS << "Unpredictable max backedge-taken count. ";
5824   }
5825
5826   OS << "\n";
5827 }
5828
5829 void ScalarEvolution::print(raw_ostream &OS, const Module *) const {
5830   // ScalarEvolution's implementation of the print method is to print
5831   // out SCEV values of all instructions that are interesting. Doing
5832   // this potentially causes it to create new SCEV objects though,
5833   // which technically conflicts with the const qualifier. This isn't
5834   // observable from outside the class though, so casting away the
5835   // const isn't dangerous.
5836   ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
5837
5838   OS << "Classifying expressions for: ";
5839   WriteAsOperand(OS, F, /*PrintType=*/false);
5840   OS << "\n";
5841   for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
5842     if (isSCEVable(I->getType()) && !isa<CmpInst>(*I)) {
5843       OS << *I << '\n';
5844       OS << "  -->  ";
5845       const SCEV *SV = SE.getSCEV(&*I);
5846       SV->print(OS);
5847
5848       const Loop *L = LI->getLoopFor((*I).getParent());
5849
5850       const SCEV *AtUse = SE.getSCEVAtScope(SV, L);
5851       if (AtUse != SV) {
5852         OS << "  -->  ";
5853         AtUse->print(OS);
5854       }
5855
5856       if (L) {
5857         OS << "\t\t" "Exits: ";
5858         const SCEV *ExitValue = SE.getSCEVAtScope(SV, L->getParentLoop());
5859         if (!ExitValue->isLoopInvariant(L)) {
5860           OS << "<<Unknown>>";
5861         } else {
5862           OS << *ExitValue;
5863         }
5864       }
5865
5866       OS << "\n";
5867     }
5868
5869   OS << "Determining loop execution counts for: ";
5870   WriteAsOperand(OS, F, /*PrintType=*/false);
5871   OS << "\n";
5872   for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
5873     PrintLoopInfo(OS, &SE, *I);
5874 }
5875