contrib/llvm/lib/Analysis/ScalarEvolution.cpp

   1 //===- ScalarEvolution.cpp - Scalar Evolution Analysis --------------------===//
   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 #include "llvm/Analysis/ScalarEvolution.h"
  62 #include "llvm/ADT/Optional.h"
  63 #include "llvm/ADT/STLExtras.h"
  64 #include "llvm/ADT/SmallPtrSet.h"
  65 #include "llvm/ADT/Statistic.h"
  66 #include "llvm/Analysis/AssumptionCache.h"
  67 #include "llvm/Analysis/ConstantFolding.h"
  68 #include "llvm/Analysis/InstructionSimplify.h"
  69 #include "llvm/Analysis/LoopInfo.h"
  70 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
  71 #include "llvm/Analysis/TargetLibraryInfo.h"
  72 #include "llvm/Analysis/ValueTracking.h"
  73 #include "llvm/IR/ConstantRange.h"
  74 #include "llvm/IR/Constants.h"
  75 #include "llvm/IR/DataLayout.h"
  76 #include "llvm/IR/DerivedTypes.h"
  77 #include "llvm/IR/Dominators.h"
  78 #include "llvm/IR/GetElementPtrTypeIterator.h"
  79 #include "llvm/IR/GlobalAlias.h"
  80 #include "llvm/IR/GlobalVariable.h"
  81 #include "llvm/IR/InstIterator.h"
  82 #include "llvm/IR/Instructions.h"
  83 #include "llvm/IR/LLVMContext.h"
  84 #include "llvm/IR/Metadata.h"
  85 #include "llvm/IR/Operator.h"
  86 #include "llvm/IR/PatternMatch.h"
  87 #include "llvm/Support/CommandLine.h"
  88 #include "llvm/Support/Debug.h"
  89 #include "llvm/Support/ErrorHandling.h"
  90 #include "llvm/Support/MathExtras.h"
  91 #include "llvm/Support/raw_ostream.h"
  92 #include "llvm/Support/SaveAndRestore.h"
  93 #include <algorithm>
  94 using namespace llvm;
  95
  96 #define DEBUG_TYPE "scalar-evolution"
  97
  98 STATISTIC(NumArrayLenItCounts,
  99           "Number of trip counts computed with array length");
 100 STATISTIC(NumTripCountsComputed,
 101           "Number of loops with predictable loop counts");
 102 STATISTIC(NumTripCountsNotComputed,
 103           "Number of loops without predictable loop counts");
 104 STATISTIC(NumBruteForceTripCountsComputed,
 105           "Number of loops with trip counts computed by force");
 106
 107 static cl::opt<unsigned>
 108 MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden,
 109                         cl::desc("Maximum number of iterations SCEV will "
 110                                  "symbolically execute a constant "
 111                                  "derived loop"),
 112                         cl::init(100));
 113
 114 // FIXME: Enable this with EXPENSIVE_CHECKS when the test suite is clean.
 115 static cl::opt<bool>
 116 VerifySCEV("verify-scev",
 117            cl::desc("Verify ScalarEvolution's backedge taken counts (slow)"));
 118 static cl::opt<bool>
 119     VerifySCEVMap("verify-scev-maps",
 120                   cl::desc("Verify no dangling value in ScalarEvolution's "
 121                            "ExprValueMap (slow)"));
 122
 123 //===----------------------------------------------------------------------===//
 124 //                           SCEV class definitions
 125 //===----------------------------------------------------------------------===//
 126
 127 //===----------------------------------------------------------------------===//
 128 // Implementation of the SCEV class.
 129 //
 130
 131 LLVM_DUMP_METHOD
 132 void SCEV::dump() const {
 133   print(dbgs());
 134   dbgs() << '\n';
 135 }
 136
 137 void SCEV::print(raw_ostream &OS) const {
 138   switch (static_cast<SCEVTypes>(getSCEVType())) {
 139   case scConstant:
 140     cast<SCEVConstant>(this)->getValue()->printAsOperand(OS, false);
 141     return;
 142   case scTruncate: {
 143     const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(this);
 144     const SCEV *Op = Trunc->getOperand();
 145     OS << "(trunc " << *Op->getType() << " " << *Op << " to "
 146        << *Trunc->getType() << ")";
 147     return;
 148   }
 149   case scZeroExtend: {
 150     const SCEVZeroExtendExpr *ZExt = cast<SCEVZeroExtendExpr>(this);
 151     const SCEV *Op = ZExt->getOperand();
 152     OS << "(zext " << *Op->getType() << " " << *Op << " to "
 153        << *ZExt->getType() << ")";
 154     return;
 155   }
 156   case scSignExtend: {
 157     const SCEVSignExtendExpr *SExt = cast<SCEVSignExtendExpr>(this);
 158     const SCEV *Op = SExt->getOperand();
 159     OS << "(sext " << *Op->getType() << " " << *Op << " to "
 160        << *SExt->getType() << ")";
 161     return;
 162   }
 163   case scAddRecExpr: {
 164     const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(this);
 165     OS << "{" << *AR->getOperand(0);
 166     for (unsigned i = 1, e = AR->getNumOperands(); i != e; ++i)
 167       OS << ",+," << *AR->getOperand(i);
 168     OS << "}<";
 169     if (AR->hasNoUnsignedWrap())
 170       OS << "nuw><";
 171     if (AR->hasNoSignedWrap())
 172       OS << "nsw><";
 173     if (AR->hasNoSelfWrap() &&
 174         !AR->getNoWrapFlags((NoWrapFlags)(FlagNUW | FlagNSW)))
 175       OS << "nw><";
 176     AR->getLoop()->getHeader()->printAsOperand(OS, /*PrintType=*/false);
 177     OS << ">";
 178     return;
 179   }
 180   case scAddExpr:
 181   case scMulExpr:
 182   case scUMaxExpr:
 183   case scSMaxExpr: {
 184     const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(this);
 185     const char *OpStr = nullptr;
 186     switch (NAry->getSCEVType()) {
 187     case scAddExpr: OpStr = " + "; break;
 188     case scMulExpr: OpStr = " * "; break;
 189     case scUMaxExpr: OpStr = " umax "; break;
 190     case scSMaxExpr: OpStr = " smax "; break;
 191     }
 192     OS << "(";
 193     for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
 194          I != E; ++I) {
 195       OS << **I;
 196       if (std::next(I) != E)
 197         OS << OpStr;
 198     }
 199     OS << ")";
 200     switch (NAry->getSCEVType()) {
 201     case scAddExpr:
 202     case scMulExpr:
 203       if (NAry->hasNoUnsignedWrap())
 204         OS << "<nuw>";
 205       if (NAry->hasNoSignedWrap())
 206         OS << "<nsw>";
 207     }
 208     return;
 209   }
 210   case scUDivExpr: {
 211     const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(this);
 212     OS << "(" << *UDiv->getLHS() << " /u " << *UDiv->getRHS() << ")";
 213     return;
 214   }
 215   case scUnknown: {
 216     const SCEVUnknown *U = cast<SCEVUnknown>(this);
 217     Type *AllocTy;
 218     if (U->isSizeOf(AllocTy)) {
 219       OS << "sizeof(" << *AllocTy << ")";
 220       return;
 221     }
 222     if (U->isAlignOf(AllocTy)) {
 223       OS << "alignof(" << *AllocTy << ")";
 224       return;
 225     }
 226
 227     Type *CTy;
 228     Constant *FieldNo;
 229     if (U->isOffsetOf(CTy, FieldNo)) {
 230       OS << "offsetof(" << *CTy << ", ";
 231       FieldNo->printAsOperand(OS, false);
 232       OS << ")";
 233       return;
 234     }
 235
 236     // Otherwise just print it normally.
 237     U->getValue()->printAsOperand(OS, false);
 238     return;
 239   }
 240   case scCouldNotCompute:
 241     OS << "***COULDNOTCOMPUTE***";
 242     return;
 243   }
 244   llvm_unreachable("Unknown SCEV kind!");
 245 }
 246
 247 Type *SCEV::getType() const {
 248   switch (static_cast<SCEVTypes>(getSCEVType())) {
 249   case scConstant:
 250     return cast<SCEVConstant>(this)->getType();
 251   case scTruncate:
 252   case scZeroExtend:
 253   case scSignExtend:
 254     return cast<SCEVCastExpr>(this)->getType();
 255   case scAddRecExpr:
 256   case scMulExpr:
 257   case scUMaxExpr:
 258   case scSMaxExpr:
 259     return cast<SCEVNAryExpr>(this)->getType();
 260   case scAddExpr:
 261     return cast<SCEVAddExpr>(this)->getType();
 262   case scUDivExpr:
 263     return cast<SCEVUDivExpr>(this)->getType();
 264   case scUnknown:
 265     return cast<SCEVUnknown>(this)->getType();
 266   case scCouldNotCompute:
 267     llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 268   }
 269   llvm_unreachable("Unknown SCEV kind!");
 270 }
 271
 272 bool SCEV::isZero() const {
 273   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 274     return SC->getValue()->isZero();
 275   return false;
 276 }
 277
 278 bool SCEV::isOne() const {
 279   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 280     return SC->getValue()->isOne();
 281   return false;
 282 }
 283
 284 bool SCEV::isAllOnesValue() const {
 285   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
 286     return SC->getValue()->isAllOnesValue();
 287   return false;
 288 }
 289
 290 bool SCEV::isNonConstantNegative() const {
 291   const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(this);
 292   if (!Mul) return false;
 293
 294   // If there is a constant factor, it will be first.
 295   const SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
 296   if (!SC) return false;
 297
 298   // Return true if the value is negative, this matches things like (-42 * V).
 299   return SC->getAPInt().isNegative();
 300 }
 301
 302 SCEVCouldNotCompute::SCEVCouldNotCompute() :
 303   SCEV(FoldingSetNodeIDRef(), scCouldNotCompute) {}
 304
 305 bool SCEVCouldNotCompute::classof(const SCEV *S) {
 306   return S->getSCEVType() == scCouldNotCompute;
 307 }
 308
 309 const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
 310   FoldingSetNodeID ID;
 311   ID.AddInteger(scConstant);
 312   ID.AddPointer(V);
 313   void *IP = nullptr;
 314   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
 315   SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
 316   UniqueSCEVs.InsertNode(S, IP);
 317   return S;
 318 }
 319
 320 const SCEV *ScalarEvolution::getConstant(const APInt &Val) {
 321   return getConstant(ConstantInt::get(getContext(), Val));
 322 }
 323
 324 const SCEV *
 325 ScalarEvolution::getConstant(Type *Ty, uint64_t V, bool isSigned) {
 326   IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
 327   return getConstant(ConstantInt::get(ITy, V, isSigned));
 328 }
 329
 330 SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID,
 331                            unsigned SCEVTy, const SCEV *op, Type *ty)
 332   : SCEV(ID, SCEVTy), Op(op), Ty(ty) {}
 333
 334 SCEVTruncateExpr::SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
 335                                    const SCEV *op, Type *ty)
 336   : SCEVCastExpr(ID, scTruncate, op, ty) {
 337   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 338          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 339          "Cannot truncate non-integer value!");
 340 }
 341
 342 SCEVZeroExtendExpr::SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
 343                                        const SCEV *op, Type *ty)
 344   : SCEVCastExpr(ID, scZeroExtend, op, ty) {
 345   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 346          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 347          "Cannot zero extend non-integer value!");
 348 }
 349
 350 SCEVSignExtendExpr::SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
 351                                        const SCEV *op, Type *ty)
 352   : SCEVCastExpr(ID, scSignExtend, op, ty) {
 353   assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
 354          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
 355          "Cannot sign extend non-integer value!");
 356 }
 357
 358 void SCEVUnknown::deleted() {
 359   // Clear this SCEVUnknown from various maps.
 360   SE->forgetMemoizedResults(this);
 361
 362   // Remove this SCEVUnknown from the uniquing map.
 363   SE->UniqueSCEVs.RemoveNode(this);
 364
 365   // Release the value.
 366   setValPtr(nullptr);
 367 }
 368
 369 void SCEVUnknown::allUsesReplacedWith(Value *New) {
 370   // Clear this SCEVUnknown from various maps.
 371   SE->forgetMemoizedResults(this);
 372
 373   // Remove this SCEVUnknown from the uniquing map.
 374   SE->UniqueSCEVs.RemoveNode(this);
 375
 376   // Update this SCEVUnknown to point to the new value. This is needed
 377   // because there may still be outstanding SCEVs which still point to
 378   // this SCEVUnknown.
 379   setValPtr(New);
 380 }
 381
 382 bool SCEVUnknown::isSizeOf(Type *&AllocTy) const {
 383   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 384     if (VCE->getOpcode() == Instruction::PtrToInt)
 385       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 386         if (CE->getOpcode() == Instruction::GetElementPtr &&
 387             CE->getOperand(0)->isNullValue() &&
 388             CE->getNumOperands() == 2)
 389           if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
 390             if (CI->isOne()) {
 391               AllocTy = cast<PointerType>(CE->getOperand(0)->getType())
 392                                  ->getElementType();
 393               return true;
 394             }
 395
 396   return false;
 397 }
 398
 399 bool SCEVUnknown::isAlignOf(Type *&AllocTy) const {
 400   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 401     if (VCE->getOpcode() == Instruction::PtrToInt)
 402       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 403         if (CE->getOpcode() == Instruction::GetElementPtr &&
 404             CE->getOperand(0)->isNullValue()) {
 405           Type *Ty =
 406             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
 407           if (StructType *STy = dyn_cast<StructType>(Ty))
 408             if (!STy->isPacked() &&
 409                 CE->getNumOperands() == 3 &&
 410                 CE->getOperand(1)->isNullValue()) {
 411               if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
 412                 if (CI->isOne() &&
 413                     STy->getNumElements() == 2 &&
 414                     STy->getElementType(0)->isIntegerTy(1)) {
 415                   AllocTy = STy->getElementType(1);
 416                   return true;
 417                 }
 418             }
 419         }
 420
 421   return false;
 422 }
 423
 424 bool SCEVUnknown::isOffsetOf(Type *&CTy, Constant *&FieldNo) const {
 425   if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
 426     if (VCE->getOpcode() == Instruction::PtrToInt)
 427       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
 428         if (CE->getOpcode() == Instruction::GetElementPtr &&
 429             CE->getNumOperands() == 3 &&
 430             CE->getOperand(0)->isNullValue() &&
 431             CE->getOperand(1)->isNullValue()) {
 432           Type *Ty =
 433             cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
 434           // Ignore vector types here so that ScalarEvolutionExpander doesn't
 435           // emit getelementptrs that index into vectors.
 436           if (Ty->isStructTy() || Ty->isArrayTy()) {
 437             CTy = Ty;
 438             FieldNo = CE->getOperand(2);
 439             return true;
 440           }
 441         }
 442
 443   return false;
 444 }
 445
 446 //===----------------------------------------------------------------------===//
 447 //                               SCEV Utilities
 448 //===----------------------------------------------------------------------===//
 449
 450 namespace {
 451 /// SCEVComplexityCompare - Return true if the complexity of the LHS is less
 452 /// than the complexity of the RHS.  This comparator is used to canonicalize
 453 /// expressions.
 454 class SCEVComplexityCompare {
 455   const LoopInfo *const LI;
 456 public:
 457   explicit SCEVComplexityCompare(const LoopInfo *li) : LI(li) {}
 458
 459   // Return true or false if LHS is less than, or at least RHS, respectively.
 460   bool operator()(const SCEV *LHS, const SCEV *RHS) const {
 461     return compare(LHS, RHS) < 0;
 462   }
 463
 464   // Return negative, zero, or positive, if LHS is less than, equal to, or
 465   // greater than RHS, respectively. A three-way result allows recursive
 466   // comparisons to be more efficient.
 467   int compare(const SCEV *LHS, const SCEV *RHS) const {
 468     // Fast-path: SCEVs are uniqued so we can do a quick equality check.
 469     if (LHS == RHS)
 470       return 0;
 471
 472     // Primarily, sort the SCEVs by their getSCEVType().
 473     unsigned LType = LHS->getSCEVType(), RType = RHS->getSCEVType();
 474     if (LType != RType)
 475       return (int)LType - (int)RType;
 476
 477     // Aside from the getSCEVType() ordering, the particular ordering
 478     // isn't very important except that it's beneficial to be consistent,
 479     // so that (a + b) and (b + a) don't end up as different expressions.
 480     switch (static_cast<SCEVTypes>(LType)) {
 481     case scUnknown: {
 482       const SCEVUnknown *LU = cast<SCEVUnknown>(LHS);
 483       const SCEVUnknown *RU = cast<SCEVUnknown>(RHS);
 484
 485       // Sort SCEVUnknown values with some loose heuristics. TODO: This is
 486       // not as complete as it could be.
 487       const Value *LV = LU->getValue(), *RV = RU->getValue();
 488
 489       // Order pointer values after integer values. This helps SCEVExpander
 490       // form GEPs.
 491       bool LIsPointer = LV->getType()->isPointerTy(),
 492         RIsPointer = RV->getType()->isPointerTy();
 493       if (LIsPointer != RIsPointer)
 494         return (int)LIsPointer - (int)RIsPointer;
 495
 496       // Compare getValueID values.
 497       unsigned LID = LV->getValueID(),
 498         RID = RV->getValueID();
 499       if (LID != RID)
 500         return (int)LID - (int)RID;
 501
 502       // Sort arguments by their position.
 503       if (const Argument *LA = dyn_cast<Argument>(LV)) {
 504         const Argument *RA = cast<Argument>(RV);
 505         unsigned LArgNo = LA->getArgNo(), RArgNo = RA->getArgNo();
 506         return (int)LArgNo - (int)RArgNo;
 507       }
 508
 509       // For instructions, compare their loop depth, and their operand
 510       // count.  This is pretty loose.
 511       if (const Instruction *LInst = dyn_cast<Instruction>(LV)) {
 512         const Instruction *RInst = cast<Instruction>(RV);
 513
 514         // Compare loop depths.
 515         const BasicBlock *LParent = LInst->getParent(),
 516           *RParent = RInst->getParent();
 517         if (LParent != RParent) {
 518           unsigned LDepth = LI->getLoopDepth(LParent),
 519             RDepth = LI->getLoopDepth(RParent);
 520           if (LDepth != RDepth)
 521             return (int)LDepth - (int)RDepth;
 522         }
 523
 524         // Compare the number of operands.
 525         unsigned LNumOps = LInst->getNumOperands(),
 526           RNumOps = RInst->getNumOperands();
 527         return (int)LNumOps - (int)RNumOps;
 528       }
 529
 530       return 0;
 531     }
 532
 533     case scConstant: {
 534       const SCEVConstant *LC = cast<SCEVConstant>(LHS);
 535       const SCEVConstant *RC = cast<SCEVConstant>(RHS);
 536
 537       // Compare constant values.
 538       const APInt &LA = LC->getAPInt();
 539       const APInt &RA = RC->getAPInt();
 540       unsigned LBitWidth = LA.getBitWidth(), RBitWidth = RA.getBitWidth();
 541       if (LBitWidth != RBitWidth)
 542         return (int)LBitWidth - (int)RBitWidth;
 543       return LA.ult(RA) ? -1 : 1;
 544     }
 545
 546     case scAddRecExpr: {
 547       const SCEVAddRecExpr *LA = cast<SCEVAddRecExpr>(LHS);
 548       const SCEVAddRecExpr *RA = cast<SCEVAddRecExpr>(RHS);
 549
 550       // Compare addrec loop depths.
 551       const Loop *LLoop = LA->getLoop(), *RLoop = RA->getLoop();
 552       if (LLoop != RLoop) {
 553         unsigned LDepth = LLoop->getLoopDepth(),
 554           RDepth = RLoop->getLoopDepth();
 555         if (LDepth != RDepth)
 556           return (int)LDepth - (int)RDepth;
 557       }
 558
 559       // Addrec complexity grows with operand count.
 560       unsigned LNumOps = LA->getNumOperands(), RNumOps = RA->getNumOperands();
 561       if (LNumOps != RNumOps)
 562         return (int)LNumOps - (int)RNumOps;
 563
 564       // Lexicographically compare.
 565       for (unsigned i = 0; i != LNumOps; ++i) {
 566         long X = compare(LA->getOperand(i), RA->getOperand(i));
 567         if (X != 0)
 568           return X;
 569       }
 570
 571       return 0;
 572     }
 573
 574     case scAddExpr:
 575     case scMulExpr:
 576     case scSMaxExpr:
 577     case scUMaxExpr: {
 578       const SCEVNAryExpr *LC = cast<SCEVNAryExpr>(LHS);
 579       const SCEVNAryExpr *RC = cast<SCEVNAryExpr>(RHS);
 580
 581       // Lexicographically compare n-ary expressions.
 582       unsigned LNumOps = LC->getNumOperands(), RNumOps = RC->getNumOperands();
 583       if (LNumOps != RNumOps)
 584         return (int)LNumOps - (int)RNumOps;
 585
 586       for (unsigned i = 0; i != LNumOps; ++i) {
 587         if (i >= RNumOps)
 588           return 1;
 589         long X = compare(LC->getOperand(i), RC->getOperand(i));
 590         if (X != 0)
 591           return X;
 592       }
 593       return (int)LNumOps - (int)RNumOps;
 594     }
 595
 596     case scUDivExpr: {
 597       const SCEVUDivExpr *LC = cast<SCEVUDivExpr>(LHS);
 598       const SCEVUDivExpr *RC = cast<SCEVUDivExpr>(RHS);
 599
 600       // Lexicographically compare udiv expressions.
 601       long X = compare(LC->getLHS(), RC->getLHS());
 602       if (X != 0)
 603         return X;
 604       return compare(LC->getRHS(), RC->getRHS());
 605     }
 606
 607     case scTruncate:
 608     case scZeroExtend:
 609     case scSignExtend: {
 610       const SCEVCastExpr *LC = cast<SCEVCastExpr>(LHS);
 611       const SCEVCastExpr *RC = cast<SCEVCastExpr>(RHS);
 612
 613       // Compare cast expressions by operand.
 614       return compare(LC->getOperand(), RC->getOperand());
 615     }
 616
 617     case scCouldNotCompute:
 618       llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
 619     }
 620     llvm_unreachable("Unknown SCEV kind!");
 621   }
 622 };
 623 }  // end anonymous namespace
 624
 625 /// Given a list of SCEV objects, order them by their complexity, and group
 626 /// objects of the same complexity together by value.  When this routine is
 627 /// finished, we know that any duplicates in the vector are consecutive and that
 628 /// complexity is monotonically increasing.
 629 ///
 630 /// Note that we go take special precautions to ensure that we get deterministic
 631 /// results from this routine.  In other words, we don't want the results of
 632 /// this to depend on where the addresses of various SCEV objects happened to
 633 /// land in memory.
 634 ///
 635 static void GroupByComplexity(SmallVectorImpl<const SCEV *> &Ops,
 636                               LoopInfo *LI) {
 637   if (Ops.size() < 2) return;  // Noop
 638   if (Ops.size() == 2) {
 639     // This is the common case, which also happens to be trivially simple.
 640     // Special case it.
 641     const SCEV *&LHS = Ops[0], *&RHS = Ops[1];
 642     if (SCEVComplexityCompare(LI)(RHS, LHS))
 643       std::swap(LHS, RHS);
 644     return;
 645   }
 646
 647   // Do the rough sort by complexity.
 648   std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
 649
 650   // Now that we are sorted by complexity, group elements of the same
 651   // complexity.  Note that this is, at worst, N^2, but the vector is likely to
 652   // be extremely short in practice.  Note that we take this approach because we
 653   // do not want to depend on the addresses of the objects we are grouping.
 654   for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
 655     const SCEV *S = Ops[i];
 656     unsigned Complexity = S->getSCEVType();
 657
 658     // If there are any objects of the same complexity and same value as this
 659     // one, group them.
 660     for (unsigned j = i+1; j != e && Ops[j]->getSCEVType() == Complexity; ++j) {
 661       if (Ops[j] == S) { // Found a duplicate.
 662         // Move it to immediately after i'th element.
 663         std::swap(Ops[i+1], Ops[j]);
 664         ++i;   // no need to rescan it.
 665         if (i == e-2) return;  // Done!
 666       }
 667     }
 668   }
 669 }
 670
 671 // Returns the size of the SCEV S.
 672 static inline int sizeOfSCEV(const SCEV *S) {
 673   struct FindSCEVSize {
 674     int Size;
 675     FindSCEVSize() : Size(0) {}
 676
 677     bool follow(const SCEV *S) {
 678       ++Size;
 679       // Keep looking at all operands of S.
 680       return true;
 681     }
 682     bool isDone() const {
 683       return false;
 684     }
 685   };
 686
 687   FindSCEVSize F;
 688   SCEVTraversal<FindSCEVSize> ST(F);
 689   ST.visitAll(S);
 690   return F.Size;
 691 }
 692
 693 namespace {
 694
 695 struct SCEVDivision : public SCEVVisitor<SCEVDivision, void> {
 696 public:
 697   // Computes the Quotient and Remainder of the division of Numerator by
 698   // Denominator.
 699   static void divide(ScalarEvolution &SE, const SCEV *Numerator,
 700                      const SCEV *Denominator, const SCEV **Quotient,
 701                      const SCEV **Remainder) {
 702     assert(Numerator && Denominator && "Uninitialized SCEV");
 703
 704     SCEVDivision D(SE, Numerator, Denominator);
 705
 706     // Check for the trivial case here to avoid having to check for it in the
 707     // rest of the code.
 708     if (Numerator == Denominator) {
 709       *Quotient = D.One;
 710       *Remainder = D.Zero;
 711       return;
 712     }
 713
 714     if (Numerator->isZero()) {
 715       *Quotient = D.Zero;
 716       *Remainder = D.Zero;
 717       return;
 718     }
 719
 720     // A simple case when N/1. The quotient is N.
 721     if (Denominator->isOne()) {
 722       *Quotient = Numerator;
 723       *Remainder = D.Zero;
 724       return;
 725     }
 726
 727     // Split the Denominator when it is a product.
 728     if (const SCEVMulExpr *T = dyn_cast<SCEVMulExpr>(Denominator)) {
 729       const SCEV *Q, *R;
 730       *Quotient = Numerator;
 731       for (const SCEV *Op : T->operands()) {
 732         divide(SE, *Quotient, Op, &Q, &R);
 733         *Quotient = Q;
 734
 735         // Bail out when the Numerator is not divisible by one of the terms of
 736         // the Denominator.
 737         if (!R->isZero()) {
 738           *Quotient = D.Zero;
 739           *Remainder = Numerator;
 740           return;
 741         }
 742       }
 743       *Remainder = D.Zero;
 744       return;
 745     }
 746
 747     D.visit(Numerator);
 748     *Quotient = D.Quotient;
 749     *Remainder = D.Remainder;
 750   }
 751
 752   // Except in the trivial case described above, we do not know how to divide
 753   // Expr by Denominator for the following functions with empty implementation.
 754   void visitTruncateExpr(const SCEVTruncateExpr *Numerator) {}
 755   void visitZeroExtendExpr(const SCEVZeroExtendExpr *Numerator) {}
 756   void visitSignExtendExpr(const SCEVSignExtendExpr *Numerator) {}
 757   void visitUDivExpr(const SCEVUDivExpr *Numerator) {}
 758   void visitSMaxExpr(const SCEVSMaxExpr *Numerator) {}
 759   void visitUMaxExpr(const SCEVUMaxExpr *Numerator) {}
 760   void visitUnknown(const SCEVUnknown *Numerator) {}
 761   void visitCouldNotCompute(const SCEVCouldNotCompute *Numerator) {}
 762
 763   void visitConstant(const SCEVConstant *Numerator) {
 764     if (const SCEVConstant *D = dyn_cast<SCEVConstant>(Denominator)) {
 765       APInt NumeratorVal = Numerator->getAPInt();
 766       APInt DenominatorVal = D->getAPInt();
 767       uint32_t NumeratorBW = NumeratorVal.getBitWidth();
 768       uint32_t DenominatorBW = DenominatorVal.getBitWidth();
 769
 770       if (NumeratorBW > DenominatorBW)
 771         DenominatorVal = DenominatorVal.sext(NumeratorBW);
 772       else if (NumeratorBW < DenominatorBW)
 773         NumeratorVal = NumeratorVal.sext(DenominatorBW);
 774
 775       APInt QuotientVal(NumeratorVal.getBitWidth(), 0);
 776       APInt RemainderVal(NumeratorVal.getBitWidth(), 0);
 777       APInt::sdivrem(NumeratorVal, DenominatorVal, QuotientVal, RemainderVal);
 778       Quotient = SE.getConstant(QuotientVal);
 779       Remainder = SE.getConstant(RemainderVal);
 780       return;
 781     }
 782   }
 783
 784   void visitAddRecExpr(const SCEVAddRecExpr *Numerator) {
 785     const SCEV *StartQ, *StartR, *StepQ, *StepR;
 786     if (!Numerator->isAffine())
 787       return cannotDivide(Numerator);
 788     divide(SE, Numerator->getStart(), Denominator, &StartQ, &StartR);
 789     divide(SE, Numerator->getStepRecurrence(SE), Denominator, &StepQ, &StepR);
 790     // Bail out if the types do not match.
 791     Type *Ty = Denominator->getType();
 792     if (Ty != StartQ->getType() || Ty != StartR->getType() ||
 793         Ty != StepQ->getType() || Ty != StepR->getType())
 794       return cannotDivide(Numerator);
 795     Quotient = SE.getAddRecExpr(StartQ, StepQ, Numerator->getLoop(),
 796                                 Numerator->getNoWrapFlags());
 797     Remainder = SE.getAddRecExpr(StartR, StepR, Numerator->getLoop(),
 798                                  Numerator->getNoWrapFlags());
 799   }
 800
 801   void visitAddExpr(const SCEVAddExpr *Numerator) {
 802     SmallVector<const SCEV *, 2> Qs, Rs;
 803     Type *Ty = Denominator->getType();
 804
 805     for (const SCEV *Op : Numerator->operands()) {
 806       const SCEV *Q, *R;
 807       divide(SE, Op, Denominator, &Q, &R);
 808
 809       // Bail out if types do not match.
 810       if (Ty != Q->getType() || Ty != R->getType())
 811         return cannotDivide(Numerator);
 812
 813       Qs.push_back(Q);
 814       Rs.push_back(R);
 815     }
 816
 817     if (Qs.size() == 1) {
 818       Quotient = Qs[0];
 819       Remainder = Rs[0];
 820       return;
 821     }
 822
 823     Quotient = SE.getAddExpr(Qs);
 824     Remainder = SE.getAddExpr(Rs);
 825   }
 826
 827   void visitMulExpr(const SCEVMulExpr *Numerator) {
 828     SmallVector<const SCEV *, 2> Qs;
 829     Type *Ty = Denominator->getType();
 830
 831     bool FoundDenominatorTerm = false;
 832     for (const SCEV *Op : Numerator->operands()) {
 833       // Bail out if types do not match.
 834       if (Ty != Op->getType())
 835         return cannotDivide(Numerator);
 836
 837       if (FoundDenominatorTerm) {
 838         Qs.push_back(Op);
 839         continue;
 840       }
 841
 842       // Check whether Denominator divides one of the product operands.
 843       const SCEV *Q, *R;
 844       divide(SE, Op, Denominator, &Q, &R);
 845       if (!R->isZero()) {
 846         Qs.push_back(Op);
 847         continue;
 848       }
 849
 850       // Bail out if types do not match.
 851       if (Ty != Q->getType())
 852         return cannotDivide(Numerator);
 853
 854       FoundDenominatorTerm = true;
 855       Qs.push_back(Q);
 856     }
 857
 858     if (FoundDenominatorTerm) {
 859       Remainder = Zero;
 860       if (Qs.size() == 1)
 861         Quotient = Qs[0];
 862       else
 863         Quotient = SE.getMulExpr(Qs);
 864       return;
 865     }
 866
 867     if (!isa<SCEVUnknown>(Denominator))
 868       return cannotDivide(Numerator);
 869
 870     // The Remainder is obtained by replacing Denominator by 0 in Numerator.
 871     ValueToValueMap RewriteMap;
 872     RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
 873         cast<SCEVConstant>(Zero)->getValue();
 874     Remainder = SCEVParameterRewriter::rewrite(Numerator, SE, RewriteMap, true);
 875
 876     if (Remainder->isZero()) {
 877       // The Quotient is obtained by replacing Denominator by 1 in Numerator.
 878       RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
 879           cast<SCEVConstant>(One)->getValue();
 880       Quotient =
 881           SCEVParameterRewriter::rewrite(Numerator, SE, RewriteMap, true);
 882       return;
 883     }
 884
 885     // Quotient is (Numerator - Remainder) divided by Denominator.
 886     const SCEV *Q, *R;
 887     const SCEV *Diff = SE.getMinusSCEV(Numerator, Remainder);
 888     // This SCEV does not seem to simplify: fail the division here.
 889     if (sizeOfSCEV(Diff) > sizeOfSCEV(Numerator))
 890       return cannotDivide(Numerator);
 891     divide(SE, Diff, Denominator, &Q, &R);
 892     if (R != Zero)
 893       return cannotDivide(Numerator);
 894     Quotient = Q;
 895   }
 896
 897 private:
 898   SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
 899                const SCEV *Denominator)
 900       : SE(S), Denominator(Denominator) {
 901     Zero = SE.getZero(Denominator->getType());
 902     One = SE.getOne(Denominator->getType());
 903
 904     // We generally do not know how to divide Expr by Denominator. We
 905     // initialize the division to a "cannot divide" state to simplify the rest
 906     // of the code.
 907     cannotDivide(Numerator);
 908   }
 909
 910   // Convenience function for giving up on the division. We set the quotient to
 911   // be equal to zero and the remainder to be equal to the numerator.
 912   void cannotDivide(const SCEV *Numerator) {
 913     Quotient = Zero;
 914     Remainder = Numerator;
 915   }
 916
 917   ScalarEvolution &SE;
 918   const SCEV *Denominator, *Quotient, *Remainder, *Zero, *One;
 919 };
 920
 921 }
 922
 923 //===----------------------------------------------------------------------===//
 924 //                      Simple SCEV method implementations
 925 //===----------------------------------------------------------------------===//
 926
 927 /// Compute BC(It, K).  The result has width W.  Assume, K > 0.
 928 static const SCEV *BinomialCoefficient(const SCEV *It, unsigned K,
 929                                        ScalarEvolution &SE,
 930                                        Type *ResultTy) {
 931   // Handle the simplest case efficiently.
 932   if (K == 1)
 933     return SE.getTruncateOrZeroExtend(It, ResultTy);
 934
 935   // We are using the following formula for BC(It, K):
 936   //
 937   //   BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / K!
 938   //
 939   // Suppose, W is the bitwidth of the return value.  We must be prepared for
 940   // overflow.  Hence, we must assure that the result of our computation is
 941   // equal to the accurate one modulo 2^W.  Unfortunately, division isn't
 942   // safe in modular arithmetic.
 943   //
 944   // However, this code doesn't use exactly that formula; the formula it uses
 945   // is something like the following, where T is the number of factors of 2 in
 946   // K! (i.e. trailing zeros in the binary representation of K!), and ^ is
 947   // exponentiation:
 948   //
 949   //   BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / 2^T / (K! / 2^T)
 950   //
 951   // This formula is trivially equivalent to the previous formula.  However,
 952   // this formula can be implemented much more efficiently.  The trick is that
 953   // K! / 2^T is odd, and exact division by an odd number *is* safe in modular
 954   // arithmetic.  To do exact division in modular arithmetic, all we have
 955   // to do is multiply by the inverse.  Therefore, this step can be done at
 956   // width W.
 957   //
 958   // The next issue is how to safely do the division by 2^T.  The way this
 959   // is done is by doing the multiplication step at a width of at least W + T
 960   // bits.  This way, the bottom W+T bits of the product are accurate. Then,
 961   // when we perform the division by 2^T (which is equivalent to a right shift
 962   // by T), the bottom W bits are accurate.  Extra bits are okay; they'll get
 963   // truncated out after the division by 2^T.
 964   //
 965   // In comparison to just directly using the first formula, this technique
 966   // is much more efficient; using the first formula requires W * K bits,
 967   // but this formula less than W + K bits. Also, the first formula requires
 968   // a division step, whereas this formula only requires multiplies and shifts.
 969   //
 970   // It doesn't matter whether the subtraction step is done in the calculation
 971   // width or the input iteration count's width; if the subtraction overflows,
 972   // the result must be zero anyway.  We prefer here to do it in the width of
 973   // the induction variable because it helps a lot for certain cases; CodeGen
 974   // isn't smart enough to ignore the overflow, which leads to much less
 975   // efficient code if the width of the subtraction is wider than the native
 976   // register width.
 977   //
 978   // (It's possible to not widen at all by pulling out factors of 2 before
 979   // the multiplication; for example, K=2 can be calculated as
 980   // It/2*(It+(It*INT_MIN/INT_MIN)+-1). However, it requires
 981   // extra arithmetic, so it's not an obvious win, and it gets
 982   // much more complicated for K > 3.)
 983
 984   // Protection from insane SCEVs; this bound is conservative,
 985   // but it probably doesn't matter.
 986   if (K > 1000)
 987     return SE.getCouldNotCompute();
 988
 989   unsigned W = SE.getTypeSizeInBits(ResultTy);
 990
 991   // Calculate K! / 2^T and T; we divide out the factors of two before
 992   // multiplying for calculating K! / 2^T to avoid overflow.
 993   // Other overflow doesn't matter because we only care about the bottom
 994   // W bits of the result.
 995   APInt OddFactorial(W, 1);
 996   unsigned T = 1;
 997   for (unsigned i = 3; i <= K; ++i) {
 998     APInt Mult(W, i);
 999     unsigned TwoFactors = Mult.countTrailingZeros();
1000     T += TwoFactors;
1001     Mult = Mult.lshr(TwoFactors);
1002     OddFactorial *= Mult;
1003   }
1004
1005   // We need at least W + T bits for the multiplication step
1006   unsigned CalculationBits = W + T;
1007
1008   // Calculate 2^T, at width T+W.
1009   APInt DivFactor = APInt::getOneBitSet(CalculationBits, T);
1010
1011   // Calculate the multiplicative inverse of K! / 2^T;
1012   // this multiplication factor will perform the exact division by
1013   // K! / 2^T.
1014   APInt Mod = APInt::getSignedMinValue(W+1);
1015   APInt MultiplyFactor = OddFactorial.zext(W+1);
1016   MultiplyFactor = MultiplyFactor.multiplicativeInverse(Mod);
1017   MultiplyFactor = MultiplyFactor.trunc(W);
1018
1019   // Calculate the product, at width T+W
1020   IntegerType *CalculationTy = IntegerType::get(SE.getContext(),
1021                                                       CalculationBits);
1022   const SCEV *Dividend = SE.getTruncateOrZeroExtend(It, CalculationTy);
1023   for (unsigned i = 1; i != K; ++i) {
1024     const SCEV *S = SE.getMinusSCEV(It, SE.getConstant(It->getType(), i));
1025     Dividend = SE.getMulExpr(Dividend,
1026                              SE.getTruncateOrZeroExtend(S, CalculationTy));
1027   }
1028
1029   // Divide by 2^T
1030   const SCEV *DivResult = SE.getUDivExpr(Dividend, SE.getConstant(DivFactor));
1031
1032   // Truncate the result, and divide by K! / 2^T.
1033
1034   return SE.getMulExpr(SE.getConstant(MultiplyFactor),
1035                        SE.getTruncateOrZeroExtend(DivResult, ResultTy));
1036 }
1037
1038 /// Return the value of this chain of recurrences at the specified iteration
1039 /// number.  We can evaluate this recurrence by multiplying each element in the
1040 /// chain by the binomial coefficient corresponding to it.  In other words, we
1041 /// can evaluate {A,+,B,+,C,+,D} as:
1042 ///
1043 ///   A*BC(It, 0) + B*BC(It, 1) + C*BC(It, 2) + D*BC(It, 3)
1044 ///
1045 /// where BC(It, k) stands for binomial coefficient.
1046 ///
1047 const SCEV *SCEVAddRecExpr::evaluateAtIteration(const SCEV *It,
1048                                                 ScalarEvolution &SE) const {
1049   const SCEV *Result = getStart();
1050   for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
1051     // The computation is correct in the face of overflow provided that the
1052     // multiplication is performed _after_ the evaluation of the binomial
1053     // coefficient.
1054     const SCEV *Coeff = BinomialCoefficient(It, i, SE, getType());
1055     if (isa<SCEVCouldNotCompute>(Coeff))
1056       return Coeff;
1057
1058     Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
1059   }
1060   return Result;
1061 }
1062
1063 //===----------------------------------------------------------------------===//
1064 //                    SCEV Expression folder implementations
1065 //===----------------------------------------------------------------------===//
1066
1067 const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op,
1068                                              Type *Ty) {
1069   assert(getTypeSizeInBits(Op->getType()) > getTypeSizeInBits(Ty) &&
1070          "This is not a truncating conversion!");
1071   assert(isSCEVable(Ty) &&
1072          "This is not a conversion to a SCEVable type!");
1073   Ty = getEffectiveSCEVType(Ty);
1074
1075   FoldingSetNodeID ID;
1076   ID.AddInteger(scTruncate);
1077   ID.AddPointer(Op);
1078   ID.AddPointer(Ty);
1079   void *IP = nullptr;
1080   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1081
1082   // Fold if the operand is constant.
1083   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1084     return getConstant(
1085       cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(), Ty)));
1086
1087   // trunc(trunc(x)) --> trunc(x)
1088   if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op))
1089     return getTruncateExpr(ST->getOperand(), Ty);
1090
1091   // trunc(sext(x)) --> sext(x) if widening or trunc(x) if narrowing
1092   if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
1093     return getTruncateOrSignExtend(SS->getOperand(), Ty);
1094
1095   // trunc(zext(x)) --> zext(x) if widening or trunc(x) if narrowing
1096   if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1097     return getTruncateOrZeroExtend(SZ->getOperand(), Ty);
1098
1099   // trunc(x1+x2+...+xN) --> trunc(x1)+trunc(x2)+...+trunc(xN) if we can
1100   // eliminate all the truncates, or we replace other casts with truncates.
1101   if (const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Op)) {
1102     SmallVector<const SCEV *, 4> Operands;
1103     bool hasTrunc = false;
1104     for (unsigned i = 0, e = SA->getNumOperands(); i != e && !hasTrunc; ++i) {
1105       const SCEV *S = getTruncateExpr(SA->getOperand(i), Ty);
1106       if (!isa<SCEVCastExpr>(SA->getOperand(i)))
1107         hasTrunc = isa<SCEVTruncateExpr>(S);
1108       Operands.push_back(S);
1109     }
1110     if (!hasTrunc)
1111       return getAddExpr(Operands);
1112     UniqueSCEVs.FindNodeOrInsertPos(ID, IP);  // Mutates IP, returns NULL.
1113   }
1114
1115   // trunc(x1*x2*...*xN) --> trunc(x1)*trunc(x2)*...*trunc(xN) if we can
1116   // eliminate all the truncates, or we replace other casts with truncates.
1117   if (const SCEVMulExpr *SM = dyn_cast<SCEVMulExpr>(Op)) {
1118     SmallVector<const SCEV *, 4> Operands;
1119     bool hasTrunc = false;
1120     for (unsigned i = 0, e = SM->getNumOperands(); i != e && !hasTrunc; ++i) {
1121       const SCEV *S = getTruncateExpr(SM->getOperand(i), Ty);
1122       if (!isa<SCEVCastExpr>(SM->getOperand(i)))
1123         hasTrunc = isa<SCEVTruncateExpr>(S);
1124       Operands.push_back(S);
1125     }
1126     if (!hasTrunc)
1127       return getMulExpr(Operands);
1128     UniqueSCEVs.FindNodeOrInsertPos(ID, IP);  // Mutates IP, returns NULL.
1129   }
1130
1131   // If the input value is a chrec scev, truncate the chrec's operands.
1132   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Op)) {
1133     SmallVector<const SCEV *, 4> Operands;
1134     for (const SCEV *Op : AddRec->operands())
1135       Operands.push_back(getTruncateExpr(Op, Ty));
1136     return getAddRecExpr(Operands, AddRec->getLoop(), SCEV::FlagAnyWrap);
1137   }
1138
1139   // The cast wasn't folded; create an explicit cast node. We can reuse
1140   // the existing insert position since if we get here, we won't have
1141   // made any changes which would invalidate it.
1142   SCEV *S = new (SCEVAllocator) SCEVTruncateExpr(ID.Intern(SCEVAllocator),
1143                                                  Op, Ty);
1144   UniqueSCEVs.InsertNode(S, IP);
1145   return S;
1146 }
1147
1148 // Get the limit of a recurrence such that incrementing by Step cannot cause
1149 // signed overflow as long as the value of the recurrence within the
1150 // loop does not exceed this limit before incrementing.
1151 static const SCEV *getSignedOverflowLimitForStep(const SCEV *Step,
1152                                                  ICmpInst::Predicate *Pred,
1153                                                  ScalarEvolution *SE) {
1154   unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
1155   if (SE->isKnownPositive(Step)) {
1156     *Pred = ICmpInst::ICMP_SLT;
1157     return SE->getConstant(APInt::getSignedMinValue(BitWidth) -
1158                            SE->getSignedRange(Step).getSignedMax());
1159   }
1160   if (SE->isKnownNegative(Step)) {
1161     *Pred = ICmpInst::ICMP_SGT;
1162     return SE->getConstant(APInt::getSignedMaxValue(BitWidth) -
1163                            SE->getSignedRange(Step).getSignedMin());
1164   }
1165   return nullptr;
1166 }
1167
1168 // Get the limit of a recurrence such that incrementing by Step cannot cause
1169 // unsigned overflow as long as the value of the recurrence within the loop does
1170 // not exceed this limit before incrementing.
1171 static const SCEV *getUnsignedOverflowLimitForStep(const SCEV *Step,
1172                                                    ICmpInst::Predicate *Pred,
1173                                                    ScalarEvolution *SE) {
1174   unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
1175   *Pred = ICmpInst::ICMP_ULT;
1176
1177   return SE->getConstant(APInt::getMinValue(BitWidth) -
1178                          SE->getUnsignedRange(Step).getUnsignedMax());
1179 }
1180
1181 namespace {
1182
1183 struct ExtendOpTraitsBase {
1184   typedef const SCEV *(ScalarEvolution::*GetExtendExprTy)(const SCEV *, Type *);
1185 };
1186
1187 // Used to make code generic over signed and unsigned overflow.
1188 template <typename ExtendOp> struct ExtendOpTraits {
1189   // Members present:
1190   //
1191   // static const SCEV::NoWrapFlags WrapType;
1192   //
1193   // static const ExtendOpTraitsBase::GetExtendExprTy GetExtendExpr;
1194   //
1195   // static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1196   //                                           ICmpInst::Predicate *Pred,
1197   //                                           ScalarEvolution *SE);
1198 };
1199
1200 template <>
1201 struct ExtendOpTraits<SCEVSignExtendExpr> : public ExtendOpTraitsBase {
1202   static const SCEV::NoWrapFlags WrapType = SCEV::FlagNSW;
1203
1204   static const GetExtendExprTy GetExtendExpr;
1205
1206   static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1207                                              ICmpInst::Predicate *Pred,
1208                                              ScalarEvolution *SE) {
1209     return getSignedOverflowLimitForStep(Step, Pred, SE);
1210   }
1211 };
1212
1213 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
1214     SCEVSignExtendExpr>::GetExtendExpr = &ScalarEvolution::getSignExtendExpr;
1215
1216 template <>
1217 struct ExtendOpTraits<SCEVZeroExtendExpr> : public ExtendOpTraitsBase {
1218   static const SCEV::NoWrapFlags WrapType = SCEV::FlagNUW;
1219
1220   static const GetExtendExprTy GetExtendExpr;
1221
1222   static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1223                                              ICmpInst::Predicate *Pred,
1224                                              ScalarEvolution *SE) {
1225     return getUnsignedOverflowLimitForStep(Step, Pred, SE);
1226   }
1227 };
1228
1229 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
1230     SCEVZeroExtendExpr>::GetExtendExpr = &ScalarEvolution::getZeroExtendExpr;
1231 }
1232
1233 // The recurrence AR has been shown to have no signed/unsigned wrap or something
1234 // close to it. Typically, if we can prove NSW/NUW for AR, then we can just as
1235 // easily prove NSW/NUW for its preincrement or postincrement sibling. This
1236 // allows normalizing a sign/zero extended AddRec as such: {sext/zext(Step +
1237 // Start),+,Step} => {(Step + sext/zext(Start),+,Step} As a result, the
1238 // expression "Step + sext/zext(PreIncAR)" is congruent with
1239 // "sext/zext(PostIncAR)"
1240 template <typename ExtendOpTy>
1241 static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
1242                                         ScalarEvolution *SE) {
1243   auto WrapType = ExtendOpTraits<ExtendOpTy>::WrapType;
1244   auto GetExtendExpr = ExtendOpTraits<ExtendOpTy>::GetExtendExpr;
1245
1246   const Loop *L = AR->getLoop();
1247   const SCEV *Start = AR->getStart();
1248   const SCEV *Step = AR->getStepRecurrence(*SE);
1249
1250   // Check for a simple looking step prior to loop entry.
1251   const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Start);
1252   if (!SA)
1253     return nullptr;
1254
1255   // Create an AddExpr for "PreStart" after subtracting Step. Full SCEV
1256   // subtraction is expensive. For this purpose, perform a quick and dirty
1257   // difference, by checking for Step in the operand list.
1258   SmallVector<const SCEV *, 4> DiffOps;
1259   for (const SCEV *Op : SA->operands())
1260     if (Op != Step)
1261       DiffOps.push_back(Op);
1262
1263   if (DiffOps.size() == SA->getNumOperands())
1264     return nullptr;
1265
1266   // Try to prove `WrapType` (SCEV::FlagNSW or SCEV::FlagNUW) on `PreStart` +
1267   // `Step`:
1268
1269   // 1. NSW/NUW flags on the step increment.
1270   auto PreStartFlags =
1271     ScalarEvolution::maskFlags(SA->getNoWrapFlags(), SCEV::FlagNUW);
1272   const SCEV *PreStart = SE->getAddExpr(DiffOps, PreStartFlags);
1273   const SCEVAddRecExpr *PreAR = dyn_cast<SCEVAddRecExpr>(
1274       SE->getAddRecExpr(PreStart, Step, L, SCEV::FlagAnyWrap));
1275
1276   // "{S,+,X} is <nsw>/<nuw>" and "the backedge is taken at least once" implies
1277   // "S+X does not sign/unsign-overflow".
1278   //
1279
1280   const SCEV *BECount = SE->getBackedgeTakenCount(L);
1281   if (PreAR && PreAR->getNoWrapFlags(WrapType) &&
1282       !isa<SCEVCouldNotCompute>(BECount) && SE->isKnownPositive(BECount))
1283     return PreStart;
1284
1285   // 2. Direct overflow check on the step operation's expression.
1286   unsigned BitWidth = SE->getTypeSizeInBits(AR->getType());
1287   Type *WideTy = IntegerType::get(SE->getContext(), BitWidth * 2);
1288   const SCEV *OperandExtendedStart =
1289       SE->getAddExpr((SE->*GetExtendExpr)(PreStart, WideTy),
1290                      (SE->*GetExtendExpr)(Step, WideTy));
1291   if ((SE->*GetExtendExpr)(Start, WideTy) == OperandExtendedStart) {
1292     if (PreAR && AR->getNoWrapFlags(WrapType)) {
1293       // If we know `AR` == {`PreStart`+`Step`,+,`Step`} is `WrapType` (FlagNSW
1294       // or FlagNUW) and that `PreStart` + `Step` is `WrapType` too, then
1295       // `PreAR` == {`PreStart`,+,`Step`} is also `WrapType`.  Cache this fact.
1296       const_cast<SCEVAddRecExpr *>(PreAR)->setNoWrapFlags(WrapType);
1297     }
1298     return PreStart;
1299   }
1300
1301   // 3. Loop precondition.
1302   ICmpInst::Predicate Pred;
1303   const SCEV *OverflowLimit =
1304       ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(Step, &Pred, SE);
1305
1306   if (OverflowLimit &&
1307       SE->isLoopEntryGuardedByCond(L, Pred, PreStart, OverflowLimit))
1308     return PreStart;
1309
1310   return nullptr;
1311 }
1312
1313 // Get the normalized zero or sign extended expression for this AddRec's Start.
1314 template <typename ExtendOpTy>
1315 static const SCEV *getExtendAddRecStart(const SCEVAddRecExpr *AR, Type *Ty,
1316                                         ScalarEvolution *SE) {
1317   auto GetExtendExpr = ExtendOpTraits<ExtendOpTy>::GetExtendExpr;
1318
1319   const SCEV *PreStart = getPreStartForExtend<ExtendOpTy>(AR, Ty, SE);
1320   if (!PreStart)
1321     return (SE->*GetExtendExpr)(AR->getStart(), Ty);
1322
1323   return SE->getAddExpr((SE->*GetExtendExpr)(AR->getStepRecurrence(*SE), Ty),
1324                         (SE->*GetExtendExpr)(PreStart, Ty));
1325 }
1326
1327 // Try to prove away overflow by looking at "nearby" add recurrences.  A
1328 // motivating example for this rule: if we know `{0,+,4}` is `ult` `-1` and it
1329 // does not itself wrap then we can conclude that `{1,+,4}` is `nuw`.
1330 //
1331 // Formally:
1332 //
1333 //     {S,+,X} == {S-T,+,X} + T
1334 //  => Ext({S,+,X}) == Ext({S-T,+,X} + T)
1335 //
1336 // If ({S-T,+,X} + T) does not overflow  ... (1)
1337 //
1338 //  RHS == Ext({S-T,+,X} + T) == Ext({S-T,+,X}) + Ext(T)
1339 //
1340 // If {S-T,+,X} does not overflow  ... (2)
1341 //
1342 //  RHS == Ext({S-T,+,X}) + Ext(T) == {Ext(S-T),+,Ext(X)} + Ext(T)
1343 //      == {Ext(S-T)+Ext(T),+,Ext(X)}
1344 //
1345 // If (S-T)+T does not overflow  ... (3)
1346 //
1347 //  RHS == {Ext(S-T)+Ext(T),+,Ext(X)} == {Ext(S-T+T),+,Ext(X)}
1348 //      == {Ext(S),+,Ext(X)} == LHS
1349 //
1350 // Thus, if (1), (2) and (3) are true for some T, then
1351 //   Ext({S,+,X}) == {Ext(S),+,Ext(X)}
1352 //
1353 // (3) is implied by (1) -- "(S-T)+T does not overflow" is simply "({S-T,+,X}+T)
1354 // does not overflow" restricted to the 0th iteration.  Therefore we only need
1355 // to check for (1) and (2).
1356 //
1357 // In the current context, S is `Start`, X is `Step`, Ext is `ExtendOpTy` and T
1358 // is `Delta` (defined below).
1359 //
1360 template <typename ExtendOpTy>
1361 bool ScalarEvolution::proveNoWrapByVaryingStart(const SCEV *Start,
1362                                                 const SCEV *Step,
1363                                                 const Loop *L) {
1364   auto WrapType = ExtendOpTraits<ExtendOpTy>::WrapType;
1365
1366   // We restrict `Start` to a constant to prevent SCEV from spending too much
1367   // time here.  It is correct (but more expensive) to continue with a
1368   // non-constant `Start` and do a general SCEV subtraction to compute
1369   // `PreStart` below.
1370   //
1371   const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start);
1372   if (!StartC)
1373     return false;
1374
1375   APInt StartAI = StartC->getAPInt();
1376
1377   for (unsigned Delta : {-2, -1, 1, 2}) {
1378     const SCEV *PreStart = getConstant(StartAI - Delta);
1379
1380     FoldingSetNodeID ID;
1381     ID.AddInteger(scAddRecExpr);
1382     ID.AddPointer(PreStart);
1383     ID.AddPointer(Step);
1384     ID.AddPointer(L);
1385     void *IP = nullptr;
1386     const auto *PreAR =
1387       static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
1388
1389     // Give up if we don't already have the add recurrence we need because
1390     // actually constructing an add recurrence is relatively expensive.
1391     if (PreAR && PreAR->getNoWrapFlags(WrapType)) {  // proves (2)
1392       const SCEV *DeltaS = getConstant(StartC->getType(), Delta);
1393       ICmpInst::Predicate Pred = ICmpInst::BAD_ICMP_PREDICATE;
1394       const SCEV *Limit = ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(
1395           DeltaS, &Pred, this);
1396       if (Limit && isKnownPredicate(Pred, PreAR, Limit))  // proves (1)
1397         return true;
1398     }
1399   }
1400
1401   return false;
1402 }
1403
1404 const SCEV *ScalarEvolution::getZeroExtendExpr(const SCEV *Op,
1405                                                Type *Ty) {
1406   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1407          "This is not an extending conversion!");
1408   assert(isSCEVable(Ty) &&
1409          "This is not a conversion to a SCEVable type!");
1410   Ty = getEffectiveSCEVType(Ty);
1411
1412   // Fold if the operand is constant.
1413   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1414     return getConstant(
1415       cast<ConstantInt>(ConstantExpr::getZExt(SC->getValue(), Ty)));
1416
1417   // zext(zext(x)) --> zext(x)
1418   if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1419     return getZeroExtendExpr(SZ->getOperand(), Ty);
1420
1421   // Before doing any expensive analysis, check to see if we've already
1422   // computed a SCEV for this Op and Ty.
1423   FoldingSetNodeID ID;
1424   ID.AddInteger(scZeroExtend);
1425   ID.AddPointer(Op);
1426   ID.AddPointer(Ty);
1427   void *IP = nullptr;
1428   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1429
1430   // zext(trunc(x)) --> zext(x) or x or trunc(x)
1431   if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
1432     // It's possible the bits taken off by the truncate were all zero bits. If
1433     // so, we should be able to simplify this further.
1434     const SCEV *X = ST->getOperand();
1435     ConstantRange CR = getUnsignedRange(X);
1436     unsigned TruncBits = getTypeSizeInBits(ST->getType());
1437     unsigned NewBits = getTypeSizeInBits(Ty);
1438     if (CR.truncate(TruncBits).zeroExtend(NewBits).contains(
1439             CR.zextOrTrunc(NewBits)))
1440       return getTruncateOrZeroExtend(X, Ty);
1441   }
1442
1443   // If the input value is a chrec scev, and we can prove that the value
1444   // did not overflow the old, smaller, value, we can zero extend all of the
1445   // operands (often constants).  This allows analysis of something like
1446   // this:  for (unsigned char X = 0; X < 100; ++X) { int Y = X; }
1447   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
1448     if (AR->isAffine()) {
1449       const SCEV *Start = AR->getStart();
1450       const SCEV *Step = AR->getStepRecurrence(*this);
1451       unsigned BitWidth = getTypeSizeInBits(AR->getType());
1452       const Loop *L = AR->getLoop();
1453
1454       if (!AR->hasNoUnsignedWrap()) {
1455         auto NewFlags = proveNoWrapViaConstantRanges(AR);
1456         const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(NewFlags);
1457       }
1458
1459       // If we have special knowledge that this addrec won't overflow,
1460       // we don't need to do any further analysis.
1461       if (AR->hasNoUnsignedWrap())
1462         return getAddRecExpr(
1463             getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1464             getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1465
1466       // Check whether the backedge-taken count is SCEVCouldNotCompute.
1467       // Note that this serves two purposes: It filters out loops that are
1468       // simply not analyzable, and it covers the case where this code is
1469       // being called from within backedge-taken count analysis, such that
1470       // attempting to ask for the backedge-taken count would likely result
1471       // in infinite recursion. In the later case, the analysis code will
1472       // cope with a conservative value, and it will take care to purge
1473       // that value once it has finished.
1474       const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
1475       if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
1476         // Manually compute the final value for AR, checking for
1477         // overflow.
1478
1479         // Check whether the backedge-taken count can be losslessly casted to
1480         // the addrec's type. The count is always unsigned.
1481         const SCEV *CastedMaxBECount =
1482           getTruncateOrZeroExtend(MaxBECount, Start->getType());
1483         const SCEV *RecastedMaxBECount =
1484           getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
1485         if (MaxBECount == RecastedMaxBECount) {
1486           Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1487           // Check whether Start+Step*MaxBECount has no unsigned overflow.
1488           const SCEV *ZMul = getMulExpr(CastedMaxBECount, Step);
1489           const SCEV *ZAdd = getZeroExtendExpr(getAddExpr(Start, ZMul), WideTy);
1490           const SCEV *WideStart = getZeroExtendExpr(Start, WideTy);
1491           const SCEV *WideMaxBECount =
1492             getZeroExtendExpr(CastedMaxBECount, WideTy);
1493           const SCEV *OperandExtendedAdd =
1494             getAddExpr(WideStart,
1495                        getMulExpr(WideMaxBECount,
1496                                   getZeroExtendExpr(Step, WideTy)));
1497           if (ZAdd == OperandExtendedAdd) {
1498             // Cache knowledge of AR NUW, which is propagated to this AddRec.
1499             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1500             // Return the expression with the addrec on the outside.
1501             return getAddRecExpr(
1502                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1503                 getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1504           }
1505           // Similar to above, only this time treat the step value as signed.
1506           // This covers loops that count down.
1507           OperandExtendedAdd =
1508             getAddExpr(WideStart,
1509                        getMulExpr(WideMaxBECount,
1510                                   getSignExtendExpr(Step, WideTy)));
1511           if (ZAdd == OperandExtendedAdd) {
1512             // Cache knowledge of AR NW, which is propagated to this AddRec.
1513             // Negative step causes unsigned wrap, but it still can't self-wrap.
1514             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1515             // Return the expression with the addrec on the outside.
1516             return getAddRecExpr(
1517                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1518                 getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1519           }
1520         }
1521       }
1522
1523       // Normally, in the cases we can prove no-overflow via a
1524       // backedge guarding condition, we can also compute a backedge
1525       // taken count for the loop.  The exceptions are assumptions and
1526       // guards present in the loop -- SCEV is not great at exploiting
1527       // these to compute max backedge taken counts, but can still use
1528       // these to prove lack of overflow.  Use this fact to avoid
1529       // doing extra work that may not pay off.
1530       if (!isa<SCEVCouldNotCompute>(MaxBECount) || HasGuards ||
1531           !AC.assumptions().empty()) {
1532         // If the backedge is guarded by a comparison with the pre-inc
1533         // value the addrec is safe. Also, if the entry is guarded by
1534         // a comparison with the start value and the backedge is
1535         // guarded by a comparison with the post-inc value, the addrec
1536         // is safe.
1537         if (isKnownPositive(Step)) {
1538           const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
1539                                       getUnsignedRange(Step).getUnsignedMax());
1540           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT, AR, N) ||
1541               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
1542                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT,
1543                                            AR->getPostIncExpr(*this), N))) {
1544             // Cache knowledge of AR NUW, which is propagated to this
1545             // AddRec.
1546             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1547             // Return the expression with the addrec on the outside.
1548             return getAddRecExpr(
1549                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1550                 getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1551           }
1552         } else if (isKnownNegative(Step)) {
1553           const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
1554                                       getSignedRange(Step).getSignedMin());
1555           if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT, AR, N) ||
1556               (isLoopEntryGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) &&
1557                isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT,
1558                                            AR->getPostIncExpr(*this), N))) {
1559             // Cache knowledge of AR NW, which is propagated to this
1560             // AddRec.  Negative step causes unsigned wrap, but it
1561             // still can't self-wrap.
1562             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1563             // Return the expression with the addrec on the outside.
1564             return getAddRecExpr(
1565                 getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1566                 getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1567           }
1568         }
1569       }
1570
1571       if (proveNoWrapByVaryingStart<SCEVZeroExtendExpr>(Start, Step, L)) {
1572         const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1573         return getAddRecExpr(
1574             getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1575             getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1576       }
1577     }
1578
1579   if (auto *SA = dyn_cast<SCEVAddExpr>(Op)) {
1580     // zext((A + B + ...)<nuw>) --> (zext(A) + zext(B) + ...)<nuw>
1581     if (SA->hasNoUnsignedWrap()) {
1582       // If the addition does not unsign overflow then we can, by definition,
1583       // commute the zero extension with the addition operation.
1584       SmallVector<const SCEV *, 4> Ops;
1585       for (const auto *Op : SA->operands())
1586         Ops.push_back(getZeroExtendExpr(Op, Ty));
1587       return getAddExpr(Ops, SCEV::FlagNUW);
1588     }
1589   }
1590
1591   // The cast wasn't folded; create an explicit cast node.
1592   // Recompute the insert position, as it may have been invalidated.
1593   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1594   SCEV *S = new (SCEVAllocator) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
1595                                                    Op, Ty);
1596   UniqueSCEVs.InsertNode(S, IP);
1597   return S;
1598 }
1599
1600 const SCEV *ScalarEvolution::getSignExtendExpr(const SCEV *Op,
1601                                                Type *Ty) {
1602   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1603          "This is not an extending conversion!");
1604   assert(isSCEVable(Ty) &&
1605          "This is not a conversion to a SCEVable type!");
1606   Ty = getEffectiveSCEVType(Ty);
1607
1608   // Fold if the operand is constant.
1609   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1610     return getConstant(
1611       cast<ConstantInt>(ConstantExpr::getSExt(SC->getValue(), Ty)));
1612
1613   // sext(sext(x)) --> sext(x)
1614   if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
1615     return getSignExtendExpr(SS->getOperand(), Ty);
1616
1617   // sext(zext(x)) --> zext(x)
1618   if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1619     return getZeroExtendExpr(SZ->getOperand(), Ty);
1620
1621   // Before doing any expensive analysis, check to see if we've already
1622   // computed a SCEV for this Op and Ty.
1623   FoldingSetNodeID ID;
1624   ID.AddInteger(scSignExtend);
1625   ID.AddPointer(Op);
1626   ID.AddPointer(Ty);
1627   void *IP = nullptr;
1628   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1629
1630   // sext(trunc(x)) --> sext(x) or x or trunc(x)
1631   if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
1632     // It's possible the bits taken off by the truncate were all sign bits. If
1633     // so, we should be able to simplify this further.
1634     const SCEV *X = ST->getOperand();
1635     ConstantRange CR = getSignedRange(X);
1636     unsigned TruncBits = getTypeSizeInBits(ST->getType());
1637     unsigned NewBits = getTypeSizeInBits(Ty);
1638     if (CR.truncate(TruncBits).signExtend(NewBits).contains(
1639             CR.sextOrTrunc(NewBits)))
1640       return getTruncateOrSignExtend(X, Ty);
1641   }
1642
1643   // sext(C1 + (C2 * x)) --> C1 + sext(C2 * x) if C1 < C2
1644   if (auto *SA = dyn_cast<SCEVAddExpr>(Op)) {
1645     if (SA->getNumOperands() == 2) {
1646       auto *SC1 = dyn_cast<SCEVConstant>(SA->getOperand(0));
1647       auto *SMul = dyn_cast<SCEVMulExpr>(SA->getOperand(1));
1648       if (SMul && SC1) {
1649         if (auto *SC2 = dyn_cast<SCEVConstant>(SMul->getOperand(0))) {
1650           const APInt &C1 = SC1->getAPInt();
1651           const APInt &C2 = SC2->getAPInt();
1652           if (C1.isStrictlyPositive() && C2.isStrictlyPositive() &&
1653               C2.ugt(C1) && C2.isPowerOf2())
1654             return getAddExpr(getSignExtendExpr(SC1, Ty),
1655                               getSignExtendExpr(SMul, Ty));
1656         }
1657       }
1658     }
1659
1660     // sext((A + B + ...)<nsw>) --> (sext(A) + sext(B) + ...)<nsw>
1661     if (SA->hasNoSignedWrap()) {
1662       // If the addition does not sign overflow then we can, by definition,
1663       // commute the sign extension with the addition operation.
1664       SmallVector<const SCEV *, 4> Ops;
1665       for (const auto *Op : SA->operands())
1666         Ops.push_back(getSignExtendExpr(Op, Ty));
1667       return getAddExpr(Ops, SCEV::FlagNSW);
1668     }
1669   }
1670   // If the input value is a chrec scev, and we can prove that the value
1671   // did not overflow the old, smaller, value, we can sign extend all of the
1672   // operands (often constants).  This allows analysis of something like
1673   // this:  for (signed char X = 0; X < 100; ++X) { int Y = X; }
1674   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
1675     if (AR->isAffine()) {
1676       const SCEV *Start = AR->getStart();
1677       const SCEV *Step = AR->getStepRecurrence(*this);
1678       unsigned BitWidth = getTypeSizeInBits(AR->getType());
1679       const Loop *L = AR->getLoop();
1680
1681       if (!AR->hasNoSignedWrap()) {
1682         auto NewFlags = proveNoWrapViaConstantRanges(AR);
1683         const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(NewFlags);
1684       }
1685
1686       // If we have special knowledge that this addrec won't overflow,
1687       // we don't need to do any further analysis.
1688       if (AR->hasNoSignedWrap())
1689         return getAddRecExpr(
1690             getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1691             getSignExtendExpr(Step, Ty), L, SCEV::FlagNSW);
1692
1693       // Check whether the backedge-taken count is SCEVCouldNotCompute.
1694       // Note that this serves two purposes: It filters out loops that are
1695       // simply not analyzable, and it covers the case where this code is
1696       // being called from within backedge-taken count analysis, such that
1697       // attempting to ask for the backedge-taken count would likely result
1698       // in infinite recursion. In the later case, the analysis code will
1699       // cope with a conservative value, and it will take care to purge
1700       // that value once it has finished.
1701       const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
1702       if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
1703         // Manually compute the final value for AR, checking for
1704         // overflow.
1705
1706         // Check whether the backedge-taken count can be losslessly casted to
1707         // the addrec's type. The count is always unsigned.
1708         const SCEV *CastedMaxBECount =
1709           getTruncateOrZeroExtend(MaxBECount, Start->getType());
1710         const SCEV *RecastedMaxBECount =
1711           getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
1712         if (MaxBECount == RecastedMaxBECount) {
1713           Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1714           // Check whether Start+Step*MaxBECount has no signed overflow.
1715           const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
1716           const SCEV *SAdd = getSignExtendExpr(getAddExpr(Start, SMul), WideTy);
1717           const SCEV *WideStart = getSignExtendExpr(Start, WideTy);
1718           const SCEV *WideMaxBECount =
1719             getZeroExtendExpr(CastedMaxBECount, WideTy);
1720           const SCEV *OperandExtendedAdd =
1721             getAddExpr(WideStart,
1722                        getMulExpr(WideMaxBECount,
1723                                   getSignExtendExpr(Step, WideTy)));
1724           if (SAdd == OperandExtendedAdd) {
1725             // Cache knowledge of AR NSW, which is propagated to this AddRec.
1726             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1727             // Return the expression with the addrec on the outside.
1728             return getAddRecExpr(
1729                 getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1730                 getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1731           }
1732           // Similar to above, only this time treat the step value as unsigned.
1733           // This covers loops that count up with an unsigned step.
1734           OperandExtendedAdd =
1735             getAddExpr(WideStart,
1736                        getMulExpr(WideMaxBECount,
1737                                   getZeroExtendExpr(Step, WideTy)));
1738           if (SAdd == OperandExtendedAdd) {
1739             // If AR wraps around then
1740             //
1741             //    abs(Step) * MaxBECount > unsigned-max(AR->getType())
1742             // => SAdd != OperandExtendedAdd
1743             //
1744             // Thus (AR is not NW => SAdd != OperandExtendedAdd) <=>
1745             // (SAdd == OperandExtendedAdd => AR is NW)
1746
1747             const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1748
1749             // Return the expression with the addrec on the outside.
1750             return getAddRecExpr(
1751                 getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1752                 getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1753           }
1754         }
1755       }
1756
1757       // Normally, in the cases we can prove no-overflow via a
1758       // backedge guarding condition, we can also compute a backedge
1759       // taken count for the loop.  The exceptions are assumptions and
1760       // guards present in the loop -- SCEV is not great at exploiting
1761       // these to compute max backedge taken counts, but can still use
1762       // these to prove lack of overflow.  Use this fact to avoid
1763       // doing extra work that may not pay off.
1764
1765       if (!isa<SCEVCouldNotCompute>(MaxBECount) || HasGuards ||
1766           !AC.assumptions().empty()) {
1767         // If the backedge is guarded by a comparison with the pre-inc
1768         // value the addrec is safe. Also, if the entry is guarded by
1769         // a comparison with the start value and the backedge is
1770         // guarded by a comparison with the post-inc value, the addrec
1771         // is safe.
1772         ICmpInst::Predicate Pred;
1773         const SCEV *OverflowLimit =
1774             getSignedOverflowLimitForStep(Step, &Pred, this);
1775         if (OverflowLimit &&
1776             (isLoopBackedgeGuardedByCond(L, Pred, AR, OverflowLimit) ||
1777              (isLoopEntryGuardedByCond(L, Pred, Start, OverflowLimit) &&
1778               isLoopBackedgeGuardedByCond(L, Pred, AR->getPostIncExpr(*this),
1779                                           OverflowLimit)))) {
1780           // Cache knowledge of AR NSW, then propagate NSW to the wide AddRec.
1781           const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1782           return getAddRecExpr(
1783               getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1784               getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1785         }
1786       }
1787
1788       // If Start and Step are constants, check if we can apply this
1789       // transformation:
1790       // sext{C1,+,C2} --> C1 + sext{0,+,C2} if C1 < C2
1791       auto *SC1 = dyn_cast<SCEVConstant>(Start);
1792       auto *SC2 = dyn_cast<SCEVConstant>(Step);
1793       if (SC1 && SC2) {
1794         const APInt &C1 = SC1->getAPInt();
1795         const APInt &C2 = SC2->getAPInt();
1796         if (C1.isStrictlyPositive() && C2.isStrictlyPositive() && C2.ugt(C1) &&
1797             C2.isPowerOf2()) {
1798           Start = getSignExtendExpr(Start, Ty);
1799           const SCEV *NewAR = getAddRecExpr(getZero(AR->getType()), Step, L,
1800                                             AR->getNoWrapFlags());
1801           return getAddExpr(Start, getSignExtendExpr(NewAR, Ty));
1802         }
1803       }
1804
1805       if (proveNoWrapByVaryingStart<SCEVSignExtendExpr>(Start, Step, L)) {
1806         const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1807         return getAddRecExpr(
1808             getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1809             getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1810       }
1811     }
1812
1813   // If the input value is provably positive and we could not simplify
1814   // away the sext build a zext instead.
1815   if (isKnownNonNegative(Op))
1816     return getZeroExtendExpr(Op, Ty);
1817
1818   // The cast wasn't folded; create an explicit cast node.
1819   // Recompute the insert position, as it may have been invalidated.
1820   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1821   SCEV *S = new (SCEVAllocator) SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
1822                                                    Op, Ty);
1823   UniqueSCEVs.InsertNode(S, IP);
1824   return S;
1825 }
1826
1827 /// getAnyExtendExpr - Return a SCEV for the given operand extended with
1828 /// unspecified bits out to the given type.
1829 ///
1830 const SCEV *ScalarEvolution::getAnyExtendExpr(const SCEV *Op,
1831                                               Type *Ty) {
1832   assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1833          "This is not an extending conversion!");
1834   assert(isSCEVable(Ty) &&
1835          "This is not a conversion to a SCEVable type!");
1836   Ty = getEffectiveSCEVType(Ty);
1837
1838   // Sign-extend negative constants.
1839   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1840     if (SC->getAPInt().isNegative())
1841       return getSignExtendExpr(Op, Ty);
1842
1843   // Peel off a truncate cast.
1844   if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Op)) {
1845     const SCEV *NewOp = T->getOperand();
1846     if (getTypeSizeInBits(NewOp->getType()) < getTypeSizeInBits(Ty))
1847       return getAnyExtendExpr(NewOp, Ty);
1848     return getTruncateOrNoop(NewOp, Ty);
1849   }
1850
1851   // Next try a zext cast. If the cast is folded, use it.
1852   const SCEV *ZExt = getZeroExtendExpr(Op, Ty);
1853   if (!isa<SCEVZeroExtendExpr>(ZExt))
1854     return ZExt;
1855
1856   // Next try a sext cast. If the cast is folded, use it.
1857   const SCEV *SExt = getSignExtendExpr(Op, Ty);
1858   if (!isa<SCEVSignExtendExpr>(SExt))
1859     return SExt;
1860
1861   // Force the cast to be folded into the operands of an addrec.
1862   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op)) {
1863     SmallVector<const SCEV *, 4> Ops;
1864     for (const SCEV *Op : AR->operands())
1865       Ops.push_back(getAnyExtendExpr(Op, Ty));
1866     return getAddRecExpr(Ops, AR->getLoop(), SCEV::FlagNW);
1867   }
1868
1869   // If the expression is obviously signed, use the sext cast value.
1870   if (isa<SCEVSMaxExpr>(Op))
1871     return SExt;
1872
1873   // Absent any other information, use the zext cast value.
1874   return ZExt;
1875 }
1876
1877 /// Process the given Ops list, which is a list of operands to be added under
1878 /// the given scale, update the given map. This is a helper function for
1879 /// getAddRecExpr. As an example of what it does, given a sequence of operands
1880 /// that would form an add expression like this:
1881 ///
1882 ///    m + n + 13 + (A * (o + p + (B * (q + m + 29)))) + r + (-1 * r)
1883 ///
1884 /// where A and B are constants, update the map with these values:
1885 ///
1886 ///    (m, 1+A*B), (n, 1), (o, A), (p, A), (q, A*B), (r, 0)
1887 ///
1888 /// and add 13 + A*B*29 to AccumulatedConstant.
1889 /// This will allow getAddRecExpr to produce this:
1890 ///
1891 ///    13+A*B*29 + n + (m * (1+A*B)) + ((o + p) * A) + (q * A*B)
1892 ///
1893 /// This form often exposes folding opportunities that are hidden in
1894 /// the original operand list.
1895 ///
1896 /// Return true iff it appears that any interesting folding opportunities
1897 /// may be exposed. This helps getAddRecExpr short-circuit extra work in
1898 /// the common case where no interesting opportunities are present, and
1899 /// is also used as a check to avoid infinite recursion.
1900 ///
1901 static bool
1902 CollectAddOperandsWithScales(DenseMap<const SCEV *, APInt> &M,
1903                              SmallVectorImpl<const SCEV *> &NewOps,
1904                              APInt &AccumulatedConstant,
1905                              const SCEV *const *Ops, size_t NumOperands,
1906                              const APInt &Scale,
1907                              ScalarEvolution &SE) {
1908   bool Interesting = false;
1909
1910   // Iterate over the add operands. They are sorted, with constants first.
1911   unsigned i = 0;
1912   while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1913     ++i;
1914     // Pull a buried constant out to the outside.
1915     if (Scale != 1 || AccumulatedConstant != 0 || C->getValue()->isZero())
1916       Interesting = true;
1917     AccumulatedConstant += Scale * C->getAPInt();
1918   }
1919
1920   // Next comes everything else. We're especially interested in multiplies
1921   // here, but they're in the middle, so just visit the rest with one loop.
1922   for (; i != NumOperands; ++i) {
1923     const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[i]);
1924     if (Mul && isa<SCEVConstant>(Mul->getOperand(0))) {
1925       APInt NewScale =
1926           Scale * cast<SCEVConstant>(Mul->getOperand(0))->getAPInt();
1927       if (Mul->getNumOperands() == 2 && isa<SCEVAddExpr>(Mul->getOperand(1))) {
1928         // A multiplication of a constant with another add; recurse.
1929         const SCEVAddExpr *Add = cast<SCEVAddExpr>(Mul->getOperand(1));
1930         Interesting |=
1931           CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
1932                                        Add->op_begin(), Add->getNumOperands(),
1933                                        NewScale, SE);
1934       } else {
1935         // A multiplication of a constant with some other value. Update
1936         // the map.
1937         SmallVector<const SCEV *, 4> MulOps(Mul->op_begin()+1, Mul->op_end());
1938         const SCEV *Key = SE.getMulExpr(MulOps);
1939         auto Pair = M.insert({Key, NewScale});
1940         if (Pair.second) {
1941           NewOps.push_back(Pair.first->first);
1942         } else {
1943           Pair.first->second += NewScale;
1944           // The map already had an entry for this value, which may indicate
1945           // a folding opportunity.
1946           Interesting = true;
1947         }
1948       }
1949     } else {
1950       // An ordinary operand. Update the map.
1951       std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
1952           M.insert({Ops[i], Scale});
1953       if (Pair.second) {
1954         NewOps.push_back(Pair.first->first);
1955       } else {
1956         Pair.first->second += Scale;
1957         // The map already had an entry for this value, which may indicate
1958         // a folding opportunity.
1959         Interesting = true;
1960       }
1961     }
1962   }
1963
1964   return Interesting;
1965 }
1966
1967 // We're trying to construct a SCEV of type `Type' with `Ops' as operands and
1968 // `OldFlags' as can't-wrap behavior.  Infer a more aggressive set of
1969 // can't-overflow flags for the operation if possible.
1970 static SCEV::NoWrapFlags
1971 StrengthenNoWrapFlags(ScalarEvolution *SE, SCEVTypes Type,
1972                       const SmallVectorImpl<const SCEV *> &Ops,
1973                       SCEV::NoWrapFlags Flags) {
1974   using namespace std::placeholders;
1975   typedef OverflowingBinaryOperator OBO;
1976
1977   bool CanAnalyze =
1978       Type == scAddExpr || Type == scAddRecExpr || Type == scMulExpr;
1979   (void)CanAnalyze;
1980   assert(CanAnalyze && "don't call from other places!");
1981
1982   int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
1983   SCEV::NoWrapFlags SignOrUnsignWrap =
1984       ScalarEvolution::maskFlags(Flags, SignOrUnsignMask);
1985
1986   // If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
1987   auto IsKnownNonNegative = [&](const SCEV *S) {
1988     return SE->isKnownNonNegative(S);
1989   };
1990
1991   if (SignOrUnsignWrap == SCEV::FlagNSW && all_of(Ops, IsKnownNonNegative))
1992     Flags =
1993         ScalarEvolution::setFlags(Flags, (SCEV::NoWrapFlags)SignOrUnsignMask);
1994
1995   SignOrUnsignWrap = ScalarEvolution::maskFlags(Flags, SignOrUnsignMask);
1996
1997   if (SignOrUnsignWrap != SignOrUnsignMask && Type == scAddExpr &&
1998       Ops.size() == 2 && isa<SCEVConstant>(Ops[0])) {
1999
2000     // (A + C) --> (A + C)<nsw> if the addition does not sign overflow
2001     // (A + C) --> (A + C)<nuw> if the addition does not unsign overflow
2002
2003     const APInt &C = cast<SCEVConstant>(Ops[0])->getAPInt();
2004     if (!(SignOrUnsignWrap & SCEV::FlagNSW)) {
2005       auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
2006           Instruction::Add, C, OBO::NoSignedWrap);
2007       if (NSWRegion.contains(SE->getSignedRange(Ops[1])))
2008         Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
2009     }
2010     if (!(SignOrUnsignWrap & SCEV::FlagNUW)) {
2011       auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
2012           Instruction::Add, C, OBO::NoUnsignedWrap);
2013       if (NUWRegion.contains(SE->getUnsignedRange(Ops[1])))
2014         Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
2015     }
2016   }
2017
2018   return Flags;
2019 }
2020
2021 /// Get a canonical add expression, or something simpler if possible.
2022 const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
2023                                         SCEV::NoWrapFlags Flags) {
2024   assert(!(Flags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
2025          "only nuw or nsw allowed");
2026   assert(!Ops.empty() && "Cannot get empty add!");
2027   if (Ops.size() == 1) return Ops[0];
2028 #ifndef NDEBUG
2029   Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2030   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2031     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2032            "SCEVAddExpr operand types don't match!");
2033 #endif
2034
2035   // Sort by complexity, this groups all similar expression types together.
2036   GroupByComplexity(Ops, &LI);
2037
2038   Flags = StrengthenNoWrapFlags(this, scAddExpr, Ops, Flags);
2039
2040   // If there are any constants, fold them together.
2041   unsigned Idx = 0;
2042   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2043     ++Idx;
2044     assert(Idx < Ops.size());
2045     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2046       // We found two constants, fold them together!
2047       Ops[0] = getConstant(LHSC->getAPInt() + RHSC->getAPInt());
2048       if (Ops.size() == 2) return Ops[0];
2049       Ops.erase(Ops.begin()+1);  // Erase the folded element
2050       LHSC = cast<SCEVConstant>(Ops[0]);
2051     }
2052
2053     // If we are left with a constant zero being added, strip it off.
2054     if (LHSC->getValue()->isZero()) {
2055       Ops.erase(Ops.begin());
2056       --Idx;
2057     }
2058
2059     if (Ops.size() == 1) return Ops[0];
2060   }
2061
2062   // Okay, check to see if the same value occurs in the operand list more than
2063   // once.  If so, merge them together into an multiply expression.  Since we
2064   // sorted the list, these values are required to be adjacent.
2065   Type *Ty = Ops[0]->getType();
2066   bool FoundMatch = false;
2067   for (unsigned i = 0, e = Ops.size(); i != e-1; ++i)
2068     if (Ops[i] == Ops[i+1]) {      //  X + Y + Y  -->  X + Y*2
2069       // Scan ahead to count how many equal operands there are.
2070       unsigned Count = 2;
2071       while (i+Count != e && Ops[i+Count] == Ops[i])
2072         ++Count;
2073       // Merge the values into a multiply.
2074       const SCEV *Scale = getConstant(Ty, Count);
2075       const SCEV *Mul = getMulExpr(Scale, Ops[i]);
2076       if (Ops.size() == Count)
2077         return Mul;
2078       Ops[i] = Mul;
2079       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+Count);
2080       --i; e -= Count - 1;
2081       FoundMatch = true;
2082     }
2083   if (FoundMatch)
2084     return getAddExpr(Ops, Flags);
2085
2086   // Check for truncates. If all the operands are truncated from the same
2087   // type, see if factoring out the truncate would permit the result to be
2088   // folded. eg., trunc(x) + m*trunc(n) --> trunc(x + trunc(m)*n)
2089   // if the contents of the resulting outer trunc fold to something simple.
2090   for (; Idx < Ops.size() && isa<SCEVTruncateExpr>(Ops[Idx]); ++Idx) {
2091     const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(Ops[Idx]);
2092     Type *DstType = Trunc->getType();
2093     Type *SrcType = Trunc->getOperand()->getType();
2094     SmallVector<const SCEV *, 8> LargeOps;
2095     bool Ok = true;
2096     // Check all the operands to see if they can be represented in the
2097     // source type of the truncate.
2098     for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
2099       if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Ops[i])) {
2100         if (T->getOperand()->getType() != SrcType) {
2101           Ok = false;
2102           break;
2103         }
2104         LargeOps.push_back(T->getOperand());
2105       } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2106         LargeOps.push_back(getAnyExtendExpr(C, SrcType));
2107       } else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Ops[i])) {
2108         SmallVector<const SCEV *, 8> LargeMulOps;
2109         for (unsigned j = 0, f = M->getNumOperands(); j != f && Ok; ++j) {
2110           if (const SCEVTruncateExpr *T =
2111                 dyn_cast<SCEVTruncateExpr>(M->getOperand(j))) {
2112             if (T->getOperand()->getType() != SrcType) {
2113               Ok = false;
2114               break;
2115             }
2116             LargeMulOps.push_back(T->getOperand());
2117           } else if (const auto *C = dyn_cast<SCEVConstant>(M->getOperand(j))) {
2118             LargeMulOps.push_back(getAnyExtendExpr(C, SrcType));
2119           } else {
2120             Ok = false;
2121             break;
2122           }
2123         }
2124         if (Ok)
2125           LargeOps.push_back(getMulExpr(LargeMulOps));
2126       } else {
2127         Ok = false;
2128         break;
2129       }
2130     }
2131     if (Ok) {
2132       // Evaluate the expression in the larger type.
2133       const SCEV *Fold = getAddExpr(LargeOps, Flags);
2134       // If it folds to something simple, use it. Otherwise, don't.
2135       if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
2136         return getTruncateExpr(Fold, DstType);
2137     }
2138   }
2139
2140   // Skip past any other cast SCEVs.
2141   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
2142     ++Idx;
2143
2144   // If there are add operands they would be next.
2145   if (Idx < Ops.size()) {
2146     bool DeletedAdd = false;
2147     while (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[Idx])) {
2148       // If we have an add, expand the add operands onto the end of the operands
2149       // list.
2150       Ops.erase(Ops.begin()+Idx);
2151       Ops.append(Add->op_begin(), Add->op_end());
2152       DeletedAdd = true;
2153     }
2154
2155     // If we deleted at least one add, we added operands to the end of the list,
2156     // and they are not necessarily sorted.  Recurse to resort and resimplify
2157     // any operands we just acquired.
2158     if (DeletedAdd)
2159       return getAddExpr(Ops);
2160   }
2161
2162   // Skip over the add expression until we get to a multiply.
2163   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
2164     ++Idx;
2165
2166   // Check to see if there are any folding opportunities present with
2167   // operands multiplied by constant values.
2168   if (Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx])) {
2169     uint64_t BitWidth = getTypeSizeInBits(Ty);
2170     DenseMap<const SCEV *, APInt> M;
2171     SmallVector<const SCEV *, 8> NewOps;
2172     APInt AccumulatedConstant(BitWidth, 0);
2173     if (CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
2174                                      Ops.data(), Ops.size(),
2175                                      APInt(BitWidth, 1), *this)) {
2176       struct APIntCompare {
2177         bool operator()(const APInt &LHS, const APInt &RHS) const {
2178           return LHS.ult(RHS);
2179         }
2180       };
2181
2182       // Some interesting folding opportunity is present, so its worthwhile to
2183       // re-generate the operands list. Group the operands by constant scale,
2184       // to avoid multiplying by the same constant scale multiple times.
2185       std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare> MulOpLists;
2186       for (const SCEV *NewOp : NewOps)
2187         MulOpLists[M.find(NewOp)->second].push_back(NewOp);
2188       // Re-generate the operands list.
2189       Ops.clear();
2190       if (AccumulatedConstant != 0)
2191         Ops.push_back(getConstant(AccumulatedConstant));
2192       for (auto &MulOp : MulOpLists)
2193         if (MulOp.first != 0)
2194           Ops.push_back(getMulExpr(getConstant(MulOp.first),
2195                                    getAddExpr(MulOp.second)));
2196       if (Ops.empty())
2197         return getZero(Ty);
2198       if (Ops.size() == 1)
2199         return Ops[0];
2200       return getAddExpr(Ops);
2201     }
2202   }
2203
2204   // If we are adding something to a multiply expression, make sure the
2205   // something is not already an operand of the multiply.  If so, merge it into
2206   // the multiply.
2207   for (; Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx]); ++Idx) {
2208     const SCEVMulExpr *Mul = cast<SCEVMulExpr>(Ops[Idx]);
2209     for (unsigned MulOp = 0, e = Mul->getNumOperands(); MulOp != e; ++MulOp) {
2210       const SCEV *MulOpSCEV = Mul->getOperand(MulOp);
2211       if (isa<SCEVConstant>(MulOpSCEV))
2212         continue;
2213       for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
2214         if (MulOpSCEV == Ops[AddOp]) {
2215           // Fold W + X + (X * Y * Z)  -->  W + (X * ((Y*Z)+1))
2216           const SCEV *InnerMul = Mul->getOperand(MulOp == 0);
2217           if (Mul->getNumOperands() != 2) {
2218             // If the multiply has more than two operands, we must get the
2219             // Y*Z term.
2220             SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
2221                                                 Mul->op_begin()+MulOp);
2222             MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
2223             InnerMul = getMulExpr(MulOps);
2224           }
2225           const SCEV *One = getOne(Ty);
2226           const SCEV *AddOne = getAddExpr(One, InnerMul);
2227           const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
2228           if (Ops.size() == 2) return OuterMul;
2229           if (AddOp < Idx) {
2230             Ops.erase(Ops.begin()+AddOp);
2231             Ops.erase(Ops.begin()+Idx-1);
2232           } else {
2233             Ops.erase(Ops.begin()+Idx);
2234             Ops.erase(Ops.begin()+AddOp-1);
2235           }
2236           Ops.push_back(OuterMul);
2237           return getAddExpr(Ops);
2238         }
2239
2240       // Check this multiply against other multiplies being added together.
2241       for (unsigned OtherMulIdx = Idx+1;
2242            OtherMulIdx < Ops.size() && isa<SCEVMulExpr>(Ops[OtherMulIdx]);
2243            ++OtherMulIdx) {
2244         const SCEVMulExpr *OtherMul = cast<SCEVMulExpr>(Ops[OtherMulIdx]);
2245         // If MulOp occurs in OtherMul, we can fold the two multiplies
2246         // together.
2247         for (unsigned OMulOp = 0, e = OtherMul->getNumOperands();
2248              OMulOp != e; ++OMulOp)
2249           if (OtherMul->getOperand(OMulOp) == MulOpSCEV) {
2250             // Fold X + (A*B*C) + (A*D*E) --> X + (A*(B*C+D*E))
2251             const SCEV *InnerMul1 = Mul->getOperand(MulOp == 0);
2252             if (Mul->getNumOperands() != 2) {
2253               SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
2254                                                   Mul->op_begin()+MulOp);
2255               MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
2256               InnerMul1 = getMulExpr(MulOps);
2257             }
2258             const SCEV *InnerMul2 = OtherMul->getOperand(OMulOp == 0);
2259             if (OtherMul->getNumOperands() != 2) {
2260               SmallVector<const SCEV *, 4> MulOps(OtherMul->op_begin(),
2261                                                   OtherMul->op_begin()+OMulOp);
2262               MulOps.append(OtherMul->op_begin()+OMulOp+1, OtherMul->op_end());
2263               InnerMul2 = getMulExpr(MulOps);
2264             }
2265             const SCEV *InnerMulSum = getAddExpr(InnerMul1,InnerMul2);
2266             const SCEV *OuterMul = getMulExpr(MulOpSCEV, InnerMulSum);
2267             if (Ops.size() == 2) return OuterMul;
2268             Ops.erase(Ops.begin()+Idx);
2269             Ops.erase(Ops.begin()+OtherMulIdx-1);
2270             Ops.push_back(OuterMul);
2271             return getAddExpr(Ops);
2272           }
2273       }
2274     }
2275   }
2276
2277   // If there are any add recurrences in the operands list, see if any other
2278   // added values are loop invariant.  If so, we can fold them into the
2279   // recurrence.
2280   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
2281     ++Idx;
2282
2283   // Scan over all recurrences, trying to fold loop invariants into them.
2284   for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
2285     // Scan all of the other operands to this add and add them to the vector if
2286     // they are loop invariant w.r.t. the recurrence.
2287     SmallVector<const SCEV *, 8> LIOps;
2288     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
2289     const Loop *AddRecLoop = AddRec->getLoop();
2290     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2291       if (isLoopInvariant(Ops[i], AddRecLoop)) {
2292         LIOps.push_back(Ops[i]);
2293         Ops.erase(Ops.begin()+i);
2294         --i; --e;
2295       }
2296
2297     // If we found some loop invariants, fold them into the recurrence.
2298     if (!LIOps.empty()) {
2299       //  NLI + LI + {Start,+,Step}  -->  NLI + {LI+Start,+,Step}
2300       LIOps.push_back(AddRec->getStart());
2301
2302       SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
2303                                              AddRec->op_end());
2304       // This follows from the fact that the no-wrap flags on the outer add
2305       // expression are applicable on the 0th iteration, when the add recurrence
2306       // will be equal to its start value.
2307       AddRecOps[0] = getAddExpr(LIOps, Flags);
2308
2309       // Build the new addrec. Propagate the NUW and NSW flags if both the
2310       // outer add and the inner addrec are guaranteed to have no overflow.
2311       // Always propagate NW.
2312       Flags = AddRec->getNoWrapFlags(setFlags(Flags, SCEV::FlagNW));
2313       const SCEV *NewRec = getAddRecExpr(AddRecOps, AddRecLoop, Flags);
2314
2315       // If all of the other operands were loop invariant, we are done.
2316       if (Ops.size() == 1) return NewRec;
2317
2318       // Otherwise, add the folded AddRec by the non-invariant parts.
2319       for (unsigned i = 0;; ++i)
2320         if (Ops[i] == AddRec) {
2321           Ops[i] = NewRec;
2322           break;
2323         }
2324       return getAddExpr(Ops);
2325     }
2326
2327     // Okay, if there weren't any loop invariants to be folded, check to see if
2328     // there are multiple AddRec's with the same loop induction variable being
2329     // added together.  If so, we can fold them.
2330     for (unsigned OtherIdx = Idx+1;
2331          OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2332          ++OtherIdx)
2333       if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
2334         // Other + {A,+,B}<L> + {C,+,D}<L>  -->  Other + {A+C,+,B+D}<L>
2335         SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
2336                                                AddRec->op_end());
2337         for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2338              ++OtherIdx)
2339           if (const auto *OtherAddRec = dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
2340             if (OtherAddRec->getLoop() == AddRecLoop) {
2341               for (unsigned i = 0, e = OtherAddRec->getNumOperands();
2342                    i != e; ++i) {
2343                 if (i >= AddRecOps.size()) {
2344                   AddRecOps.append(OtherAddRec->op_begin()+i,
2345                                    OtherAddRec->op_end());
2346                   break;
2347                 }
2348                 AddRecOps[i] = getAddExpr(AddRecOps[i],
2349                                           OtherAddRec->getOperand(i));
2350               }
2351               Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
2352             }
2353         // Step size has changed, so we cannot guarantee no self-wraparound.
2354         Ops[Idx] = getAddRecExpr(AddRecOps, AddRecLoop, SCEV::FlagAnyWrap);
2355         return getAddExpr(Ops);
2356       }
2357
2358     // Otherwise couldn't fold anything into this recurrence.  Move onto the
2359     // next one.
2360   }
2361
2362   // Okay, it looks like we really DO need an add expr.  Check to see if we
2363   // already have one, otherwise create a new one.
2364   FoldingSetNodeID ID;
2365   ID.AddInteger(scAddExpr);
2366   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2367     ID.AddPointer(Ops[i]);
2368   void *IP = nullptr;
2369   SCEVAddExpr *S =
2370     static_cast<SCEVAddExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2371   if (!S) {
2372     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2373     std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2374     S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
2375                                         O, Ops.size());
2376     UniqueSCEVs.InsertNode(S, IP);
2377   }
2378   S->setNoWrapFlags(Flags);
2379   return S;
2380 }
2381
2382 static uint64_t umul_ov(uint64_t i, uint64_t j, bool &Overflow) {
2383   uint64_t k = i*j;
2384   if (j > 1 && k / j != i) Overflow = true;
2385   return k;
2386 }
2387
2388 /// Compute the result of "n choose k", the binomial coefficient.  If an
2389 /// intermediate computation overflows, Overflow will be set and the return will
2390 /// be garbage. Overflow is not cleared on absence of overflow.
2391 static uint64_t Choose(uint64_t n, uint64_t k, bool &Overflow) {
2392   // We use the multiplicative formula:
2393   //     n(n-1)(n-2)...(n-(k-1)) / k(k-1)(k-2)...1 .
2394   // At each iteration, we take the n-th term of the numeral and divide by the
2395   // (k-n)th term of the denominator.  This division will always produce an
2396   // integral result, and helps reduce the chance of overflow in the
2397   // intermediate computations. However, we can still overflow even when the
2398   // final result would fit.
2399
2400   if (n == 0 || n == k) return 1;
2401   if (k > n) return 0;
2402
2403   if (k > n/2)
2404     k = n-k;
2405
2406   uint64_t r = 1;
2407   for (uint64_t i = 1; i <= k; ++i) {
2408     r = umul_ov(r, n-(i-1), Overflow);
2409     r /= i;
2410   }
2411   return r;
2412 }
2413
2414 /// Determine if any of the operands in this SCEV are a constant or if
2415 /// any of the add or multiply expressions in this SCEV contain a constant.
2416 static bool containsConstantSomewhere(const SCEV *StartExpr) {
2417   SmallVector<const SCEV *, 4> Ops;
2418   Ops.push_back(StartExpr);
2419   while (!Ops.empty()) {
2420     const SCEV *CurrentExpr = Ops.pop_back_val();
2421     if (isa<SCEVConstant>(*CurrentExpr))
2422       return true;
2423
2424     if (isa<SCEVAddExpr>(*CurrentExpr) || isa<SCEVMulExpr>(*CurrentExpr)) {
2425       const auto *CurrentNAry = cast<SCEVNAryExpr>(CurrentExpr);
2426       Ops.append(CurrentNAry->op_begin(), CurrentNAry->op_end());
2427     }
2428   }
2429   return false;
2430 }
2431
2432 /// Get a canonical multiply expression, or something simpler if possible.
2433 const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
2434                                         SCEV::NoWrapFlags Flags) {
2435   assert(Flags == maskFlags(Flags, SCEV::FlagNUW | SCEV::FlagNSW) &&
2436          "only nuw or nsw allowed");
2437   assert(!Ops.empty() && "Cannot get empty mul!");
2438   if (Ops.size() == 1) return Ops[0];
2439 #ifndef NDEBUG
2440   Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2441   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2442     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2443            "SCEVMulExpr operand types don't match!");
2444 #endif
2445
2446   // Sort by complexity, this groups all similar expression types together.
2447   GroupByComplexity(Ops, &LI);
2448
2449   Flags = StrengthenNoWrapFlags(this, scMulExpr, Ops, Flags);
2450
2451   // If there are any constants, fold them together.
2452   unsigned Idx = 0;
2453   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2454
2455     // C1*(C2+V) -> C1*C2 + C1*V
2456     if (Ops.size() == 2)
2457         if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1]))
2458           // If any of Add's ops are Adds or Muls with a constant,
2459           // apply this transformation as well.
2460           if (Add->getNumOperands() == 2)
2461             if (containsConstantSomewhere(Add))
2462               return getAddExpr(getMulExpr(LHSC, Add->getOperand(0)),
2463                                 getMulExpr(LHSC, Add->getOperand(1)));
2464
2465     ++Idx;
2466     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2467       // We found two constants, fold them together!
2468       ConstantInt *Fold =
2469           ConstantInt::get(getContext(), LHSC->getAPInt() * RHSC->getAPInt());
2470       Ops[0] = getConstant(Fold);
2471       Ops.erase(Ops.begin()+1);  // Erase the folded element
2472       if (Ops.size() == 1) return Ops[0];
2473       LHSC = cast<SCEVConstant>(Ops[0]);
2474     }
2475
2476     // If we are left with a constant one being multiplied, strip it off.
2477     if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
2478       Ops.erase(Ops.begin());
2479       --Idx;
2480     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
2481       // If we have a multiply of zero, it will always be zero.
2482       return Ops[0];
2483     } else if (Ops[0]->isAllOnesValue()) {
2484       // If we have a mul by -1 of an add, try distributing the -1 among the
2485       // add operands.
2486       if (Ops.size() == 2) {
2487         if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1])) {
2488           SmallVector<const SCEV *, 4> NewOps;
2489           bool AnyFolded = false;
2490           for (const SCEV *AddOp : Add->operands()) {
2491             const SCEV *Mul = getMulExpr(Ops[0], AddOp);
2492             if (!isa<SCEVMulExpr>(Mul)) AnyFolded = true;
2493             NewOps.push_back(Mul);
2494           }
2495           if (AnyFolded)
2496             return getAddExpr(NewOps);
2497         } else if (const auto *AddRec = dyn_cast<SCEVAddRecExpr>(Ops[1])) {
2498           // Negation preserves a recurrence's no self-wrap property.
2499           SmallVector<const SCEV *, 4> Operands;
2500           for (const SCEV *AddRecOp : AddRec->operands())
2501             Operands.push_back(getMulExpr(Ops[0], AddRecOp));
2502
2503           return getAddRecExpr(Operands, AddRec->getLoop(),
2504                                AddRec->getNoWrapFlags(SCEV::FlagNW));
2505         }
2506       }
2507     }
2508
2509     if (Ops.size() == 1)
2510       return Ops[0];
2511   }
2512
2513   // Skip over the add expression until we get to a multiply.
2514   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
2515     ++Idx;
2516
2517   // If there are mul operands inline them all into this expression.
2518   if (Idx < Ops.size()) {
2519     bool DeletedMul = false;
2520     while (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[Idx])) {
2521       // If we have an mul, expand the mul operands onto the end of the operands
2522       // list.
2523       Ops.erase(Ops.begin()+Idx);
2524       Ops.append(Mul->op_begin(), Mul->op_end());
2525       DeletedMul = true;
2526     }
2527
2528     // If we deleted at least one mul, we added operands to the end of the list,
2529     // and they are not necessarily sorted.  Recurse to resort and resimplify
2530     // any operands we just acquired.
2531     if (DeletedMul)
2532       return getMulExpr(Ops);
2533   }
2534
2535   // If there are any add recurrences in the operands list, see if any other
2536   // added values are loop invariant.  If so, we can fold them into the
2537   // recurrence.
2538   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
2539     ++Idx;
2540
2541   // Scan over all recurrences, trying to fold loop invariants into them.
2542   for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
2543     // Scan all of the other operands to this mul and add them to the vector if
2544     // they are loop invariant w.r.t. the recurrence.
2545     SmallVector<const SCEV *, 8> LIOps;
2546     const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
2547     const Loop *AddRecLoop = AddRec->getLoop();
2548     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2549       if (isLoopInvariant(Ops[i], AddRecLoop)) {
2550         LIOps.push_back(Ops[i]);
2551         Ops.erase(Ops.begin()+i);
2552         --i; --e;
2553       }
2554
2555     // If we found some loop invariants, fold them into the recurrence.
2556     if (!LIOps.empty()) {
2557       //  NLI * LI * {Start,+,Step}  -->  NLI * {LI*Start,+,LI*Step}
2558       SmallVector<const SCEV *, 4> NewOps;
2559       NewOps.reserve(AddRec->getNumOperands());
2560       const SCEV *Scale = getMulExpr(LIOps);
2561       for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
2562         NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i)));
2563
2564       // Build the new addrec. Propagate the NUW and NSW flags if both the
2565       // outer mul and the inner addrec are guaranteed to have no overflow.
2566       //
2567       // No self-wrap cannot be guaranteed after changing the step size, but
2568       // will be inferred if either NUW or NSW is true.
2569       Flags = AddRec->getNoWrapFlags(clearFlags(Flags, SCEV::FlagNW));
2570       const SCEV *NewRec = getAddRecExpr(NewOps, AddRecLoop, Flags);
2571
2572       // If all of the other operands were loop invariant, we are done.
2573       if (Ops.size() == 1) return NewRec;
2574
2575       // Otherwise, multiply the folded AddRec by the non-invariant parts.
2576       for (unsigned i = 0;; ++i)
2577         if (Ops[i] == AddRec) {
2578           Ops[i] = NewRec;
2579           break;
2580         }
2581       return getMulExpr(Ops);
2582     }
2583
2584     // Okay, if there weren't any loop invariants to be folded, check to see if
2585     // there are multiple AddRec's with the same loop induction variable being
2586     // multiplied together.  If so, we can fold them.
2587
2588     // {A1,+,A2,+,...,+,An}<L> * {B1,+,B2,+,...,+,Bn}<L>
2589     // = {x=1 in [ sum y=x..2x [ sum z=max(y-x, y-n)..min(x,n) [
2590     //       choose(x, 2x)*choose(2x-y, x-z)*A_{y-z}*B_z
2591     //   ]]],+,...up to x=2n}.
2592     // Note that the arguments to choose() are always integers with values
2593     // known at compile time, never SCEV objects.
2594     //
2595     // The implementation avoids pointless extra computations when the two
2596     // addrec's are of different length (mathematically, it's equivalent to
2597     // an infinite stream of zeros on the right).
2598     bool OpsModified = false;
2599     for (unsigned OtherIdx = Idx+1;
2600          OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2601          ++OtherIdx) {
2602       const SCEVAddRecExpr *OtherAddRec =
2603         dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]);
2604       if (!OtherAddRec || OtherAddRec->getLoop() != AddRecLoop)
2605         continue;
2606
2607       bool Overflow = false;
2608       Type *Ty = AddRec->getType();
2609       bool LargerThan64Bits = getTypeSizeInBits(Ty) > 64;
2610       SmallVector<const SCEV*, 7> AddRecOps;
2611       for (int x = 0, xe = AddRec->getNumOperands() +
2612              OtherAddRec->getNumOperands() - 1; x != xe && !Overflow; ++x) {
2613         const SCEV *Term = getZero(Ty);
2614         for (int y = x, ye = 2*x+1; y != ye && !Overflow; ++y) {
2615           uint64_t Coeff1 = Choose(x, 2*x - y, Overflow);
2616           for (int z = std::max(y-x, y-(int)AddRec->getNumOperands()+1),
2617                  ze = std::min(x+1, (int)OtherAddRec->getNumOperands());
2618                z < ze && !Overflow; ++z) {
2619             uint64_t Coeff2 = Choose(2*x - y, x-z, Overflow);
2620             uint64_t Coeff;
2621             if (LargerThan64Bits)
2622               Coeff = umul_ov(Coeff1, Coeff2, Overflow);
2623             else
2624               Coeff = Coeff1*Coeff2;
2625             const SCEV *CoeffTerm = getConstant(Ty, Coeff);
2626             const SCEV *Term1 = AddRec->getOperand(y-z);
2627             const SCEV *Term2 = OtherAddRec->getOperand(z);
2628             Term = getAddExpr(Term, getMulExpr(CoeffTerm, Term1,Term2));
2629           }
2630         }
2631         AddRecOps.push_back(Term);
2632       }
2633       if (!Overflow) {
2634         const SCEV *NewAddRec = getAddRecExpr(AddRecOps, AddRec->getLoop(),
2635                                               SCEV::FlagAnyWrap);
2636         if (Ops.size() == 2) return NewAddRec;
2637         Ops[Idx] = NewAddRec;
2638         Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
2639         OpsModified = true;
2640         AddRec = dyn_cast<SCEVAddRecExpr>(NewAddRec);
2641         if (!AddRec)
2642           break;
2643       }
2644     }
2645     if (OpsModified)
2646       return getMulExpr(Ops);
2647
2648     // Otherwise couldn't fold anything into this recurrence.  Move onto the
2649     // next one.
2650   }
2651
2652   // Okay, it looks like we really DO need an mul expr.  Check to see if we
2653   // already have one, otherwise create a new one.
2654   FoldingSetNodeID ID;
2655   ID.AddInteger(scMulExpr);
2656   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2657     ID.AddPointer(Ops[i]);
2658   void *IP = nullptr;
2659   SCEVMulExpr *S =
2660     static_cast<SCEVMulExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2661   if (!S) {
2662     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2663     std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2664     S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
2665                                         O, Ops.size());
2666     UniqueSCEVs.InsertNode(S, IP);
2667   }
2668   S->setNoWrapFlags(Flags);
2669   return S;
2670 }
2671
2672 /// Get a canonical unsigned division expression, or something simpler if
2673 /// possible.
2674 const SCEV *ScalarEvolution::getUDivExpr(const SCEV *LHS,
2675                                          const SCEV *RHS) {
2676   assert(getEffectiveSCEVType(LHS->getType()) ==
2677          getEffectiveSCEVType(RHS->getType()) &&
2678          "SCEVUDivExpr operand types don't match!");
2679
2680   if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
2681     if (RHSC->getValue()->equalsInt(1))
2682       return LHS;                               // X udiv 1 --> x
2683     // If the denominator is zero, the result of the udiv is undefined. Don't
2684     // try to analyze it, because the resolution chosen here may differ from
2685     // the resolution chosen in other parts of the compiler.
2686     if (!RHSC->getValue()->isZero()) {
2687       // Determine if the division can be folded into the operands of
2688       // its operands.
2689       // TODO: Generalize this to non-constants by using known-bits information.
2690       Type *Ty = LHS->getType();
2691       unsigned LZ = RHSC->getAPInt().countLeadingZeros();
2692       unsigned MaxShiftAmt = getTypeSizeInBits(Ty) - LZ - 1;
2693       // For non-power-of-two values, effectively round the value up to the
2694       // nearest power of two.
2695       if (!RHSC->getAPInt().isPowerOf2())
2696         ++MaxShiftAmt;
2697       IntegerType *ExtTy =
2698         IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
2699       if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
2700         if (const SCEVConstant *Step =
2701             dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this))) {
2702           // {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
2703           const APInt &StepInt = Step->getAPInt();
2704           const APInt &DivInt = RHSC->getAPInt();
2705           if (!StepInt.urem(DivInt) &&
2706               getZeroExtendExpr(AR, ExtTy) ==
2707               getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
2708                             getZeroExtendExpr(Step, ExtTy),
2709                             AR->getLoop(), SCEV::FlagAnyWrap)) {
2710             SmallVector<const SCEV *, 4> Operands;
2711             for (const SCEV *Op : AR->operands())
2712               Operands.push_back(getUDivExpr(Op, RHS));
2713             return getAddRecExpr(Operands, AR->getLoop(), SCEV::FlagNW);
2714           }
2715           /// Get a canonical UDivExpr for a recurrence.
2716           /// {X,+,N}/C => {Y,+,N}/C where Y=X-(X%N). Safe when C%N=0.
2717           // We can currently only fold X%N if X is constant.
2718           const SCEVConstant *StartC = dyn_cast<SCEVConstant>(AR->getStart());
2719           if (StartC && !DivInt.urem(StepInt) &&
2720               getZeroExtendExpr(AR, ExtTy) ==
2721               getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
2722                             getZeroExtendExpr(Step, ExtTy),
2723                             AR->getLoop(), SCEV::FlagAnyWrap)) {
2724             const APInt &StartInt = StartC->getAPInt();
2725             const APInt &StartRem = StartInt.urem(StepInt);
2726             if (StartRem != 0)
2727               LHS = getAddRecExpr(getConstant(StartInt - StartRem), Step,
2728                                   AR->getLoop(), SCEV::FlagNW);
2729           }
2730         }
2731       // (A*B)/C --> A*(B/C) if safe and B/C can be folded.
2732       if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
2733         SmallVector<const SCEV *, 4> Operands;
2734         for (const SCEV *Op : M->operands())
2735           Operands.push_back(getZeroExtendExpr(Op, ExtTy));
2736         if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
2737           // Find an operand that's safely divisible.
2738           for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
2739             const SCEV *Op = M->getOperand(i);
2740             const SCEV *Div = getUDivExpr(Op, RHSC);
2741             if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
2742               Operands = SmallVector<const SCEV *, 4>(M->op_begin(),
2743                                                       M->op_end());
2744               Operands[i] = Div;
2745               return getMulExpr(Operands);
2746             }
2747           }
2748       }
2749       // (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
2750       if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(LHS)) {
2751         SmallVector<const SCEV *, 4> Operands;
2752         for (const SCEV *Op : A->operands())
2753           Operands.push_back(getZeroExtendExpr(Op, ExtTy));
2754         if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
2755           Operands.clear();
2756           for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
2757             const SCEV *Op = getUDivExpr(A->getOperand(i), RHS);
2758             if (isa<SCEVUDivExpr>(Op) ||
2759                 getMulExpr(Op, RHS) != A->getOperand(i))
2760               break;
2761             Operands.push_back(Op);
2762           }
2763           if (Operands.size() == A->getNumOperands())
2764             return getAddExpr(Operands);
2765         }
2766       }
2767
2768       // Fold if both operands are constant.
2769       if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
2770         Constant *LHSCV = LHSC->getValue();
2771         Constant *RHSCV = RHSC->getValue();
2772         return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
2773                                                                    RHSCV)));
2774       }
2775     }
2776   }
2777
2778   FoldingSetNodeID ID;
2779   ID.AddInteger(scUDivExpr);
2780   ID.AddPointer(LHS);
2781   ID.AddPointer(RHS);
2782   void *IP = nullptr;
2783   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
2784   SCEV *S = new (SCEVAllocator) SCEVUDivExpr(ID.Intern(SCEVAllocator),
2785                                              LHS, RHS);
2786   UniqueSCEVs.InsertNode(S, IP);
2787   return S;
2788 }
2789
2790 static const APInt gcd(const SCEVConstant *C1, const SCEVConstant *C2) {
2791   APInt A = C1->getAPInt().abs();
2792   APInt B = C2->getAPInt().abs();
2793   uint32_t ABW = A.getBitWidth();
2794   uint32_t BBW = B.getBitWidth();
2795
2796   if (ABW > BBW)
2797     B = B.zext(ABW);
2798   else if (ABW < BBW)
2799     A = A.zext(BBW);
2800
2801   return APIntOps::GreatestCommonDivisor(A, B);
2802 }
2803
2804 /// Get a canonical unsigned division expression, or something simpler if
2805 /// possible. There is no representation for an exact udiv in SCEV IR, but we
2806 /// can attempt to remove factors from the LHS and RHS.  We can't do this when
2807 /// it's not exact because the udiv may be clearing bits.
2808 const SCEV *ScalarEvolution::getUDivExactExpr(const SCEV *LHS,
2809                                               const SCEV *RHS) {
2810   // TODO: we could try to find factors in all sorts of things, but for now we
2811   // just deal with u/exact (multiply, constant). See SCEVDivision towards the
2812   // end of this file for inspiration.
2813
2814   const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(LHS);
2815   if (!Mul)
2816     return getUDivExpr(LHS, RHS);
2817
2818   if (const SCEVConstant *RHSCst = dyn_cast<SCEVConstant>(RHS)) {
2819     // If the mulexpr multiplies by a constant, then that constant must be the
2820     // first element of the mulexpr.
2821     if (const auto *LHSCst = dyn_cast<SCEVConstant>(Mul->getOperand(0))) {
2822       if (LHSCst == RHSCst) {
2823         SmallVector<const SCEV *, 2> Operands;
2824         Operands.append(Mul->op_begin() + 1, Mul->op_end());
2825         return getMulExpr(Operands);
2826       }
2827
2828       // We can't just assume that LHSCst divides RHSCst cleanly, it could be
2829       // that there's a factor provided by one of the other terms. We need to
2830       // check.
2831       APInt Factor = gcd(LHSCst, RHSCst);
2832       if (!Factor.isIntN(1)) {
2833         LHSCst =
2834             cast<SCEVConstant>(getConstant(LHSCst->getAPInt().udiv(Factor)));
2835         RHSCst =
2836             cast<SCEVConstant>(getConstant(RHSCst->getAPInt().udiv(Factor)));
2837         SmallVector<const SCEV *, 2> Operands;
2838         Operands.push_back(LHSCst);
2839         Operands.append(Mul->op_begin() + 1, Mul->op_end());
2840         LHS = getMulExpr(Operands);
2841         RHS = RHSCst;
2842         Mul = dyn_cast<SCEVMulExpr>(LHS);
2843         if (!Mul)
2844           return getUDivExactExpr(LHS, RHS);
2845       }
2846     }
2847   }
2848
2849   for (int i = 0, e = Mul->getNumOperands(); i != e; ++i) {
2850     if (Mul->getOperand(i) == RHS) {
2851       SmallVector<const SCEV *, 2> Operands;
2852       Operands.append(Mul->op_begin(), Mul->op_begin() + i);
2853       Operands.append(Mul->op_begin() + i + 1, Mul->op_end());
2854       return getMulExpr(Operands);
2855     }
2856   }
2857
2858   return getUDivExpr(LHS, RHS);
2859 }
2860
2861 /// Get an add recurrence expression for the specified loop.  Simplify the
2862 /// expression as much as possible.
2863 const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start, const SCEV *Step,
2864                                            const Loop *L,
2865                                            SCEV::NoWrapFlags Flags) {
2866   SmallVector<const SCEV *, 4> Operands;
2867   Operands.push_back(Start);
2868   if (const SCEVAddRecExpr *StepChrec = dyn_cast<SCEVAddRecExpr>(Step))
2869     if (StepChrec->getLoop() == L) {
2870       Operands.append(StepChrec->op_begin(), StepChrec->op_end());
2871       return getAddRecExpr(Operands, L, maskFlags(Flags, SCEV::FlagNW));
2872     }
2873
2874   Operands.push_back(Step);
2875   return getAddRecExpr(Operands, L, Flags);
2876 }
2877
2878 /// Get an add recurrence expression for the specified loop.  Simplify the
2879 /// expression as much as possible.
2880 const SCEV *
2881 ScalarEvolution::getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
2882                                const Loop *L, SCEV::NoWrapFlags Flags) {
2883   if (Operands.size() == 1) return Operands[0];
2884 #ifndef NDEBUG
2885   Type *ETy = getEffectiveSCEVType(Operands[0]->getType());
2886   for (unsigned i = 1, e = Operands.size(); i != e; ++i)
2887     assert(getEffectiveSCEVType(Operands[i]->getType()) == ETy &&
2888            "SCEVAddRecExpr operand types don't match!");
2889   for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2890     assert(isLoopInvariant(Operands[i], L) &&
2891            "SCEVAddRecExpr operand is not loop-invariant!");
2892 #endif
2893
2894   if (Operands.back()->isZero()) {
2895     Operands.pop_back();
2896     return getAddRecExpr(Operands, L, SCEV::FlagAnyWrap); // {X,+,0}  -->  X
2897   }
2898
2899   // It's tempting to want to call getMaxBackedgeTakenCount count here and
2900   // use that information to infer NUW and NSW flags. However, computing a
2901   // BE count requires calling getAddRecExpr, so we may not yet have a
2902   // meaningful BE count at this point (and if we don't, we'd be stuck
2903   // with a SCEVCouldNotCompute as the cached BE count).
2904
2905   Flags = StrengthenNoWrapFlags(this, scAddRecExpr, Operands, Flags);
2906
2907   // Canonicalize nested AddRecs in by nesting them in order of loop depth.
2908   if (const SCEVAddRecExpr *NestedAR = dyn_cast<SCEVAddRecExpr>(Operands[0])) {
2909     const Loop *NestedLoop = NestedAR->getLoop();
2910     if (L->contains(NestedLoop)
2911             ? (L->getLoopDepth() < NestedLoop->getLoopDepth())
2912             : (!NestedLoop->contains(L) &&
2913                DT.dominates(L->getHeader(), NestedLoop->getHeader()))) {
2914       SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
2915                                                   NestedAR->op_end());
2916       Operands[0] = NestedAR->getStart();
2917       // AddRecs require their operands be loop-invariant with respect to their
2918       // loops. Don't perform this transformation if it would break this
2919       // requirement.
2920       bool AllInvariant = all_of(
2921           Operands, [&](const SCEV *Op) { return isLoopInvariant(Op, L); });
2922
2923       if (AllInvariant) {
2924         // Create a recurrence for the outer loop with the same step size.
2925         //
2926         // The outer recurrence keeps its NW flag but only keeps NUW/NSW if the
2927         // inner recurrence has the same property.
2928         SCEV::NoWrapFlags OuterFlags =
2929           maskFlags(Flags, SCEV::FlagNW | NestedAR->getNoWrapFlags());
2930
2931         NestedOperands[0] = getAddRecExpr(Operands, L, OuterFlags);
2932         AllInvariant = all_of(NestedOperands, [&](const SCEV *Op) {
2933           return isLoopInvariant(Op, NestedLoop);
2934         });
2935
2936         if (AllInvariant) {
2937           // Ok, both add recurrences are valid after the transformation.
2938           //
2939           // The inner recurrence keeps its NW flag but only keeps NUW/NSW if
2940           // the outer recurrence has the same property.
2941           SCEV::NoWrapFlags InnerFlags =
2942             maskFlags(NestedAR->getNoWrapFlags(), SCEV::FlagNW | Flags);
2943           return getAddRecExpr(NestedOperands, NestedLoop, InnerFlags);
2944         }
2945       }
2946       // Reset Operands to its original state.
2947       Operands[0] = NestedAR;
2948     }
2949   }
2950
2951   // Okay, it looks like we really DO need an addrec expr.  Check to see if we
2952   // already have one, otherwise create a new one.
2953   FoldingSetNodeID ID;
2954   ID.AddInteger(scAddRecExpr);
2955   for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2956     ID.AddPointer(Operands[i]);
2957   ID.AddPointer(L);
2958   void *IP = nullptr;
2959   SCEVAddRecExpr *S =
2960     static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2961   if (!S) {
2962     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
2963     std::uninitialized_copy(Operands.begin(), Operands.end(), O);
2964     S = new (SCEVAllocator) SCEVAddRecExpr(ID.Intern(SCEVAllocator),
2965                                            O, Operands.size(), L);
2966     UniqueSCEVs.InsertNode(S, IP);
2967   }
2968   S->setNoWrapFlags(Flags);
2969   return S;
2970 }
2971
2972 const SCEV *
2973 ScalarEvolution::getGEPExpr(Type *PointeeType, const SCEV *BaseExpr,
2974                             const SmallVectorImpl<const SCEV *> &IndexExprs,
2975                             bool InBounds) {
2976   // getSCEV(Base)->getType() has the same address space as Base->getType()
2977   // because SCEV::getType() preserves the address space.
2978   Type *IntPtrTy = getEffectiveSCEVType(BaseExpr->getType());
2979   // FIXME(PR23527): Don't blindly transfer the inbounds flag from the GEP
2980   // instruction to its SCEV, because the Instruction may be guarded by control
2981   // flow and the no-overflow bits may not be valid for the expression in any
2982   // context. This can be fixed similarly to how these flags are handled for
2983   // adds.
2984   SCEV::NoWrapFlags Wrap = InBounds ? SCEV::FlagNSW : SCEV::FlagAnyWrap;
2985
2986   const SCEV *TotalOffset = getZero(IntPtrTy);
2987   // The address space is unimportant. The first thing we do on CurTy is getting
2988   // its element type.
2989   Type *CurTy = PointerType::getUnqual(PointeeType);
2990   for (const SCEV *IndexExpr : IndexExprs) {
2991     // Compute the (potentially symbolic) offset in bytes for this index.
2992     if (StructType *STy = dyn_cast<StructType>(CurTy)) {
2993       // For a struct, add the member offset.
2994       ConstantInt *Index = cast<SCEVConstant>(IndexExpr)->getValue();
2995       unsigned FieldNo = Index->getZExtValue();
2996       const SCEV *FieldOffset = getOffsetOfExpr(IntPtrTy, STy, FieldNo);
2997
2998       // Add the field offset to the running total offset.
2999       TotalOffset = getAddExpr(TotalOffset, FieldOffset);
3000
3001       // Update CurTy to the type of the field at Index.
3002       CurTy = STy->getTypeAtIndex(Index);
3003     } else {
3004       // Update CurTy to its element type.
3005       CurTy = cast<SequentialType>(CurTy)->getElementType();
3006       // For an array, add the element offset, explicitly scaled.
3007       const SCEV *ElementSize = getSizeOfExpr(IntPtrTy, CurTy);
3008       // Getelementptr indices are signed.
3009       IndexExpr = getTruncateOrSignExtend(IndexExpr, IntPtrTy);
3010
3011       // Multiply the index by the element size to compute the element offset.
3012       const SCEV *LocalOffset = getMulExpr(IndexExpr, ElementSize, Wrap);
3013
3014       // Add the element offset to the running total offset.
3015       TotalOffset = getAddExpr(TotalOffset, LocalOffset);
3016     }
3017   }
3018
3019   // Add the total offset from all the GEP indices to the base.
3020   return getAddExpr(BaseExpr, TotalOffset, Wrap);
3021 }
3022
3023 const SCEV *ScalarEvolution::getSMaxExpr(const SCEV *LHS,
3024                                          const SCEV *RHS) {
3025   SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
3026   return getSMaxExpr(Ops);
3027 }
3028
3029 const SCEV *
3030 ScalarEvolution::getSMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
3031   assert(!Ops.empty() && "Cannot get empty smax!");
3032   if (Ops.size() == 1) return Ops[0];
3033 #ifndef NDEBUG
3034   Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
3035   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
3036     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
3037            "SCEVSMaxExpr operand types don't match!");
3038 #endif
3039
3040   // Sort by complexity, this groups all similar expression types together.
3041   GroupByComplexity(Ops, &LI);
3042
3043   // If there are any constants, fold them together.
3044   unsigned Idx = 0;
3045   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3046     ++Idx;
3047     assert(Idx < Ops.size());
3048     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3049       // We found two constants, fold them together!
3050       ConstantInt *Fold = ConstantInt::get(
3051           getContext(), APIntOps::smax(LHSC->getAPInt(), RHSC->getAPInt()));
3052       Ops[0] = getConstant(Fold);
3053       Ops.erase(Ops.begin()+1);  // Erase the folded element
3054       if (Ops.size() == 1) return Ops[0];
3055       LHSC = cast<SCEVConstant>(Ops[0]);
3056     }
3057
3058     // If we are left with a constant minimum-int, strip it off.
3059     if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(true)) {
3060       Ops.erase(Ops.begin());
3061       --Idx;
3062     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(true)) {
3063       // If we have an smax with a constant maximum-int, it will always be
3064       // maximum-int.
3065       return Ops[0];
3066     }
3067
3068     if (Ops.size() == 1) return Ops[0];
3069   }
3070
3071   // Find the first SMax
3072   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scSMaxExpr)
3073     ++Idx;
3074
3075   // Check to see if one of the operands is an SMax. If so, expand its operands
3076   // onto our operand list, and recurse to simplify.
3077   if (Idx < Ops.size()) {
3078     bool DeletedSMax = false;
3079     while (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(Ops[Idx])) {
3080       Ops.erase(Ops.begin()+Idx);
3081       Ops.append(SMax->op_begin(), SMax->op_end());
3082       DeletedSMax = true;
3083     }
3084
3085     if (DeletedSMax)
3086       return getSMaxExpr(Ops);
3087   }
3088
3089   // Okay, check to see if the same value occurs in the operand list twice.  If
3090   // so, delete one.  Since we sorted the list, these values are required to
3091   // be adjacent.
3092   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
3093     //  X smax Y smax Y  -->  X smax Y
3094     //  X smax Y         -->  X, if X is always greater than Y
3095     if (Ops[i] == Ops[i+1] ||
3096         isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
3097       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
3098       --i; --e;
3099     } else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
3100       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
3101       --i; --e;
3102     }
3103
3104   if (Ops.size() == 1) return Ops[0];
3105
3106   assert(!Ops.empty() && "Reduced smax down to nothing!");
3107
3108   // Okay, it looks like we really DO need an smax expr.  Check to see if we
3109   // already have one, otherwise create a new one.
3110   FoldingSetNodeID ID;
3111   ID.AddInteger(scSMaxExpr);
3112   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
3113     ID.AddPointer(Ops[i]);
3114   void *IP = nullptr;
3115   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
3116   const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
3117   std::uninitialized_copy(Ops.begin(), Ops.end(), O);
3118   SCEV *S = new (SCEVAllocator) SCEVSMaxExpr(ID.Intern(SCEVAllocator),
3119                                              O, Ops.size());
3120   UniqueSCEVs.InsertNode(S, IP);
3121   return S;
3122 }
3123
3124 const SCEV *ScalarEvolution::getUMaxExpr(const SCEV *LHS,
3125                                          const SCEV *RHS) {
3126   SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
3127   return getUMaxExpr(Ops);
3128 }
3129
3130 const SCEV *
3131 ScalarEvolution::getUMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
3132   assert(!Ops.empty() && "Cannot get empty umax!");
3133   if (Ops.size() == 1) return Ops[0];
3134 #ifndef NDEBUG
3135   Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
3136   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
3137     assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
3138            "SCEVUMaxExpr operand types don't match!");
3139 #endif
3140
3141   // Sort by complexity, this groups all similar expression types together.
3142   GroupByComplexity(Ops, &LI);
3143
3144   // If there are any constants, fold them together.
3145   unsigned Idx = 0;
3146   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3147     ++Idx;
3148     assert(Idx < Ops.size());
3149     while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3150       // We found two constants, fold them together!
3151       ConstantInt *Fold = ConstantInt::get(
3152           getContext(), APIntOps::umax(LHSC->getAPInt(), RHSC->getAPInt()));
3153       Ops[0] = getConstant(Fold);
3154       Ops.erase(Ops.begin()+1);  // Erase the folded element
3155       if (Ops.size() == 1) return Ops[0];
3156       LHSC = cast<SCEVConstant>(Ops[0]);
3157     }
3158
3159     // If we are left with a constant minimum-int, strip it off.
3160     if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(false)) {
3161       Ops.erase(Ops.begin());
3162       --Idx;
3163     } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(false)) {
3164       // If we have an umax with a constant maximum-int, it will always be
3165       // maximum-int.
3166       return Ops[0];
3167     }
3168
3169     if (Ops.size() == 1) return Ops[0];
3170   }
3171
3172   // Find the first UMax
3173   while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scUMaxExpr)
3174     ++Idx;
3175
3176   // Check to see if one of the operands is a UMax. If so, expand its operands
3177   // onto our operand list, and recurse to simplify.
3178   if (Idx < Ops.size()) {
3179     bool DeletedUMax = false;
3180     while (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(Ops[Idx])) {
3181       Ops.erase(Ops.begin()+Idx);
3182       Ops.append(UMax->op_begin(), UMax->op_end());
3183       DeletedUMax = true;
3184     }
3185
3186     if (DeletedUMax)
3187       return getUMaxExpr(Ops);
3188   }
3189
3190   // Okay, check to see if the same value occurs in the operand list twice.  If
3191   // so, delete one.  Since we sorted the list, these values are required to
3192   // be adjacent.
3193   for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
3194     //  X umax Y umax Y  -->  X umax Y
3195     //  X umax Y         -->  X, if X is always greater than Y
3196     if (Ops[i] == Ops[i+1] ||
3197         isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
3198       Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
3199       --i; --e;
3200     } else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
3201       Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
3202       --i; --e;
3203     }
3204
3205   if (Ops.size() == 1) return Ops[0];
3206
3207   assert(!Ops.empty() && "Reduced umax down to nothing!");
3208
3209   // Okay, it looks like we really DO need a umax expr.  Check to see if we
3210   // already have one, otherwise create a new one.
3211   FoldingSetNodeID ID;
3212   ID.AddInteger(scUMaxExpr);
3213   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
3214     ID.AddPointer(Ops[i]);
3215   void *IP = nullptr;
3216   if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
3217   const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
3218   std::uninitialized_copy(Ops.begin(), Ops.end(), O);
3219   SCEV *S = new (SCEVAllocator) SCEVUMaxExpr(ID.Intern(SCEVAllocator),
3220                                              O, Ops.size());
3221   UniqueSCEVs.InsertNode(S, IP);
3222   return S;
3223 }
3224
3225 const SCEV *ScalarEvolution::getSMinExpr(const SCEV *LHS,
3226                                          const SCEV *RHS) {
3227   // ~smax(~x, ~y) == smin(x, y).
3228   return getNotSCEV(getSMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
3229 }
3230
3231 const SCEV *ScalarEvolution::getUMinExpr(const SCEV *LHS,
3232                                          const SCEV *RHS) {
3233   // ~umax(~x, ~y) == umin(x, y)
3234   return getNotSCEV(getUMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
3235 }
3236
3237 const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
3238   // We can bypass creating a target-independent
3239   // constant expression and then folding it back into a ConstantInt.
3240   // This is just a compile-time optimization.
3241   return getConstant(IntTy, getDataLayout().getTypeAllocSize(AllocTy));
3242 }
3243
3244 const SCEV *ScalarEvolution::getOffsetOfExpr(Type *IntTy,
3245                                              StructType *STy,
3246                                              unsigned FieldNo) {
3247   // We can bypass creating a target-independent
3248   // constant expression and then folding it back into a ConstantInt.
3249   // This is just a compile-time optimization.
3250   return getConstant(
3251       IntTy, getDataLayout().getStructLayout(STy)->getElementOffset(FieldNo));
3252 }
3253
3254 const SCEV *ScalarEvolution::getUnknown(Value *V) {
3255   // Don't attempt to do anything other than create a SCEVUnknown object
3256   // here.  createSCEV only calls getUnknown after checking for all other
3257   // interesting possibilities, and any other code that calls getUnknown
3258   // is doing so in order to hide a value from SCEV canonicalization.
3259
3260   FoldingSetNodeID ID;
3261   ID.AddInteger(scUnknown);
3262   ID.AddPointer(V);
3263   void *IP = nullptr;
3264   if (SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) {
3265     assert(cast<SCEVUnknown>(S)->getValue() == V &&
3266            "Stale SCEVUnknown in uniquing map!");
3267     return S;
3268   }
3269   SCEV *S = new (SCEVAllocator) SCEVUnknown(ID.Intern(SCEVAllocator), V, this,
3270                                             FirstUnknown);
3271   FirstUnknown = cast<SCEVUnknown>(S);
3272   UniqueSCEVs.InsertNode(S, IP);
3273   return S;
3274 }
3275
3276 //===----------------------------------------------------------------------===//
3277 //            Basic SCEV Analysis and PHI Idiom Recognition Code
3278 //
3279
3280 /// Test if values of the given type are analyzable within the SCEV
3281 /// framework. This primarily includes integer types, and it can optionally
3282 /// include pointer types if the ScalarEvolution class has access to
3283 /// target-specific information.
3284 bool ScalarEvolution::isSCEVable(Type *Ty) const {
3285   // Integers and pointers are always SCEVable.
3286   return Ty->isIntegerTy() || Ty->isPointerTy();
3287 }
3288
3289 /// Return the size in bits of the specified type, for which isSCEVable must
3290 /// return true.
3291 uint64_t ScalarEvolution::getTypeSizeInBits(Type *Ty) const {
3292   assert(isSCEVable(Ty) && "Type is not SCEVable!");
3293   return getDataLayout().getTypeSizeInBits(Ty);
3294 }
3295
3296 /// Return a type with the same bitwidth as the given type and which represents
3297 /// how SCEV will treat the given type, for which isSCEVable must return
3298 /// true. For pointer types, this is the pointer-sized integer type.
3299 Type *ScalarEvolution::getEffectiveSCEVType(Type *Ty) const {
3300   assert(isSCEVable(Ty) && "Type is not SCEVable!");
3301
3302   if (Ty->isIntegerTy())
3303     return Ty;
3304
3305   // The only other support type is pointer.
3306   assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
3307   return getDataLayout().getIntPtrType(Ty);
3308 }
3309
3310 const SCEV *ScalarEvolution::getCouldNotCompute() {
3311   return CouldNotCompute.get();
3312 }
3313
3314
3315 bool ScalarEvolution::checkValidity(const SCEV *S) const {
3316   // Helper class working with SCEVTraversal to figure out if a SCEV contains
3317   // a SCEVUnknown with null value-pointer. FindInvalidSCEVUnknown::FindOne
3318   // is set iff if find such SCEVUnknown.
3319   //
3320   struct FindInvalidSCEVUnknown {
3321     bool FindOne;
3322     FindInvalidSCEVUnknown() { FindOne = false; }
3323     bool follow(const SCEV *S) {
3324       switch (static_cast<SCEVTypes>(S->getSCEVType())) {
3325       case scConstant:
3326         return false;
3327       case scUnknown:
3328         if (!cast<SCEVUnknown>(S)->getValue())
3329           FindOne = true;
3330         return false;
3331       default:
3332         return true;
3333       }
3334     }
3335     bool isDone() const { return FindOne; }
3336   };
3337
3338   FindInvalidSCEVUnknown F;
3339   SCEVTraversal<FindInvalidSCEVUnknown> ST(F);
3340   ST.visitAll(S);
3341
3342   return !F.FindOne;
3343 }
3344
3345 namespace {
3346 // Helper class working with SCEVTraversal to figure out if a SCEV contains
3347 // a sub SCEV of scAddRecExpr type.  FindInvalidSCEVUnknown::FoundOne is set
3348 // iff if such sub scAddRecExpr type SCEV is found.
3349 struct FindAddRecurrence {
3350   bool FoundOne;
3351   FindAddRecurrence() : FoundOne(false) {}
3352
3353   bool follow(const SCEV *S) {
3354     switch (static_cast<SCEVTypes>(S->getSCEVType())) {
3355     case scAddRecExpr:
3356       FoundOne = true;
3357     case scConstant:
3358     case scUnknown:
3359     case scCouldNotCompute:
3360       return false;
3361     default:
3362       return true;
3363     }
3364   }
3365   bool isDone() const { return FoundOne; }
3366 };
3367 }
3368
3369 bool ScalarEvolution::containsAddRecurrence(const SCEV *S) {
3370   HasRecMapType::iterator I = HasRecMap.find_as(S);
3371   if (I != HasRecMap.end())
3372     return I->second;
3373
3374   FindAddRecurrence F;
3375   SCEVTraversal<FindAddRecurrence> ST(F);
3376   ST.visitAll(S);
3377   HasRecMap.insert({S, F.FoundOne});
3378   return F.FoundOne;
3379 }
3380
3381 /// Return the Value set from S.
3382 SetVector<Value *> *ScalarEvolution::getSCEVValues(const SCEV *S) {
3383   ExprValueMapType::iterator SI = ExprValueMap.find_as(S);
3384   if (SI == ExprValueMap.end())
3385     return nullptr;
3386 #ifndef NDEBUG
3387   if (VerifySCEVMap) {
3388     // Check there is no dangling Value in the set returned.
3389     for (const auto &VE : SI->second)
3390       assert(ValueExprMap.count(VE));
3391   }
3392 #endif
3393   return &SI->second;
3394 }
3395
3396 /// Erase Value from ValueExprMap and ExprValueMap.  If ValueExprMap.erase(V) is
3397 /// not used together with forgetMemoizedResults(S), eraseValueFromMap should be
3398 /// used instead to ensure whenever V->S is removed from ValueExprMap, V is also
3399 /// removed from the set of ExprValueMap[S].
3400 void ScalarEvolution::eraseValueFromMap(Value *V) {
3401   ValueExprMapType::iterator I = ValueExprMap.find_as(V);
3402   if (I != ValueExprMap.end()) {
3403     const SCEV *S = I->second;
3404     SetVector<Value *> *SV = getSCEVValues(S);
3405     // Remove V from the set of ExprValueMap[S]
3406     if (SV)
3407       SV->remove(V);
3408     ValueExprMap.erase(V);
3409   }
3410 }
3411
3412 /// Return an existing SCEV if it exists, otherwise analyze the expression and
3413 /// create a new one.
3414 const SCEV *ScalarEvolution::getSCEV(Value *V) {
3415   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
3416
3417   const SCEV *S = getExistingSCEV(V);
3418   if (S == nullptr) {
3419     S = createSCEV(V);
3420     // During PHI resolution, it is possible to create two SCEVs for the same
3421     // V, so it is needed to double check whether V->S is inserted into
3422     // ValueExprMap before insert S->V into ExprValueMap.
3423     std::pair<ValueExprMapType::iterator, bool> Pair =
3424         ValueExprMap.insert({SCEVCallbackVH(V, this), S});
3425     if (Pair.second)
3426       ExprValueMap[S].insert(V);
3427   }
3428   return S;
3429 }
3430
3431 const SCEV *ScalarEvolution::getExistingSCEV(Value *V) {
3432   assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
3433
3434   ValueExprMapType::iterator I = ValueExprMap.find_as(V);
3435   if (I != ValueExprMap.end()) {
3436     const SCEV *S = I->second;
3437     if (checkValidity(S))
3438       return S;
3439     forgetMemoizedResults(S);
3440     ValueExprMap.erase(I);
3441   }
3442   return nullptr;
3443 }
3444
3445 /// Return a SCEV corresponding to -V = -1*V
3446 ///
3447 const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V,
3448                                              SCEV::NoWrapFlags Flags) {
3449   if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3450     return getConstant(
3451                cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
3452
3453   Type *Ty = V->getType();
3454   Ty = getEffectiveSCEVType(Ty);
3455   return getMulExpr(
3456       V, getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty))), Flags);
3457 }
3458
3459 /// Return a SCEV corresponding to ~V = -1-V
3460 const SCEV *ScalarEvolution::getNotSCEV(const SCEV *V) {
3461   if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3462     return getConstant(
3463                 cast<ConstantInt>(ConstantExpr::getNot(VC->getValue())));
3464
3465   Type *Ty = V->getType();
3466   Ty = getEffectiveSCEVType(Ty);
3467   const SCEV *AllOnes =
3468                    getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty)));
3469   return getMinusSCEV(AllOnes, V);
3470 }
3471
3472 const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
3473                                           SCEV::NoWrapFlags Flags) {
3474   // Fast path: X - X --> 0.
3475   if (LHS == RHS)
3476     return getZero(LHS->getType());
3477
3478   // We represent LHS - RHS as LHS + (-1)*RHS. This transformation
3479   // makes it so that we cannot make much use of NUW.
3480   auto AddFlags = SCEV::FlagAnyWrap;
3481   const bool RHSIsNotMinSigned =
3482       !getSignedRange(RHS).getSignedMin().isMinSignedValue();
3483   if (maskFlags(Flags, SCEV::FlagNSW) == SCEV::FlagNSW) {
3484     // Let M be the minimum representable signed value. Then (-1)*RHS
3485     // signed-wraps if and only if RHS is M. That can happen even for
3486     // a NSW subtraction because e.g. (-1)*M signed-wraps even though
3487     // -1 - M does not. So to transfer NSW from LHS - RHS to LHS +
3488     // (-1)*RHS, we need to prove that RHS != M.
3489     //
3490     // If LHS is non-negative and we know that LHS - RHS does not
3491     // signed-wrap, then RHS cannot be M. So we can rule out signed-wrap
3492     // either by proving that RHS > M or that LHS >= 0.
3493     if (RHSIsNotMinSigned || isKnownNonNegative(LHS)) {
3494       AddFlags = SCEV::FlagNSW;
3495     }
3496   }
3497
3498   // FIXME: Find a correct way to transfer NSW to (-1)*M when LHS -
3499   // RHS is NSW and LHS >= 0.
3500   //
3501   // The difficulty here is that the NSW flag may have been proven
3502   // relative to a loop that is to be found in a recurrence in LHS and
3503   // not in RHS. Applying NSW to (-1)*M may then let the NSW have a
3504   // larger scope than intended.
3505   auto NegFlags = RHSIsNotMinSigned ? SCEV::FlagNSW : SCEV::FlagAnyWrap;
3506
3507   return getAddExpr(LHS, getNegativeSCEV(RHS, NegFlags), AddFlags);
3508 }
3509
3510 const SCEV *
3511 ScalarEvolution::getTruncateOrZeroExtend(const SCEV *V, Type *Ty) {
3512   Type *SrcTy = V->getType();
3513   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3514          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3515          "Cannot truncate or zero extend with non-integer arguments!");
3516   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3517     return V;  // No conversion
3518   if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
3519     return getTruncateExpr(V, Ty);
3520   return getZeroExtendExpr(V, Ty);
3521 }
3522
3523 const SCEV *
3524 ScalarEvolution::getTruncateOrSignExtend(const SCEV *V,
3525                                          Type *Ty) {
3526   Type *SrcTy = V->getType();
3527   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3528          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3529          "Cannot truncate or zero extend with non-integer arguments!");
3530   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3531     return V;  // No conversion
3532   if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
3533     return getTruncateExpr(V, Ty);
3534   return getSignExtendExpr(V, Ty);
3535 }
3536
3537 const SCEV *
3538 ScalarEvolution::getNoopOrZeroExtend(const SCEV *V, Type *Ty) {
3539   Type *SrcTy = V->getType();
3540   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3541          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3542          "Cannot noop or zero extend with non-integer arguments!");
3543   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3544          "getNoopOrZeroExtend cannot truncate!");
3545   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3546     return V;  // No conversion
3547   return getZeroExtendExpr(V, Ty);
3548 }
3549
3550 const SCEV *
3551 ScalarEvolution::getNoopOrSignExtend(const SCEV *V, Type *Ty) {
3552   Type *SrcTy = V->getType();
3553   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3554          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3555          "Cannot noop or sign extend with non-integer arguments!");
3556   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3557          "getNoopOrSignExtend cannot truncate!");
3558   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3559     return V;  // No conversion
3560   return getSignExtendExpr(V, Ty);
3561 }
3562
3563 const SCEV *
3564 ScalarEvolution::getNoopOrAnyExtend(const SCEV *V, Type *Ty) {
3565   Type *SrcTy = V->getType();
3566   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3567          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3568          "Cannot noop or any extend with non-integer arguments!");
3569   assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3570          "getNoopOrAnyExtend cannot truncate!");
3571   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3572     return V;  // No conversion
3573   return getAnyExtendExpr(V, Ty);
3574 }
3575
3576 const SCEV *
3577 ScalarEvolution::getTruncateOrNoop(const SCEV *V, Type *Ty) {
3578   Type *SrcTy = V->getType();
3579   assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3580          (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3581          "Cannot truncate or noop with non-integer arguments!");
3582   assert(getTypeSizeInBits(SrcTy) >= getTypeSizeInBits(Ty) &&
3583          "getTruncateOrNoop cannot extend!");
3584   if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3585     return V;  // No conversion
3586   return getTruncateExpr(V, Ty);
3587 }
3588
3589 const SCEV *ScalarEvolution::getUMaxFromMismatchedTypes(const SCEV *LHS,
3590                                                         const SCEV *RHS) {
3591   const SCEV *PromotedLHS = LHS;
3592   const SCEV *PromotedRHS = RHS;
3593
3594   if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
3595     PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
3596   else
3597     PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
3598
3599   return getUMaxExpr(PromotedLHS, PromotedRHS);
3600 }
3601
3602 const SCEV *ScalarEvolution::getUMinFromMismatchedTypes(const SCEV *LHS,
3603                                                         const SCEV *RHS) {
3604   const SCEV *PromotedLHS = LHS;
3605   const SCEV *PromotedRHS = RHS;
3606
3607   if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
3608     PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
3609   else
3610     PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
3611
3612   return getUMinExpr(PromotedLHS, PromotedRHS);
3613 }
3614
3615 const SCEV *ScalarEvolution::getPointerBase(const SCEV *V) {
3616   // A pointer operand may evaluate to a nonpointer expression, such as null.
3617   if (!V->getType()->isPointerTy())
3618     return V;
3619
3620   if (const SCEVCastExpr *Cast = dyn_cast<SCEVCastExpr>(V)) {
3621     return getPointerBase(Cast->getOperand());
3622   } else if (const SCEVNAryExpr *NAry = dyn_cast<SCEVNAryExpr>(V)) {
3623     const SCEV *PtrOp = nullptr;
3624     for (const SCEV *NAryOp : NAry->operands()) {
3625       if (NAryOp->getType()->isPointerTy()) {
3626         // Cannot find the base of an expression with multiple pointer operands.
3627         if (PtrOp)
3628           return V;
3629         PtrOp = NAryOp;
3630       }
3631     }
3632     if (!PtrOp)
3633       return V;
3634     return getPointerBase(PtrOp);
3635   }
3636   return V;
3637 }
3638
3639 /// Push users of the given Instruction onto the given Worklist.
3640 static void
3641 PushDefUseChildren(Instruction *I,
3642                    SmallVectorImpl<Instruction *> &Worklist) {
3643   // Push the def-use children onto the Worklist stack.
3644   for (User *U : I->users())
3645     Worklist.push_back(cast<Instruction>(U));
3646 }
3647
3648 void ScalarEvolution::forgetSymbolicName(Instruction *PN, const SCEV *SymName) {
3649   SmallVector<Instruction *, 16> Worklist;
3650   PushDefUseChildren(PN, Worklist);
3651
3652   SmallPtrSet<Instruction *, 8> Visited;
3653   Visited.insert(PN);
3654   while (!Worklist.empty()) {
3655     Instruction *I = Worklist.pop_back_val();
3656     if (!Visited.insert(I).second)
3657       continue;
3658
3659     auto It = ValueExprMap.find_as(static_cast<Value *>(I));
3660     if (It != ValueExprMap.end()) {
3661       const SCEV *Old = It->second;
3662
3663       // Short-circuit the def-use traversal if the symbolic name
3664       // ceases to appear in expressions.
3665       if (Old != SymName && !hasOperand(Old, SymName))
3666         continue;
3667
3668       // SCEVUnknown for a PHI either means that it has an unrecognized
3669       // structure, it's a PHI that's in the progress of being computed
3670       // by createNodeForPHI, or it's a single-value PHI. In the first case,
3671       // additional loop trip count information isn't going to change anything.
3672       // In the second case, createNodeForPHI will perform the necessary
3673       // updates on its own when it gets to that point. In the third, we do
3674       // want to forget the SCEVUnknown.
3675       if (!isa<PHINode>(I) ||
3676           !isa<SCEVUnknown>(Old) ||
3677           (I != PN && Old == SymName)) {
3678         forgetMemoizedResults(Old);
3679         ValueExprMap.erase(It);
3680       }
3681     }
3682
3683     PushDefUseChildren(I, Worklist);
3684   }
3685 }
3686
3687 namespace {
3688 class SCEVInitRewriter : public SCEVRewriteVisitor<SCEVInitRewriter> {
3689 public:
3690   static const SCEV *rewrite(const SCEV *S, const Loop *L,
3691                              ScalarEvolution &SE) {
3692     SCEVInitRewriter Rewriter(L, SE);
3693     const SCEV *Result = Rewriter.visit(S);
3694     return Rewriter.isValid() ? Result : SE.getCouldNotCompute();
3695   }
3696
3697   SCEVInitRewriter(const Loop *L, ScalarEvolution &SE)
3698       : SCEVRewriteVisitor(SE), L(L), Valid(true) {}
3699
3700   const SCEV *visitUnknown(const SCEVUnknown *Expr) {
3701     if (!(SE.getLoopDisposition(Expr, L) == ScalarEvolution::LoopInvariant))
3702       Valid = false;
3703     return Expr;
3704   }
3705
3706   const SCEV *visitAddRecExpr(const SCEVAddRecExpr *Expr) {
3707     // Only allow AddRecExprs for this loop.
3708     if (Expr->getLoop() == L)
3709       return Expr->getStart();
3710     Valid = false;
3711     return Expr;
3712   }
3713
3714   bool isValid() { return Valid; }
3715
3716 private:
3717   const Loop *L;
3718   bool Valid;
3719 };
3720
3721 class SCEVShiftRewriter : public SCEVRewriteVisitor<SCEVShiftRewriter> {
3722 public:
3723   static const SCEV *rewrite(const SCEV *S, const Loop *L,
3724                              ScalarEvolution &SE) {
3725     SCEVShiftRewriter Rewriter(L, SE);
3726     const SCEV *Result = Rewriter.visit(S);
3727     return Rewriter.isValid() ? Result : SE.getCouldNotCompute();
3728   }
3729
3730   SCEVShiftRewriter(const Loop *L, ScalarEvolution &SE)
3731       : SCEVRewriteVisitor(SE), L(L), Valid(true) {}
3732
3733   const SCEV *visitUnknown(const SCEVUnknown *Expr) {
3734     // Only allow AddRecExprs for this loop.
3735     if (!(SE.getLoopDisposition(Expr, L) == ScalarEvolution::LoopInvariant))
3736       Valid = false;
3737     return Expr;
3738   }
3739
3740   const SCEV *visitAddRecExpr(const SCEVAddRecExpr *Expr) {
3741     if (Expr->getLoop() == L && Expr->isAffine())
3742       return SE.getMinusSCEV(Expr, Expr->getStepRecurrence(SE));
3743     Valid = false;
3744     return Expr;
3745   }
3746   bool isValid() { return Valid; }
3747
3748 private:
3749   const Loop *L;
3750   bool Valid;
3751 };
3752 } // end anonymous namespace
3753
3754 SCEV::NoWrapFlags
3755 ScalarEvolution::proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR) {
3756   if (!AR->isAffine())
3757     return SCEV::FlagAnyWrap;
3758
3759   typedef OverflowingBinaryOperator OBO;
3760   SCEV::NoWrapFlags Result = SCEV::FlagAnyWrap;
3761
3762   if (!AR->hasNoSignedWrap()) {
3763     ConstantRange AddRecRange = getSignedRange(AR);
3764     ConstantRange IncRange = getSignedRange(AR->getStepRecurrence(*this));
3765
3766     auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
3767         Instruction::Add, IncRange, OBO::NoSignedWrap);
3768     if (NSWRegion.contains(AddRecRange))
3769       Result = ScalarEvolution::setFlags(Result, SCEV::FlagNSW);
3770   }
3771
3772   if (!AR->hasNoUnsignedWrap()) {
3773     ConstantRange AddRecRange = getUnsignedRange(AR);
3774     ConstantRange IncRange = getUnsignedRange(AR->getStepRecurrence(*this));
3775
3776     auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
3777         Instruction::Add, IncRange, OBO::NoUnsignedWrap);
3778     if (NUWRegion.contains(AddRecRange))
3779       Result = ScalarEvolution::setFlags(Result, SCEV::FlagNUW);
3780   }
3781
3782   return Result;
3783 }
3784
3785 namespace {
3786 /// Represents an abstract binary operation.  This may exist as a
3787 /// normal instruction or constant expression, or may have been
3788 /// derived from an expression tree.
3789 struct BinaryOp {
3790   unsigned Opcode;
3791   Value *LHS;
3792   Value *RHS;
3793   bool IsNSW;
3794   bool IsNUW;
3795
3796   /// Op is set if this BinaryOp corresponds to a concrete LLVM instruction or
3797   /// constant expression.
3798   Operator *Op;
3799
3800   explicit BinaryOp(Operator *Op)
3801       : Opcode(Op->getOpcode()), LHS(Op->getOperand(0)), RHS(Op->getOperand(1)),
3802         IsNSW(false), IsNUW(false), Op(Op) {
3803     if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(Op)) {
3804       IsNSW = OBO->hasNoSignedWrap();
3805       IsNUW = OBO->hasNoUnsignedWrap();
3806     }
3807   }
3808
3809   explicit BinaryOp(unsigned Opcode, Value *LHS, Value *RHS, bool IsNSW = false,
3810                     bool IsNUW = false)
3811       : Opcode(Opcode), LHS(LHS), RHS(RHS), IsNSW(IsNSW), IsNUW(IsNUW),
3812         Op(nullptr) {}
3813 };
3814 }
3815
3816
3817 /// Try to map \p V into a BinaryOp, and return \c None on failure.
3818 static Optional<BinaryOp> MatchBinaryOp(Value *V, DominatorTree &DT) {
3819   auto *Op = dyn_cast<Operator>(V);
3820   if (!Op)
3821     return None;
3822
3823   // Implementation detail: all the cleverness here should happen without
3824   // creating new SCEV expressions -- our caller knowns tricks to avoid creating
3825   // SCEV expressions when possible, and we should not break that.
3826
3827   switch (Op->getOpcode()) {
3828   case Instruction::Add:
3829   case Instruction::Sub:
3830   case Instruction::Mul:
3831   case Instruction::UDiv:
3832   case Instruction::And:
3833   case Instruction::Or:
3834   case Instruction::AShr:
3835   case Instruction::Shl:
3836     return BinaryOp(Op);
3837
3838   case Instruction::Xor:
3839     if (auto *RHSC = dyn_cast<ConstantInt>(Op->getOperand(1)))
3840       // If the RHS of the xor is a signbit, then this is just an add.
3841       // Instcombine turns add of signbit into xor as a strength reduction step.
3842       if (RHSC->getValue().isSignBit())
3843         return BinaryOp(Instruction::Add, Op->getOperand(0), Op->getOperand(1));
3844     return BinaryOp(Op);
3845
3846   case Instruction::LShr:
3847     // Turn logical shift right of a constant into a unsigned divide.
3848     if (ConstantInt *SA = dyn_cast<ConstantInt>(Op->getOperand(1))) {
3849       uint32_t BitWidth = cast<IntegerType>(Op->getType())->getBitWidth();
3850
3851       // If the shift count is not less than the bitwidth, the result of
3852       // the shift is undefined. Don't try to analyze it, because the
3853       // resolution chosen here may differ from the resolution chosen in
3854       // other parts of the compiler.
3855       if (SA->getValue().ult(BitWidth)) {
3856         Constant *X =
3857             ConstantInt::get(SA->getContext(),
3858                              APInt::getOneBitSet(BitWidth, SA->getZExtValue()));
3859         return BinaryOp(Instruction::UDiv, Op->getOperand(0), X);
3860       }
3861     }
3862     return BinaryOp(Op);
3863
3864   case Instruction::ExtractValue: {
3865     auto *EVI = cast<ExtractValueInst>(Op);
3866     if (EVI->getNumIndices() != 1 || EVI->getIndices()[0] != 0)
3867       break;
3868
3869     auto *CI = dyn_cast<CallInst>(EVI->getAggregateOperand());
3870     if (!CI)
3871       break;
3872
3873     if (auto *F = CI->getCalledFunction())
3874       switch (F->getIntrinsicID()) {
3875       case Intrinsic::sadd_with_overflow:
3876       case Intrinsic::uadd_with_overflow: {
3877         if (!isOverflowIntrinsicNoWrap(cast<IntrinsicInst>(CI), DT))
3878           return BinaryOp(Instruction::Add, CI->getArgOperand(0),
3879                           CI->getArgOperand(1));
3880
3881         // Now that we know that all uses of the arithmetic-result component of
3882         // CI are guarded by the overflow check, we can go ahead and pretend
3883         // that the arithmetic is non-overflowing.
3884         if (F->getIntrinsicID() == Intrinsic::sadd_with_overflow)
3885           return BinaryOp(Instruction::Add, CI->getArgOperand(0),
3886                           CI->getArgOperand(1), /* IsNSW = */ true,
3887                           /* IsNUW = */ false);
3888         else
3889           return BinaryOp(Instruction::Add, CI->getArgOperand(0),
3890                           CI->getArgOperand(1), /* IsNSW = */ false,
3891                           /* IsNUW*/ true);
3892       }
3893
3894       case Intrinsic::ssub_with_overflow:
3895       case Intrinsic::usub_with_overflow:
3896         return BinaryOp(Instruction::Sub, CI->getArgOperand(0),
3897                         CI->getArgOperand(1));
3898
3899       case Intrinsic::smul_with_overflow:
3900       case Intrinsic::umul_with_overflow:
3901         return BinaryOp(Instruction::Mul, CI->getArgOperand(0),
3902                         CI->getArgOperand(1));
3903       default:
3904         break;
3905       }
3906   }
3907
3908   default:
3909     break;
3910   }
3911
3912   return None;
3913 }
3914
3915 const SCEV *ScalarEvolution::createAddRecFromPHI(PHINode *PN) {
3916   const Loop *L = LI.getLoopFor(PN->getParent());
3917   if (!L || L->getHeader() != PN->getParent())
3918     return nullptr;
3919
3920   // The loop may have multiple entrances or multiple exits; we can analyze
3921   // this phi as an addrec if it has a unique entry value and a unique
3922   // backedge value.
3923   Value *BEValueV = nullptr, *StartValueV = nullptr;
3924   for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
3925     Value *V = PN->getIncomingValue(i);
3926     if (L->contains(PN->getIncomingBlock(i))) {
3927       if (!BEValueV) {
3928         BEValueV = V;
3929       } else if (BEValueV != V) {
3930         BEValueV = nullptr;
3931         break;
3932       }
3933     } else if (!StartValueV) {
3934       StartValueV = V;
3935     } else if (StartValueV != V) {
3936       StartValueV = nullptr;
3937       break;
3938     }
3939   }
3940   if (BEValueV && StartValueV) {
3941     // While we are analyzing this PHI node, handle its value symbolically.
3942     const SCEV *SymbolicName = getUnknown(PN);
3943     assert(ValueExprMap.find_as(PN) == ValueExprMap.end() &&
3944            "PHI node already processed?");
3945     ValueExprMap.insert({SCEVCallbackVH(PN, this), SymbolicName});
3946
3947     // Using this symbolic name for the PHI, analyze the value coming around
3948     // the back-edge.
3949     const SCEV *BEValue = getSCEV(BEValueV);
3950
3951     // NOTE: If BEValue is loop invariant, we know that the PHI node just
3952     // has a special value for the first iteration of the loop.
3953
3954     // If the value coming around the backedge is an add with the symbolic
3955     // value we just inserted, then we found a simple induction variable!
3956     if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(BEValue)) {
3957       // If there is a single occurrence of the symbolic value, replace it
3958       // with a recurrence.
3959       unsigned FoundIndex = Add->getNumOperands();
3960       for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
3961         if (Add->getOperand(i) == SymbolicName)
3962           if (FoundIndex == e) {
3963             FoundIndex = i;
3964             break;
3965           }
3966
3967       if (FoundIndex != Add->getNumOperands()) {
3968         // Create an add with everything but the specified operand.
3969         SmallVector<const SCEV *, 8> Ops;
3970         for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
3971           if (i != FoundIndex)
3972             Ops.push_back(Add->getOperand(i));
3973         const SCEV *Accum = getAddExpr(Ops);
3974
3975         // This is not a valid addrec if the step amount is varying each
3976         // loop iteration, but is not itself an addrec in this loop.
3977         if (isLoopInvariant(Accum, L) ||
3978             (isa<SCEVAddRecExpr>(Accum) &&
3979              cast<SCEVAddRecExpr>(Accum)->getLoop() == L)) {
3980           SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
3981
3982           if (auto BO = MatchBinaryOp(BEValueV, DT)) {
3983             if (BO->Opcode == Instruction::Add && BO->LHS == PN) {
3984               if (BO->IsNUW)
3985                 Flags = setFlags(Flags, SCEV::FlagNUW);
3986               if (BO->IsNSW)
3987                 Flags = setFlags(Flags, SCEV::FlagNSW);
3988             }
3989           } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(BEValueV)) {
3990             // If the increment is an inbounds GEP, then we know the address
3991             // space cannot be wrapped around. We cannot make any guarantee
3992             // about signed or unsigned overflow because pointers are
3993             // unsigned but we may have a negative index from the base
3994             // pointer. We can guarantee that no unsigned wrap occurs if the
3995             // indices form a positive value.
3996             if (GEP->isInBounds() && GEP->getOperand(0) == PN) {
3997               Flags = setFlags(Flags, SCEV::FlagNW);
3998
3999               const SCEV *Ptr = getSCEV(GEP->getPointerOperand());
4000               if (isKnownPositive(getMinusSCEV(getSCEV(GEP), Ptr)))
4001                 Flags = setFlags(Flags, SCEV::FlagNUW);
4002             }
4003
4004             // We cannot transfer nuw and nsw flags from subtraction
4005             // operations -- sub nuw X, Y is not the same as add nuw X, -Y
4006             // for instance.
4007           }
4008
4009           const SCEV *StartVal = getSCEV(StartValueV);
4010           const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, Flags);
4011
4012           // Okay, for the entire analysis of this edge we assumed the PHI
4013           // to be symbolic.  We now need to go back and purge all of the
4014           // entries for the scalars that use the symbolic expression.
4015           forgetSymbolicName(PN, SymbolicName);
4016           ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
4017
4018           // We can add Flags to the post-inc expression only if we
4019           // know that it us *undefined behavior* for BEValueV to
4020           // overflow.
4021           if (auto *BEInst = dyn_cast<Instruction>(BEValueV))
4022             if (isLoopInvariant(Accum, L) && isAddRecNeverPoison(BEInst, L))
4023               (void)getAddRecExpr(getAddExpr(StartVal, Accum), Accum, L, Flags);
4024
4025           return PHISCEV;
4026         }
4027       }
4028     } else {
4029       // Otherwise, this could be a loop like this:
4030       //     i = 0;  for (j = 1; ..; ++j) { ....  i = j; }
4031       // In this case, j = {1,+,1}  and BEValue is j.
4032       // Because the other in-value of i (0) fits the evolution of BEValue
4033       // i really is an addrec evolution.
4034       //
4035       // We can generalize this saying that i is the shifted value of BEValue
4036       // by one iteration:
4037       //   PHI(f(0), f({1,+,1})) --> f({0,+,1})
4038       const SCEV *Shifted = SCEVShiftRewriter::rewrite(BEValue, L, *this);
4039       const SCEV *Start = SCEVInitRewriter::rewrite(Shifted, L, *this);
4040       if (Shifted != getCouldNotCompute() &&
4041           Start != getCouldNotCompute()) {
4042         const SCEV *StartVal = getSCEV(StartValueV);
4043         if (Start == StartVal) {
4044           // Okay, for the entire analysis of this edge we assumed the PHI
4045           // to be symbolic.  We now need to go back and purge all of the
4046           // entries for the scalars that use the symbolic expression.
4047           forgetSymbolicName(PN, SymbolicName);
4048           ValueExprMap[SCEVCallbackVH(PN, this)] = Shifted;
4049           return Shifted;
4050         }
4051       }
4052     }
4053
4054     // Remove the temporary PHI node SCEV that has been inserted while intending
4055     // to create an AddRecExpr for this PHI node. We can not keep this temporary
4056     // as it will prevent later (possibly simpler) SCEV expressions to be added
4057     // to the ValueExprMap.
4058     ValueExprMap.erase(PN);
4059   }
4060
4061   return nullptr;
4062 }
4063
4064 // Checks if the SCEV S is available at BB.  S is considered available at BB
4065 // if S can be materialized at BB without introducing a fault.
4066 static bool IsAvailableOnEntry(const Loop *L, DominatorTree &DT, const SCEV *S,
4067                                BasicBlock *BB) {
4068   struct CheckAvailable {
4069     bool TraversalDone = false;
4070     bool Available = true;
4071
4072     const Loop *L = nullptr;  // The loop BB is in (can be nullptr)
4073     BasicBlock *BB = nullptr;
4074     DominatorTree &DT;
4075
4076     CheckAvailable(const Loop *L, BasicBlock *BB, DominatorTree &DT)
4077       : L(L), BB(BB), DT(DT) {}
4078
4079     bool setUnavailable() {
4080       TraversalDone = true;
4081       Available = false;
4082       return false;
4083     }
4084
4085     bool follow(const SCEV *S) {
4086       switch (S->getSCEVType()) {
4087       case scConstant: case scTruncate: case scZeroExtend: case scSignExtend:
4088       case scAddExpr: case scMulExpr: case scUMaxExpr: case scSMaxExpr:
4089         // These expressions are available if their operand(s) is/are.
4090         return true;
4091
4092       case scAddRecExpr: {
4093         // We allow add recurrences that are on the loop BB is in, or some
4094         // outer loop.  This guarantees availability because the value of the
4095         // add recurrence at BB is simply the "current" value of the induction
4096         // variable.  We can relax this in the future; for instance an add
4097         // recurrence on a sibling dominating loop is also available at BB.
4098         const auto *ARLoop = cast<SCEVAddRecExpr>(S)->getLoop();
4099         if (L && (ARLoop == L || ARLoop->contains(L)))
4100           return true;
4101
4102         return setUnavailable();
4103       }
4104
4105       case scUnknown: {
4106         // For SCEVUnknown, we check for simple dominance.
4107         const auto *SU = cast<SCEVUnknown>(S);
4108         Value *V = SU->getValue();
4109
4110         if (isa<Argument>(V))
4111           return false;
4112
4113         if (isa<Instruction>(V) && DT.dominates(cast<Instruction>(V), BB))
4114           return false;
4115
4116         return setUnavailable();
4117       }
4118
4119       case scUDivExpr:
4120       case scCouldNotCompute:
4121         // We do not try to smart about these at all.
4122         return setUnavailable();
4123       }
4124       llvm_unreachable("switch should be fully covered!");
4125     }
4126
4127     bool isDone() { return TraversalDone; }
4128   };
4129
4130   CheckAvailable CA(L, BB, DT);
4131   SCEVTraversal<CheckAvailable> ST(CA);
4132
4133   ST.visitAll(S);
4134   return CA.Available;
4135 }
4136
4137 // Try to match a control flow sequence that branches out at BI and merges back
4138 // at Merge into a "C ? LHS : RHS" select pattern.  Return true on a successful
4139 // match.
4140 static bool BrPHIToSelect(DominatorTree &DT, BranchInst *BI, PHINode *Merge,
4141                           Value *&C, Value *&LHS, Value *&RHS) {
4142   C = BI->getCondition();
4143
4144   BasicBlockEdge LeftEdge(BI->getParent(), BI->getSuccessor(0));
4145   BasicBlockEdge RightEdge(BI->getParent(), BI->getSuccessor(1));
4146
4147   if (!LeftEdge.isSingleEdge())
4148     return false;
4149
4150   assert(RightEdge.isSingleEdge() && "Follows from LeftEdge.isSingleEdge()");
4151
4152   Use &LeftUse = Merge->getOperandUse(0);
4153   Use &RightUse = Merge->getOperandUse(1);
4154
4155   if (DT.dominates(LeftEdge, LeftUse) && DT.dominates(RightEdge, RightUse)) {
4156     LHS = LeftUse;
4157     RHS = RightUse;
4158     return true;
4159   }
4160
4161   if (DT.dominates(LeftEdge, RightUse) && DT.dominates(RightEdge, LeftUse)) {
4162     LHS = RightUse;
4163     RHS = LeftUse;
4164     return true;
4165   }
4166
4167   return false;
4168 }
4169
4170 const SCEV *ScalarEvolution::createNodeFromSelectLikePHI(PHINode *PN) {
4171   if (PN->getNumIncomingValues() == 2) {
4172     const Loop *L = LI.getLoopFor(PN->getParent());
4173
4174     // We don't want to break LCSSA, even in a SCEV expression tree.
4175     for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
4176       if (LI.getLoopFor(PN->getIncomingBlock(i)) != L)
4177         return nullptr;
4178
4179     // Try to match
4180     //
4181     //  br %cond, label %left, label %right
4182     // left:
4183     //  br label %merge
4184     // right:
4185     //  br label %merge
4186     // merge:
4187     //  V = phi [ %x, %left ], [ %y, %right ]
4188     //
4189     // as "select %cond, %x, %y"
4190
4191     BasicBlock *IDom = DT[PN->getParent()]->getIDom()->getBlock();
4192     assert(IDom && "At least the entry block should dominate PN");
4193
4194     auto *BI = dyn_cast<BranchInst>(IDom->getTerminator());
4195     Value *Cond = nullptr, *LHS = nullptr, *RHS = nullptr;
4196
4197     if (BI && BI->isConditional() &&
4198         BrPHIToSelect(DT, BI, PN, Cond, LHS, RHS) &&
4199         IsAvailableOnEntry(L, DT, getSCEV(LHS), PN->getParent()) &&
4200         IsAvailableOnEntry(L, DT, getSCEV(RHS), PN->getParent()))
4201       return createNodeForSelectOrPHI(PN, Cond, LHS, RHS);
4202   }
4203
4204   return nullptr;
4205 }
4206
4207 const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
4208   if (const SCEV *S = createAddRecFromPHI(PN))
4209     return S;
4210
4211   if (const SCEV *S = createNodeFromSelectLikePHI(PN))
4212     return S;
4213
4214   // If the PHI has a single incoming value, follow that value, unless the
4215   // PHI's incoming blocks are in a different loop, in which case doing so
4216   // risks breaking LCSSA form. Instcombine would normally zap these, but
4217   // it doesn't have DominatorTree information, so it may miss cases.
4218   if (Value *V = SimplifyInstruction(PN, getDataLayout(), &TLI, &DT, &AC))
4219     if (LI.replacementPreservesLCSSAForm(PN, V))
4220       return getSCEV(V);
4221
4222   // If it's not a loop phi, we can't handle it yet.
4223   return getUnknown(PN);
4224 }
4225
4226 const SCEV *ScalarEvolution::createNodeForSelectOrPHI(Instruction *I,
4227                                                       Value *Cond,
4228                                                       Value *TrueVal,
4229                                                       Value *FalseVal) {
4230   // Handle "constant" branch or select. This can occur for instance when a
4231   // loop pass transforms an inner loop and moves on to process the outer loop.
4232   if (auto *CI = dyn_cast<ConstantInt>(Cond))
4233     return getSCEV(CI->isOne() ? TrueVal : FalseVal);
4234
4235   // Try to match some simple smax or umax patterns.
4236   auto *ICI = dyn_cast<ICmpInst>(Cond);
4237   if (!ICI)
4238     return getUnknown(I);
4239
4240   Value *LHS = ICI->getOperand(0);
4241   Value *RHS = ICI->getOperand(1);
4242
4243   switch (ICI->getPredicate()) {
4244   case ICmpInst::ICMP_SLT:
4245   case ICmpInst::ICMP_SLE:
4246     std::swap(LHS, RHS);
4247   // fall through
4248   case ICmpInst::ICMP_SGT:
4249   case ICmpInst::ICMP_SGE:
4250     // a >s b ? a+x : b+x  ->  smax(a, b)+x
4251     // a >s b ? b+x : a+x  ->  smin(a, b)+x
4252     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType())) {
4253       const SCEV *LS = getNoopOrSignExtend(getSCEV(LHS), I->getType());
4254       const SCEV *RS = getNoopOrSignExtend(getSCEV(RHS), I->getType());
4255       const SCEV *LA = getSCEV(TrueVal);
4256       const SCEV *RA = getSCEV(FalseVal);
4257       const SCEV *LDiff = getMinusSCEV(LA, LS);
4258       const SCEV *RDiff = getMinusSCEV(RA, RS);
4259       if (LDiff == RDiff)
4260         return getAddExpr(getSMaxExpr(LS, RS), LDiff);
4261       LDiff = getMinusSCEV(LA, RS);
4262       RDiff = getMinusSCEV(RA, LS);
4263       if (LDiff == RDiff)
4264         return getAddExpr(getSMinExpr(LS, RS), LDiff);
4265     }
4266     break;
4267   case ICmpInst::ICMP_ULT:
4268   case ICmpInst::ICMP_ULE:
4269     std::swap(LHS, RHS);
4270   // fall through
4271   case ICmpInst::ICMP_UGT:
4272   case ICmpInst::ICMP_UGE:
4273     // a >u b ? a+x : b+x  ->  umax(a, b)+x
4274     // a >u b ? b+x : a+x  ->  umin(a, b)+x
4275     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType())) {
4276       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
4277       const SCEV *RS = getNoopOrZeroExtend(getSCEV(RHS), I->getType());
4278       const SCEV *LA = getSCEV(TrueVal);
4279       const SCEV *RA = getSCEV(FalseVal);
4280       const SCEV *LDiff = getMinusSCEV(LA, LS);
4281       const SCEV *RDiff = getMinusSCEV(RA, RS);
4282       if (LDiff == RDiff)
4283         return getAddExpr(getUMaxExpr(LS, RS), LDiff);
4284       LDiff = getMinusSCEV(LA, RS);
4285       RDiff = getMinusSCEV(RA, LS);
4286       if (LDiff == RDiff)
4287         return getAddExpr(getUMinExpr(LS, RS), LDiff);
4288     }
4289     break;
4290   case ICmpInst::ICMP_NE:
4291     // n != 0 ? n+x : 1+x  ->  umax(n, 1)+x
4292     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType()) &&
4293         isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
4294       const SCEV *One = getOne(I->getType());
4295       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
4296       const SCEV *LA = getSCEV(TrueVal);
4297       const SCEV *RA = getSCEV(FalseVal);
4298       const SCEV *LDiff = getMinusSCEV(LA, LS);
4299       const SCEV *RDiff = getMinusSCEV(RA, One);
4300       if (LDiff == RDiff)
4301         return getAddExpr(getUMaxExpr(One, LS), LDiff);
4302     }
4303     break;
4304   case ICmpInst::ICMP_EQ:
4305     // n == 0 ? 1+x : n+x  ->  umax(n, 1)+x
4306     if (getTypeSizeInBits(LHS->getType()) <= getTypeSizeInBits(I->getType()) &&
4307         isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
4308       const SCEV *One = getOne(I->getType());
4309       const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), I->getType());
4310       const SCEV *LA = getSCEV(TrueVal);
4311       const SCEV *RA = getSCEV(FalseVal);
4312       const SCEV *LDiff = getMinusSCEV(LA, One);
4313       const SCEV *RDiff = getMinusSCEV(RA, LS);
4314       if (LDiff == RDiff)
4315         return getAddExpr(getUMaxExpr(One, LS), LDiff);
4316     }
4317     break;
4318   default:
4319     break;
4320   }
4321
4322   return getUnknown(I);
4323 }
4324
4325 /// Expand GEP instructions into add and multiply operations. This allows them
4326 /// to be analyzed by regular SCEV code.
4327 const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
4328   // Don't attempt to analyze GEPs over unsized objects.
4329   if (!GEP->getSourceElementType()->isSized())
4330     return getUnknown(GEP);
4331
4332   SmallVector<const SCEV *, 4> IndexExprs;
4333   for (auto Index = GEP->idx_begin(); Index != GEP->idx_end(); ++Index)
4334     IndexExprs.push_back(getSCEV(*Index));
4335   return getGEPExpr(GEP->getSourceElementType(),
4336                     getSCEV(GEP->getPointerOperand()),
4337                     IndexExprs, GEP->isInBounds());
4338 }
4339
4340 uint32_t
4341 ScalarEvolution::GetMinTrailingZeros(const SCEV *S) {
4342   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
4343     return C->getAPInt().countTrailingZeros();
4344
4345   if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(S))
4346     return std::min(GetMinTrailingZeros(T->getOperand()),
4347                     (uint32_t)getTypeSizeInBits(T->getType()));
4348
4349   if (const SCEVZeroExtendExpr *E = dyn_cast<SCEVZeroExtendExpr>(S)) {
4350     uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
4351     return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
4352              getTypeSizeInBits(E->getType()) : OpRes;
4353   }
4354
4355   if (const SCEVSignExtendExpr *E = dyn_cast<SCEVSignExtendExpr>(S)) {
4356     uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
4357     return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
4358              getTypeSizeInBits(E->getType()) : OpRes;
4359   }
4360
4361   if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(S)) {
4362     // The result is the min of all operands results.
4363     uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
4364     for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
4365       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
4366     return MinOpRes;
4367   }
4368
4369   if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
4370     // The result is the sum of all operands results.
4371     uint32_t SumOpRes = GetMinTrailingZeros(M->getOperand(0));
4372     uint32_t BitWidth = getTypeSizeInBits(M->getType());
4373     for (unsigned i = 1, e = M->getNumOperands();
4374          SumOpRes != BitWidth && i != e; ++i)
4375       SumOpRes = std::min(SumOpRes + GetMinTrailingZeros(M->getOperand(i)),
4376                           BitWidth);
4377     return SumOpRes;
4378   }
4379
4380   if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(S)) {
4381     // The result is the min of all operands results.
4382     uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
4383     for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
4384       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
4385     return MinOpRes;
4386   }
4387
4388   if (const SCEVSMaxExpr *M = dyn_cast<SCEVSMaxExpr>(S)) {
4389     // The result is the min of all operands results.
4390     uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
4391     for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
4392       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
4393     return MinOpRes;
4394   }
4395
4396   if (const SCEVUMaxExpr *M = dyn_cast<SCEVUMaxExpr>(S)) {
4397     // The result is the min of all operands results.
4398     uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
4399     for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
4400       MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
4401     return MinOpRes;
4402   }
4403
4404   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
4405     // For a SCEVUnknown, ask ValueTracking.
4406     unsigned BitWidth = getTypeSizeInBits(U->getType());
4407     APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
4408     computeKnownBits(U->getValue(), Zeros, Ones, getDataLayout(), 0, &AC,
4409                      nullptr, &DT);
4410     return Zeros.countTrailingOnes();
4411   }
4412
4413   // SCEVUDivExpr
4414   return 0;
4415 }
4416
4417 /// Helper method to assign a range to V from metadata present in the IR.
4418 static Optional<ConstantRange> GetRangeFromMetadata(Value *V) {
4419   if (Instruction *I = dyn_cast<Instruction>(V))
4420     if (MDNode *MD = I->getMetadata(LLVMContext::MD_range))
4421       return getConstantRangeFromMetadata(*MD);
4422
4423   return None;
4424 }
4425
4426 /// Determine the range for a particular SCEV.  If SignHint is
4427 /// HINT_RANGE_UNSIGNED (resp. HINT_RANGE_SIGNED) then getRange prefers ranges
4428 /// with a "cleaner" unsigned (resp. signed) representation.
4429 ConstantRange
4430 ScalarEvolution::getRange(const SCEV *S,
4431                           ScalarEvolution::RangeSignHint SignHint) {
4432   DenseMap<const SCEV *, ConstantRange> &Cache =
4433       SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED ? UnsignedRanges
4434                                                        : SignedRanges;
4435
4436   // See if we've computed this range already.
4437   DenseMap<const SCEV *, ConstantRange>::iterator I = Cache.find(S);
4438   if (I != Cache.end())
4439     return I->second;
4440
4441   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
4442     return setRange(C, SignHint, ConstantRange(C->getAPInt()));
4443
4444   unsigned BitWidth = getTypeSizeInBits(S->getType());
4445   ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
4446
4447   // If the value has known zeros, the maximum value will have those known zeros
4448   // as well.
4449   uint32_t TZ = GetMinTrailingZeros(S);
4450   if (TZ != 0) {
4451     if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED)
4452       ConservativeResult =
4453           ConstantRange(APInt::getMinValue(BitWidth),
4454                         APInt::getMaxValue(BitWidth).lshr(TZ).shl(TZ) + 1);
4455     else
4456       ConservativeResult = ConstantRange(
4457           APInt::getSignedMinValue(BitWidth),
4458           APInt::getSignedMaxValue(BitWidth).ashr(TZ).shl(TZ) + 1);
4459   }
4460
4461   if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
4462     ConstantRange X = getRange(Add->getOperand(0), SignHint);
4463     for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
4464       X = X.add(getRange(Add->getOperand(i), SignHint));
4465     return setRange(Add, SignHint, ConservativeResult.intersectWith(X));
4466   }
4467
4468   if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
4469     ConstantRange X = getRange(Mul->getOperand(0), SignHint);
4470     for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
4471       X = X.multiply(getRange(Mul->getOperand(i), SignHint));
4472     return setRange(Mul, SignHint, ConservativeResult.intersectWith(X));
4473   }
4474
4475   if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
4476     ConstantRange X = getRange(SMax->getOperand(0), SignHint);
4477     for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
4478       X = X.smax(getRange(SMax->getOperand(i), SignHint));
4479     return setRange(SMax, SignHint, ConservativeResult.intersectWith(X));
4480   }
4481
4482   if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
4483     ConstantRange X = getRange(UMax->getOperand(0), SignHint);
4484     for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
4485       X = X.umax(getRange(UMax->getOperand(i), SignHint));
4486     return setRange(UMax, SignHint, ConservativeResult.intersectWith(X));
4487   }
4488
4489   if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
4490     ConstantRange X = getRange(UDiv->getLHS(), SignHint);
4491     ConstantRange Y = getRange(UDiv->getRHS(), SignHint);
4492     return setRange(UDiv, SignHint,
4493                     ConservativeResult.intersectWith(X.udiv(Y)));
4494   }
4495
4496   if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
4497     ConstantRange X = getRange(ZExt->getOperand(), SignHint);
4498     return setRange(ZExt, SignHint,
4499                     ConservativeResult.intersectWith(X.zeroExtend(BitWidth)));
4500   }
4501
4502   if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
4503     ConstantRange X = getRange(SExt->getOperand(), SignHint);
4504     return setRange(SExt, SignHint,
4505                     ConservativeResult.intersectWith(X.signExtend(BitWidth)));
4506   }
4507
4508   if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
4509     ConstantRange X = getRange(Trunc->getOperand(), SignHint);
4510     return setRange(Trunc, SignHint,
4511                     ConservativeResult.intersectWith(X.truncate(BitWidth)));
4512   }
4513
4514   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
4515     // If there's no unsigned wrap, the value will never be less than its
4516     // initial value.
4517     if (AddRec->hasNoUnsignedWrap())
4518       if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
4519         if (!C->getValue()->isZero())
4520           ConservativeResult = ConservativeResult.intersectWith(
4521               ConstantRange(C->getAPInt(), APInt(BitWidth, 0)));
4522
4523     // If there's no signed wrap, and all the operands have the same sign or
4524     // zero, the value won't ever change sign.
4525     if (AddRec->hasNoSignedWrap()) {
4526       bool AllNonNeg = true;
4527       bool AllNonPos = true;
4528       for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
4529         if (!isKnownNonNegative(AddRec->getOperand(i))) AllNonNeg = false;
4530         if (!isKnownNonPositive(AddRec->getOperand(i))) AllNonPos = false;
4531       }
4532       if (AllNonNeg)
4533         ConservativeResult = ConservativeResult.intersectWith(
4534           ConstantRange(APInt(BitWidth, 0),
4535                         APInt::getSignedMinValue(BitWidth)));
4536       else if (AllNonPos)
4537         ConservativeResult = ConservativeResult.intersectWith(
4538           ConstantRange(APInt::getSignedMinValue(BitWidth),
4539                         APInt(BitWidth, 1)));
4540     }
4541
4542     // TODO: non-affine addrec
4543     if (AddRec->isAffine()) {
4544       const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
4545       if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
4546           getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
4547         auto RangeFromAffine = getRangeForAffineAR(
4548             AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount,
4549             BitWidth);
4550         if (!RangeFromAffine.isFullSet())
4551           ConservativeResult =
4552               ConservativeResult.intersectWith(RangeFromAffine);
4553
4554         auto RangeFromFactoring = getRangeViaFactoring(
4555             AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount,
4556             BitWidth);
4557         if (!RangeFromFactoring.isFullSet())
4558           ConservativeResult =
4559               ConservativeResult.intersectWith(RangeFromFactoring);
4560       }
4561     }
4562
4563     return setRange(AddRec, SignHint, ConservativeResult);
4564   }
4565
4566   if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
4567     // Check if the IR explicitly contains !range metadata.
4568     Optional<ConstantRange> MDRange = GetRangeFromMetadata(U->getValue());
4569     if (MDRange.hasValue())
4570       ConservativeResult = ConservativeResult.intersectWith(MDRange.getValue());
4571
4572     // Split here to avoid paying the compile-time cost of calling both
4573     // computeKnownBits and ComputeNumSignBits.  This restriction can be lifted
4574     // if needed.
4575     const DataLayout &DL = getDataLayout();
4576     if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED) {
4577       // For a SCEVUnknown, ask ValueTracking.
4578       APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
4579       computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, &AC, nullptr, &DT);
4580       if (Ones != ~Zeros + 1)
4581         ConservativeResult =
4582             ConservativeResult.intersectWith(ConstantRange(Ones, ~Zeros + 1));
4583     } else {
4584       assert(SignHint == ScalarEvolution::HINT_RANGE_SIGNED &&
4585              "generalize as needed!");
4586       unsigned NS = ComputeNumSignBits(U->getValue(), DL, 0, &AC, nullptr, &DT);
4587       if (NS > 1)
4588         ConservativeResult = ConservativeResult.intersectWith(
4589             ConstantRange(APInt::getSignedMinValue(BitWidth).ashr(NS - 1),
4590                           APInt::getSignedMaxValue(BitWidth).ashr(NS - 1) + 1));
4591     }
4592
4593     return setRange(U, SignHint, ConservativeResult);
4594   }
4595
4596   return setRange(S, SignHint, ConservativeResult);
4597 }
4598
4599 ConstantRange ScalarEvolution::getRangeForAffineAR(const SCEV *Start,
4600                                                    const SCEV *Step,
4601                                                    const SCEV *MaxBECount,
4602                                                    unsigned BitWidth) {
4603   assert(!isa<SCEVCouldNotCompute>(MaxBECount) &&
4604          getTypeSizeInBits(MaxBECount->getType()) <= BitWidth &&
4605          "Precondition!");
4606
4607   ConstantRange Result(BitWidth, /* isFullSet = */ true);
4608
4609   // Check for overflow.  This must be done with ConstantRange arithmetic
4610   // because we could be called from within the ScalarEvolution overflow
4611   // checking code.
4612
4613   MaxBECount = getNoopOrZeroExtend(MaxBECount, Start->getType());
4614   ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
4615   ConstantRange ZExtMaxBECountRange =
4616       MaxBECountRange.zextOrTrunc(BitWidth * 2 + 1);
4617
4618   ConstantRange StepSRange = getSignedRange(Step);
4619   ConstantRange SExtStepSRange = StepSRange.sextOrTrunc(BitWidth * 2 + 1);
4620
4621   ConstantRange StartURange = getUnsignedRange(Start);
4622   ConstantRange EndURange =
4623       StartURange.add(MaxBECountRange.multiply(StepSRange));
4624
4625   // Check for unsigned overflow.
4626   ConstantRange ZExtStartURange = StartURange.zextOrTrunc(BitWidth * 2 + 1);
4627   ConstantRange ZExtEndURange = EndURange.zextOrTrunc(BitWidth * 2 + 1);
4628   if (ZExtStartURange.add(ZExtMaxBECountRange.multiply(SExtStepSRange)) ==
4629       ZExtEndURange) {
4630     APInt Min = APIntOps::umin(StartURange.getUnsignedMin(),
4631                                EndURange.getUnsignedMin());
4632     APInt Max = APIntOps::umax(StartURange.getUnsignedMax(),
4633                                EndURange.getUnsignedMax());
4634     bool IsFullRange = Min.isMinValue() && Max.isMaxValue();
4635     if (!IsFullRange)
4636       Result =
4637           Result.intersectWith(ConstantRange(Min, Max + 1));
4638   }
4639
4640   ConstantRange StartSRange = getSignedRange(Start);
4641   ConstantRange EndSRange =
4642       StartSRange.add(MaxBECountRange.multiply(StepSRange));
4643
4644   // Check for signed overflow. This must be done with ConstantRange
4645   // arithmetic because we could be called from within the ScalarEvolution
4646   // overflow checking code.
4647   ConstantRange SExtStartSRange = StartSRange.sextOrTrunc(BitWidth * 2 + 1);
4648   ConstantRange SExtEndSRange = EndSRange.sextOrTrunc(BitWidth * 2 + 1);
4649   if (SExtStartSRange.add(ZExtMaxBECountRange.multiply(SExtStepSRange)) ==
4650       SExtEndSRange) {
4651     APInt Min =
4652         APIntOps::smin(StartSRange.getSignedMin(), EndSRange.getSignedMin());
4653     APInt Max =
4654         APIntOps::smax(StartSRange.getSignedMax(), EndSRange.getSignedMax());
4655     bool IsFullRange = Min.isMinSignedValue() && Max.isMaxSignedValue();
4656     if (!IsFullRange)
4657       Result =
4658           Result.intersectWith(ConstantRange(Min, Max + 1));
4659   }
4660
4661   return Result;
4662 }
4663
4664 ConstantRange ScalarEvolution::getRangeViaFactoring(const SCEV *Start,
4665                                                     const SCEV *Step,
4666                                                     const SCEV *MaxBECount,
4667                                                     unsigned BitWidth) {
4668   //    RangeOf({C?A:B,+,C?P:Q}) == RangeOf(C?{A,+,P}:{B,+,Q})
4669   // == RangeOf({A,+,P}) union RangeOf({B,+,Q})
4670
4671   struct SelectPattern {
4672     Value *Condition = nullptr;
4673     APInt TrueValue;
4674     APInt FalseValue;
4675
4676     explicit SelectPattern(ScalarEvolution &SE, unsigned BitWidth,
4677                            const SCEV *S) {
4678       Optional<unsigned> CastOp;
4679       APInt Offset(BitWidth, 0);
4680
4681       assert(SE.getTypeSizeInBits(S->getType()) == BitWidth &&
4682              "Should be!");
4683
4684       // Peel off a constant offset:
4685       if (auto *SA = dyn_cast<SCEVAddExpr>(S)) {
4686         // In the future we could consider being smarter here and handle
4687         // {Start+Step,+,Step} too.
4688         if (SA->getNumOperands() != 2 || !isa<SCEVConstant>(SA->getOperand(0)))
4689           return;
4690
4691         Offset = cast<SCEVConstant>(SA->getOperand(0))->getAPInt();
4692         S = SA->getOperand(1);
4693       }
4694
4695       // Peel off a cast operation
4696       if (auto *SCast = dyn_cast<SCEVCastExpr>(S)) {
4697         CastOp = SCast->getSCEVType();
4698         S = SCast->getOperand();
4699       }
4700
4701       using namespace llvm::PatternMatch;
4702
4703       auto *SU = dyn_cast<SCEVUnknown>(S);
4704       const APInt *TrueVal, *FalseVal;
4705       if (!SU ||
4706           !match(SU->getValue(), m_Select(m_Value(Condition), m_APInt(TrueVal),
4707                                           m_APInt(FalseVal)))) {
4708         Condition = nullptr;
4709         return;
4710       }
4711
4712       TrueValue = *TrueVal;
4713       FalseValue = *FalseVal;
4714
4715       // Re-apply the cast we peeled off earlier
4716       if (CastOp.hasValue())
4717         switch (*CastOp) {
4718         default:
4719           llvm_unreachable("Unknown SCEV cast type!");
4720
4721         case scTruncate:
4722           TrueValue = TrueValue.trunc(BitWidth);
4723           FalseValue = FalseValue.trunc(BitWidth);
4724           break;
4725         case scZeroExtend:
4726           TrueValue = TrueValue.zext(BitWidth);
4727           FalseValue = FalseValue.zext(BitWidth);
4728           break;
4729         case scSignExtend:
4730           TrueValue = TrueValue.sext(BitWidth);
4731           FalseValue = FalseValue.sext(BitWidth);
4732           break;
4733         }
4734
4735       // Re-apply the constant offset we peeled off earlier
4736       TrueValue += Offset;
4737       FalseValue += Offset;
4738     }
4739
4740     bool isRecognized() { return Condition != nullptr; }
4741   };
4742
4743   SelectPattern StartPattern(*this, BitWidth, Start);
4744   if (!StartPattern.isRecognized())
4745     return ConstantRange(BitWidth, /* isFullSet = */ true);
4746
4747   SelectPattern StepPattern(*this, BitWidth, Step);
4748   if (!StepPattern.isRecognized())
4749     return ConstantRange(BitWidth, /* isFullSet = */ true);
4750
4751   if (StartPattern.Condition != StepPattern.Condition) {
4752     // We don't handle this case today; but we could, by considering four
4753     // possibilities below instead of two. I'm not sure if there are cases where
4754     // that will help over what getRange already does, though.
4755     return ConstantRange(BitWidth, /* isFullSet = */ true);
4756   }
4757
4758   // NB! Calling ScalarEvolution::getConstant is fine, but we should not try to
4759   // construct arbitrary general SCEV expressions here.  This function is called
4760   // from deep in the call stack, and calling getSCEV (on a sext instruction,
4761   // say) can end up caching a suboptimal value.
4762
4763   // FIXME: without the explicit `this` receiver below, MSVC errors out with
4764   // C2352 and C2512 (otherwise it isn't needed).
4765
4766   const SCEV *TrueStart = this->getConstant(StartPattern.TrueValue);
4767   const SCEV *TrueStep = this->getConstant(StepPattern.TrueValue);
4768   const SCEV *FalseStart = this->getConstant(StartPattern.FalseValue);
4769   const SCEV *FalseStep = this->getConstant(StepPattern.FalseValue);
4770
4771   ConstantRange TrueRange =
4772       this->getRangeForAffineAR(TrueStart, TrueStep, MaxBECount, BitWidth);
4773   ConstantRange FalseRange =
4774       this->getRangeForAffineAR(FalseStart, FalseStep, MaxBECount, BitWidth);
4775
4776   return TrueRange.unionWith(FalseRange);
4777 }
4778
4779 SCEV::NoWrapFlags ScalarEvolution::getNoWrapFlagsFromUB(const Value *V) {
4780   if (isa<ConstantExpr>(V)) return SCEV::FlagAnyWrap;
4781   const BinaryOperator *BinOp = cast<BinaryOperator>(V);
4782
4783   // Return early if there are no flags to propagate to the SCEV.
4784   SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
4785   if (BinOp->hasNoUnsignedWrap())
4786     Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
4787   if (BinOp->hasNoSignedWrap())
4788     Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
4789   if (Flags == SCEV::FlagAnyWrap)
4790     return SCEV::FlagAnyWrap;
4791
4792   return isSCEVExprNeverPoison(BinOp) ? Flags : SCEV::FlagAnyWrap;
4793 }
4794
4795 bool ScalarEvolution::isSCEVExprNeverPoison(const Instruction *I) {
4796   // Here we check that I is in the header of the innermost loop containing I,
4797   // since we only deal with instructions in the loop header. The actual loop we
4798   // need to check later will come from an add recurrence, but getting that
4799   // requires computing the SCEV of the operands, which can be expensive. This
4800   // check we can do cheaply to rule out some cases early.
4801   Loop *InnermostContainingLoop = LI.getLoopFor(I->getParent());
4802   if (InnermostContainingLoop == nullptr ||
4803       InnermostContainingLoop->getHeader() != I->getParent())
4804     return false;
4805
4806   // Only proceed if we can prove that I does not yield poison.
4807   if (!isKnownNotFullPoison(I)) return false;
4808
4809   // At this point we know that if I is executed, then it does not wrap
4810   // according to at least one of NSW or NUW. If I is not executed, then we do
4811   // not know if the calculation that I represents would wrap. Multiple
4812   // instructions can map to the same SCEV. If we apply NSW or NUW from I to
4813   // the SCEV, we must guarantee no wrapping for that SCEV also when it is
4814   // derived from other instructions that map to the same SCEV. We cannot make
4815   // that guarantee for cases where I is not executed. So we need to find the
4816   // loop that I is considered in relation to and prove that I is executed for
4817   // every iteration of that loop. That implies that the value that I
4818   // calculates does not wrap anywhere in the loop, so then we can apply the
4819   // flags to the SCEV.
4820   //
4821   // We check isLoopInvariant to disambiguate in case we are adding recurrences
4822   // from different loops, so that we know which loop to prove that I is
4823   // executed in.
4824   for (unsigned OpIndex = 0; OpIndex < I->getNumOperands(); ++OpIndex) {
4825     // I could be an extractvalue from a call to an overflow intrinsic.
4826     // TODO: We can do better here in some cases.
4827     if (!isSCEVable(I->getOperand(OpIndex)->getType()))
4828       return false;
4829     const SCEV *Op = getSCEV(I->getOperand(OpIndex));
4830     if (auto *AddRec = dyn_cast<SCEVAddRecExpr>(Op)) {
4831       bool AllOtherOpsLoopInvariant = true;
4832       for (unsigned OtherOpIndex = 0; OtherOpIndex < I->getNumOperands();
4833            ++OtherOpIndex) {
4834         if (OtherOpIndex != OpIndex) {
4835           const SCEV *OtherOp = getSCEV(I->getOperand(OtherOpIndex));
4836           if (!isLoopInvariant(OtherOp, AddRec->getLoop())) {
4837             AllOtherOpsLoopInvariant = false;
4838             break;
4839           }
4840         }
4841       }
4842       if (AllOtherOpsLoopInvariant &&
4843           isGuaranteedToExecuteForEveryIteration(I, AddRec->getLoop()))
4844         return true;
4845     }
4846   }
4847   return false;
4848 }
4849
4850 bool ScalarEvolution::isAddRecNeverPoison(const Instruction *I, const Loop *L) {
4851   // If we know that \c I can never be poison period, then that's enough.
4852   if (isSCEVExprNeverPoison(I))
4853     return true;
4854
4855   // For an add recurrence specifically, we assume that infinite loops without
4856   // side effects are undefined behavior, and then reason as follows:
4857   //
4858   // If the add recurrence is poison in any iteration, it is poison on all
4859   // future iterations (since incrementing poison yields poison). If the result
4860   // of the add recurrence is fed into the loop latch condition and the loop
4861   // does not contain any throws or exiting blocks other than the latch, we now
4862   // have the ability to "choose" whether the backedge is taken or not (by
4863   // choosing a sufficiently evil value for the poison feeding into the branch)
4864   // for every iteration including and after the one in which \p I first became
4865   // poison.  There are two possibilities (let's call the iteration in which \p
4866   // I first became poison as K):
4867   //
4868   //  1. In the set of iterations including and after K, the loop body executes
4869   //     no side effects.  In this case executing the backege an infinte number
4870   //     of times will yield undefined behavior.
4871   //
4872   //  2. In the set of iterations including and after K, the loop body executes
4873   //     at least one side effect.  In this case, that specific instance of side
4874   //     effect is control dependent on poison, which also yields undefined
4875   //     behavior.
4876
4877   auto *ExitingBB = L->getExitingBlock();
4878   auto *LatchBB = L->getLoopLatch();
4879   if (!ExitingBB || !LatchBB || ExitingBB != LatchBB)
4880     return false;
4881
4882   SmallPtrSet<const Instruction *, 16> Pushed;
4883   SmallVector<const Instruction *, 8> PoisonStack;
4884
4885   // We start by assuming \c I, the post-inc add recurrence, is poison.  Only
4886   // things that are known to be fully poison under that assumption go on the
4887   // PoisonStack.
4888   Pushed.insert(I);
4889   PoisonStack.push_back(I);
4890
4891   bool LatchControlDependentOnPoison = false;
4892   while (!PoisonStack.empty() && !LatchControlDependentOnPoison) {
4893     const Instruction *Poison = PoisonStack.pop_back_val();
4894
4895     for (auto *PoisonUser : Poison->users()) {
4896       if (propagatesFullPoison(cast<Instruction>(PoisonUser))) {
4897         if (Pushed.insert(cast<Instruction>(PoisonUser)).second)
4898           PoisonStack.push_back(cast<Instruction>(PoisonUser));
4899       } else if (auto *BI = dyn_cast<BranchInst>(PoisonUser)) {
4900         assert(BI->isConditional() && "Only possibility!");
4901         if (BI->getParent() == LatchBB) {
4902           LatchControlDependentOnPoison = true;
4903           break;
4904         }
4905       }
4906     }
4907   }
4908
4909   return LatchControlDependentOnPoison && loopHasNoAbnormalExits(L);
4910 }
4911
4912 bool ScalarEvolution::loopHasNoAbnormalExits(const Loop *L) {
4913   auto Itr = LoopHasNoAbnormalExits.find(L);
4914   if (Itr == LoopHasNoAbnormalExits.end()) {
4915     auto NoAbnormalExitInBB = [&](BasicBlock *BB) {
4916       return all_of(*BB, [](Instruction &I) {
4917         return isGuaranteedToTransferExecutionToSuccessor(&I);
4918       });
4919     };
4920
4921     auto InsertPair = LoopHasNoAbnormalExits.insert(
4922         {L, all_of(L->getBlocks(), NoAbnormalExitInBB)});
4923     assert(InsertPair.second && "We just checked!");
4924     Itr = InsertPair.first;
4925   }
4926
4927   return Itr->second;
4928 }
4929
4930 const SCEV *ScalarEvolution::createSCEV(Value *V) {
4931   if (!isSCEVable(V->getType()))
4932     return getUnknown(V);
4933
4934   if (Instruction *I = dyn_cast<Instruction>(V)) {
4935     // Don't attempt to analyze instructions in blocks that aren't
4936     // reachable. Such instructions don't matter, and they aren't required
4937     // to obey basic rules for definitions dominating uses which this
4938     // analysis depends on.
4939     if (!DT.isReachableFromEntry(I->getParent()))
4940       return getUnknown(V);
4941   } else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
4942     return getConstant(CI);
4943   else if (isa<ConstantPointerNull>(V))
4944     return getZero(V->getType());
4945   else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
4946     return GA->isInterposable() ? getUnknown(V) : getSCEV(GA->getAliasee());
4947   else if (!isa<ConstantExpr>(V))
4948     return getUnknown(V);
4949
4950   Operator *U = cast<Operator>(V);
4951   if (auto BO = MatchBinaryOp(U, DT)) {
4952     switch (BO->Opcode) {
4953     case Instruction::Add: {
4954       // The simple thing to do would be to just call getSCEV on both operands
4955       // and call getAddExpr with the result. However if we're looking at a
4956       // bunch of things all added together, this can be quite inefficient,
4957       // because it leads to N-1 getAddExpr calls for N ultimate operands.
4958       // Instead, gather up all the operands and make a single getAddExpr call.
4959       // LLVM IR canonical form means we need only traverse the left operands.
4960       SmallVector<const SCEV *, 4> AddOps;
4961       do {
4962         if (BO->Op) {
4963           if (auto *OpSCEV = getExistingSCEV(BO->Op)) {
4964             AddOps.push_back(OpSCEV);
4965             break;
4966           }
4967
4968           // If a NUW or NSW flag can be applied to the SCEV for this
4969           // addition, then compute the SCEV for this addition by itself
4970           // with a separate call to getAddExpr. We need to do that
4971           // instead of pushing the operands of the addition onto AddOps,
4972           // since the flags are only known to apply to this particular
4973           // addition - they may not apply to other additions that can be
4974           // formed with operands from AddOps.
4975           const SCEV *RHS = getSCEV(BO->RHS);
4976           SCEV::NoWrapFlags Flags = getNoWrapFlagsFromUB(BO->Op);
4977           if (Flags != SCEV::FlagAnyWrap) {
4978             const SCEV *LHS = getSCEV(BO->LHS);
4979             if (BO->Opcode == Instruction::Sub)
4980               AddOps.push_back(getMinusSCEV(LHS, RHS, Flags));
4981             else
4982               AddOps.push_back(getAddExpr(LHS, RHS, Flags));
4983             break;
4984           }
4985         }
4986
4987         if (BO->Opcode == Instruction::Sub)
4988           AddOps.push_back(getNegativeSCEV(getSCEV(BO->RHS)));
4989         else
4990           AddOps.push_back(getSCEV(BO->RHS));
4991
4992         auto NewBO = MatchBinaryOp(BO->LHS, DT);
4993         if (!NewBO || (NewBO->Opcode != Instruction::Add &&
4994                        NewBO->Opcode != Instruction::Sub)) {
4995           AddOps.push_back(getSCEV(BO->LHS));
4996           break;
4997         }
4998         BO = NewBO;
4999       } while (true);
5000
5001       return getAddExpr(AddOps);
5002     }
5003
5004     case Instruction::Mul: {
5005       SmallVector<const SCEV *, 4> MulOps;
5006       do {
5007         if (BO->Op) {
5008           if (auto *OpSCEV = getExistingSCEV(BO->Op)) {
5009             MulOps.push_back(OpSCEV);
5010             break;
5011           }
5012
5013           SCEV::NoWrapFlags Flags = getNoWrapFlagsFromUB(BO->Op);
5014           if (Flags != SCEV::FlagAnyWrap) {
5015             MulOps.push_back(
5016                 getMulExpr(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags));
5017             break;
5018           }
5019         }
5020
5021         MulOps.push_back(getSCEV(BO->RHS));
5022         auto NewBO = MatchBinaryOp(BO->LHS, DT);
5023         if (!NewBO || NewBO->Opcode != Instruction::Mul) {
5024           MulOps.push_back(getSCEV(BO->LHS));
5025           break;
5026         }
5027         BO = NewBO;
5028       } while (true);
5029
5030       return getMulExpr(MulOps);
5031     }
5032     case Instruction::UDiv:
5033       return getUDivExpr(getSCEV(BO->LHS), getSCEV(BO->RHS));
5034     case Instruction::Sub: {
5035       SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
5036       if (BO->Op)
5037         Flags = getNoWrapFlagsFromUB(BO->Op);
5038       return getMinusSCEV(getSCEV(BO->LHS), getSCEV(BO->RHS), Flags);
5039     }
5040     case Instruction::And:
5041       // For an expression like x&255 that merely masks off the high bits,
5042       // use zext(trunc(x)) as the SCEV expression.
5043       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
5044         if (CI->isNullValue())
5045           return getSCEV(BO->RHS);
5046         if (CI->isAllOnesValue())
5047           return getSCEV(BO->LHS);
5048         const APInt &A = CI->getValue();
5049
5050         // Instcombine's ShrinkDemandedConstant may strip bits out of
5051         // constants, obscuring what would otherwise be a low-bits mask.
5052         // Use computeKnownBits to compute what ShrinkDemandedConstant
5053         // knew about to reconstruct a low-bits mask value.
5054         unsigned LZ = A.countLeadingZeros();
5055         unsigned TZ = A.countTrailingZeros();
5056         unsigned BitWidth = A.getBitWidth();
5057         APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
5058         computeKnownBits(BO->LHS, KnownZero, KnownOne, getDataLayout(),
5059                          0, &AC, nullptr, &DT);
5060
5061         APInt EffectiveMask =
5062             APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ);
5063         if ((LZ != 0 || TZ != 0) && !((~A & ~KnownZero) & EffectiveMask)) {
5064           const SCEV *MulCount = getConstant(ConstantInt::get(
5065               getContext(), APInt::getOneBitSet(BitWidth, TZ)));
5066           return getMulExpr(
5067               getZeroExtendExpr(
5068                   getTruncateExpr(
5069                       getUDivExactExpr(getSCEV(BO->LHS), MulCount),
5070                       IntegerType::get(getContext(), BitWidth - LZ - TZ)),
5071                   BO->LHS->getType()),
5072               MulCount);
5073         }
5074       }
5075       break;
5076
5077     case Instruction::Or:
5078       // If the RHS of the Or is a constant, we may have something like:
5079       // X*4+1 which got turned into X*4|1.  Handle this as an Add so loop
5080       // optimizations will transparently handle this case.
5081       //
5082       // In order for this transformation to be safe, the LHS must be of the
5083       // form X*(2^n) and the Or constant must be less than 2^n.
5084       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
5085         const SCEV *LHS = getSCEV(BO->LHS);
5086         const APInt &CIVal = CI->getValue();
5087         if (GetMinTrailingZeros(LHS) >=
5088             (CIVal.getBitWidth() - CIVal.countLeadingZeros())) {
5089           // Build a plain add SCEV.
5090           const SCEV *S = getAddExpr(LHS, getSCEV(CI));
5091           // If the LHS of the add was an addrec and it has no-wrap flags,
5092           // transfer the no-wrap flags, since an or won't introduce a wrap.
5093           if (const SCEVAddRecExpr *NewAR = dyn_cast<SCEVAddRecExpr>(S)) {
5094             const SCEVAddRecExpr *OldAR = cast<SCEVAddRecExpr>(LHS);
5095             const_cast<SCEVAddRecExpr *>(NewAR)->setNoWrapFlags(
5096                 OldAR->getNoWrapFlags());
5097           }
5098           return S;
5099         }
5100       }
5101       break;
5102
5103     case Instruction::Xor:
5104       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
5105         // If the RHS of xor is -1, then this is a not operation.
5106         if (CI->isAllOnesValue())
5107           return getNotSCEV(getSCEV(BO->LHS));
5108
5109         // Model xor(and(x, C), C) as and(~x, C), if C is a low-bits mask.
5110         // This is a variant of the check for xor with -1, and it handles
5111         // the case where instcombine has trimmed non-demanded bits out
5112         // of an xor with -1.
5113         if (auto *LBO = dyn_cast<BinaryOperator>(BO->LHS))
5114           if (ConstantInt *LCI = dyn_cast<ConstantInt>(LBO->getOperand(1)))
5115             if (LBO->getOpcode() == Instruction::And &&
5116                 LCI->getValue() == CI->getValue())
5117               if (const SCEVZeroExtendExpr *Z =
5118                       dyn_cast<SCEVZeroExtendExpr>(getSCEV(BO->LHS))) {
5119                 Type *UTy = BO->LHS->getType();
5120                 const SCEV *Z0 = Z->getOperand();
5121                 Type *Z0Ty = Z0->getType();
5122                 unsigned Z0TySize = getTypeSizeInBits(Z0Ty);
5123
5124                 // If C is a low-bits mask, the zero extend is serving to
5125                 // mask off the high bits. Complement the operand and
5126                 // re-apply the zext.
5127                 if (APIntOps::isMask(Z0TySize, CI->getValue()))
5128                   return getZeroExtendExpr(getNotSCEV(Z0), UTy);
5129
5130                 // If C is a single bit, it may be in the sign-bit position
5131                 // before the zero-extend. In this case, represent the xor
5132                 // using an add, which is equivalent, and re-apply the zext.
5133                 APInt Trunc = CI->getValue().trunc(Z0TySize);
5134                 if (Trunc.zext(getTypeSizeInBits(UTy)) == CI->getValue() &&
5135                     Trunc.isSignBit())
5136                   return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
5137                                            UTy);
5138               }
5139       }
5140       break;
5141
5142   case Instruction::Shl:
5143     // Turn shift left of a constant amount into a multiply.
5144     if (ConstantInt *SA = dyn_cast<ConstantInt>(BO->RHS)) {
5145       uint32_t BitWidth = cast<IntegerType>(SA->getType())->getBitWidth();
5146
5147       // If the shift count is not less than the bitwidth, the result of
5148       // the shift is undefined. Don't try to analyze it, because the
5149       // resolution chosen here may differ from the resolution chosen in
5150       // other parts of the compiler.
5151       if (SA->getValue().uge(BitWidth))
5152         break;
5153
5154       // It is currently not resolved how to interpret NSW for left
5155       // shift by BitWidth - 1, so we avoid applying flags in that
5156       // case. Remove this check (or this comment) once the situation
5157       // is resolved. See
5158       // http://lists.llvm.org/pipermail/llvm-dev/2015-April/084195.html
5159       // and http://reviews.llvm.org/D8890 .
5160       auto Flags = SCEV::FlagAnyWrap;
5161       if (BO->Op && SA->getValue().ult(BitWidth - 1))
5162         Flags = getNoWrapFlagsFromUB(BO->Op);
5163
5164       Constant *X = ConstantInt::get(getContext(),
5165         APInt::getOneBitSet(BitWidth, SA->getZExtValue()));
5166       return getMulExpr(getSCEV(BO->LHS), getSCEV(X), Flags);
5167     }
5168     break;
5169
5170     case Instruction::AShr:
5171       // For a two-shift sext-inreg, use sext(trunc(x)) as the SCEV expression.
5172       if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS))
5173         if (Operator *L = dyn_cast<Operator>(BO->LHS))
5174           if (L->getOpcode() == Instruction::Shl &&
5175               L->getOperand(1) == BO->RHS) {
5176             uint64_t BitWidth = getTypeSizeInBits(BO->LHS->getType());
5177
5178             // If the shift count is not less than the bitwidth, the result of
5179             // the shift is undefined. Don't try to analyze it, because the
5180             // resolution chosen here may differ from the resolution chosen in
5181             // other parts of the compiler.
5182             if (CI->getValue().uge(BitWidth))
5183               break;
5184
5185             uint64_t Amt = BitWidth - CI->getZExtValue();
5186             if (Amt == BitWidth)
5187               return getSCEV(L->getOperand(0)); // shift by zero --> noop
5188             return getSignExtendExpr(
5189                 getTruncateExpr(getSCEV(L->getOperand(0)),
5190                                 IntegerType::get(getContext(), Amt)),
5191                 BO->LHS->getType());
5192           }
5193       break;
5194     }
5195   }
5196
5197   switch (U->getOpcode()) {
5198   case Instruction::Trunc:
5199     return getTruncateExpr(getSCEV(U->getOperand(0)), U->getType());
5200
5201   case Instruction::ZExt:
5202     return getZeroExtendExpr(getSCEV(U->getOperand(0)), U->getType());
5203
5204   case Instruction::SExt:
5205     return getSignExtendExpr(getSCEV(U->getOperand(0)), U->getType());
5206
5207   case Instruction::BitCast:
5208     // BitCasts are no-op casts so we just eliminate the cast.
5209     if (isSCEVable(U->getType()) && isSCEVable(U->getOperand(0)->getType()))
5210       return getSCEV(U->getOperand(0));
5211     break;
5212
5213   // It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
5214   // lead to pointer expressions which cannot safely be expanded to GEPs,
5215   // because ScalarEvolution doesn't respect the GEP aliasing rules when
5216   // simplifying integer expressions.
5217
5218   case Instruction::GetElementPtr:
5219     return createNodeForGEP(cast<GEPOperator>(U));
5220
5221   case Instruction::PHI:
5222     return createNodeForPHI(cast<PHINode>(U));
5223
5224   case Instruction::Select:
5225     // U can also be a select constant expr, which let fall through.  Since
5226     // createNodeForSelect only works for a condition that is an `ICmpInst`, and
5227     // constant expressions cannot have instructions as operands, we'd have
5228     // returned getUnknown for a select constant expressions anyway.
5229     if (isa<Instruction>(U))
5230       return createNodeForSelectOrPHI(cast<Instruction>(U), U->getOperand(0),
5231                                       U->getOperand(1), U->getOperand(2));
5232     break;
5233
5234   case Instruction::Call:
5235   case Instruction::Invoke:
5236     if (Value *RV = CallSite(U).getReturnedArgOperand())
5237       return getSCEV(RV);
5238     break;
5239   }
5240
5241   return getUnknown(V);
5242 }
5243
5244
5245
5246 //===----------------------------------------------------------------------===//
5247 //                   Iteration Count Computation Code
5248 //
5249
5250 unsigned ScalarEvolution::getSmallConstantTripCount(Loop *L) {
5251   if (BasicBlock *ExitingBB = L->getExitingBlock())
5252     return getSmallConstantTripCount(L, ExitingBB);
5253
5254   // No trip count information for multiple exits.
5255   return 0;
5256 }
5257
5258 unsigned ScalarEvolution::getSmallConstantTripCount(Loop *L,
5259                                                     BasicBlock *ExitingBlock) {
5260   assert(ExitingBlock && "Must pass a non-null exiting block!");
5261   assert(L->isLoopExiting(ExitingBlock) &&
5262          "Exiting block must actually branch out of the loop!");
5263   const SCEVConstant *ExitCount =
5264       dyn_cast<SCEVConstant>(getExitCount(L, ExitingBlock));
5265   if (!ExitCount)
5266     return 0;
5267
5268   ConstantInt *ExitConst = ExitCount->getValue();
5269
5270   // Guard against huge trip counts.
5271   if (ExitConst->getValue().getActiveBits() > 32)
5272     return 0;
5273
5274   // In case of integer overflow, this returns 0, which is correct.
5275   return ((unsigned)ExitConst->getZExtValue()) + 1;
5276 }
5277
5278 unsigned ScalarEvolution::getSmallConstantTripMultiple(Loop *L) {
5279   if (BasicBlock *ExitingBB = L->getExitingBlock())
5280     return getSmallConstantTripMultiple(L, ExitingBB);
5281
5282   // No trip multiple information for multiple exits.
5283   return 0;
5284 }
5285
5286 /// Returns the largest constant divisor of the trip count of this loop as a
5287 /// normal unsigned value, if possible. This means that the actual trip count is
5288 /// always a multiple of the returned value (don't forget the trip count could
5289 /// very well be zero as well!).
5290 ///
5291 /// Returns 1 if the trip count is unknown or not guaranteed to be the
5292 /// multiple of a constant (which is also the case if the trip count is simply
5293 /// constant, use getSmallConstantTripCount for that case), Will also return 1
5294 /// if the trip count is very large (>= 2^32).
5295 ///
5296 /// As explained in the comments for getSmallConstantTripCount, this assumes
5297 /// that control exits the loop via ExitingBlock.
5298 unsigned
5299 ScalarEvolution::getSmallConstantTripMultiple(Loop *L,
5300                                               BasicBlock *ExitingBlock) {
5301   assert(ExitingBlock && "Must pass a non-null exiting block!");
5302   assert(L->isLoopExiting(ExitingBlock) &&
5303          "Exiting block must actually branch out of the loop!");
5304   const SCEV *ExitCount = getExitCount(L, ExitingBlock);
5305   if (ExitCount == getCouldNotCompute())
5306     return 1;
5307
5308   // Get the trip count from the BE count by adding 1.
5309   const SCEV *TCMul = getAddExpr(ExitCount, getOne(ExitCount->getType()));
5310   // FIXME: SCEV distributes multiplication as V1*C1 + V2*C1. We could attempt
5311   // to factor simple cases.
5312   if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(TCMul))
5313     TCMul = Mul->getOperand(0);
5314
5315   const SCEVConstant *MulC = dyn_cast<SCEVConstant>(TCMul);
5316   if (!MulC)
5317     return 1;
5318
5319   ConstantInt *Result = MulC->getValue();
5320
5321   // Guard against huge trip counts (this requires checking
5322   // for zero to handle the case where the trip count == -1 and the
5323   // addition wraps).
5324   if (!Result || Result->getValue().getActiveBits() > 32 ||
5325       Result->getValue().getActiveBits() == 0)
5326     return 1;
5327
5328   return (unsigned)Result->getZExtValue();
5329 }
5330
5331 /// Get the expression for the number of loop iterations for which this loop is
5332 /// guaranteed not to exit via ExitingBlock. Otherwise return
5333 /// SCEVCouldNotCompute.
5334 const SCEV *ScalarEvolution::getExitCount(Loop *L, BasicBlock *ExitingBlock) {
5335   return getBackedgeTakenInfo(L).getExact(ExitingBlock, this);
5336 }
5337
5338 const SCEV *
5339 ScalarEvolution::getPredicatedBackedgeTakenCount(const Loop *L,
5340                                                  SCEVUnionPredicate &Preds) {
5341   return getPredicatedBackedgeTakenInfo(L).getExact(this, &Preds);
5342 }
5343
5344 const SCEV *ScalarEvolution::getBackedgeTakenCount(const Loop *L) {
5345   return getBackedgeTakenInfo(L).getExact(this);
5346 }
5347
5348 /// Similar to getBackedgeTakenCount, except return the least SCEV value that is
5349 /// known never to be less than the actual backedge taken count.
5350 const SCEV *ScalarEvolution::getMaxBackedgeTakenCount(const Loop *L) {
5351   return getBackedgeTakenInfo(L).getMax(this);
5352 }
5353
5354 /// Push PHI nodes in the header of the given loop onto the given Worklist.
5355 static void
5356 PushLoopPHIs(const Loop *L, SmallVectorImpl<Instruction *> &Worklist) {
5357   BasicBlock *Header = L->getHeader();
5358
5359   // Push all Loop-header PHIs onto the Worklist stack.
5360   for (BasicBlock::iterator I = Header->begin();
5361        PHINode *PN = dyn_cast<PHINode>(I); ++I)
5362     Worklist.push_back(PN);
5363 }
5364
5365 const ScalarEvolution::BackedgeTakenInfo &
5366 ScalarEvolution::getPredicatedBackedgeTakenInfo(const Loop *L) {
5367   auto &BTI = getBackedgeTakenInfo(L);
5368   if (BTI.hasFullInfo())
5369     return BTI;
5370
5371   auto Pair = PredicatedBackedgeTakenCounts.insert({L, BackedgeTakenInfo()});
5372
5373   if (!Pair.second)
5374     return Pair.first->second;
5375
5376   BackedgeTakenInfo Result =
5377       computeBackedgeTakenCount(L, /*AllowPredicates=*/true);
5378
5379   return PredicatedBackedgeTakenCounts.find(L)->second = Result;
5380 }
5381
5382 const ScalarEvolution::BackedgeTakenInfo &
5383 ScalarEvolution::getBackedgeTakenInfo(const Loop *L) {
5384   // Initially insert an invalid entry for this loop. If the insertion
5385   // succeeds, proceed to actually compute a backedge-taken count and
5386   // update the value. The temporary CouldNotCompute value tells SCEV
5387   // code elsewhere that it shouldn't attempt to request a new
5388   // backedge-taken count, which could result in infinite recursion.
5389   std::pair<DenseMap<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
5390       BackedgeTakenCounts.insert({L, BackedgeTakenInfo()});
5391   if (!Pair.second)
5392     return Pair.first->second;
5393
5394   // computeBackedgeTakenCount may allocate memory for its result. Inserting it
5395   // into the BackedgeTakenCounts map transfers ownership. Otherwise, the result
5396   // must be cleared in this scope.
5397   BackedgeTakenInfo Result = computeBackedgeTakenCount(L);
5398
5399   if (Result.getExact(this) != getCouldNotCompute()) {
5400     assert(isLoopInvariant(Result.getExact(this), L) &&
5401            isLoopInvariant(Result.getMax(this), L) &&
5402            "Computed backedge-taken count isn't loop invariant for loop!");
5403     ++NumTripCountsComputed;
5404   }
5405   else if (Result.getMax(this) == getCouldNotCompute() &&
5406            isa<PHINode>(L->getHeader()->begin())) {
5407     // Only count loops that have phi nodes as not being computable.
5408     ++NumTripCountsNotComputed;
5409   }
5410
5411   // Now that we know more about the trip count for this loop, forget any
5412   // existing SCEV values for PHI nodes in this loop since they are only
5413   // conservative estimates made without the benefit of trip count
5414   // information. This is similar to the code in forgetLoop, except that
5415   // it handles SCEVUnknown PHI nodes specially.
5416   if (Result.hasAnyInfo()) {
5417     SmallVector<Instruction *, 16> Worklist;
5418     PushLoopPHIs(L, Worklist);
5419
5420     SmallPtrSet<Instruction *, 8> Visited;
5421     while (!Worklist.empty()) {
5422       Instruction *I = Worklist.pop_back_val();
5423       if (!Visited.insert(I).second)
5424         continue;
5425
5426       ValueExprMapType::iterator It =
5427         ValueExprMap.find_as(static_cast<Value *>(I));
5428       if (It != ValueExprMap.end()) {
5429         const SCEV *Old = It->second;
5430
5431         // SCEVUnknown for a PHI either means that it has an unrecognized
5432         // structure, or it's a PHI that's in the progress of being computed
5433         // by createNodeForPHI.  In the former case, additional loop trip
5434         // count information isn't going to change anything. In the later
5435         // case, createNodeForPHI will perform the necessary updates on its
5436         // own when it gets to that point.
5437         if (!isa<PHINode>(I) || !isa<SCEVUnknown>(Old)) {
5438           forgetMemoizedResults(Old);
5439           ValueExprMap.erase(It);
5440         }
5441         if (PHINode *PN = dyn_cast<PHINode>(I))
5442           ConstantEvolutionLoopExitValue.erase(PN);
5443       }
5444
5445       PushDefUseChildren(I, Worklist);
5446     }
5447   }
5448
5449   // Re-lookup the insert position, since the call to
5450   // computeBackedgeTakenCount above could result in a
5451   // recusive call to getBackedgeTakenInfo (on a different
5452   // loop), which would invalidate the iterator computed
5453   // earlier.
5454   return BackedgeTakenCounts.find(L)->second = Result;
5455 }
5456
5457 void ScalarEvolution::forgetLoop(const Loop *L) {
5458   // Drop any stored trip count value.
5459   auto RemoveLoopFromBackedgeMap =
5460       [L](DenseMap<const Loop *, BackedgeTakenInfo> &Map) {
5461         auto BTCPos = Map.find(L);
5462         if (BTCPos != Map.end()) {
5463           BTCPos->second.clear();
5464           Map.erase(BTCPos);
5465         }
5466       };
5467
5468   RemoveLoopFromBackedgeMap(BackedgeTakenCounts);
5469   RemoveLoopFromBackedgeMap(PredicatedBackedgeTakenCounts);
5470
5471   // Drop information about expressions based on loop-header PHIs.
5472   SmallVector<Instruction *, 16> Worklist;
5473   PushLoopPHIs(L, Worklist);
5474
5475   SmallPtrSet<Instruction *, 8> Visited;
5476   while (!Worklist.empty()) {
5477     Instruction *I = Worklist.pop_back_val();
5478     if (!Visited.insert(I).second)
5479       continue;
5480
5481     ValueExprMapType::iterator It =
5482       ValueExprMap.find_as(static_cast<Value *>(I));
5483     if (It != ValueExprMap.end()) {
5484       forgetMemoizedResults(It->second);
5485       ValueExprMap.erase(It);
5486       if (PHINode *PN = dyn_cast<PHINode>(I))
5487         ConstantEvolutionLoopExitValue.erase(PN);
5488     }
5489
5490     PushDefUseChildren(I, Worklist);
5491   }
5492
5493   // Forget all contained loops too, to avoid dangling entries in the
5494   // ValuesAtScopes map.
5495   for (Loop *I : *L)
5496     forgetLoop(I);
5497
5498   LoopHasNoAbnormalExits.erase(L);
5499 }
5500
5501 void ScalarEvolution::forgetValue(Value *V) {
5502   Instruction *I = dyn_cast<Instruction>(V);
5503   if (!I) return;
5504
5505   // Drop information about expressions based on loop-header PHIs.
5506   SmallVector<Instruction *, 16> Worklist;
5507   Worklist.push_back(I);
5508
5509   SmallPtrSet<Instruction *, 8> Visited;
5510   while (!Worklist.empty()) {
5511     I = Worklist.pop_back_val();
5512     if (!Visited.insert(I).second)
5513       continue;
5514
5515     ValueExprMapType::iterator It =
5516       ValueExprMap.find_as(static_cast<Value *>(I));
5517     if (It != ValueExprMap.end()) {
5518       forgetMemoizedResults(It->second);
5519       ValueExprMap.erase(It);
5520       if (PHINode *PN = dyn_cast<PHINode>(I))
5521         ConstantEvolutionLoopExitValue.erase(PN);
5522     }
5523
5524     PushDefUseChildren(I, Worklist);
5525   }
5526 }
5527
5528 /// Get the exact loop backedge taken count considering all loop exits. A
5529 /// computable result can only be returned for loops with a single exit.
5530 /// Returning the minimum taken count among all exits is incorrect because one
5531 /// of the loop's exit limit's may have been skipped. howFarToZero assumes that
5532 /// the limit of each loop test is never skipped. This is a valid assumption as
5533 /// long as the loop exits via that test. For precise results, it is the
5534 /// caller's responsibility to specify the relevant loop exit using
5535 /// getExact(ExitingBlock, SE).
5536 const SCEV *
5537 ScalarEvolution::BackedgeTakenInfo::getExact(
5538     ScalarEvolution *SE, SCEVUnionPredicate *Preds) const {
5539   // If any exits were not computable, the loop is not computable.
5540   if (!ExitNotTaken.isCompleteList()) return SE->getCouldNotCompute();
5541
5542   // We need exactly one computable exit.
5543   if (!ExitNotTaken.ExitingBlock) return SE->getCouldNotCompute();
5544   assert(ExitNotTaken.ExactNotTaken && "uninitialized not-taken info");
5545
5546   const SCEV *BECount = nullptr;
5547   for (auto &ENT : ExitNotTaken) {
5548     assert(ENT.ExactNotTaken != SE->getCouldNotCompute() && "bad exit SCEV");
5549
5550     if (!BECount)
5551       BECount = ENT.ExactNotTaken;
5552     else if (BECount != ENT.ExactNotTaken)
5553       return SE->getCouldNotCompute();
5554     if (Preds && ENT.getPred())
5555       Preds->add(ENT.getPred());
5556
5557     assert((Preds || ENT.hasAlwaysTruePred()) &&
5558            "Predicate should be always true!");
5559   }
5560
5561   assert(BECount && "Invalid not taken count for loop exit");
5562   return BECount;
5563 }
5564
5565 /// Get the exact not taken count for this loop exit.
5566 const SCEV *
5567 ScalarEvolution::BackedgeTakenInfo::getExact(BasicBlock *ExitingBlock,
5568                                              ScalarEvolution *SE) const {
5569   for (auto &ENT : ExitNotTaken)
5570     if (ENT.ExitingBlock == ExitingBlock && ENT.hasAlwaysTruePred())
5571       return ENT.ExactNotTaken;
5572
5573   return SE->getCouldNotCompute();
5574 }
5575
5576 /// getMax - Get the max backedge taken count for the loop.
5577 const SCEV *
5578 ScalarEvolution::BackedgeTakenInfo::getMax(ScalarEvolution *SE) const {
5579   for (auto &ENT : ExitNotTaken)
5580     if (!ENT.hasAlwaysTruePred())
5581       return SE->getCouldNotCompute();
5582
5583   return Max ? Max : SE->getCouldNotCompute();
5584 }
5585
5586 bool ScalarEvolution::BackedgeTakenInfo::hasOperand(const SCEV *S,
5587                                                     ScalarEvolution *SE) const {
5588   if (Max && Max != SE->getCouldNotCompute() && SE->hasOperand(Max, S))
5589     return true;
5590
5591   if (!ExitNotTaken.ExitingBlock)
5592     return false;
5593
5594   for (auto &ENT : ExitNotTaken)
5595     if (ENT.ExactNotTaken != SE->getCouldNotCompute() &&
5596         SE->hasOperand(ENT.ExactNotTaken, S))
5597       return true;
5598
5599   return false;
5600 }
5601
5602 /// Allocate memory for BackedgeTakenInfo and copy the not-taken count of each
5603 /// computable exit into a persistent ExitNotTakenInfo array.
5604 ScalarEvolution::BackedgeTakenInfo::BackedgeTakenInfo(
5605     SmallVectorImpl<EdgeInfo> &ExitCounts, bool Complete, const SCEV *MaxCount)
5606     : Max(MaxCount) {
5607
5608   if (!Complete)
5609     ExitNotTaken.setIncomplete();
5610
5611   unsigned NumExits = ExitCounts.size();
5612   if (NumExits == 0) return;
5613
5614   ExitNotTaken.ExitingBlock = ExitCounts[0].ExitBlock;
5615   ExitNotTaken.ExactNotTaken = ExitCounts[0].Taken;
5616
5617   // Determine the number of ExitNotTakenExtras structures that we need.
5618   unsigned ExtraInfoSize = 0;
5619   if (NumExits > 1)
5620     ExtraInfoSize = 1 + std::count_if(std::next(ExitCounts.begin()),
5621                                       ExitCounts.end(), [](EdgeInfo &Entry) {
5622                                         return !Entry.Pred.isAlwaysTrue();
5623                                       });
5624   else if (!ExitCounts[0].Pred.isAlwaysTrue())
5625     ExtraInfoSize = 1;
5626
5627   ExitNotTakenExtras *ENT = nullptr;
5628
5629   // Allocate the ExitNotTakenExtras structures and initialize the first
5630   // element (ExitNotTaken).
5631   if (ExtraInfoSize > 0) {
5632     ENT = new ExitNotTakenExtras[ExtraInfoSize];
5633     ExitNotTaken.ExtraInfo = &ENT[0];
5634     *ExitNotTaken.getPred() = std::move(ExitCounts[0].Pred);
5635   }
5636
5637   if (NumExits == 1)
5638     return;
5639
5640   assert(ENT && "ExitNotTakenExtras is NULL while having more than one exit");
5641
5642   auto &Exits = ExitNotTaken.ExtraInfo->Exits;
5643
5644   // Handle the rare case of multiple computable exits.
5645   for (unsigned i = 1, PredPos = 1; i < NumExits; ++i) {
5646     ExitNotTakenExtras *Ptr = nullptr;
5647     if (!ExitCounts[i].Pred.isAlwaysTrue()) {
5648       Ptr = &ENT[PredPos++];
5649       Ptr->Pred = std::move(ExitCounts[i].Pred);
5650     }
5651
5652     Exits.emplace_back(ExitCounts[i].ExitBlock, ExitCounts[i].Taken, Ptr);
5653   }
5654 }
5655
5656 /// Invalidate this result and free the ExitNotTakenInfo array.
5657 void ScalarEvolution::BackedgeTakenInfo::clear() {
5658   ExitNotTaken.ExitingBlock = nullptr;
5659   ExitNotTaken.ExactNotTaken = nullptr;
5660   delete[] ExitNotTaken.ExtraInfo;
5661 }
5662
5663 /// Compute the number of times the backedge of the specified loop will execute.
5664 ScalarEvolution::BackedgeTakenInfo
5665 ScalarEvolution::computeBackedgeTakenCount(const Loop *L,
5666                                            bool AllowPredicates) {
5667   SmallVector<BasicBlock *, 8> ExitingBlocks;
5668   L->getExitingBlocks(ExitingBlocks);
5669
5670   SmallVector<EdgeInfo, 4> ExitCounts;
5671   bool CouldComputeBECount = true;
5672   BasicBlock *Latch = L->getLoopLatch(); // may be NULL.
5673   const SCEV *MustExitMaxBECount = nullptr;
5674   const SCEV *MayExitMaxBECount = nullptr;
5675
5676   // Compute the ExitLimit for each loop exit. Use this to populate ExitCounts
5677   // and compute maxBECount.
5678   // Do a union of all the predicates here.
5679   for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
5680     BasicBlock *ExitBB = ExitingBlocks[i];
5681     ExitLimit EL = computeExitLimit(L, ExitBB, AllowPredicates);
5682
5683     assert((AllowPredicates || EL.Pred.isAlwaysTrue()) &&
5684            "Predicated exit limit when predicates are not allowed!");
5685
5686     // 1. For each exit that can be computed, add an entry to ExitCounts.
5687     // CouldComputeBECount is true only if all exits can be computed.
5688     if (EL.Exact == getCouldNotCompute())
5689       // We couldn't compute an exact value for this exit, so
5690       // we won't be able to compute an exact value for the loop.
5691       CouldComputeBECount = false;
5692     else
5693       ExitCounts.emplace_back(EdgeInfo(ExitBB, EL.Exact, EL.Pred));
5694
5695     // 2. Derive the loop's MaxBECount from each exit's max number of
5696     // non-exiting iterations. Partition the loop exits into two kinds:
5697     // LoopMustExits and LoopMayExits.
5698     //
5699     // If the exit dominates the loop latch, it is a LoopMustExit otherwise it
5700     // is a LoopMayExit.  If any computable LoopMustExit is found, then
5701     // MaxBECount is the minimum EL.Max of computable LoopMustExits. Otherwise,
5702     // MaxBECount is conservatively the maximum EL.Max, where CouldNotCompute is
5703     // considered greater than any computable EL.Max.
5704     if (EL.Max != getCouldNotCompute() && Latch &&
5705         DT.dominates(ExitBB, Latch)) {
5706       if (!MustExitMaxBECount)
5707         MustExitMaxBECount = EL.Max;
5708       else {
5709         MustExitMaxBECount =
5710           getUMinFromMismatchedTypes(MustExitMaxBECount, EL.Max);
5711       }
5712     } else if (MayExitMaxBECount != getCouldNotCompute()) {
5713       if (!MayExitMaxBECount || EL.Max == getCouldNotCompute())
5714         MayExitMaxBECount = EL.Max;
5715       else {
5716         MayExitMaxBECount =
5717           getUMaxFromMismatchedTypes(MayExitMaxBECount, EL.Max);
5718       }
5719     }
5720   }
5721   const SCEV *MaxBECount = MustExitMaxBECount ? MustExitMaxBECount :
5722     (MayExitMaxBECount ? MayExitMaxBECount : getCouldNotCompute());
5723   return BackedgeTakenInfo(ExitCounts, CouldComputeBECount, MaxBECount);
5724 }
5725
5726 ScalarEvolution::ExitLimit
5727 ScalarEvolution::computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
5728                                   bool AllowPredicates) {
5729
5730   // Okay, we've chosen an exiting block.  See what condition causes us to exit
5731   // at this block and remember the exit block and whether all other targets
5732   // lead to the loop header.
5733   bool MustExecuteLoopHeader = true;
5734   BasicBlock *Exit = nullptr;
5735   for (auto *SBB : successors(ExitingBlock))
5736     if (!L->contains(SBB)) {
5737       if (Exit) // Multiple exit successors.
5738         return getCouldNotCompute();
5739       Exit = SBB;
5740     } else if (SBB != L->getHeader()) {
5741       MustExecuteLoopHeader = false;
5742     }
5743
5744   // At this point, we know we have a conditional branch that determines whether
5745   // the loop is exited.  However, we don't know if the branch is executed each
5746   // time through the loop.  If not, then the execution count of the branch will
5747   // not be equal to the trip count of the loop.
5748   //
5749   // Currently we check for this by checking to see if the Exit branch goes to
5750   // the loop header.  If so, we know it will always execute the same number of
5751   // times as the loop.  We also handle the case where the exit block *is* the
5752   // loop header.  This is common for un-rotated loops.
5753   //
5754   // If both of those tests fail, walk up the unique predecessor chain to the
5755   // header, stopping if there is an edge that doesn't exit the loop. If the
5756   // header is reached, the execution count of the branch will be equal to the
5757   // trip count of the loop.
5758   //
5759   //  More extensive analysis could be done to handle more cases here.
5760   //
5761   if (!MustExecuteLoopHeader && ExitingBlock != L->getHeader()) {
5762     // The simple checks failed, try climbing the unique predecessor chain
5763     // up to the header.
5764     bool Ok = false;
5765     for (BasicBlock *BB = ExitingBlock; BB; ) {
5766       BasicBlock *Pred = BB->getUniquePredecessor();
5767       if (!Pred)
5768         return getCouldNotCompute();
5769       TerminatorInst *PredTerm = Pred->getTerminator();
5770       for (const BasicBlock *PredSucc : PredTerm->successors()) {
5771         if (PredSucc == BB)
5772           continue;
5773         // If the predecessor has a successor that isn't BB and isn't
5774         // outside the loop, assume the worst.
5775         if (L->contains(PredSucc))
5776           return getCouldNotCompute();
5777       }
5778       if (Pred == L->getHeader()) {
5779         Ok = true;
5780         break;
5781       }
5782       BB = Pred;
5783     }
5784     if (!Ok)
5785       return getCouldNotCompute();
5786   }
5787
5788   bool IsOnlyExit = (L->getExitingBlock() != nullptr);
5789   TerminatorInst *Term = ExitingBlock->getTerminator();
5790   if (BranchInst *BI = dyn_cast<BranchInst>(Term)) {
5791     assert(BI->isConditional() && "If unconditional, it can't be in loop!");
5792     // Proceed to the next level to examine the exit condition expression.
5793     return computeExitLimitFromCond(
5794         L, BI->getCondition(), BI->getSuccessor(0), BI->getSuccessor(1),
5795         /*ControlsExit=*/IsOnlyExit, AllowPredicates);
5796   }
5797
5798   if (SwitchInst *SI = dyn_cast<SwitchInst>(Term))
5799     return computeExitLimitFromSingleExitSwitch(L, SI, Exit,
5800                                                 /*ControlsExit=*/IsOnlyExit);
5801
5802   return getCouldNotCompute();
5803 }
5804
5805 ScalarEvolution::ExitLimit
5806 ScalarEvolution::computeExitLimitFromCond(const Loop *L,
5807                                           Value *ExitCond,
5808                                           BasicBlock *TBB,
5809                                           BasicBlock *FBB,
5810                                           bool ControlsExit,
5811                                           bool AllowPredicates) {
5812   // Check if the controlling expression for this loop is an And or Or.
5813   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(ExitCond)) {
5814     if (BO->getOpcode() == Instruction::And) {
5815       // Recurse on the operands of the and.
5816       bool EitherMayExit = L->contains(TBB);
5817       ExitLimit EL0 = computeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
5818                                                ControlsExit && !EitherMayExit,
5819                                                AllowPredicates);
5820       ExitLimit EL1 = computeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
5821                                                ControlsExit && !EitherMayExit,
5822                                                AllowPredicates);
5823       const SCEV *BECount = getCouldNotCompute();
5824       const SCEV *MaxBECount = getCouldNotCompute();
5825       if (EitherMayExit) {
5826         // Both conditions must be true for the loop to continue executing.
5827         // Choose the less conservative count.
5828         if (EL0.Exact == getCouldNotCompute() ||
5829             EL1.Exact == getCouldNotCompute())
5830           BECount = getCouldNotCompute();
5831         else
5832           BECount = getUMinFromMismatchedTypes(EL0.Exact, EL1.Exact);
5833         if (EL0.Max == getCouldNotCompute())
5834           MaxBECount = EL1.Max;
5835         else if (EL1.Max == getCouldNotCompute())
5836           MaxBECount = EL0.Max;
5837         else
5838           MaxBECount = getUMinFromMismatchedTypes(EL0.Max, EL1.Max);
5839       } else {
5840         // Both conditions must be true at the same time for the loop to exit.
5841         // For now, be conservative.
5842         assert(L->contains(FBB) && "Loop block has no successor in loop!");
5843         if (EL0.Max == EL1.Max)
5844           MaxBECount = EL0.Max;
5845         if (EL0.Exact == EL1.Exact)
5846           BECount = EL0.Exact;
5847       }
5848
5849       SCEVUnionPredicate NP;
5850       NP.add(&EL0.Pred);
5851       NP.add(&EL1.Pred);
5852       // There are cases (e.g. PR26207) where computeExitLimitFromCond is able
5853       // to be more aggressive when computing BECount than when computing
5854       // MaxBECount.  In these cases it is possible for EL0.Exact and EL1.Exact
5855       // to match, but for EL0.Max and EL1.Max to not.
5856       if (isa<SCEVCouldNotCompute>(MaxBECount) &&
5857           !isa<SCEVCouldNotCompute>(BECount))
5858         MaxBECount = BECount;
5859
5860       return ExitLimit(BECount, MaxBECount, NP);
5861     }
5862     if (BO->getOpcode() == Instruction::Or) {
5863       // Recurse on the operands of the or.
5864       bool EitherMayExit = L->contains(FBB);
5865       ExitLimit EL0 = computeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
5866                                                ControlsExit && !EitherMayExit,
5867                                                AllowPredicates);
5868       ExitLimit EL1 = computeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
5869                                                ControlsExit && !EitherMayExit,
5870                                                AllowPredicates);
5871       const SCEV *BECount = getCouldNotCompute();
5872       const SCEV *MaxBECount = getCouldNotCompute();
5873       if (EitherMayExit) {
5874         // Both conditions must be false for the loop to continue executing.
5875         // Choose the less conservative count.
5876         if (EL0.Exact == getCouldNotCompute() ||
5877             EL1.Exact == getCouldNotCompute())
5878           BECount = getCouldNotCompute();
5879         else
5880           BECount = getUMinFromMismatchedTypes(EL0.Exact, EL1.Exact);
5881         if (EL0.Max == getCouldNotCompute())
5882           MaxBECount = EL1.Max;
5883         else if (EL1.Max == getCouldNotCompute())
5884           MaxBECount = EL0.Max;
5885         else
5886           MaxBECount = getUMinFromMismatchedTypes(EL0.Max, EL1.Max);
5887       } else {
5888         // Both conditions must be false at the same time for the loop to exit.
5889         // For now, be conservative.
5890         assert(L->contains(TBB) && "Loop block has no successor in loop!");
5891         if (EL0.Max == EL1.Max)
5892           MaxBECount = EL0.Max;
5893         if (EL0.Exact == EL1.Exact)
5894           BECount = EL0.Exact;
5895       }
5896
5897       SCEVUnionPredicate NP;
5898       NP.add(&EL0.Pred);
5899       NP.add(&EL1.Pred);
5900       return ExitLimit(BECount, MaxBECount, NP);
5901     }
5902   }
5903
5904   // With an icmp, it may be feasible to compute an exact backedge-taken count.
5905   // Proceed to the next level to examine the icmp.
5906   if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond)) {
5907     ExitLimit EL =
5908         computeExitLimitFromICmp(L, ExitCondICmp, TBB, FBB, ControlsExit);
5909     if (EL.hasFullInfo() || !AllowPredicates)
5910       return EL;
5911
5912     // Try again, but use SCEV predicates this time.
5913     return computeExitLimitFromICmp(L, ExitCondICmp, TBB, FBB, ControlsExit,
5914                                     /*AllowPredicates=*/true);
5915   }
5916
5917   // Check for a constant condition. These are normally stripped out by
5918   // SimplifyCFG, but ScalarEvolution may be used by a pass which wishes to
5919   // preserve the CFG and is temporarily leaving constant conditions
5920   // in place.
5921   if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
5922     if (L->contains(FBB) == !CI->getZExtValue())
5923       // The backedge is always taken.
5924       return getCouldNotCompute();
5925     else
5926       // The backedge is never taken.
5927       return getZero(CI->getType());
5928   }
5929
5930   // If it's not an integer or pointer comparison then compute it the hard way.
5931   return computeExitCountExhaustively(L, ExitCond, !L->contains(TBB));
5932 }
5933
5934 ScalarEvolution::ExitLimit
5935 ScalarEvolution::computeExitLimitFromICmp(const Loop *L,
5936                                           ICmpInst *ExitCond,
5937                                           BasicBlock *TBB,
5938                                           BasicBlock *FBB,
5939                                           bool ControlsExit,
5940                                           bool AllowPredicates) {
5941
5942   // If the condition was exit on true, convert the condition to exit on false
5943   ICmpInst::Predicate Cond;
5944   if (!L->contains(FBB))
5945     Cond = ExitCond->getPredicate();
5946   else
5947     Cond = ExitCond->getInversePredicate();
5948
5949   // Handle common loops like: for (X = "string"; *X; ++X)
5950   if (LoadInst *LI = dyn_cast<LoadInst>(ExitCond->getOperand(0)))
5951     if (Constant *RHS = dyn_cast<Constant>(ExitCond->getOperand(1))) {
5952       ExitLimit ItCnt =
5953         computeLoadConstantCompareExitLimit(LI, RHS, L, Cond);
5954       if (ItCnt.hasAnyInfo())
5955         return ItCnt;
5956     }
5957
5958   const SCEV *LHS = getSCEV(ExitCond->getOperand(0));
5959   const SCEV *RHS = getSCEV(ExitCond->getOperand(1));
5960
5961   // Try to evaluate any dependencies out of the loop.
5962   LHS = getSCEVAtScope(LHS, L);
5963   RHS = getSCEVAtScope(RHS, L);
5964
5965   // At this point, we would like to compute how many iterations of the
5966   // loop the predicate will return true for these inputs.
5967   if (isLoopInvariant(LHS, L) && !isLoopInvariant(RHS, L)) {
5968     // If there is a loop-invariant, force it into the RHS.
5969     std::swap(LHS, RHS);
5970     Cond = ICmpInst::getSwappedPredicate(Cond);
5971   }
5972
5973   // Simplify the operands before analyzing them.
5974   (void)SimplifyICmpOperands(Cond, LHS, RHS);
5975
5976   // If we have a comparison of a chrec against a constant, try to use value
5977   // ranges to answer this query.
5978   if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
5979     if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS))
5980       if (AddRec->getLoop() == L) {
5981         // Form the constant range.
5982         ConstantRange CompRange(
5983             ICmpInst::makeConstantRange(Cond, RHSC->getAPInt()));
5984
5985         const SCEV *Ret = AddRec->getNumIterationsInRange(CompRange, *this);
5986         if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
5987       }
5988
5989   switch (Cond) {
5990   case ICmpInst::ICMP_NE: {                     // while (X != Y)
5991     // Convert to: while (X-Y != 0)
5992     ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit,
5993                                 AllowPredicates);
5994     if (EL.hasAnyInfo()) return EL;
5995     break;
5996   }
5997   case ICmpInst::ICMP_EQ: {                     // while (X == Y)
5998     // Convert to: while (X-Y == 0)
5999     ExitLimit EL = howFarToNonZero(getMinusSCEV(LHS, RHS), L);
6000     if (EL.hasAnyInfo()) return EL;
6001     break;
6002   }
6003   case ICmpInst::ICMP_SLT:
6004   case ICmpInst::ICMP_ULT: {                    // while (X < Y)
6005     bool IsSigned = Cond == ICmpInst::ICMP_SLT;
6006     ExitLimit EL = howManyLessThans(LHS, RHS, L, IsSigned, ControlsExit,
6007                                     AllowPredicates);
6008     if (EL.hasAnyInfo()) return EL;
6009     break;
6010   }
6011   case ICmpInst::ICMP_SGT:
6012   case ICmpInst::ICMP_UGT: {                    // while (X > Y)
6013     bool IsSigned = Cond == ICmpInst::ICMP_SGT;
6014     ExitLimit EL =
6015         howManyGreaterThans(LHS, RHS, L, IsSigned, ControlsExit,
6016                             AllowPredicates);
6017     if (EL.hasAnyInfo()) return EL;
6018     break;
6019   }
6020   default:
6021     break;
6022   }
6023
6024   auto *ExhaustiveCount =
6025       computeExitCountExhaustively(L, ExitCond, !L->contains(TBB));
6026
6027   if (!isa<SCEVCouldNotCompute>(ExhaustiveCount))
6028     return ExhaustiveCount;
6029
6030   return computeShiftCompareExitLimit(ExitCond->getOperand(0),
6031                                       ExitCond->getOperand(1), L, Cond);
6032 }
6033
6034 ScalarEvolution::ExitLimit
6035 ScalarEvolution::computeExitLimitFromSingleExitSwitch(const Loop *L,
6036                                                       SwitchInst *Switch,
6037                                                       BasicBlock *ExitingBlock,
6038                                                       bool ControlsExit) {
6039   assert(!L->contains(ExitingBlock) && "Not an exiting block!");
6040
6041   // Give up if the exit is the default dest of a switch.
6042   if (Switch->getDefaultDest() == ExitingBlock)
6043     return getCouldNotCompute();
6044
6045   assert(L->contains(Switch->getDefaultDest()) &&
6046          "Default case must not exit the loop!");
6047   const SCEV *LHS = getSCEVAtScope(Switch->getCondition(), L);
6048   const SCEV *RHS = getConstant(Switch->findCaseDest(ExitingBlock));
6049
6050   // while (X != Y) --> while (X-Y != 0)
6051   ExitLimit EL = howFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit);
6052   if (EL.hasAnyInfo())
6053     return EL;
6054
6055   return getCouldNotCompute();
6056 }
6057
6058 static ConstantInt *
6059 EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C,
6060                                 ScalarEvolution &SE) {
6061   const SCEV *InVal = SE.getConstant(C);
6062   const SCEV *Val = AddRec->evaluateAtIteration(InVal, SE);
6063   assert(isa<SCEVConstant>(Val) &&
6064          "Evaluation of SCEV at constant didn't fold correctly?");
6065   return cast<SCEVConstant>(Val)->getValue();
6066 }
6067
6068 /// Given an exit condition of 'icmp op load X, cst', try to see if we can
6069 /// compute the backedge execution count.
6070 ScalarEvolution::ExitLimit
6071 ScalarEvolution::computeLoadConstantCompareExitLimit(
6072   LoadInst *LI,
6073   Constant *RHS,
6074   const Loop *L,
6075   ICmpInst::Predicate predicate) {
6076
6077   if (LI->isVolatile()) return getCouldNotCompute();
6078
6079   // Check to see if the loaded pointer is a getelementptr of a global.
6080   // TODO: Use SCEV instead of manually grubbing with GEPs.
6081   GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getOperand(0));
6082   if (!GEP) return getCouldNotCompute();
6083
6084   // Make sure that it is really a constant global we are gepping, with an
6085   // initializer, and make sure the first IDX is really 0.
6086   GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0));
6087   if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer() ||
6088       GEP->getNumOperands() < 3 || !isa<Constant>(GEP->getOperand(1)) ||
6089       !cast<Constant>(GEP->getOperand(1))->isNullValue())
6090     return getCouldNotCompute();
6091
6092   // Okay, we allow one non-constant index into the GEP instruction.
6093   Value *VarIdx = nullptr;
6094   std::vector<Constant*> Indexes;
6095   unsigned VarIdxNum = 0;
6096   for (unsigned i = 2, e = GEP->getNumOperands(); i != e; ++i)
6097     if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
6098       Indexes.push_back(CI);
6099     } else if (!isa<ConstantInt>(GEP->getOperand(i))) {
6100       if (VarIdx) return getCouldNotCompute();  // Multiple non-constant idx's.
6101       VarIdx = GEP->getOperand(i);
6102       VarIdxNum = i-2;
6103       Indexes.push_back(nullptr);
6104     }
6105
6106   // Loop-invariant loads may be a byproduct of loop optimization. Skip them.
6107   if (!VarIdx)
6108     return getCouldNotCompute();
6109
6110   // Okay, we know we have a (load (gep GV, 0, X)) comparison with a constant.
6111   // Check to see if X is a loop variant variable value now.
6112   const SCEV *Idx = getSCEV(VarIdx);
6113   Idx = getSCEVAtScope(Idx, L);
6114
6115   // We can only recognize very limited forms of loop index expressions, in
6116   // particular, only affine AddRec's like {C1,+,C2}.
6117   const SCEVAddRecExpr *IdxExpr = dyn_cast<SCEVAddRecExpr>(Idx);
6118   if (!IdxExpr || !IdxExpr->isAffine() || isLoopInvariant(IdxExpr, L) ||
6119       !isa<SCEVConstant>(IdxExpr->getOperand(0)) ||
6120       !isa<SCEVConstant>(IdxExpr->getOperand(1)))
6121     return getCouldNotCompute();
6122
6123   unsigned MaxSteps = MaxBruteForceIterations;
6124   for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
6125     ConstantInt *ItCst = ConstantInt::get(
6126                            cast<IntegerType>(IdxExpr->getType()), IterationNum);
6127     ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst, *this);
6128
6129     // Form the GEP offset.
6130     Indexes[VarIdxNum] = Val;
6131
6132     Constant *Result = ConstantFoldLoadThroughGEPIndices(GV->getInitializer(),
6133                                                          Indexes);
6134     if (!Result) break;  // Cannot compute!
6135
6136     // Evaluate the condition for this iteration.
6137     Result = ConstantExpr::getICmp(predicate, Result, RHS);
6138     if (!isa<ConstantInt>(Result)) break;  // Couldn't decide for sure
6139     if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
6140       ++NumArrayLenItCounts;
6141       return getConstant(ItCst);   // Found terminating iteration!
6142     }
6143   }
6144   return getCouldNotCompute();
6145 }
6146
6147 ScalarEvolution::ExitLimit ScalarEvolution::computeShiftCompareExitLimit(
6148     Value *LHS, Value *RHSV, const Loop *L, ICmpInst::Predicate Pred) {
6149   ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV);
6150   if (!RHS)
6151     return getCouldNotCompute();
6152
6153   const BasicBlock *Latch = L->getLoopLatch();
6154   if (!Latch)
6155     return getCouldNotCompute();
6156
6157   const BasicBlock *Predecessor = L->getLoopPredecessor();
6158   if (!Predecessor)
6159     return getCouldNotCompute();
6160
6161   // Return true if V is of the form "LHS `shift_op` <positive constant>".
6162   // Return LHS in OutLHS and shift_opt in OutOpCode.
6163   auto MatchPositiveShift =
6164       [](Value *V, Value *&OutLHS, Instruction::BinaryOps &OutOpCode) {
6165
6166     using namespace PatternMatch;
6167
6168     ConstantInt *ShiftAmt;
6169     if (match(V, m_LShr(m_Value(OutLHS), m_ConstantInt(ShiftAmt))))
6170       OutOpCode = Instruction::LShr;
6171     else if (match(V, m_AShr(m_Value(OutLHS), m_ConstantInt(ShiftAmt))))
6172       OutOpCode = Instruction::AShr;
6173     else if (match(V, m_Shl(m_Value(OutLHS), m_ConstantInt(ShiftAmt))))
6174       OutOpCode = Instruction::Shl;
6175     else
6176       return false;
6177
6178     return ShiftAmt->getValue().isStrictlyPositive();
6179   };
6180
6181   // Recognize a "shift recurrence" either of the form %iv or of %iv.shifted in
6182   //
6183   // loop:
6184   //   %iv = phi i32 [ %iv.shifted, %loop ], [ %val, %preheader ]
6185   //   %iv.shifted = lshr i32 %iv, <positive constant>
6186   //
6187   // Return true on a succesful match.  Return the corresponding PHI node (%iv
6188   // above) in PNOut and the opcode of the shift operation in OpCodeOut.
6189   auto MatchShiftRecurrence =
6190       [&](Value *V, PHINode *&PNOut, Instruction::BinaryOps &OpCodeOut) {
6191     Optional<Instruction::BinaryOps> PostShiftOpCode;
6192
6193     {
6194       Instruction::BinaryOps OpC;
6195       Value *V;
6196
6197       // If we encounter a shift instruction, "peel off" the shift operation,
6198       // and remember that we did so.  Later when we inspect %iv's backedge
6199       // value, we will make sure that the backedge value uses the same
6200       // operation.
6201       //
6202       // Note: the peeled shift operation does not have to be the same
6203       // instruction as the one feeding into the PHI's backedge value.  We only
6204       // really care about it being the same *kind* of shift instruction --
6205       // that's all that is required for our later inferences to hold.
6206       if (MatchPositiveShift(LHS, V, OpC)) {
6207         PostShiftOpCode = OpC;
6208         LHS = V;
6209       }
6210     }
6211
6212     PNOut = dyn_cast<PHINode>(LHS);
6213     if (!PNOut || PNOut->getParent() != L->getHeader())
6214       return false;
6215
6216     Value *BEValue = PNOut->getIncomingValueForBlock(Latch);
6217     Value *OpLHS;
6218
6219     return
6220         // The backedge value for the PHI node must be a shift by a positive
6221         // amount
6222         MatchPositiveShift(BEValue, OpLHS, OpCodeOut) &&
6223
6224         // of the PHI node itself
6225         OpLHS == PNOut &&
6226
6227         // and the kind of shift should be match the kind of shift we peeled
6228         // off, if any.
6229         (!PostShiftOpCode.hasValue() || *PostShiftOpCode == OpCodeOut);
6230   };
6231
6232   PHINode *PN;
6233   Instruction::BinaryOps OpCode;
6234   if (!MatchShiftRecurrence(LHS, PN, OpCode))
6235     return getCouldNotCompute();
6236
6237   const DataLayout &DL = getDataLayout();
6238
6239   // The key rationale for this optimization is that for some kinds of shift
6240   // recurrences, the value of the recurrence "stabilizes" to either 0 or -1
6241   // within a finite number of iterations.  If the condition guarding the
6242   // backedge (in the sense that the backedge is taken if the condition is true)
6243   // is false for the value the shift recurrence stabilizes to, then we know
6244   // that the backedge is taken only a finite number of times.
6245
6246   ConstantInt *StableValue = nullptr;
6247   switch (OpCode) {
6248   default:
6249     llvm_unreachable("Impossible case!");
6250
6251   case Instruction::AShr: {
6252     // {K,ashr,<positive-constant>} stabilizes to signum(K) in at most
6253     // bitwidth(K) iterations.
6254     Value *FirstValue = PN->getIncomingValueForBlock(Predecessor);
6255     bool KnownZero, KnownOne;
6256     ComputeSignBit(FirstValue, KnownZero, KnownOne, DL, 0, nullptr,
6257                    Predecessor->getTerminator(), &DT);
6258     auto *Ty = cast<IntegerType>(RHS->getType());
6259     if (KnownZero)
6260       StableValue = ConstantInt::get(Ty, 0);
6261     else if (KnownOne)
6262       StableValue = ConstantInt::get(Ty, -1, true);
6263     else
6264       return getCouldNotCompute();
6265
6266     break;
6267   }
6268   case Instruction::LShr:
6269   case Instruction::Shl:
6270     // Both {K,lshr,<positive-constant>} and {K,shl,<positive-constant>}
6271     // stabilize to 0 in at most bitwidth(K) iterations.
6272     StableValue = ConstantInt::get(cast<IntegerType>(RHS->getType()), 0);
6273     break;
6274   }
6275
6276   auto *Result =
6277       ConstantFoldCompareInstOperands(Pred, StableValue, RHS, DL, &TLI);
6278   assert(Result->getType()->isIntegerTy(1) &&
6279          "Otherwise cannot be an operand to a branch instruction");
6280
6281   if (Result->isZeroValue()) {
6282     unsigned BitWidth = getTypeSizeInBits(RHS->getType());
6283     const SCEV *UpperBound =
6284         getConstant(getEffectiveSCEVType(RHS->getType()), BitWidth);
6285     SCEVUnionPredicate P;
6286     return ExitLimit(getCouldNotCompute(), UpperBound, P);
6287   }
6288
6289   return getCouldNotCompute();
6290 }
6291
6292 /// Return true if we can constant fold an instruction of the specified type,
6293 /// assuming that all operands were constants.
6294 static bool CanConstantFold(const Instruction *I) {
6295   if (isa<BinaryOperator>(I) || isa<CmpInst>(I) ||
6296       isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I) ||
6297       isa<LoadInst>(I))
6298     return true;
6299
6300   if (const CallInst *CI = dyn_cast<CallInst>(I))
6301     if (const Function *F = CI->getCalledFunction())
6302       return canConstantFoldCallTo(F);
6303   return false;
6304 }
6305
6306 /// Determine whether this instruction can constant evolve within this loop
6307 /// assuming its operands can all constant evolve.
6308 static bool canConstantEvolve(Instruction *I, const Loop *L) {
6309   // An instruction outside of the loop can't be derived from a loop PHI.
6310   if (!L->contains(I)) return false;
6311
6312   if (isa<PHINode>(I)) {
6313     // We don't currently keep track of the control flow needed to evaluate
6314     // PHIs, so we cannot handle PHIs inside of loops.
6315     return L->getHeader() == I->getParent();
6316   }
6317
6318   // If we won't be able to constant fold this expression even if the operands
6319   // are constants, bail early.
6320   return CanConstantFold(I);
6321 }
6322
6323 /// getConstantEvolvingPHIOperands - Implement getConstantEvolvingPHI by
6324 /// recursing through each instruction operand until reaching a loop header phi.
6325 static PHINode *
6326 getConstantEvolvingPHIOperands(Instruction *UseInst, const Loop *L,
6327                                DenseMap<Instruction *, PHINode *> &PHIMap) {
6328
6329   // Otherwise, we can evaluate this instruction if all of its operands are
6330   // constant or derived from a PHI node themselves.
6331   PHINode *PHI = nullptr;
6332   for (Value *Op : UseInst->operands()) {
6333     if (isa<Constant>(Op)) continue;
6334
6335     Instruction *OpInst = dyn_cast<Instruction>(Op);
6336     if (!OpInst || !canConstantEvolve(OpInst, L)) return nullptr;
6337
6338     PHINode *P = dyn_cast<PHINode>(OpInst);
6339     if (!P)
6340       // If this operand is already visited, reuse the prior result.
6341       // We may have P != PHI if this is the deepest point at which the
6342       // inconsistent paths meet.
6343       P = PHIMap.lookup(OpInst);
6344     if (!P) {
6345       // Recurse and memoize the results, whether a phi is found or not.
6346       // This recursive call invalidates pointers into PHIMap.
6347       P = getConstantEvolvingPHIOperands(OpInst, L, PHIMap);
6348       PHIMap[OpInst] = P;
6349     }
6350     if (!P)
6351       return nullptr;  // Not evolving from PHI
6352     if (PHI && PHI != P)
6353       return nullptr;  // Evolving from multiple different PHIs.
6354     PHI = P;
6355   }
6356   // This is a expression evolving from a constant PHI!
6357   return PHI;
6358 }
6359
6360 /// getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node
6361 /// in the loop that V is derived from.  We allow arbitrary operations along the
6362 /// way, but the operands of an operation must either be constants or a value
6363 /// derived from a constant PHI.  If this expression does not fit with these
6364 /// constraints, return null.
6365 static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
6366   Instruction *I = dyn_cast<Instruction>(V);
6367   if (!I || !canConstantEvolve(I, L)) return nullptr;
6368
6369   if (PHINode *PN = dyn_cast<PHINode>(I))
6370     return PN;
6371
6372   // Record non-constant instructions contained by the loop.
6373   DenseMap<Instruction *, PHINode *> PHIMap;
6374   return getConstantEvolvingPHIOperands(I, L, PHIMap);
6375 }
6376
6377 /// EvaluateExpression - Given an expression that passes the
6378 /// getConstantEvolvingPHI predicate, evaluate its value assuming the PHI node
6379 /// in the loop has the value PHIVal.  If we can't fold this expression for some
6380 /// reason, return null.
6381 static Constant *EvaluateExpression(Value *V, const Loop *L,
6382                                     DenseMap<Instruction *, Constant *> &Vals,
6383                                     const DataLayout &DL,
6384                                     const TargetLibraryInfo *TLI) {
6385   // Convenient constant check, but redundant for recursive calls.
6386   if (Constant *C = dyn_cast<Constant>(V)) return C;
6387   Instruction *I = dyn_cast<Instruction>(V);
6388   if (!I) return nullptr;
6389
6390   if (Constant *C = Vals.lookup(I)) return C;
6391
6392   // An instruction inside the loop depends on a value outside the loop that we
6393   // weren't given a mapping for, or a value such as a call inside the loop.
6394   if (!canConstantEvolve(I, L)) return nullptr;
6395
6396   // An unmapped PHI can be due to a branch or another loop inside this loop,
6397   // or due to this not being the initial iteration through a loop where we
6398   // couldn't compute the evolution of this particular PHI last time.
6399   if (isa<PHINode>(I)) return nullptr;
6400
6401   std::vector<Constant*> Operands(I->getNumOperands());
6402
6403   for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
6404     Instruction *Operand = dyn_cast<Instruction>(I->getOperand(i));
6405     if (!Operand) {
6406       Operands[i] = dyn_cast<Constant>(I->getOperand(i));
6407       if (!Operands[i]) return nullptr;
6408       continue;
6409     }
6410     Constant *C = EvaluateExpression(Operand, L, Vals, DL, TLI);
6411     Vals[Operand] = C;
6412     if (!C) return nullptr;
6413     Operands[i] = C;
6414   }
6415
6416   if (CmpInst *CI = dyn_cast<CmpInst>(I))
6417     return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
6418                                            Operands[1], DL, TLI);
6419   if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
6420     if (!LI->isVolatile())
6421       return ConstantFoldLoadFromConstPtr(Operands[0], LI->getType(), DL);
6422   }
6423   return ConstantFoldInstOperands(I, Operands, DL, TLI);
6424 }
6425
6426
6427 // If every incoming value to PN except the one for BB is a specific Constant,
6428 // return that, else return nullptr.
6429 static Constant *getOtherIncomingValue(PHINode *PN, BasicBlock *BB) {
6430   Constant *IncomingVal = nullptr;
6431
6432   for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
6433     if (PN->getIncomingBlock(i) == BB)
6434       continue;
6435
6436     auto *CurrentVal = dyn_cast<Constant>(PN->getIncomingValue(i));
6437     if (!CurrentVal)
6438       return nullptr;
6439
6440     if (IncomingVal != CurrentVal) {
6441       if (IncomingVal)
6442         return nullptr;
6443       IncomingVal = CurrentVal;
6444     }
6445   }
6446
6447   return IncomingVal;
6448 }
6449
6450 /// getConstantEvolutionLoopExitValue - If we know that the specified Phi is
6451 /// in the header of its containing loop, we know the loop executes a
6452 /// constant number of times, and the PHI node is just a recurrence
6453 /// involving constants, fold it.
6454 Constant *
6455 ScalarEvolution::getConstantEvolutionLoopExitValue(PHINode *PN,
6456                                                    const APInt &BEs,
6457                                                    const Loop *L) {
6458   auto I = ConstantEvolutionLoopExitValue.find(PN);
6459   if (I != ConstantEvolutionLoopExitValue.end())
6460     return I->second;
6461
6462   if (BEs.ugt(MaxBruteForceIterations))
6463     return ConstantEvolutionLoopExitValue[PN] = nullptr;  // Not going to evaluate it.
6464
6465   Constant *&RetVal = ConstantEvolutionLoopExitValue[PN];
6466
6467   DenseMap<Instruction *, Constant *> CurrentIterVals;
6468   BasicBlock *Header = L->getHeader();
6469   assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
6470
6471   BasicBlock *Latch = L->getLoopLatch();
6472   if (!Latch)
6473     return nullptr;
6474
6475   for (auto &I : *Header) {
6476     PHINode *PHI = dyn_cast<PHINode>(&I);
6477     if (!PHI) break;
6478     auto *StartCST = getOtherIncomingValue(PHI, Latch);
6479     if (!StartCST) continue;
6480     CurrentIterVals[PHI] = StartCST;
6481   }
6482   if (!CurrentIterVals.count(PN))
6483     return RetVal = nullptr;
6484
6485   Value *BEValue = PN->getIncomingValueForBlock(Latch);
6486
6487   // Execute the loop symbolically to determine the exit value.
6488   if (BEs.getActiveBits() >= 32)
6489     return RetVal = nullptr; // More than 2^32-1 iterations?? Not doing it!
6490
6491   unsigned NumIterations = BEs.getZExtValue(); // must be in range
6492   unsigned IterationNum = 0;
6493   const DataLayout &DL = getDataLayout();
6494   for (; ; ++IterationNum) {
6495     if (IterationNum == NumIterations)
6496       return RetVal = CurrentIterVals[PN];  // Got exit value!
6497
6498     // Compute the value of the PHIs for the next iteration.
6499     // EvaluateExpression adds non-phi values to the CurrentIterVals map.
6500     DenseMap<Instruction *, Constant *> NextIterVals;
6501     Constant *NextPHI =
6502         EvaluateExpression(BEValue, L, CurrentIterVals, DL, &TLI);
6503     if (!NextPHI)
6504       return nullptr;        // Couldn't evaluate!
6505     NextIterVals[PN] = NextPHI;
6506
6507     bool StoppedEvolving = NextPHI == CurrentIterVals[PN];
6508
6509     // Also evaluate the other PHI nodes.  However, we don't get to stop if we
6510     // cease to be able to evaluate one of them or if they stop evolving,
6511     // because that doesn't necessarily prevent us from computing PN.
6512     SmallVector<std::pair<PHINode *, Constant *>, 8> PHIsToCompute;
6513     for (const auto &I : CurrentIterVals) {
6514       PHINode *PHI = dyn_cast<PHINode>(I.first);
6515       if (!PHI || PHI == PN || PHI->getParent() != Header) continue;
6516       PHIsToCompute.emplace_back(PHI, I.second);
6517     }
6518     // We use two distinct loops because EvaluateExpression may invalidate any
6519     // iterators into CurrentIterVals.
6520     for (const auto &I : PHIsToCompute) {
6521       PHINode *PHI = I.first;
6522       Constant *&NextPHI = NextIterVals[PHI];
6523       if (!NextPHI) {   // Not already computed.
6524         Value *BEValue = PHI->getIncomingValueForBlock(Latch);
6525         NextPHI = EvaluateExpression(BEValue, L, CurrentIterVals, DL, &TLI);
6526       }
6527       if (NextPHI != I.second)
6528         StoppedEvolving = false;
6529     }
6530
6531     // If all entries in CurrentIterVals == NextIterVals then we can stop
6532     // iterating, the loop can't continue to change.
6533     if (StoppedEvolving)
6534       return RetVal = CurrentIterVals[PN];
6535
6536     CurrentIterVals.swap(NextIterVals);
6537   }
6538 }
6539
6540 const SCEV *ScalarEvolution::computeExitCountExhaustively(const Loop *L,
6541                                                           Value *Cond,
6542                                                           bool ExitWhen) {
6543   PHINode *PN = getConstantEvolvingPHI(Cond, L);
6544   if (!PN) return getCouldNotCompute();
6545
6546   // If the loop is canonicalized, the PHI will have exactly two entries.
6547   // That's the only form we support here.
6548   if (PN->getNumIncomingValues() != 2) return getCouldNotCompute();
6549
6550   DenseMap<Instruction *, Constant *> CurrentIterVals;
6551   BasicBlock *Header = L->getHeader();
6552   assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
6553
6554   BasicBlock *Latch = L->getLoopLatch();
6555   assert(Latch && "Should follow from NumIncomingValues == 2!");
6556
6557   for (auto &I : *Header) {
6558     PHINode *PHI = dyn_cast<PHINode>(&I);
6559     if (!PHI)
6560       break;
6561     auto *StartCST = getOtherIncomingValue(PHI, Latch);
6562     if (!StartCST) continue;
6563     CurrentIterVals[PHI] = StartCST;
6564   }
6565   if (!CurrentIterVals.count(PN))
6566     return getCouldNotCompute();
6567
6568   // Okay, we find a PHI node that defines the trip count of this loop.  Execute
6569   // the loop symbolically to determine when the condition gets a value of
6570   // "ExitWhen".
6571   unsigned MaxIterations = MaxBruteForceIterations;   // Limit analysis.
6572   const DataLayout &DL = getDataLayout();
6573   for (unsigned IterationNum = 0; IterationNum != MaxIterations;++IterationNum){
6574     auto *CondVal = dyn_cast_or_null<ConstantInt>(
6575         EvaluateExpression(Cond, L, CurrentIterVals, DL, &TLI));
6576
6577     // Couldn't symbolically evaluate.
6578     if (!CondVal) return getCouldNotCompute();
6579
6580     if (CondVal->getValue() == uint64_t(ExitWhen)) {
6581       ++NumBruteForceTripCountsComputed;
6582       return getConstant(Type::getInt32Ty(getContext()), IterationNum);
6583     }
6584
6585     // Update all the PHI nodes for the next iteration.
6586     DenseMap<Instruction *, Constant *> NextIterVals;
6587
6588     // Create a list of which PHIs we need to compute. We want to do this before
6589     // calling EvaluateExpression on them because that may invalidate iterators
6590     // into CurrentIterVals.
6591     SmallVector<PHINode *, 8> PHIsToCompute;
6592     for (const auto &I : CurrentIterVals) {
6593       PHINode *PHI = dyn_cast<PHINode>(I.first);
6594       if (!PHI || PHI->getParent() != Header) continue;
6595       PHIsToCompute.push_back(PHI);
6596     }
6597     for (PHINode *PHI : PHIsToCompute) {
6598       Constant *&NextPHI = NextIterVals[PHI];
6599       if (NextPHI) continue;    // Already computed!
6600
6601       Value *BEValue = PHI->getIncomingValueForBlock(Latch);
6602       NextPHI = EvaluateExpression(BEValue, L, CurrentIterVals, DL, &TLI);
6603     }
6604     CurrentIterVals.swap(NextIterVals);
6605   }
6606
6607   // Too many iterations were needed to evaluate.
6608   return getCouldNotCompute();
6609 }
6610
6611 const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
6612   SmallVector<std::pair<const Loop *, const SCEV *>, 2> &Values =
6613       ValuesAtScopes[V];
6614   // Check to see if we've folded this expression at this loop before.
6615   for (auto &LS : Values)
6616     if (LS.first == L)
6617       return LS.second ? LS.second : V;
6618
6619   Values.emplace_back(L, nullptr);
6620
6621   // Otherwise compute it.
6622   const SCEV *C = computeSCEVAtScope(V, L);
6623   for (auto &LS : reverse(ValuesAtScopes[V]))
6624     if (LS.first == L) {
6625       LS.second = C;
6626       break;
6627     }
6628   return C;
6629 }
6630
6631 /// This builds up a Constant using the ConstantExpr interface.  That way, we
6632 /// will return Constants for objects which aren't represented by a
6633 /// SCEVConstant, because SCEVConstant is restricted to ConstantInt.
6634 /// Returns NULL if the SCEV isn't representable as a Constant.
6635 static Constant *BuildConstantFromSCEV(const SCEV *V) {
6636   switch (static_cast<SCEVTypes>(V->getSCEVType())) {
6637     case scCouldNotCompute:
6638     case scAddRecExpr:
6639       break;
6640     case scConstant:
6641       return cast<SCEVConstant>(V)->getValue();
6642     case scUnknown:
6643       return dyn_cast<Constant>(cast<SCEVUnknown>(V)->getValue());
6644     case scSignExtend: {
6645       const SCEVSignExtendExpr *SS = cast<SCEVSignExtendExpr>(V);
6646       if (Constant *CastOp = BuildConstantFromSCEV(SS->getOperand()))
6647         return ConstantExpr::getSExt(CastOp, SS->getType());
6648       break;
6649     }
6650     case scZeroExtend: {
6651       const SCEVZeroExtendExpr *SZ = cast<SCEVZeroExtendExpr>(V);
6652       if (Constant *CastOp = BuildConstantFromSCEV(SZ->getOperand()))
6653         return ConstantExpr::getZExt(CastOp, SZ->getType());
6654       break;
6655     }
6656     case scTruncate: {
6657       const SCEVTruncateExpr *ST = cast<SCEVTruncateExpr>(V);
6658       if (Constant *CastOp = BuildConstantFromSCEV(ST->getOperand()))
6659         return ConstantExpr::getTrunc(CastOp, ST->getType());
6660       break;
6661     }
6662     case scAddExpr: {
6663       const SCEVAddExpr *SA = cast<SCEVAddExpr>(V);
6664       if (Constant *C = BuildConstantFromSCEV(SA->getOperand(0))) {
6665         if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
6666           unsigned AS = PTy->getAddressSpace();
6667           Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
6668           C = ConstantExpr::getBitCast(C, DestPtrTy);
6669         }
6670         for (unsigned i = 1, e = SA->getNumOperands(); i != e; ++i) {
6671           Constant *C2 = BuildConstantFromSCEV(SA->getOperand(i));
6672           if (!C2) return nullptr;
6673
6674           // First pointer!
6675           if (!C->getType()->isPointerTy() && C2->getType()->isPointerTy()) {
6676             unsigned AS = C2->getType()->getPointerAddressSpace();
6677             std::swap(C, C2);
6678             Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
6679             // The offsets have been converted to bytes.  We can add bytes to an
6680             // i8* by GEP with the byte count in the first index.
6681             C = ConstantExpr::getBitCast(C, DestPtrTy);
6682           }
6683
6684           // Don't bother trying to sum two pointers. We probably can't
6685           // statically compute a load that results from it anyway.
6686           if (C2->getType()->isPointerTy())
6687             return nullptr;
6688
6689           if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
6690             if (PTy->getElementType()->isStructTy())
6691               C2 = ConstantExpr::getIntegerCast(
6692                   C2, Type::getInt32Ty(C->getContext()), true);
6693             C = ConstantExpr::getGetElementPtr(PTy->getElementType(), C, C2);
6694           } else
6695             C = ConstantExpr::getAdd(C, C2);
6696         }
6697         return C;
6698       }
6699       break;
6700     }
6701     case scMulExpr: {
6702       const SCEVMulExpr *SM = cast<SCEVMulExpr>(V);
6703       if (Constant *C = BuildConstantFromSCEV(SM->getOperand(0))) {
6704         // Don't bother with pointers at all.
6705         if (C->getType()->isPointerTy()) return nullptr;
6706         for (unsigned i = 1, e = SM->getNumOperands(); i != e; ++i) {
6707           Constant *C2 = BuildConstantFromSCEV(SM->getOperand(i));
6708           if (!C2 || C2->getType()->isPointerTy()) return nullptr;
6709           C = ConstantExpr::getMul(C, C2);
6710         }
6711         return C;
6712       }
6713       break;
6714     }
6715     case scUDivExpr: {
6716       const SCEVUDivExpr *SU = cast<SCEVUDivExpr>(V);
6717       if (Constant *LHS = BuildConstantFromSCEV(SU->getLHS()))
6718         if (Constant *RHS = BuildConstantFromSCEV(SU->getRHS()))
6719           if (LHS->getType() == RHS->getType())
6720             return ConstantExpr::getUDiv(LHS, RHS);
6721       break;
6722     }
6723     case scSMaxExpr:
6724     case scUMaxExpr:
6725       break; // TODO: smax, umax.
6726   }
6727   return nullptr;
6728 }
6729
6730 const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
6731   if (isa<SCEVConstant>(V)) return V;
6732
6733   // If this instruction is evolved from a constant-evolving PHI, compute the
6734   // exit value from the loop without using SCEVs.
6735   if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V)) {
6736     if (Instruction *I = dyn_cast<Instruction>(SU->getValue())) {
6737       const Loop *LI = this->LI[I->getParent()];
6738       if (LI && LI->getParentLoop() == L)  // Looking for loop exit value.
6739         if (PHINode *PN = dyn_cast<PHINode>(I))
6740           if (PN->getParent() == LI->getHeader()) {
6741             // Okay, there is no closed form solution for the PHI node.  Check
6742             // to see if the loop that contains it has a known backedge-taken
6743             // count.  If so, we may be able to force computation of the exit
6744             // value.
6745             const SCEV *BackedgeTakenCount = getBackedgeTakenCount(LI);
6746             if (const SCEVConstant *BTCC =
6747                   dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
6748               // Okay, we know how many times the containing loop executes.  If
6749               // this is a constant evolving PHI node, get the final value at
6750               // the specified iteration number.
6751               Constant *RV =
6752                   getConstantEvolutionLoopExitValue(PN, BTCC->getAPInt(), LI);
6753               if (RV) return getSCEV(RV);
6754             }
6755           }
6756
6757       // Okay, this is an expression that we cannot symbolically evaluate
6758       // into a SCEV.  Check to see if it's possible to symbolically evaluate
6759       // the arguments into constants, and if so, try to constant propagate the
6760       // result.  This is particularly useful for computing loop exit values.
6761       if (CanConstantFold(I)) {
6762         SmallVector<Constant *, 4> Operands;
6763         bool MadeImprovement = false;
6764         for (Value *Op : I->operands()) {
6765           if (Constant *C = dyn_cast<Constant>(Op)) {
6766             Operands.push_back(C);
6767             continue;
6768           }
6769
6770           // If any of the operands is non-constant and if they are
6771           // non-integer and non-pointer, don't even try to analyze them
6772           // with scev techniques.
6773           if (!isSCEVable(Op->getType()))
6774             return V;
6775
6776           const SCEV *OrigV = getSCEV(Op);
6777           const SCEV *OpV = getSCEVAtScope(OrigV, L);
6778           MadeImprovement |= OrigV != OpV;
6779
6780           Constant *C = BuildConstantFromSCEV(OpV);
6781           if (!C) return V;
6782           if (C->getType() != Op->getType())
6783             C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
6784                                                               Op->getType(),
6785                                                               false),
6786                                       C, Op->getType());
6787           Operands.push_back(C);
6788         }
6789
6790         // Check to see if getSCEVAtScope actually made an improvement.
6791         if (MadeImprovement) {
6792           Constant *C = nullptr;
6793           const DataLayout &DL = getDataLayout();
6794           if (const CmpInst *CI = dyn_cast<CmpInst>(I))
6795             C = ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
6796                                                 Operands[1], DL, &TLI);
6797           else if (const LoadInst *LI = dyn_cast<LoadInst>(I)) {
6798             if (!LI->isVolatile())
6799               C = ConstantFoldLoadFromConstPtr(Operands[0], LI->getType(), DL);
6800           } else
6801             C = ConstantFoldInstOperands(I, Operands, DL, &TLI);
6802           if (!C) return V;
6803           return getSCEV(C);
6804         }
6805       }
6806     }
6807
6808     // This is some other type of SCEVUnknown, just return it.
6809     return V;
6810   }
6811
6812   if (const SCEVCommutativeExpr *Comm = dyn_cast<SCEVCommutativeExpr>(V)) {
6813     // Avoid performing the look-up in the common case where the specified
6814     // expression has no loop-variant portions.
6815     for (unsigned i = 0, e = Comm->getNumOperands(); i != e; ++i) {
6816       const SCEV *OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
6817       if (OpAtScope != Comm->getOperand(i)) {
6818         // Okay, at least one of these operands is loop variant but might be
6819         // foldable.  Build a new instance of the folded commutative expression.
6820         SmallVector<const SCEV *, 8> NewOps(Comm->op_begin(),
6821                                             Comm->op_begin()+i);
6822         NewOps.push_back(OpAtScope);
6823
6824         for (++i; i != e; ++i) {
6825           OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
6826           NewOps.push_back(OpAtScope);
6827         }
6828         if (isa<SCEVAddExpr>(Comm))
6829           return getAddExpr(NewOps);
6830         if (isa<SCEVMulExpr>(Comm))
6831           return getMulExpr(NewOps);
6832         if (isa<SCEVSMaxExpr>(Comm))
6833           return getSMaxExpr(NewOps);
6834         if (isa<SCEVUMaxExpr>(Comm))
6835           return getUMaxExpr(NewOps);
6836         llvm_unreachable("Unknown commutative SCEV type!");
6837       }
6838     }
6839     // If we got here, all operands are loop invariant.
6840     return Comm;
6841   }
6842
6843   if (const SCEVUDivExpr *Div = dyn_cast<SCEVUDivExpr>(V)) {
6844     const SCEV *LHS = getSCEVAtScope(Div->getLHS(), L);
6845     const SCEV *RHS = getSCEVAtScope(Div->getRHS(), L);
6846     if (LHS == Div->getLHS() && RHS == Div->getRHS())
6847       return Div;   // must be loop invariant
6848     return getUDivExpr(LHS, RHS);
6849   }
6850
6851   // If this is a loop recurrence for a loop that does not contain L, then we
6852   // are dealing with the final value computed by the loop.
6853   if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V)) {
6854     // First, attempt to evaluate each operand.
6855     // Avoid performing the look-up in the common case where the specified
6856     // expression has no loop-variant portions.
6857     for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
6858       const SCEV *OpAtScope = getSCEVAtScope(AddRec->getOperand(i), L);
6859       if (OpAtScope == AddRec->getOperand(i))
6860         continue;
6861
6862       // Okay, at least one of these operands is loop variant but might be
6863       // foldable.  Build a new instance of the folded commutative expression.
6864       SmallVector<const SCEV *, 8> NewOps(AddRec->op_begin(),
6865                                           AddRec->op_begin()+i);
6866       NewOps.push_back(OpAtScope);
6867       for (++i; i != e; ++i)
6868         NewOps.push_back(getSCEVAtScope(AddRec->getOperand(i), L));
6869
6870       const SCEV *FoldedRec =
6871         getAddRecExpr(NewOps, AddRec->getLoop(),
6872                       AddRec->getNoWrapFlags(SCEV::FlagNW));
6873       AddRec = dyn_cast<SCEVAddRecExpr>(FoldedRec);
6874       // The addrec may be folded to a nonrecurrence, for example, if the
6875       // induction variable is multiplied by zero after constant folding. Go
6876       // ahead and return the folded value.
6877       if (!AddRec)
6878         return FoldedRec;
6879       break;
6880     }
6881
6882     // If the scope is outside the addrec's loop, evaluate it by using the
6883     // loop exit value of the addrec.
6884     if (!AddRec->getLoop()->contains(L)) {
6885       // To evaluate this recurrence, we need to know how many times the AddRec
6886       // loop iterates.  Compute this now.
6887       const SCEV *BackedgeTakenCount = getBackedgeTakenCount(AddRec->getLoop());
6888       if (BackedgeTakenCount == getCouldNotCompute()) return AddRec;
6889
6890       // Then, evaluate the AddRec.
6891       return AddRec->evaluateAtIteration(BackedgeTakenCount, *this);
6892     }
6893
6894     return AddRec;
6895   }
6896
6897   if (const SCEVZeroExtendExpr *Cast = dyn_cast<SCEVZeroExtendExpr>(V)) {
6898     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
6899     if (Op == Cast->getOperand())
6900       return Cast;  // must be loop invariant
6901     return getZeroExtendExpr(Op, Cast->getType());
6902   }
6903
6904   if (const SCEVSignExtendExpr *Cast = dyn_cast<SCEVSignExtendExpr>(V)) {
6905     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
6906     if (Op == Cast->getOperand())
6907       return Cast;  // must be loop invariant
6908     return getSignExtendExpr(Op, Cast->getType());
6909   }
6910
6911   if (const SCEVTruncateExpr *Cast = dyn_cast<SCEVTruncateExpr>(V)) {
6912     const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
6913     if (Op == Cast->getOperand())
6914       return Cast;  // must be loop invariant
6915     return getTruncateExpr(Op, Cast->getType());
6916   }
6917
6918   llvm_unreachable("Unknown SCEV type!");
6919 }
6920
6921 const SCEV *ScalarEvolution::getSCEVAtScope(Value *V, const Loop *L) {
6922   return getSCEVAtScope(getSCEV(V), L);
6923 }
6924
6925 /// Finds the minimum unsigned root of the following equation:
6926 ///
6927 ///     A * X = B (mod N)
6928 ///
6929 /// where N = 2^BW and BW is the common bit width of A and B. The signedness of
6930 /// A and B isn't important.
6931 ///
6932 /// If the equation does not have a solution, SCEVCouldNotCompute is returned.
6933 static const SCEV *SolveLinEquationWithOverflow(const APInt &A, const APInt &B,
6934                                                ScalarEvolution &SE) {
6935   uint32_t BW = A.getBitWidth();
6936   assert(BW == B.getBitWidth() && "Bit widths must be the same.");
6937   assert(A != 0 && "A must be non-zero.");
6938
6939   // 1. D = gcd(A, N)
6940   //
6941   // The gcd of A and N may have only one prime factor: 2. The number of
6942   // trailing zeros in A is its multiplicity
6943   uint32_t Mult2 = A.countTrailingZeros();
6944   // D = 2^Mult2
6945
6946   // 2. Check if B is divisible by D.
6947   //
6948   // B is divisible by D if and only if the multiplicity of prime factor 2 for B
6949   // is not less than multiplicity of this prime factor for D.
6950   if (B.countTrailingZeros() < Mult2)
6951     return SE.getCouldNotCompute();
6952
6953   // 3. Compute I: the multiplicative inverse of (A / D) in arithmetic
6954   // modulo (N / D).
6955   //
6956   // (N / D) may need BW+1 bits in its representation.  Hence, we'll use this
6957   // bit width during computations.
6958   APInt AD = A.lshr(Mult2).zext(BW + 1);  // AD = A / D
6959   APInt Mod(BW + 1, 0);
6960   Mod.setBit(BW - Mult2);  // Mod = N / D
6961   APInt I = AD.multiplicativeInverse(Mod);
6962
6963   // 4. Compute the minimum unsigned root of the equation:
6964   // I * (B / D) mod (N / D)
6965   APInt Result = (I * B.lshr(Mult2).zext(BW + 1)).urem(Mod);
6966
6967   // The result is guaranteed to be less than 2^BW so we may truncate it to BW
6968   // bits.
6969   return SE.getConstant(Result.trunc(BW));
6970 }
6971
6972 /// Find the roots of the quadratic equation for the given quadratic chrec
6973 /// {L,+,M,+,N}.  This returns either the two roots (which might be the same) or
6974 /// two SCEVCouldNotCompute objects.
6975 ///
6976 static Optional<std::pair<const SCEVConstant *,const SCEVConstant *>>
6977 SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
6978   assert(AddRec->getNumOperands() == 3 && "This is not a quadratic chrec!");
6979   const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
6980   const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
6981   const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
6982
6983   // We currently can only solve this if the coefficients are constants.
6984   if (!LC || !MC || !NC)
6985     return None;
6986
6987   uint32_t BitWidth = LC->getAPInt().getBitWidth();
6988   const APInt &L = LC->getAPInt();
6989   const APInt &M = MC->getAPInt();
6990   const APInt &N = NC->getAPInt();
6991   APInt Two(BitWidth, 2);
6992   APInt Four(BitWidth, 4);
6993
6994   {
6995     using namespace APIntOps;
6996     const APInt& C = L;
6997     // Convert from chrec coefficients to polynomial coefficients AX^2+BX+C
6998     // The B coefficient is M-N/2
6999     APInt B(M);
7000     B -= sdiv(N,Two);
7001
7002     // The A coefficient is N/2
7003     APInt A(N.sdiv(Two));
7004
7005     // Compute the B^2-4ac term.
7006     APInt SqrtTerm(B);
7007     SqrtTerm *= B;
7008     SqrtTerm -= Four * (A * C);
7009
7010     if (SqrtTerm.isNegative()) {
7011       // The loop is provably infinite.
7012       return None;
7013     }
7014
7015     // Compute sqrt(B^2-4ac). This is guaranteed to be the nearest
7016     // integer value or else APInt::sqrt() will assert.
7017     APInt SqrtVal(SqrtTerm.sqrt());
7018
7019     // Compute the two solutions for the quadratic formula.
7020     // The divisions must be performed as signed divisions.
7021     APInt NegB(-B);
7022     APInt TwoA(A << 1);
7023     if (TwoA.isMinValue())
7024       return None;
7025
7026     LLVMContext &Context = SE.getContext();
7027
7028     ConstantInt *Solution1 =
7029       ConstantInt::get(Context, (NegB + SqrtVal).sdiv(TwoA));
7030     ConstantInt *Solution2 =
7031       ConstantInt::get(Context, (NegB - SqrtVal).sdiv(TwoA));
7032
7033     return std::make_pair(cast<SCEVConstant>(SE.getConstant(Solution1)),
7034                           cast<SCEVConstant>(SE.getConstant(Solution2)));
7035   } // end APIntOps namespace
7036 }
7037
7038 ScalarEvolution::ExitLimit
7039 ScalarEvolution::howFarToZero(const SCEV *V, const Loop *L, bool ControlsExit,
7040                               bool AllowPredicates) {
7041
7042   // This is only used for loops with a "x != y" exit test. The exit condition
7043   // is now expressed as a single expression, V = x-y. So the exit test is
7044   // effectively V != 0.  We know and take advantage of the fact that this
7045   // expression only being used in a comparison by zero context.
7046
7047   SCEVUnionPredicate P;
7048   // If the value is a constant
7049   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
7050     // If the value is already zero, the branch will execute zero times.
7051     if (C->getValue()->isZero()) return C;
7052     return getCouldNotCompute();  // Otherwise it will loop infinitely.
7053   }
7054
7055   const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V);
7056   if (!AddRec && AllowPredicates)
7057     // Try to make this an AddRec using runtime tests, in the first X
7058     // iterations of this loop, where X is the SCEV expression found by the
7059     // algorithm below.
7060     AddRec = convertSCEVToAddRecWithPredicates(V, L, P);
7061
7062   if (!AddRec || AddRec->getLoop() != L)
7063     return getCouldNotCompute();
7064
7065   // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
7066   // the quadratic equation to solve it.
7067   if (AddRec->isQuadratic() && AddRec->getType()->isIntegerTy()) {
7068     if (auto Roots = SolveQuadraticEquation(AddRec, *this)) {
7069       const SCEVConstant *R1 = Roots->first;
7070       const SCEVConstant *R2 = Roots->second;
7071       // Pick the smallest positive root value.
7072       if (ConstantInt *CB = dyn_cast<ConstantInt>(ConstantExpr::getICmp(
7073               CmpInst::ICMP_ULT, R1->getValue(), R2->getValue()))) {
7074         if (!CB->getZExtValue())
7075           std::swap(R1, R2); // R1 is the minimum root now.
7076
7077         // We can only use this value if the chrec ends up with an exact zero
7078         // value at this index.  When solving for "X*X != 5", for example, we
7079         // should not accept a root of 2.
7080         const SCEV *Val = AddRec->evaluateAtIteration(R1, *this);
7081         if (Val->isZero())
7082           return ExitLimit(R1, R1, P); // We found a quadratic root!
7083       }
7084     }
7085     return getCouldNotCompute();
7086   }
7087
7088   // Otherwise we can only handle this if it is affine.
7089   if (!AddRec->isAffine())
7090     return getCouldNotCompute();
7091
7092   // If this is an affine expression, the execution count of this branch is
7093   // the minimum unsigned root of the following equation:
7094   //
7095   //     Start + Step*N = 0 (mod 2^BW)
7096   //
7097   // equivalent to:
7098   //
7099   //             Step*N = -Start (mod 2^BW)
7100   //
7101   // where BW is the common bit width of Start and Step.
7102
7103   // Get the initial value for the loop.
7104   const SCEV *Start = getSCEVAtScope(AddRec->getStart(), L->getParentLoop());
7105   const SCEV *Step = getSCEVAtScope(AddRec->getOperand(1), L->getParentLoop());
7106
7107   // For now we handle only constant steps.
7108   //
7109   // TODO: Handle a nonconstant Step given AddRec<NUW>. If the
7110   // AddRec is NUW, then (in an unsigned sense) it cannot be counting up to wrap
7111   // to 0, it must be counting down to equal 0. Consequently, N = Start / -Step.
7112   // We have not yet seen any such cases.
7113   const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
7114   if (!StepC || StepC->getValue()->equalsInt(0))
7115     return getCouldNotCompute();
7116
7117   // For positive steps (counting up until unsigned overflow):
7118   //   N = -Start/Step (as unsigned)
7119   // For negative steps (counting down to zero):
7120   //   N = Start/-Step
7121   // First compute the unsigned distance from zero in the direction of Step.
7122   bool CountDown = StepC->getAPInt().isNegative();
7123   const SCEV *Distance = CountDown ? Start : getNegativeSCEV(Start);
7124
7125   // Handle unitary steps, which cannot wraparound.
7126   // 1*N = -Start; -1*N = Start (mod 2^BW), so:
7127   //   N = Distance (as unsigned)
7128   if (StepC->getValue()->equalsInt(1) || StepC->getValue()->isAllOnesValue()) {
7129     ConstantRange CR = getUnsignedRange(Start);
7130     const SCEV *MaxBECount;
7131     if (!CountDown && CR.getUnsignedMin().isMinValue())
7132       // When counting up, the worst starting value is 1, not 0.
7133       MaxBECount = CR.getUnsignedMax().isMinValue()
7134         ? getConstant(APInt::getMinValue(CR.getBitWidth()))
7135         : getConstant(APInt::getMaxValue(CR.getBitWidth()));
7136     else
7137       MaxBECount = getConstant(CountDown ? CR.getUnsignedMax()
7138                                          : -CR.getUnsignedMin());
7139     return ExitLimit(Distance, MaxBECount, P);
7140   }
7141
7142   // As a special case, handle the instance where Step is a positive power of
7143   // two. In this case, determining whether Step divides Distance evenly can be
7144   // done by counting and comparing the number of trailing zeros of Step and
7145   // Distance.
7146   if (!CountDown) {
7147     const APInt &StepV = StepC->getAPInt();
7148     // StepV.isPowerOf2() returns true if StepV is an positive power of two.  It
7149     // also returns true if StepV is maximally negative (eg, INT_MIN), but that
7150     // case is not handled as this code is guarded by !CountDown.
7151     if (StepV.isPowerOf2() &&
7152         GetMinTrailingZeros(Distance) >= StepV.countTrailingZeros()) {
7153       // Here we've constrained the equation to be of the form
7154       //
7155       //   2^(N + k) * Distance' = (StepV == 2^N) * X (mod 2^W)  ... (0)
7156       //
7157       // where we're operating on a W bit wide integer domain and k is
7158       // non-negative.  The smallest unsigned solution for X is the trip count.
7159       //
7160       // (0) is equivalent to:
7161       //
7162       //      2^(N + k) * Distance' - 2^N * X = L * 2^W
7163       // <=>  2^N(2^k * Distance' - X) = L * 2^(W - N) * 2^N
7164       // <=>  2^k * Distance' - X = L * 2^(W - N)
7165       // <=>  2^k * Distance'     = L * 2^(W - N) + X    ... (1)
7166       //
7167       // The smallest X satisfying (1) is unsigned remainder of dividing the LHS
7168       // by 2^(W - N).
7169       //
7170       // <=>  X = 2^k * Distance' URem 2^(W - N)   ... (2)
7171       //
7172       // E.g. say we're solving
7173       //
7174       //   2 * Val = 2 * X  (in i8)   ... (3)
7175       //
7176       // then from (2), we get X = Val URem i8 128 (k = 0 in this case).
7177       //
7178       // Note: It is tempting to solve (3) by setting X = Val, but Val is not
7179       // necessarily the smallest unsigned value of X that satisfies (3).
7180       // E.g. if Val is i8 -127 then the smallest value of X that satisfies (3)
7181       // is i8 1, not i8 -127
7182
7183       const auto *ModuloResult = getUDivExactExpr(Distance, Step);
7184
7185       // Since SCEV does not have a URem node, we construct one using a truncate
7186       // and a zero extend.
7187
7188       unsigned NarrowWidth = StepV.getBitWidth() - StepV.countTrailingZeros();
7189       auto *NarrowTy = IntegerType::get(getContext(), NarrowWidth);
7190       auto *WideTy = Distance->getType();
7191
7192       const SCEV *Limit =
7193           getZeroExtendExpr(getTruncateExpr(ModuloResult, NarrowTy), WideTy);
7194       return ExitLimit(Limit, Limit, P);
7195     }
7196   }
7197
7198   // If the condition controls loop exit (the loop exits only if the expression
7199   // is true) and the addition is no-wrap we can use unsigned divide to
7200   // compute the backedge count.  In this case, the step may not divide the
7201   // distance, but we don't care because if the condition is "missed" the loop
7202   // will have undefined behavior due to wrapping.
7203   if (ControlsExit && AddRec->hasNoSelfWrap() &&
7204       loopHasNoAbnormalExits(AddRec->getLoop())) {
7205     const SCEV *Exact =
7206         getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
7207     return ExitLimit(Exact, Exact, P);
7208   }
7209
7210   // Then, try to solve the above equation provided that Start is constant.
7211   if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start)) {
7212     const SCEV *E = SolveLinEquationWithOverflow(
7213         StepC->getValue()->getValue(), -StartC->getValue()->getValue(), *this);
7214     return ExitLimit(E, E, P);
7215   }
7216   return getCouldNotCompute();
7217 }
7218
7219 ScalarEvolution::ExitLimit
7220 ScalarEvolution::howFarToNonZero(const SCEV *V, const Loop *L) {
7221   // Loops that look like: while (X == 0) are very strange indeed.  We don't
7222   // handle them yet except for the trivial case.  This could be expanded in the
7223   // future as needed.
7224
7225   // If the value is a constant, check to see if it is known to be non-zero
7226   // already.  If so, the backedge will execute zero times.
7227   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
7228     if (!C->getValue()->isNullValue())
7229       return getZero(C->getType());
7230     return getCouldNotCompute();  // Otherwise it will loop infinitely.
7231   }
7232
7233   // We could implement others, but I really doubt anyone writes loops like
7234   // this, and if they did, they would already be constant folded.
7235   return getCouldNotCompute();
7236 }
7237
7238 std::pair<BasicBlock *, BasicBlock *>
7239 ScalarEvolution::getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB) {
7240   // If the block has a unique predecessor, then there is no path from the
7241   // predecessor to the block that does not go through the direct edge
7242   // from the predecessor to the block.
7243   if (BasicBlock *Pred = BB->getSinglePredecessor())
7244     return {Pred, BB};
7245
7246   // A loop's header is defined to be a block that dominates the loop.
7247   // If the header has a unique predecessor outside the loop, it must be
7248   // a block that has exactly one successor that can reach the loop.
7249   if (Loop *L = LI.getLoopFor(BB))
7250     return {L->getLoopPredecessor(), L->getHeader()};
7251
7252   return {nullptr, nullptr};
7253 }
7254
7255 /// SCEV structural equivalence is usually sufficient for testing whether two
7256 /// expressions are equal, however for the purposes of looking for a condition
7257 /// guarding a loop, it can be useful to be a little more general, since a
7258 /// front-end may have replicated the controlling expression.
7259 ///
7260 static bool HasSameValue(const SCEV *A, const SCEV *B) {
7261   // Quick check to see if they are the same SCEV.
7262   if (A == B) return true;
7263
7264   auto ComputesEqualValues = [](const Instruction *A, const Instruction *B) {
7265     // Not all instructions that are "identical" compute the same value.  For
7266     // instance, two distinct alloca instructions allocating the same type are
7267     // identical and do not read memory; but compute distinct values.
7268     return A->isIdenticalTo(B) && (isa<BinaryOperator>(A) || isa<GetElementPtrInst>(A));
7269   };
7270
7271   // Otherwise, if they're both SCEVUnknown, it's possible that they hold
7272   // two different instructions with the same value. Check for this case.
7273   if (const SCEVUnknown *AU = dyn_cast<SCEVUnknown>(A))
7274     if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
7275       if (const Instruction *AI = dyn_cast<Instruction>(AU->getValue()))
7276         if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))
7277           if (ComputesEqualValues(AI, BI))
7278             return true;
7279
7280   // Otherwise assume they may have a different value.
7281   return false;
7282 }
7283
7284 bool ScalarEvolution::SimplifyICmpOperands(ICmpInst::Predicate &Pred,
7285                                            const SCEV *&LHS, const SCEV *&RHS,
7286                                            unsigned Depth) {
7287   bool Changed = false;
7288
7289   // If we hit the max recursion limit bail out.
7290   if (Depth >= 3)
7291     return false;
7292
7293   // Canonicalize a constant to the right side.
7294   if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
7295     // Check for both operands constant.
7296     if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
7297       if (ConstantExpr::getICmp(Pred,
7298                                 LHSC->getValue(),
7299                                 RHSC->getValue())->isNullValue())
7300         goto trivially_false;
7301       else
7302         goto trivially_true;
7303     }
7304     // Otherwise swap the operands to put the constant on the right.
7305     std::swap(LHS, RHS);
7306     Pred = ICmpInst::getSwappedPredicate(Pred);
7307     Changed = true;
7308   }
7309
7310   // If we're comparing an addrec with a value which is loop-invariant in the
7311   // addrec's loop, put the addrec on the left. Also make a dominance check,
7312   // as both operands could be addrecs loop-invariant in each other's loop.
7313   if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS)) {
7314     const Loop *L = AR->getLoop();
7315     if (isLoopInvariant(LHS, L) && properlyDominates(LHS, L->getHeader())) {
7316       std::swap(LHS, RHS);
7317       Pred = ICmpInst::getSwappedPredicate(Pred);
7318       Changed = true;
7319     }
7320   }
7321
7322   // If there's a constant operand, canonicalize comparisons with boundary
7323   // cases, and canonicalize *-or-equal comparisons to regular comparisons.
7324   if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
7325     const APInt &RA = RC->getAPInt();
7326     switch (Pred) {
7327     default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
7328     case ICmpInst::ICMP_EQ:
7329     case ICmpInst::ICMP_NE:
7330       // Fold ((-1) * %a) + %b == 0 (equivalent to %b-%a == 0) into %a == %b.
7331       if (!RA)
7332         if (const SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(LHS))
7333           if (const SCEVMulExpr *ME = dyn_cast<SCEVMulExpr>(AE->getOperand(0)))
7334             if (AE->getNumOperands() == 2 && ME->getNumOperands() == 2 &&
7335                 ME->getOperand(0)->isAllOnesValue()) {
7336               RHS = AE->getOperand(1);
7337               LHS = ME->getOperand(1);
7338               Changed = true;
7339             }
7340       break;
7341     case ICmpInst::ICMP_UGE:
7342       if ((RA - 1).isMinValue()) {
7343         Pred = ICmpInst::ICMP_NE;
7344         RHS = getConstant(RA - 1);
7345         Changed = true;
7346         break;
7347       }
7348       if (RA.isMaxValue()) {
7349         Pred = ICmpInst::ICMP_EQ;
7350         Changed = true;
7351         break;
7352       }
7353       if (RA.isMinValue()) goto trivially_true;
7354
7355       Pred = ICmpInst::ICMP_UGT;
7356       RHS = getConstant(RA - 1);
7357       Changed = true;
7358       break;
7359     case ICmpInst::ICMP_ULE:
7360       if ((RA + 1).isMaxValue()) {
7361         Pred = ICmpInst::ICMP_NE;
7362         RHS = getConstant(RA + 1);
7363         Changed = true;
7364         break;
7365       }
7366       if (RA.isMinValue()) {
7367         Pred = ICmpInst::ICMP_EQ;
7368         Changed = true;
7369         break;
7370       }
7371       if (RA.isMaxValue()) goto trivially_true;
7372
7373       Pred = ICmpInst::ICMP_ULT;
7374       RHS = getConstant(RA + 1);
7375       Changed = true;
7376       break;
7377     case ICmpInst::ICMP_SGE:
7378       if ((RA - 1).isMinSignedValue()) {
7379         Pred = ICmpInst::ICMP_NE;
7380         RHS = getConstant(RA - 1);
7381         Changed = true;
7382         break;
7383       }
7384       if (RA.isMaxSignedValue()) {
7385         Pred = ICmpInst::ICMP_EQ;
7386         Changed = true;
7387         break;
7388       }
7389       if (RA.isMinSignedValue()) goto trivially_true;
7390
7391       Pred = ICmpInst::ICMP_SGT;
7392       RHS = getConstant(RA - 1);
7393       Changed = true;
7394       break;
7395     case ICmpInst::ICMP_SLE:
7396       if ((RA + 1).isMaxSignedValue()) {
7397         Pred = ICmpInst::ICMP_NE;
7398         RHS = getConstant(RA + 1);
7399         Changed = true;
7400         break;
7401       }
7402       if (RA.isMinSignedValue()) {
7403         Pred = ICmpInst::ICMP_EQ;
7404         Changed = true;
7405         break;
7406       }
7407       if (RA.isMaxSignedValue()) goto trivially_true;
7408
7409       Pred = ICmpInst::ICMP_SLT;
7410       RHS = getConstant(RA + 1);
7411       Changed = true;
7412       break;
7413     case ICmpInst::ICMP_UGT:
7414       if (RA.isMinValue()) {
7415         Pred = ICmpInst::ICMP_NE;
7416         Changed = true;
7417         break;
7418       }
7419       if ((RA + 1).isMaxValue()) {
7420         Pred = ICmpInst::ICMP_EQ;
7421         RHS = getConstant(RA + 1);
7422         Changed = true;
7423         break;
7424       }
7425       if (RA.isMaxValue()) goto trivially_false;
7426       break;
7427     case ICmpInst::ICMP_ULT:
7428       if (RA.isMaxValue()) {
7429         Pred = ICmpInst::ICMP_NE;
7430         Changed = true;
7431         break;
7432       }
7433       if ((RA - 1).isMinValue()) {
7434         Pred = ICmpInst::ICMP_EQ;
7435         RHS = getConstant(RA - 1);
7436         Changed = true;
7437         break;
7438       }
7439       if (RA.isMinValue()) goto trivially_false;
7440       break;
7441     case ICmpInst::ICMP_SGT:
7442       if (RA.isMinSignedValue()) {
7443         Pred = ICmpInst::ICMP_NE;
7444         Changed = true;
7445         break;
7446       }
7447       if ((RA + 1).isMaxSignedValue()) {
7448         Pred = ICmpInst::ICMP_EQ;
7449         RHS = getConstant(RA + 1);
7450         Changed = true;
7451         break;
7452       }
7453       if (RA.isMaxSignedValue()) goto trivially_false;
7454       break;
7455     case ICmpInst::ICMP_SLT:
7456       if (RA.isMaxSignedValue()) {
7457         Pred = ICmpInst::ICMP_NE;
7458         Changed = true;
7459         break;
7460       }
7461       if ((RA - 1).isMinSignedValue()) {
7462        Pred = ICmpInst::ICMP_EQ;
7463        RHS = getConstant(RA - 1);
7464         Changed = true;
7465        break;
7466       }
7467       if (RA.isMinSignedValue()) goto trivially_false;
7468       break;
7469     }
7470   }
7471
7472   // Check for obvious equality.
7473   if (HasSameValue(LHS, RHS)) {
7474     if (ICmpInst::isTrueWhenEqual(Pred))
7475       goto trivially_true;
7476     if (ICmpInst::isFalseWhenEqual(Pred))
7477       goto trivially_false;
7478   }
7479
7480   // If possible, canonicalize GE/LE comparisons to GT/LT comparisons, by
7481   // adding or subtracting 1 from one of the operands.
7482   switch (Pred) {
7483   case ICmpInst::ICMP_SLE:
7484     if (!getSignedRange(RHS).getSignedMax().isMaxSignedValue()) {
7485       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
7486                        SCEV::FlagNSW);
7487       Pred = ICmpInst::ICMP_SLT;
7488       Changed = true;
7489     } else if (!getSignedRange(LHS).getSignedMin().isMinSignedValue()) {
7490       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
7491                        SCEV::FlagNSW);
7492       Pred = ICmpInst::ICMP_SLT;
7493       Changed = true;
7494     }
7495     break;
7496   case ICmpInst::ICMP_SGE:
7497     if (!getSignedRange(RHS).getSignedMin().isMinSignedValue()) {
7498       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
7499                        SCEV::FlagNSW);
7500       Pred = ICmpInst::ICMP_SGT;
7501       Changed = true;
7502     } else if (!getSignedRange(LHS).getSignedMax().isMaxSignedValue()) {
7503       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
7504                        SCEV::FlagNSW);
7505       Pred = ICmpInst::ICMP_SGT;
7506       Changed = true;
7507     }
7508     break;
7509   case ICmpInst::ICMP_ULE:
7510     if (!getUnsignedRange(RHS).getUnsignedMax().isMaxValue()) {
7511       RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
7512                        SCEV::FlagNUW);
7513       Pred = ICmpInst::ICMP_ULT;
7514       Changed = true;
7515     } else if (!getUnsignedRange(LHS).getUnsignedMin().isMinValue()) {
7516       LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS);
7517       Pred = ICmpInst::ICMP_ULT;
7518       Changed = true;
7519     }
7520     break;
7521   case ICmpInst::ICMP_UGE:
7522     if (!getUnsignedRange(RHS).getUnsignedMin().isMinValue()) {
7523       RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS);
7524       Pred = ICmpInst::ICMP_UGT;
7525       Changed = true;
7526     } else if (!getUnsignedRange(LHS).getUnsignedMax().isMaxValue()) {
7527       LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
7528                        SCEV::FlagNUW);
7529       Pred = ICmpInst::ICMP_UGT;
7530       Changed = true;
7531     }
7532     break;
7533   default:
7534     break;
7535   }
7536
7537   // TODO: More simplifications are possible here.
7538
7539   // Recursively simplify until we either hit a recursion limit or nothing
7540   // changes.
7541   if (Changed)
7542     return SimplifyICmpOperands(Pred, LHS, RHS, Depth+1);
7543
7544   return Changed;
7545
7546 trivially_true:
7547   // Return 0 == 0.
7548   LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
7549   Pred = ICmpInst::ICMP_EQ;
7550   return true;
7551
7552 trivially_false:
7553   // Return 0 != 0.
7554   LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
7555   Pred = ICmpInst::ICMP_NE;
7556   return true;
7557 }
7558
7559 bool ScalarEvolution::isKnownNegative(const SCEV *S) {
7560   return getSignedRange(S).getSignedMax().isNegative();
7561 }
7562
7563 bool ScalarEvolution::isKnownPositive(const SCEV *S) {
7564   return getSignedRange(S).getSignedMin().isStrictlyPositive();
7565 }
7566
7567 bool ScalarEvolution::isKnownNonNegative(const SCEV *S) {
7568   return !getSignedRange(S).getSignedMin().isNegative();
7569 }
7570
7571 bool ScalarEvolution::isKnownNonPositive(const SCEV *S) {
7572   return !getSignedRange(S).getSignedMax().isStrictlyPositive();
7573 }
7574
7575 bool ScalarEvolution::isKnownNonZero(const SCEV *S) {
7576   return isKnownNegative(S) || isKnownPositive(S);
7577 }
7578
7579 bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
7580                                        const SCEV *LHS, const SCEV *RHS) {
7581   // Canonicalize the inputs first.
7582   (void)SimplifyICmpOperands(Pred, LHS, RHS);
7583
7584   // If LHS or RHS is an addrec, check to see if the condition is true in
7585   // every iteration of the loop.
7586   // If LHS and RHS are both addrec, both conditions must be true in
7587   // every iteration of the loop.
7588   const SCEVAddRecExpr *LAR = dyn_cast<SCEVAddRecExpr>(LHS);
7589   const SCEVAddRecExpr *RAR = dyn_cast<SCEVAddRecExpr>(RHS);
7590   bool LeftGuarded = false;
7591   bool RightGuarded = false;
7592   if (LAR) {
7593     const Loop *L = LAR->getLoop();
7594     if (isLoopEntryGuardedByCond(L, Pred, LAR->getStart(), RHS) &&
7595         isLoopBackedgeGuardedByCond(L, Pred, LAR->getPostIncExpr(*this), RHS)) {
7596       if (!RAR) return true;
7597       LeftGuarded = true;
7598     }
7599   }
7600   if (RAR) {
7601     const Loop *L = RAR->getLoop();
7602     if (isLoopEntryGuardedByCond(L, Pred, LHS, RAR->getStart()) &&
7603         isLoopBackedgeGuardedByCond(L, Pred, LHS, RAR->getPostIncExpr(*this))) {
7604       if (!LAR) return true;
7605       RightGuarded = true;
7606     }
7607   }
7608   if (LeftGuarded && RightGuarded)
7609     return true;
7610
7611   if (isKnownPredicateViaSplitting(Pred, LHS, RHS))
7612     return true;
7613
7614   // Otherwise see what can be done with known constant ranges.
7615   return isKnownPredicateViaConstantRanges(Pred, LHS, RHS);
7616 }
7617
7618 bool ScalarEvolution::isMonotonicPredicate(const SCEVAddRecExpr *LHS,
7619                                            ICmpInst::Predicate Pred,
7620                                            bool &Increasing) {
7621   bool Result = isMonotonicPredicateImpl(LHS, Pred, Increasing);
7622
7623 #ifndef NDEBUG
7624   // Verify an invariant: inverting the predicate should turn a monotonically
7625   // increasing change to a monotonically decreasing one, and vice versa.
7626   bool IncreasingSwapped;
7627   bool ResultSwapped = isMonotonicPredicateImpl(
7628       LHS, ICmpInst::getSwappedPredicate(Pred), IncreasingSwapped);
7629
7630   assert(Result == ResultSwapped && "should be able to analyze both!");
7631   if (ResultSwapped)
7632     assert(Increasing == !IncreasingSwapped &&
7633            "monotonicity should flip as we flip the predicate");
7634 #endif
7635
7636   return Result;
7637 }
7638
7639 bool ScalarEvolution::isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS,
7640                                                ICmpInst::Predicate Pred,
7641                                                bool &Increasing) {
7642
7643   // A zero step value for LHS means the induction variable is essentially a
7644   // loop invariant value. We don't really depend on the predicate actually
7645   // flipping from false to true (for increasing predicates, and the other way
7646   // around for decreasing predicates), all we care about is that *if* the
7647   // predicate changes then it only changes from false to true.
7648   //
7649   // A zero step value in itself is not very useful, but there may be places
7650   // where SCEV can prove X >= 0 but not prove X > 0, so it is helpful to be
7651   // as general as possible.
7652
7653   switch (Pred) {
7654   default:
7655     return false; // Conservative answer
7656
7657   case ICmpInst::ICMP_UGT:
7658   case ICmpInst::ICMP_UGE:
7659   case ICmpInst::ICMP_ULT:
7660   case ICmpInst::ICMP_ULE:
7661     if (!LHS->hasNoUnsignedWrap())
7662       return false;
7663
7664     Increasing = Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE;
7665     return true;
7666
7667   case ICmpInst::ICMP_SGT:
7668   case ICmpInst::ICMP_SGE:
7669   case ICmpInst::ICMP_SLT:
7670   case ICmpInst::ICMP_SLE: {
7671     if (!LHS->hasNoSignedWrap())
7672       return false;
7673
7674     const SCEV *Step = LHS->getStepRecurrence(*this);
7675
7676     if (isKnownNonNegative(Step)) {
7677       Increasing = Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE;
7678       return true;
7679     }
7680
7681     if (isKnownNonPositive(Step)) {
7682       Increasing = Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE;
7683       return true;
7684     }
7685
7686     return false;
7687   }
7688
7689   }
7690
7691   llvm_unreachable("switch has default clause!");
7692 }
7693
7694 bool ScalarEvolution::isLoopInvariantPredicate(
7695     ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS, const Loop *L,
7696     ICmpInst::Predicate &InvariantPred, const SCEV *&InvariantLHS,
7697     const SCEV *&InvariantRHS) {
7698
7699   // If there is a loop-invariant, force it into the RHS, otherwise bail out.
7700   if (!isLoopInvariant(RHS, L)) {
7701     if (!isLoopInvariant(LHS, L))
7702       return false;
7703
7704     std::swap(LHS, RHS);
7705     Pred = ICmpInst::getSwappedPredicate(Pred);
7706   }
7707
7708   const SCEVAddRecExpr *ArLHS = dyn_cast<SCEVAddRecExpr>(LHS);
7709   if (!ArLHS || ArLHS->getLoop() != L)
7710     return false;
7711
7712   bool Increasing;
7713   if (!isMonotonicPredicate(ArLHS, Pred, Increasing))
7714     return false;
7715
7716   // If the predicate "ArLHS `Pred` RHS" monotonically increases from false to
7717   // true as the loop iterates, and the backedge is control dependent on
7718   // "ArLHS `Pred` RHS" == true then we can reason as follows:
7719   //
7720   //   * if the predicate was false in the first iteration then the predicate
7721   //     is never evaluated again, since the loop exits without taking the
7722   //     backedge.
7723   //   * if the predicate was true in the first iteration then it will
7724   //     continue to be true for all future iterations since it is
7725   //     monotonically increasing.
7726   //
7727   // For both the above possibilities, we can replace the loop varying
7728   // predicate with its value on the first iteration of the loop (which is
7729   // loop invariant).
7730   //
7731   // A similar reasoning applies for a monotonically decreasing predicate, by
7732   // replacing true with false and false with true in the above two bullets.
7733
7734   auto P = Increasing ? Pred : ICmpInst::getInversePredicate(Pred);
7735
7736   if (!isLoopBackedgeGuardedByCond(L, P, LHS, RHS))
7737     return false;
7738
7739   InvariantPred = Pred;
7740   InvariantLHS = ArLHS->getStart();
7741   InvariantRHS = RHS;
7742   return true;
7743 }
7744
7745 bool ScalarEvolution::isKnownPredicateViaConstantRanges(
7746     ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
7747   if (HasSameValue(LHS, RHS))
7748     return ICmpInst::isTrueWhenEqual(Pred);
7749
7750   // This code is split out from isKnownPredicate because it is called from
7751   // within isLoopEntryGuardedByCond.
7752
7753   auto CheckRanges =
7754       [&](const ConstantRange &RangeLHS, const ConstantRange &RangeRHS) {
7755     return ConstantRange::makeSatisfyingICmpRegion(Pred, RangeRHS)
7756         .contains(RangeLHS);
7757   };
7758
7759   // The check at the top of the function catches the case where the values are
7760   // known to be equal.
7761   if (Pred == CmpInst::ICMP_EQ)
7762     return false;
7763
7764   if (Pred == CmpInst::ICMP_NE)
7765     return CheckRanges(getSignedRange(LHS), getSignedRange(RHS)) ||
7766            CheckRanges(getUnsignedRange(LHS), getUnsignedRange(RHS)) ||
7767            isKnownNonZero(getMinusSCEV(LHS, RHS));
7768
7769   if (CmpInst::isSigned(Pred))
7770     return CheckRanges(getSignedRange(LHS), getSignedRange(RHS));
7771
7772   return CheckRanges(getUnsignedRange(LHS), getUnsignedRange(RHS));
7773 }
7774
7775 bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
7776                                                     const SCEV *LHS,
7777                                                     const SCEV *RHS) {
7778
7779   // Match Result to (X + Y)<ExpectedFlags> where Y is a constant integer.
7780   // Return Y via OutY.
7781   auto MatchBinaryAddToConst =
7782       [this](const SCEV *Result, const SCEV *X, APInt &OutY,
7783              SCEV::NoWrapFlags ExpectedFlags) {
7784     const SCEV *NonConstOp, *ConstOp;
7785     SCEV::NoWrapFlags FlagsPresent;
7786
7787     if (!splitBinaryAdd(Result, ConstOp, NonConstOp, FlagsPresent) ||
7788         !isa<SCEVConstant>(ConstOp) || NonConstOp != X)
7789       return false;
7790
7791     OutY = cast<SCEVConstant>(ConstOp)->getAPInt();
7792     return (FlagsPresent & ExpectedFlags) == ExpectedFlags;
7793   };
7794
7795   APInt C;
7796
7797   switch (Pred) {
7798   default:
7799     break;
7800
7801   case ICmpInst::ICMP_SGE:
7802     std::swap(LHS, RHS);
7803   case ICmpInst::ICMP_SLE:
7804     // X s<= (X + C)<nsw> if C >= 0
7805     if (MatchBinaryAddToConst(RHS, LHS, C, SCEV::FlagNSW) && C.isNonNegative())
7806       return true;
7807
7808     // (X + C)<nsw> s<= X if C <= 0
7809     if (MatchBinaryAddToConst(LHS, RHS, C, SCEV::FlagNSW) &&
7810         !C.isStrictlyPositive())
7811       return true;
7812     break;
7813
7814   case ICmpInst::ICMP_SGT:
7815     std::swap(LHS, RHS);
7816   case ICmpInst::ICMP_SLT:
7817     // X s< (X + C)<nsw> if C > 0
7818     if (MatchBinaryAddToConst(RHS, LHS, C, SCEV::FlagNSW) &&
7819         C.isStrictlyPositive())
7820       return true;
7821
7822     // (X + C)<nsw> s< X if C < 0
7823     if (MatchBinaryAddToConst(LHS, RHS, C, SCEV::FlagNSW) && C.isNegative())
7824       return true;
7825     break;
7826   }
7827
7828   return false;
7829 }
7830
7831 bool ScalarEvolution::isKnownPredicateViaSplitting(ICmpInst::Predicate Pred,
7832                                                    const SCEV *LHS,
7833                                                    const SCEV *RHS) {
7834   if (Pred != ICmpInst::ICMP_ULT || ProvingSplitPredicate)
7835     return false;
7836
7837   // Allowing arbitrary number of activations of isKnownPredicateViaSplitting on
7838   // the stack can result in exponential time complexity.
7839   SaveAndRestore<bool> Restore(ProvingSplitPredicate, true);
7840
7841   // If L >= 0 then I `ult` L <=> I >= 0 && I `slt` L
7842   //
7843   // To prove L >= 0 we use isKnownNonNegative whereas to prove I >= 0 we use
7844   // isKnownPredicate.  isKnownPredicate is more powerful, but also more
7845   // expensive; and using isKnownNonNegative(RHS) is sufficient for most of the
7846   // interesting cases seen in practice.  We can consider "upgrading" L >= 0 to
7847   // use isKnownPredicate later if needed.
7848   return isKnownNonNegative(RHS) &&
7849          isKnownPredicate(CmpInst::ICMP_SGE, LHS, getZero(LHS->getType())) &&
7850          isKnownPredicate(CmpInst::ICMP_SLT, LHS, RHS);
7851 }
7852
7853 bool ScalarEvolution::isImpliedViaGuard(BasicBlock *BB,
7854                                         ICmpInst::Predicate Pred,
7855                                         const SCEV *LHS, const SCEV *RHS) {
7856   // No need to even try if we know the module has no guards.
7857   if (!HasGuards)
7858     return false;
7859
7860   return any_of(*BB, [&](Instruction &I) {
7861     using namespace llvm::PatternMatch;
7862
7863     Value *Condition;
7864     return match(&I, m_Intrinsic<Intrinsic::experimental_guard>(
7865                          m_Value(Condition))) &&
7866            isImpliedCond(Pred, LHS, RHS, Condition, false);
7867   });
7868 }
7869
7870 /// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is
7871 /// protected by a conditional between LHS and RHS.  This is used to
7872 /// to eliminate casts.
7873 bool
7874 ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
7875                                              ICmpInst::Predicate Pred,
7876                                              const SCEV *LHS, const SCEV *RHS) {
7877   // Interpret a null as meaning no loop, where there is obviously no guard
7878   // (interprocedural conditions notwithstanding).
7879   if (!L) return true;
7880
7881   if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
7882     return true;
7883
7884   BasicBlock *Latch = L->getLoopLatch();
7885   if (!Latch)
7886     return false;
7887
7888   BranchInst *LoopContinuePredicate =
7889     dyn_cast<BranchInst>(Latch->getTerminator());
7890   if (LoopContinuePredicate && LoopContinuePredicate->isConditional() &&
7891       isImpliedCond(Pred, LHS, RHS,
7892                     LoopContinuePredicate->getCondition(),
7893                     LoopContinuePredicate->getSuccessor(0) != L->getHeader()))
7894     return true;
7895
7896   // We don't want more than one activation of the following loops on the stack
7897   // -- that can lead to O(n!) time complexity.
7898   if (WalkingBEDominatingConds)
7899     return false;
7900
7901   SaveAndRestore<bool> ClearOnExit(WalkingBEDominatingConds, true);
7902
7903   // See if we can exploit a trip count to prove the predicate.
7904   const auto &BETakenInfo = getBackedgeTakenInfo(L);
7905   const SCEV *LatchBECount = BETakenInfo.getExact(Latch, this);
7906   if (LatchBECount != getCouldNotCompute()) {
7907     // We know that Latch branches back to the loop header exactly
7908     // LatchBECount times.  This means the backdege condition at Latch is
7909     // equivalent to  "{0,+,1} u< LatchBECount".
7910     Type *Ty = LatchBECount->getType();
7911     auto NoWrapFlags = SCEV::NoWrapFlags(SCEV::FlagNUW | SCEV::FlagNW);
7912     const SCEV *LoopCounter =
7913       getAddRecExpr(getZero(Ty), getOne(Ty), L, NoWrapFlags);
7914     if (isImpliedCond(Pred, LHS, RHS, ICmpInst::ICMP_ULT, LoopCounter,
7915                       LatchBECount))
7916       return true;
7917   }
7918
7919   // Check conditions due to any @llvm.assume intrinsics.
7920   for (auto &AssumeVH : AC.assumptions()) {
7921     if (!AssumeVH)
7922       continue;
7923     auto *CI = cast<CallInst>(AssumeVH);
7924     if (!DT.dominates(CI, Latch->getTerminator()))
7925       continue;
7926
7927     if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
7928       return true;
7929   }
7930
7931   // If the loop is not reachable from the entry block, we risk running into an
7932   // infinite loop as we walk up into the dom tree.  These loops do not matter
7933   // anyway, so we just return a conservative answer when we see them.
7934   if (!DT.isReachableFromEntry(L->getHeader()))
7935     return false;
7936
7937   if (isImpliedViaGuard(Latch, Pred, LHS, RHS))
7938     return true;
7939
7940   for (DomTreeNode *DTN = DT[Latch], *HeaderDTN = DT[L->getHeader()];
7941        DTN != HeaderDTN; DTN = DTN->getIDom()) {
7942
7943     assert(DTN && "should reach the loop header before reaching the root!");
7944
7945     BasicBlock *BB = DTN->getBlock();
7946     if (isImpliedViaGuard(BB, Pred, LHS, RHS))
7947       return true;
7948
7949     BasicBlock *PBB = BB->getSinglePredecessor();
7950     if (!PBB)
7951       continue;
7952
7953     BranchInst *ContinuePredicate = dyn_cast<BranchInst>(PBB->getTerminator());
7954     if (!ContinuePredicate || !ContinuePredicate->isConditional())
7955       continue;
7956
7957     Value *Condition = ContinuePredicate->getCondition();
7958
7959     // If we have an edge `E` within the loop body that dominates the only
7960     // latch, the condition guarding `E` also guards the backedge.  This
7961     // reasoning works only for loops with a single latch.
7962
7963     BasicBlockEdge DominatingEdge(PBB, BB);
7964     if (DominatingEdge.isSingleEdge()) {
7965       // We're constructively (and conservatively) enumerating edges within the
7966       // loop body that dominate the latch.  The dominator tree better agree
7967       // with us on this:
7968       assert(DT.dominates(DominatingEdge, Latch) && "should be!");
7969
7970       if (isImpliedCond(Pred, LHS, RHS, Condition,
7971                         BB != ContinuePredicate->getSuccessor(0)))
7972         return true;
7973     }
7974   }
7975
7976   return false;
7977 }
7978
7979 bool
7980 ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
7981                                           ICmpInst::Predicate Pred,
7982                                           const SCEV *LHS, const SCEV *RHS) {
7983   // Interpret a null as meaning no loop, where there is obviously no guard
7984   // (interprocedural conditions notwithstanding).
7985   if (!L) return false;
7986
7987   if (isKnownPredicateViaConstantRanges(Pred, LHS, RHS))
7988     return true;
7989
7990   // Starting at the loop predecessor, climb up the predecessor chain, as long
7991   // as there are predecessors that can be found that have unique successors
7992   // leading to the original header.
7993   for (std::pair<BasicBlock *, BasicBlock *>
7994          Pair(L->getLoopPredecessor(), L->getHeader());
7995        Pair.first;
7996        Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
7997
7998     if (isImpliedViaGuard(Pair.first, Pred, LHS, RHS))
7999       return true;
8000
8001     BranchInst *LoopEntryPredicate =
8002       dyn_cast<BranchInst>(Pair.first->getTerminator());
8003     if (!LoopEntryPredicate ||
8004         LoopEntryPredicate->isUnconditional())
8005       continue;
8006
8007     if (isImpliedCond(Pred, LHS, RHS,
8008                       LoopEntryPredicate->getCondition(),
8009                       LoopEntryPredicate->getSuccessor(0) != Pair.second))
8010       return true;
8011   }
8012
8013   // Check conditions due to any @llvm.assume intrinsics.
8014   for (auto &AssumeVH : AC.assumptions()) {
8015     if (!AssumeVH)
8016       continue;
8017     auto *CI = cast<CallInst>(AssumeVH);
8018     if (!DT.dominates(CI, L->getHeader()))
8019       continue;
8020
8021     if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
8022       return true;
8023   }
8024
8025   return false;
8026 }
8027
8028 namespace {
8029 /// RAII wrapper to prevent recursive application of isImpliedCond.
8030 /// ScalarEvolution's PendingLoopPredicates set must be empty unless we are
8031 /// currently evaluating isImpliedCond.
8032 struct MarkPendingLoopPredicate {
8033   Value *Cond;
8034   DenseSet<Value*> &LoopPreds;
8035   bool Pending;
8036
8037   MarkPendingLoopPredicate(Value *C, DenseSet<Value*> &LP)
8038     : Cond(C), LoopPreds(LP) {
8039     Pending = !LoopPreds.insert(Cond).second;
8040   }
8041   ~MarkPendingLoopPredicate() {
8042     if (!Pending)
8043       LoopPreds.erase(Cond);
8044   }
8045 };
8046 } // end anonymous namespace
8047
8048 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
8049                                     const SCEV *LHS, const SCEV *RHS,
8050                                     Value *FoundCondValue,
8051                                     bool Inverse) {
8052   MarkPendingLoopPredicate Mark(FoundCondValue, PendingLoopPredicates);
8053   if (Mark.Pending)
8054     return false;
8055
8056   // Recursively handle And and Or conditions.
8057   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FoundCondValue)) {
8058     if (BO->getOpcode() == Instruction::And) {
8059       if (!Inverse)
8060         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
8061                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
8062     } else if (BO->getOpcode() == Instruction::Or) {
8063       if (Inverse)
8064         return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
8065                isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
8066     }
8067   }
8068
8069   ICmpInst *ICI = dyn_cast<ICmpInst>(FoundCondValue);
8070   if (!ICI) return false;
8071
8072   // Now that we found a conditional branch that dominates the loop or controls
8073   // the loop latch. Check to see if it is the comparison we are looking for.
8074   ICmpInst::Predicate FoundPred;
8075   if (Inverse)
8076     FoundPred = ICI->getInversePredicate();
8077   else
8078     FoundPred = ICI->getPredicate();
8079
8080   const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
8081   const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
8082
8083   return isImpliedCond(Pred, LHS, RHS, FoundPred, FoundLHS, FoundRHS);
8084 }
8085
8086 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS,
8087                                     const SCEV *RHS,
8088                                     ICmpInst::Predicate FoundPred,
8089                                     const SCEV *FoundLHS,
8090                                     const SCEV *FoundRHS) {
8091   // Balance the types.
8092   if (getTypeSizeInBits(LHS->getType()) <
8093       getTypeSizeInBits(FoundLHS->getType())) {
8094     if (CmpInst::isSigned(Pred)) {
8095       LHS = getSignExtendExpr(LHS, FoundLHS->getType());
8096       RHS = getSignExtendExpr(RHS, FoundLHS->getType());
8097     } else {
8098       LHS = getZeroExtendExpr(LHS, FoundLHS->getType());
8099       RHS = getZeroExtendExpr(RHS, FoundLHS->getType());
8100     }
8101   } else if (getTypeSizeInBits(LHS->getType()) >
8102       getTypeSizeInBits(FoundLHS->getType())) {
8103     if (CmpInst::isSigned(FoundPred)) {
8104       FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
8105       FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
8106     } else {
8107       FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
8108       FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
8109     }
8110   }
8111
8112   // Canonicalize the query to match the way instcombine will have
8113   // canonicalized the comparison.
8114   if (SimplifyICmpOperands(Pred, LHS, RHS))
8115     if (LHS == RHS)
8116       return CmpInst::isTrueWhenEqual(Pred);
8117   if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
8118     if (FoundLHS == FoundRHS)
8119       return CmpInst::isFalseWhenEqual(FoundPred);
8120
8121   // Check to see if we can make the LHS or RHS match.
8122   if (LHS == FoundRHS || RHS == FoundLHS) {
8123     if (isa<SCEVConstant>(RHS)) {
8124       std::swap(FoundLHS, FoundRHS);
8125       FoundPred = ICmpInst::getSwappedPredicate(FoundPred);
8126     } else {
8127       std::swap(LHS, RHS);
8128       Pred = ICmpInst::getSwappedPredicate(Pred);
8129     }
8130   }
8131
8132   // Check whether the found predicate is the same as the desired predicate.
8133   if (FoundPred == Pred)
8134     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
8135
8136   // Check whether swapping the found predicate makes it the same as the
8137   // desired predicate.
8138   if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
8139     if (isa<SCEVConstant>(RHS))
8140       return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
8141     else
8142       return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
8143                                    RHS, LHS, FoundLHS, FoundRHS);
8144   }
8145
8146   // Unsigned comparison is the same as signed comparison when both the operands
8147   // are non-negative.
8148   if (CmpInst::isUnsigned(FoundPred) &&
8149       CmpInst::getSignedPredicate(FoundPred) == Pred &&
8150       isKnownNonNegative(FoundLHS) && isKnownNonNegative(FoundRHS))
8151     return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
8152
8153   // Check if we can make progress by sharpening ranges.
8154   if (FoundPred == ICmpInst::ICMP_NE &&
8155       (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
8156
8157     const SCEVConstant *C = nullptr;
8158     const SCEV *V = nullptr;
8159
8160     if (isa<SCEVConstant>(FoundLHS)) {
8161       C = cast<SCEVConstant>(FoundLHS);
8162       V = FoundRHS;
8163     } else {
8164       C = cast<SCEVConstant>(FoundRHS);
8165       V = FoundLHS;
8166     }
8167
8168     // The guarding predicate tells us that C != V. If the known range
8169     // of V is [C, t), we can sharpen the range to [C + 1, t).  The
8170     // range we consider has to correspond to same signedness as the
8171     // predicate we're interested in folding.
8172
8173     APInt Min = ICmpInst::isSigned(Pred) ?
8174         getSignedRange(V).getSignedMin() : getUnsignedRange(V).getUnsignedMin();
8175
8176     if (Min == C->getAPInt()) {
8177       // Given (V >= Min && V != Min) we conclude V >= (Min + 1).
8178       // This is true even if (Min + 1) wraps around -- in case of
8179       // wraparound, (Min + 1) < Min, so (V >= Min => V >= (Min + 1)).
8180
8181       APInt SharperMin = Min + 1;
8182
8183       switch (Pred) {
8184         case ICmpInst::ICMP_SGE:
8185         case ICmpInst::ICMP_UGE:
8186           // We know V `Pred` SharperMin.  If this implies LHS `Pred`
8187           // RHS, we're done.
8188           if (isImpliedCondOperands(Pred, LHS, RHS, V,
8189                                     getConstant(SharperMin)))
8190             return true;
8191
8192         case ICmpInst::ICMP_SGT:
8193         case ICmpInst::ICMP_UGT:
8194           // We know from the range information that (V `Pred` Min ||
8195           // V == Min).  We know from the guarding condition that !(V
8196           // == Min).  This gives us
8197           //
8198           //       V `Pred` Min || V == Min && !(V == Min)
8199           //   =>  V `Pred` Min
8200           //
8201           // If V `Pred` Min implies LHS `Pred` RHS, we're done.
8202
8203           if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
8204             return true;
8205
8206         default:
8207           // No change
8208           break;
8209       }
8210     }
8211   }
8212
8213   // Check whether the actual condition is beyond sufficient.
8214   if (FoundPred == ICmpInst::ICMP_EQ)
8215     if (ICmpInst::isTrueWhenEqual(Pred))
8216       if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
8217         return true;
8218   if (Pred == ICmpInst::ICMP_NE)
8219     if (!ICmpInst::isTrueWhenEqual(FoundPred))
8220       if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
8221         return true;
8222
8223   // Otherwise assume the worst.
8224   return false;
8225 }
8226
8227 bool ScalarEvolution::splitBinaryAdd(const SCEV *Expr,
8228                                      const SCEV *&L, const SCEV *&R,
8229                                      SCEV::NoWrapFlags &Flags) {
8230   const auto *AE = dyn_cast<SCEVAddExpr>(Expr);
8231   if (!AE || AE->getNumOperands() != 2)
8232     return false;
8233
8234   L = AE->getOperand(0);
8235   R = AE->getOperand(1);
8236   Flags = AE->getNoWrapFlags();
8237   return true;
8238 }
8239
8240 bool ScalarEvolution::computeConstantDifference(const SCEV *Less,
8241                                                 const SCEV *More,
8242                                                 APInt &C) {
8243   // We avoid subtracting expressions here because this function is usually
8244   // fairly deep in the call stack (i.e. is called many times).
8245
8246   if (isa<SCEVAddRecExpr>(Less) && isa<SCEVAddRecExpr>(More)) {
8247     const auto *LAR = cast<SCEVAddRecExpr>(Less);
8248     const auto *MAR = cast<SCEVAddRecExpr>(More);
8249
8250     if (LAR->getLoop() != MAR->getLoop())
8251       return false;
8252
8253     // We look at affine expressions only; not for correctness but to keep
8254     // getStepRecurrence cheap.
8255     if (!LAR->isAffine() || !MAR->isAffine())
8256       return false;
8257
8258     if (LAR->getStepRecurrence(*this) != MAR->getStepRecurrence(*this))
8259       return false;
8260
8261     Less = LAR->getStart();
8262     More = MAR->getStart();
8263
8264     // fall through
8265   }
8266
8267   if (isa<SCEVConstant>(Less) && isa<SCEVConstant>(More)) {
8268     const auto &M = cast<SCEVConstant>(More)->getAPInt();
8269     const auto &L = cast<SCEVConstant>(Less)->getAPInt();
8270     C = M - L;
8271     return true;
8272   }
8273
8274   const SCEV *L, *R;
8275   SCEV::NoWrapFlags Flags;
8276   if (splitBinaryAdd(Less, L, R, Flags))
8277     if (const auto *LC = dyn_cast<SCEVConstant>(L))
8278       if (R == More) {
8279         C = -(LC->getAPInt());
8280         return true;
8281       }
8282
8283   if (splitBinaryAdd(More, L, R, Flags))
8284     if (const auto *LC = dyn_cast<SCEVConstant>(L))
8285       if (R == Less) {
8286         C = LC->getAPInt();
8287         return true;
8288       }
8289
8290   return false;
8291 }
8292
8293 bool ScalarEvolution::isImpliedCondOperandsViaNoOverflow(
8294     ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
8295     const SCEV *FoundLHS, const SCEV *FoundRHS) {
8296   if (Pred != CmpInst::ICMP_SLT && Pred != CmpInst::ICMP_ULT)
8297     return false;
8298
8299   const auto *AddRecLHS = dyn_cast<SCEVAddRecExpr>(LHS);
8300   if (!AddRecLHS)
8301     return false;
8302
8303   const auto *AddRecFoundLHS = dyn_cast<SCEVAddRecExpr>(FoundLHS);
8304   if (!AddRecFoundLHS)
8305     return false;
8306
8307   // We'd like to let SCEV reason about control dependencies, so we constrain
8308   // both the inequalities to be about add recurrences on the same loop.  This
8309   // way we can use isLoopEntryGuardedByCond later.
8310
8311   const Loop *L = AddRecFoundLHS->getLoop();
8312   if (L != AddRecLHS->getLoop())
8313     return false;
8314
8315   //  FoundLHS u< FoundRHS u< -C =>  (FoundLHS + C) u< (FoundRHS + C) ... (1)
8316   //
8317   //  FoundLHS s< FoundRHS s< INT_MIN - C => (FoundLHS + C) s< (FoundRHS + C)
8318   //                                                                  ... (2)
8319   //
8320   // Informal proof for (2), assuming (1) [*]:
8321   //
8322   // We'll also assume (A s< B) <=> ((A + INT_MIN) u< (B + INT_MIN)) ... (3)[**]
8323   //
8324   // Then
8325   //
8326   //       FoundLHS s< FoundRHS s< INT_MIN - C
8327   // <=>  (FoundLHS + INT_MIN) u< (FoundRHS + INT_MIN) u< -C   [ using (3) ]
8328   // <=>  (FoundLHS + INT_MIN + C) u< (FoundRHS + INT_MIN + C) [ using (1) ]
8329   // <=>  (FoundLHS + INT_MIN + C + INT_MIN) s<
8330   //                        (FoundRHS + INT_MIN + C + INT_MIN) [ using (3) ]
8331   // <=>  FoundLHS + C s< FoundRHS + C
8332   //
8333   // [*]: (1) can be proved by ruling out overflow.
8334   //
8335   // [**]: This can be proved by analyzing all the four possibilities:
8336   //    (A s< 0, B s< 0), (A s< 0, B s>= 0), (A s>= 0, B s< 0) and
8337   //    (A s>= 0, B s>= 0).
8338   //
8339   // Note:
8340   // Despite (2), "FoundRHS s< INT_MIN - C" does not mean that "FoundRHS + C"
8341   // will not sign underflow.  For instance, say FoundLHS = (i8 -128), FoundRHS
8342   // = (i8 -127) and C = (i8 -100).  Then INT_MIN - C = (i8 -28), and FoundRHS
8343   // s< (INT_MIN - C).  Lack of sign overflow / underflow in "FoundRHS + C" is
8344   // neither necessary nor sufficient to prove "(FoundLHS + C) s< (FoundRHS +
8345   // C)".
8346
8347   APInt LDiff, RDiff;
8348   if (!computeConstantDifference(FoundLHS, LHS, LDiff) ||
8349       !computeConstantDifference(FoundRHS, RHS, RDiff) ||
8350       LDiff != RDiff)
8351     return false;
8352
8353   if (LDiff == 0)
8354     return true;
8355
8356   APInt FoundRHSLimit;
8357
8358   if (Pred == CmpInst::ICMP_ULT) {
8359     FoundRHSLimit = -RDiff;
8360   } else {
8361     assert(Pred == CmpInst::ICMP_SLT && "Checked above!");
8362     FoundRHSLimit = APInt::getSignedMinValue(getTypeSizeInBits(RHS->getType())) - RDiff;
8363   }
8364
8365   // Try to prove (1) or (2), as needed.
8366   return isLoopEntryGuardedByCond(L, Pred, FoundRHS,
8367                                   getConstant(FoundRHSLimit));
8368 }
8369
8370 bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
8371                                             const SCEV *LHS, const SCEV *RHS,
8372                                             const SCEV *FoundLHS,
8373                                             const SCEV *FoundRHS) {
8374   if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
8375     return true;
8376
8377   if (isImpliedCondOperandsViaNoOverflow(Pred, LHS, RHS, FoundLHS, FoundRHS))
8378     return true;
8379
8380   return isImpliedCondOperandsHelper(Pred, LHS, RHS,
8381                                      FoundLHS, FoundRHS) ||
8382          // ~x < ~y --> x > y
8383          isImpliedCondOperandsHelper(Pred, LHS, RHS,
8384                                      getNotSCEV(FoundRHS),
8385                                      getNotSCEV(FoundLHS));
8386 }
8387
8388
8389 /// If Expr computes ~A, return A else return nullptr
8390 static const SCEV *MatchNotExpr(const SCEV *Expr) {
8391   const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Expr);
8392   if (!Add || Add->getNumOperands() != 2 ||
8393       !Add->getOperand(0)->isAllOnesValue())
8394     return nullptr;
8395
8396   const SCEVMulExpr *AddRHS = dyn_cast<SCEVMulExpr>(Add->getOperand(1));
8397   if (!AddRHS || AddRHS->getNumOperands() != 2 ||
8398       !AddRHS->getOperand(0)->isAllOnesValue())
8399     return nullptr;
8400
8401   return AddRHS->getOperand(1);
8402 }
8403
8404
8405 /// Is MaybeMaxExpr an SMax or UMax of Candidate and some other values?
8406 template<typename MaxExprType>
8407 static bool IsMaxConsistingOf(const SCEV *MaybeMaxExpr,
8408                               const SCEV *Candidate) {
8409   const MaxExprType *MaxExpr = dyn_cast<MaxExprType>(MaybeMaxExpr);
8410   if (!MaxExpr) return false;
8411
8412   return find(MaxExpr->operands(), Candidate) != MaxExpr->op_end();
8413 }
8414
8415
8416 /// Is MaybeMinExpr an SMin or UMin of Candidate and some other values?
8417 template<typename MaxExprType>
8418 static bool IsMinConsistingOf(ScalarEvolution &SE,
8419                               const SCEV *MaybeMinExpr,
8420                               const SCEV *Candidate) {
8421   const SCEV *MaybeMaxExpr = MatchNotExpr(MaybeMinExpr);
8422   if (!MaybeMaxExpr)
8423     return false;
8424
8425   return IsMaxConsistingOf<MaxExprType>(MaybeMaxExpr, SE.getNotSCEV(Candidate));
8426 }
8427
8428 static bool IsKnownPredicateViaAddRecStart(ScalarEvolution &SE,
8429                                            ICmpInst::Predicate Pred,
8430                                            const SCEV *LHS, const SCEV *RHS) {
8431
8432   // If both sides are affine addrecs for the same loop, with equal
8433   // steps, and we know the recurrences don't wrap, then we only
8434   // need to check the predicate on the starting values.
8435
8436   if (!ICmpInst::isRelational(Pred))
8437     return false;
8438
8439   const SCEVAddRecExpr *LAR = dyn_cast<SCEVAddRecExpr>(LHS);
8440   if (!LAR)
8441     return false;
8442   const SCEVAddRecExpr *RAR = dyn_cast<SCEVAddRecExpr>(RHS);
8443   if (!RAR)
8444     return false;
8445   if (LAR->getLoop() != RAR->getLoop())
8446     return false;
8447   if (!LAR->isAffine() || !RAR->isAffine())
8448     return false;
8449
8450   if (LAR->getStepRecurrence(SE) != RAR->getStepRecurrence(SE))
8451     return false;
8452
8453   SCEV::NoWrapFlags NW = ICmpInst::isSigned(Pred) ?
8454                          SCEV::FlagNSW : SCEV::FlagNUW;
8455   if (!LAR->getNoWrapFlags(NW) || !RAR->getNoWrapFlags(NW))
8456     return false;
8457
8458   return SE.isKnownPredicate(Pred, LAR->getStart(), RAR->getStart());
8459 }
8460
8461 /// Is LHS `Pred` RHS true on the virtue of LHS or RHS being a Min or Max
8462 /// expression?
8463 static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE,
8464                                         ICmpInst::Predicate Pred,
8465                                         const SCEV *LHS, const SCEV *RHS) {
8466   switch (Pred) {
8467   default:
8468     return false;
8469
8470   case ICmpInst::ICMP_SGE:
8471     std::swap(LHS, RHS);
8472     // fall through
8473   case ICmpInst::ICMP_SLE:
8474     return
8475       // min(A, ...) <= A
8476       IsMinConsistingOf<SCEVSMaxExpr>(SE, LHS, RHS) ||
8477       // A <= max(A, ...)
8478       IsMaxConsistingOf<SCEVSMaxExpr>(RHS, LHS);
8479
8480   case ICmpInst::ICMP_UGE:
8481     std::swap(LHS, RHS);
8482     // fall through
8483   case ICmpInst::ICMP_ULE:
8484     return
8485       // min(A, ...) <= A
8486       IsMinConsistingOf<SCEVUMaxExpr>(SE, LHS, RHS) ||
8487       // A <= max(A, ...)
8488       IsMaxConsistingOf<SCEVUMaxExpr>(RHS, LHS);
8489   }
8490
8491   llvm_unreachable("covered switch fell through?!");
8492 }
8493
8494 bool
8495 ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
8496                                              const SCEV *LHS, const SCEV *RHS,
8497                                              const SCEV *FoundLHS,
8498                                              const SCEV *FoundRHS) {
8499   auto IsKnownPredicateFull =
8500       [this](ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
8501     return isKnownPredicateViaConstantRanges(Pred, LHS, RHS) ||
8502            IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS) ||
8503            IsKnownPredicateViaAddRecStart(*this, Pred, LHS, RHS) ||
8504            isKnownPredicateViaNoOverflow(Pred, LHS, RHS);
8505   };
8506
8507   switch (Pred) {
8508   default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
8509   case ICmpInst::ICMP_EQ:
8510   case ICmpInst::ICMP_NE:
8511     if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
8512       return true;
8513     break;
8514   case ICmpInst::ICMP_SLT:
8515   case ICmpInst::ICMP_SLE:
8516     if (IsKnownPredicateFull(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
8517         IsKnownPredicateFull(ICmpInst::ICMP_SGE, RHS, FoundRHS))
8518       return true;
8519     break;
8520   case ICmpInst::ICMP_SGT:
8521   case ICmpInst::ICMP_SGE:
8522     if (IsKnownPredicateFull(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
8523         IsKnownPredicateFull(ICmpInst::ICMP_SLE, RHS, FoundRHS))
8524       return true;
8525     break;
8526   case ICmpInst::ICMP_ULT:
8527   case ICmpInst::ICMP_ULE:
8528     if (IsKnownPredicateFull(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
8529         IsKnownPredicateFull(ICmpInst::ICMP_UGE, RHS, FoundRHS))
8530       return true;
8531     break;
8532   case ICmpInst::ICMP_UGT:
8533   case ICmpInst::ICMP_UGE:
8534     if (IsKnownPredicateFull(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
8535         IsKnownPredicateFull(ICmpInst::ICMP_ULE, RHS, FoundRHS))
8536       return true;
8537     break;
8538   }
8539
8540   return false;
8541 }
8542
8543 bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
8544                                                      const SCEV *LHS,
8545                                                      const SCEV *RHS,
8546                                                      const SCEV *FoundLHS,
8547                                                      const SCEV *FoundRHS) {
8548   if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
8549     // The restriction on `FoundRHS` be lifted easily -- it exists only to
8550     // reduce the compile time impact of this optimization.
8551     return false;
8552
8553   const SCEVAddExpr *AddLHS = dyn_cast<SCEVAddExpr>(LHS);
8554   if (!AddLHS || AddLHS->getOperand(1) != FoundLHS ||
8555       !isa<SCEVConstant>(AddLHS->getOperand(0)))
8556     return false;
8557
8558   APInt ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getAPInt();
8559
8560   // `FoundLHSRange` is the range we know `FoundLHS` to be in by virtue of the
8561   // antecedent "`FoundLHS` `Pred` `FoundRHS`".
8562   ConstantRange FoundLHSRange =
8563       ConstantRange::makeAllowedICmpRegion(Pred, ConstFoundRHS);
8564
8565   // Since `LHS` is `FoundLHS` + `AddLHS->getOperand(0)`, we can compute a range
8566   // for `LHS`:
8567   APInt Addend = cast<SCEVConstant>(AddLHS->getOperand(0))->getAPInt();
8568   ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(Addend));
8569
8570   // We can also compute the range of values for `LHS` that satisfy the
8571   // consequent, "`LHS` `Pred` `RHS`":
8572   APInt ConstRHS = cast<SCEVConstant>(RHS)->getAPInt();
8573   ConstantRange SatisfyingLHSRange =
8574       ConstantRange::makeSatisfyingICmpRegion(Pred, ConstRHS);
8575
8576   // The antecedent implies the consequent if every value of `LHS` that
8577   // satisfies the antecedent also satisfies the consequent.
8578   return SatisfyingLHSRange.contains(LHSRange);
8579 }
8580
8581 bool ScalarEvolution::doesIVOverflowOnLT(const SCEV *RHS, const SCEV *Stride,
8582                                          bool IsSigned, bool NoWrap) {
8583   if (NoWrap) return false;
8584
8585   unsigned BitWidth = getTypeSizeInBits(RHS->getType());
8586   const SCEV *One = getOne(Stride->getType());
8587
8588   if (IsSigned) {
8589     APInt MaxRHS = getSignedRange(RHS).getSignedMax();
8590     APInt MaxValue = APInt::getSignedMaxValue(BitWidth);
8591     APInt MaxStrideMinusOne = getSignedRange(getMinusSCEV(Stride, One))
8592                                 .getSignedMax();
8593
8594     // SMaxRHS + SMaxStrideMinusOne > SMaxValue => overflow!
8595     return (MaxValue - MaxStrideMinusOne).slt(MaxRHS);
8596   }
8597
8598   APInt MaxRHS = getUnsignedRange(RHS).getUnsignedMax();
8599   APInt MaxValue = APInt::getMaxValue(BitWidth);
8600   APInt MaxStrideMinusOne = getUnsignedRange(getMinusSCEV(Stride, One))
8601                               .getUnsignedMax();
8602
8603   // UMaxRHS + UMaxStrideMinusOne > UMaxValue => overflow!
8604   return (MaxValue - MaxStrideMinusOne).ult(MaxRHS);
8605 }
8606
8607 bool ScalarEvolution::doesIVOverflowOnGT(const SCEV *RHS, const SCEV *Stride,
8608                                          bool IsSigned, bool NoWrap) {
8609   if (NoWrap) return false;
8610
8611   unsigned BitWidth = getTypeSizeInBits(RHS->getType());
8612   const SCEV *One = getOne(Stride->getType());
8613
8614   if (IsSigned) {
8615     APInt MinRHS = getSignedRange(RHS).getSignedMin();
8616     APInt MinValue = APInt::getSignedMinValue(BitWidth);
8617     APInt MaxStrideMinusOne = getSignedRange(getMinusSCEV(Stride, One))
8618                                .getSignedMax();
8619
8620     // SMinRHS - SMaxStrideMinusOne < SMinValue => overflow!
8621     return (MinValue + MaxStrideMinusOne).sgt(MinRHS);
8622   }
8623
8624   APInt MinRHS = getUnsignedRange(RHS).getUnsignedMin();
8625   APInt MinValue = APInt::getMinValue(BitWidth);
8626   APInt MaxStrideMinusOne = getUnsignedRange(getMinusSCEV(Stride, One))
8627                             .getUnsignedMax();
8628
8629   // UMinRHS - UMaxStrideMinusOne < UMinValue => overflow!
8630   return (MinValue + MaxStrideMinusOne).ugt(MinRHS);
8631 }
8632
8633 const SCEV *ScalarEvolution::computeBECount(const SCEV *Delta, const SCEV *Step,
8634                                             bool Equality) {
8635   const SCEV *One = getOne(Step->getType());
8636   Delta = Equality ? getAddExpr(Delta, Step)
8637                    : getAddExpr(Delta, getMinusSCEV(Step, One));
8638   return getUDivExpr(Delta, Step);
8639 }
8640
8641 ScalarEvolution::ExitLimit
8642 ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
8643                                   const Loop *L, bool IsSigned,
8644                                   bool ControlsExit, bool AllowPredicates) {
8645   SCEVUnionPredicate P;
8646   // We handle only IV < Invariant
8647   if (!isLoopInvariant(RHS, L))
8648     return getCouldNotCompute();
8649
8650   const SCEVAddRecExpr *IV = dyn_cast<SCEVAddRecExpr>(LHS);
8651   if (!IV && AllowPredicates)
8652     // Try to make this an AddRec using runtime tests, in the first X
8653     // iterations of this loop, where X is the SCEV expression found by the
8654     // algorithm below.
8655     IV = convertSCEVToAddRecWithPredicates(LHS, L, P);
8656
8657   // Avoid weird loops
8658   if (!IV || IV->getLoop() != L || !IV->isAffine())
8659     return getCouldNotCompute();
8660
8661   bool NoWrap = ControlsExit &&
8662                 IV->getNoWrapFlags(IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW);
8663
8664   const SCEV *Stride = IV->getStepRecurrence(*this);
8665
8666   // Avoid negative or zero stride values
8667   if (!isKnownPositive(Stride))
8668     return getCouldNotCompute();
8669
8670   // Avoid proven overflow cases: this will ensure that the backedge taken count
8671   // will not generate any unsigned overflow. Relaxed no-overflow conditions
8672   // exploit NoWrapFlags, allowing to optimize in presence of undefined
8673   // behaviors like the case of C language.
8674   if (!Stride->isOne() && doesIVOverflowOnLT(RHS, Stride, IsSigned, NoWrap))
8675     return getCouldNotCompute();
8676
8677   ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SLT
8678                                       : ICmpInst::ICMP_ULT;
8679   const SCEV *Start = IV->getStart();
8680   const SCEV *End = RHS;
8681   if (!isLoopEntryGuardedByCond(L, Cond, getMinusSCEV(Start, Stride), RHS))
8682     End = IsSigned ? getSMaxExpr(RHS, Start) : getUMaxExpr(RHS, Start);
8683
8684   const SCEV *BECount = computeBECount(getMinusSCEV(End, Start), Stride, false);
8685
8686   APInt MinStart = IsSigned ? getSignedRange(Start).getSignedMin()
8687                             : getUnsignedRange(Start).getUnsignedMin();
8688
8689   APInt MinStride = IsSigned ? getSignedRange(Stride).getSignedMin()
8690                              : getUnsignedRange(Stride).getUnsignedMin();
8691
8692   unsigned BitWidth = getTypeSizeInBits(LHS->getType());
8693   APInt Limit = IsSigned ? APInt::getSignedMaxValue(BitWidth) - (MinStride - 1)
8694                          : APInt::getMaxValue(BitWidth) - (MinStride - 1);
8695
8696   // Although End can be a MAX expression we estimate MaxEnd considering only
8697   // the case End = RHS. This is safe because in the other case (End - Start)
8698   // is zero, leading to a zero maximum backedge taken count.
8699   APInt MaxEnd =
8700     IsSigned ? APIntOps::smin(getSignedRange(RHS).getSignedMax(), Limit)
8701              : APIntOps::umin(getUnsignedRange(RHS).getUnsignedMax(), Limit);
8702
8703   const SCEV *MaxBECount;
8704   if (isa<SCEVConstant>(BECount))
8705     MaxBECount = BECount;
8706   else
8707     MaxBECount = computeBECount(getConstant(MaxEnd - MinStart),
8708                                 getConstant(MinStride), false);
8709
8710   if (isa<SCEVCouldNotCompute>(MaxBECount))
8711     MaxBECount = BECount;
8712
8713   return ExitLimit(BECount, MaxBECount, P);
8714 }
8715
8716 ScalarEvolution::ExitLimit
8717 ScalarEvolution::howManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
8718                                      const Loop *L, bool IsSigned,
8719                                      bool ControlsExit, bool AllowPredicates) {
8720   SCEVUnionPredicate P;
8721   // We handle only IV > Invariant
8722   if (!isLoopInvariant(RHS, L))
8723     return getCouldNotCompute();
8724
8725   const SCEVAddRecExpr *IV = dyn_cast<SCEVAddRecExpr>(LHS);
8726   if (!IV && AllowPredicates)
8727     // Try to make this an AddRec using runtime tests, in the first X
8728     // iterations of this loop, where X is the SCEV expression found by the
8729     // algorithm below.
8730     IV = convertSCEVToAddRecWithPredicates(LHS, L, P);
8731
8732   // Avoid weird loops
8733   if (!IV || IV->getLoop() != L || !IV->isAffine())
8734     return getCouldNotCompute();
8735
8736   bool NoWrap = ControlsExit &&
8737                 IV->getNoWrapFlags(IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW);
8738
8739   const SCEV *Stride = getNegativeSCEV(IV->getStepRecurrence(*this));
8740
8741   // Avoid negative or zero stride values
8742   if (!isKnownPositive(Stride))
8743     return getCouldNotCompute();
8744
8745   // Avoid proven overflow cases: this will ensure that the backedge taken count
8746   // will not generate any unsigned overflow. Relaxed no-overflow conditions
8747   // exploit NoWrapFlags, allowing to optimize in presence of undefined
8748   // behaviors like the case of C language.
8749   if (!Stride->isOne() && doesIVOverflowOnGT(RHS, Stride, IsSigned, NoWrap))
8750     return getCouldNotCompute();
8751
8752   ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SGT
8753                                       : ICmpInst::ICMP_UGT;
8754
8755   const SCEV *Start = IV->getStart();
8756   const SCEV *End = RHS;
8757   if (!isLoopEntryGuardedByCond(L, Cond, getAddExpr(Start, Stride), RHS))
8758     End = IsSigned ? getSMinExpr(RHS, Start) : getUMinExpr(RHS, Start);
8759
8760   const SCEV *BECount = computeBECount(getMinusSCEV(Start, End), Stride, false);
8761
8762   APInt MaxStart = IsSigned ? getSignedRange(Start).getSignedMax()
8763                             : getUnsignedRange(Start).getUnsignedMax();
8764
8765   APInt MinStride = IsSigned ? getSignedRange(Stride).getSignedMin()
8766                              : getUnsignedRange(Stride).getUnsignedMin();
8767
8768   unsigned BitWidth = getTypeSizeInBits(LHS->getType());
8769   APInt Limit = IsSigned ? APInt::getSignedMinValue(BitWidth) + (MinStride - 1)
8770                          : APInt::getMinValue(BitWidth) + (MinStride - 1);
8771
8772   // Although End can be a MIN expression we estimate MinEnd considering only
8773   // the case End = RHS. This is safe because in the other case (Start - End)
8774   // is zero, leading to a zero maximum backedge taken count.
8775   APInt MinEnd =
8776     IsSigned ? APIntOps::smax(getSignedRange(RHS).getSignedMin(), Limit)
8777              : APIntOps::umax(getUnsignedRange(RHS).getUnsignedMin(), Limit);
8778
8779
8780   const SCEV *MaxBECount = getCouldNotCompute();
8781   if (isa<SCEVConstant>(BECount))
8782     MaxBECount = BECount;
8783   else
8784     MaxBECount = computeBECount(getConstant(MaxStart - MinEnd),
8785                                 getConstant(MinStride), false);
8786
8787   if (isa<SCEVCouldNotCompute>(MaxBECount))
8788     MaxBECount = BECount;
8789
8790   return ExitLimit(BECount, MaxBECount, P);
8791 }
8792
8793 const SCEV *SCEVAddRecExpr::getNumIterationsInRange(const ConstantRange &Range,
8794                                                     ScalarEvolution &SE) const {
8795   if (Range.isFullSet())  // Infinite loop.
8796     return SE.getCouldNotCompute();
8797
8798   // If the start is a non-zero constant, shift the range to simplify things.
8799   if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
8800     if (!SC->getValue()->isZero()) {
8801       SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
8802       Operands[0] = SE.getZero(SC->getType());
8803       const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
8804                                              getNoWrapFlags(FlagNW));
8805       if (const auto *ShiftedAddRec = dyn_cast<SCEVAddRecExpr>(Shifted))
8806         return ShiftedAddRec->getNumIterationsInRange(
8807             Range.subtract(SC->getAPInt()), SE);
8808       // This is strange and shouldn't happen.
8809       return SE.getCouldNotCompute();
8810     }
8811
8812   // The only time we can solve this is when we have all constant indices.
8813   // Otherwise, we cannot determine the overflow conditions.
8814   if (any_of(operands(), [](const SCEV *Op) { return !isa<SCEVConstant>(Op); }))
8815     return SE.getCouldNotCompute();
8816
8817   // Okay at this point we know that all elements of the chrec are constants and
8818   // that the start element is zero.
8819
8820   // First check to see if the range contains zero.  If not, the first
8821   // iteration exits.
8822   unsigned BitWidth = SE.getTypeSizeInBits(getType());
8823   if (!Range.contains(APInt(BitWidth, 0)))
8824     return SE.getZero(getType());
8825
8826   if (isAffine()) {
8827     // If this is an affine expression then we have this situation:
8828     //   Solve {0,+,A} in Range  ===  Ax in Range
8829
8830     // We know that zero is in the range.  If A is positive then we know that
8831     // the upper value of the range must be the first possible exit value.
8832     // If A is negative then the lower of the range is the last possible loop
8833     // value.  Also note that we already checked for a full range.
8834     APInt One(BitWidth,1);
8835     APInt A = cast<SCEVConstant>(getOperand(1))->getAPInt();
8836     APInt End = A.sge(One) ? (Range.getUpper() - One) : Range.getLower();
8837
8838     // The exit value should be (End+A)/A.
8839     APInt ExitVal = (End + A).udiv(A);
8840     ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
8841
8842     // Evaluate at the exit value.  If we really did fall out of the valid
8843     // range, then we computed our trip count, otherwise wrap around or other
8844     // things must have happened.
8845     ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue, SE);
8846     if (Range.contains(Val->getValue()))
8847       return SE.getCouldNotCompute();  // Something strange happened
8848
8849     // Ensure that the previous value is in the range.  This is a sanity check.
8850     assert(Range.contains(
8851            EvaluateConstantChrecAtConstant(this,
8852            ConstantInt::get(SE.getContext(), ExitVal - One), SE)->getValue()) &&
8853            "Linear scev computation is off in a bad way!");
8854     return SE.getConstant(ExitValue);
8855   } else if (isQuadratic()) {
8856     // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of the
8857     // quadratic equation to solve it.  To do this, we must frame our problem in
8858     // terms of figuring out when zero is crossed, instead of when
8859     // Range.getUpper() is crossed.
8860     SmallVector<const SCEV *, 4> NewOps(op_begin(), op_end());
8861     NewOps[0] = SE.getNegativeSCEV(SE.getConstant(Range.getUpper()));
8862     const SCEV *NewAddRec = SE.getAddRecExpr(NewOps, getLoop(),
8863                                              // getNoWrapFlags(FlagNW)
8864                                              FlagAnyWrap);
8865
8866     // Next, solve the constructed addrec
8867     if (auto Roots =
8868             SolveQuadraticEquation(cast<SCEVAddRecExpr>(NewAddRec), SE)) {
8869       const SCEVConstant *R1 = Roots->first;
8870       const SCEVConstant *R2 = Roots->second;
8871       // Pick the smallest positive root value.
8872       if (ConstantInt *CB = dyn_cast<ConstantInt>(ConstantExpr::getICmp(
8873               ICmpInst::ICMP_ULT, R1->getValue(), R2->getValue()))) {
8874         if (!CB->getZExtValue())
8875           std::swap(R1, R2); // R1 is the minimum root now.
8876
8877         // Make sure the root is not off by one.  The returned iteration should
8878         // not be in the range, but the previous one should be.  When solving
8879         // for "X*X < 5", for example, we should not return a root of 2.
8880         ConstantInt *R1Val =
8881             EvaluateConstantChrecAtConstant(this, R1->getValue(), SE);
8882         if (Range.contains(R1Val->getValue())) {
8883           // The next iteration must be out of the range...
8884           ConstantInt *NextVal =
8885               ConstantInt::get(SE.getContext(), R1->getAPInt() + 1);
8886
8887           R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
8888           if (!Range.contains(R1Val->getValue()))
8889             return SE.getConstant(NextVal);
8890           return SE.getCouldNotCompute(); // Something strange happened
8891         }
8892
8893         // If R1 was not in the range, then it is a good return value.  Make
8894         // sure that R1-1 WAS in the range though, just in case.
8895         ConstantInt *NextVal =
8896             ConstantInt::get(SE.getContext(), R1->getAPInt() - 1);
8897         R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
8898         if (Range.contains(R1Val->getValue()))
8899           return R1;
8900         return SE.getCouldNotCompute(); // Something strange happened
8901       }
8902     }
8903   }
8904
8905   return SE.getCouldNotCompute();
8906 }
8907
8908 namespace {
8909 struct FindUndefs {
8910   bool Found;
8911   FindUndefs() : Found(false) {}
8912
8913   bool follow(const SCEV *S) {
8914     if (const SCEVUnknown *C = dyn_cast<SCEVUnknown>(S)) {
8915       if (isa<UndefValue>(C->getValue()))
8916         Found = true;
8917     } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
8918       if (isa<UndefValue>(C->getValue()))
8919         Found = true;
8920     }
8921
8922     // Keep looking if we haven't found it yet.
8923     return !Found;
8924   }
8925   bool isDone() const {
8926     // Stop recursion if we have found an undef.
8927     return Found;
8928   }
8929 };
8930 }
8931
8932 // Return true when S contains at least an undef value.
8933 static inline bool
8934 containsUndefs(const SCEV *S) {
8935   FindUndefs F;
8936   SCEVTraversal<FindUndefs> ST(F);
8937   ST.visitAll(S);
8938
8939   return F.Found;
8940 }
8941
8942 namespace {
8943 // Collect all steps of SCEV expressions.
8944 struct SCEVCollectStrides {
8945   ScalarEvolution &SE;
8946   SmallVectorImpl<const SCEV *> &Strides;
8947
8948   SCEVCollectStrides(ScalarEvolution &SE, SmallVectorImpl<const SCEV *> &S)
8949       : SE(SE), Strides(S) {}
8950
8951   bool follow(const SCEV *S) {
8952     if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S))
8953       Strides.push_back(AR->getStepRecurrence(SE));
8954     return true;
8955   }
8956   bool isDone() const { return false; }
8957 };
8958
8959 // Collect all SCEVUnknown and SCEVMulExpr expressions.
8960 struct SCEVCollectTerms {
8961   SmallVectorImpl<const SCEV *> &Terms;
8962
8963   SCEVCollectTerms(SmallVectorImpl<const SCEV *> &T)
8964       : Terms(T) {}
8965
8966   bool follow(const SCEV *S) {
8967     if (isa<SCEVUnknown>(S) || isa<SCEVMulExpr>(S)) {
8968       if (!containsUndefs(S))
8969         Terms.push_back(S);
8970
8971       // Stop recursion: once we collected a term, do not walk its operands.
8972       return false;
8973     }
8974
8975     // Keep looking.
8976     return true;
8977   }
8978   bool isDone() const { return false; }
8979 };
8980
8981 // Check if a SCEV contains an AddRecExpr.
8982 struct SCEVHasAddRec {
8983   bool &ContainsAddRec;
8984
8985   SCEVHasAddRec(bool &ContainsAddRec) : ContainsAddRec(ContainsAddRec) {
8986    ContainsAddRec = false;
8987   }
8988
8989   bool follow(const SCEV *S) {
8990     if (isa<SCEVAddRecExpr>(S)) {
8991       ContainsAddRec = true;
8992
8993       // Stop recursion: once we collected a term, do not walk its operands.
8994       return false;
8995     }
8996
8997     // Keep looking.
8998     return true;
8999   }
9000   bool isDone() const { return false; }
9001 };
9002
9003 // Find factors that are multiplied with an expression that (possibly as a
9004 // subexpression) contains an AddRecExpr. In the expression:
9005 //
9006 //  8 * (100 +  %p * %q * (%a + {0, +, 1}_loop))
9007 //
9008 // "%p * %q" are factors multiplied by the expression "(%a + {0, +, 1}_loop)"
9009 // that contains the AddRec {0, +, 1}_loop. %p * %q are likely to be array size
9010 // parameters as they form a product with an induction variable.
9011 //
9012 // This collector expects all array size parameters to be in the same MulExpr.
9013 // It might be necessary to later add support for collecting parameters that are
9014 // spread over different nested MulExpr.
9015 struct SCEVCollectAddRecMultiplies {
9016   SmallVectorImpl<const SCEV *> &Terms;
9017   ScalarEvolution &SE;
9018
9019   SCEVCollectAddRecMultiplies(SmallVectorImpl<const SCEV *> &T, ScalarEvolution &SE)
9020       : Terms(T), SE(SE) {}
9021
9022   bool follow(const SCEV *S) {
9023     if (auto *Mul = dyn_cast<SCEVMulExpr>(S)) {
9024       bool HasAddRec = false;
9025       SmallVector<const SCEV *, 0> Operands;
9026       for (auto Op : Mul->operands()) {
9027         if (isa<SCEVUnknown>(Op)) {
9028           Operands.push_back(Op);
9029         } else {
9030           bool ContainsAddRec;
9031           SCEVHasAddRec ContiansAddRec(ContainsAddRec);
9032           visitAll(Op, ContiansAddRec);
9033           HasAddRec |= ContainsAddRec;
9034         }
9035       }
9036       if (Operands.size() == 0)
9037         return true;
9038
9039       if (!HasAddRec)
9040         return false;
9041
9042       Terms.push_back(SE.getMulExpr(Operands));
9043       // Stop recursion: once we collected a term, do not walk its operands.
9044       return false;
9045     }
9046
9047     // Keep looking.
9048     return true;
9049   }
9050   bool isDone() const { return false; }
9051 };
9052 }
9053
9054 /// Find parametric terms in this SCEVAddRecExpr. We first for parameters in
9055 /// two places:
9056 ///   1) The strides of AddRec expressions.
9057 ///   2) Unknowns that are multiplied with AddRec expressions.
9058 void ScalarEvolution::collectParametricTerms(const SCEV *Expr,
9059     SmallVectorImpl<const SCEV *> &Terms) {
9060   SmallVector<const SCEV *, 4> Strides;
9061   SCEVCollectStrides StrideCollector(*this, Strides);
9062   visitAll(Expr, StrideCollector);
9063
9064   DEBUG({
9065       dbgs() << "Strides:\n";
9066       for (const SCEV *S : Strides)
9067         dbgs() << *S << "\n";
9068     });
9069
9070   for (const SCEV *S : Strides) {
9071     SCEVCollectTerms TermCollector(Terms);
9072     visitAll(S, TermCollector);
9073   }
9074
9075   DEBUG({
9076       dbgs() << "Terms:\n";
9077       for (const SCEV *T : Terms)
9078         dbgs() << *T << "\n";
9079     });
9080
9081   SCEVCollectAddRecMultiplies MulCollector(Terms, *this);
9082   visitAll(Expr, MulCollector);
9083 }
9084
9085 static bool findArrayDimensionsRec(ScalarEvolution &SE,
9086                                    SmallVectorImpl<const SCEV *> &Terms,
9087                                    SmallVectorImpl<const SCEV *> &Sizes) {
9088   int Last = Terms.size() - 1;
9089   const SCEV *Step = Terms[Last];
9090
9091   // End of recursion.
9092   if (Last == 0) {
9093     if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Step)) {
9094       SmallVector<const SCEV *, 2> Qs;
9095       for (const SCEV *Op : M->operands())
9096         if (!isa<SCEVConstant>(Op))
9097           Qs.push_back(Op);
9098
9099       Step = SE.getMulExpr(Qs);
9100     }
9101
9102     Sizes.push_back(Step);
9103     return true;
9104   }
9105
9106   for (const SCEV *&Term : Terms) {
9107     // Normalize the terms before the next call to findArrayDimensionsRec.
9108     const SCEV *Q, *R;
9109     SCEVDivision::divide(SE, Term, Step, &Q, &R);
9110
9111     // Bail out when GCD does not evenly divide one of the terms.
9112     if (!R->isZero())
9113       return false;
9114
9115     Term = Q;
9116   }
9117
9118   // Remove all SCEVConstants.
9119   Terms.erase(std::remove_if(Terms.begin(), Terms.end(), [](const SCEV *E) {
9120                 return isa<SCEVConstant>(E);
9121               }),
9122               Terms.end());
9123
9124   if (Terms.size() > 0)
9125     if (!findArrayDimensionsRec(SE, Terms, Sizes))
9126       return false;
9127
9128   Sizes.push_back(Step);
9129   return true;
9130 }
9131
9132 // Returns true when S contains at least a SCEVUnknown parameter.
9133 static inline bool
9134 containsParameters(const SCEV *S) {
9135   struct FindParameter {
9136     bool FoundParameter;
9137     FindParameter() : FoundParameter(false) {}
9138
9139     bool follow(const SCEV *S) {
9140       if (isa<SCEVUnknown>(S)) {
9141         FoundParameter = true;
9142         // Stop recursion: we found a parameter.
9143         return false;
9144       }
9145       // Keep looking.
9146       return true;
9147     }
9148     bool isDone() const {
9149       // Stop recursion if we have found a parameter.
9150       return FoundParameter;
9151     }
9152   };
9153
9154   FindParameter F;
9155   SCEVTraversal<FindParameter> ST(F);
9156   ST.visitAll(S);
9157
9158   return F.FoundParameter;
9159 }
9160
9161 // Returns true when one of the SCEVs of Terms contains a SCEVUnknown parameter.
9162 static inline bool
9163 containsParameters(SmallVectorImpl<const SCEV *> &Terms) {
9164   for (const SCEV *T : Terms)
9165     if (containsParameters(T))
9166       return true;
9167   return false;
9168 }
9169
9170 // Return the number of product terms in S.
9171 static inline int numberOfTerms(const SCEV *S) {
9172   if (const SCEVMulExpr *Expr = dyn_cast<SCEVMulExpr>(S))
9173     return Expr->getNumOperands();
9174   return 1;
9175 }
9176
9177 static const SCEV *removeConstantFactors(ScalarEvolution &SE, const SCEV *T) {
9178   if (isa<SCEVConstant>(T))
9179     return nullptr;
9180
9181   if (isa<SCEVUnknown>(T))
9182     return T;
9183
9184   if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(T)) {
9185     SmallVector<const SCEV *, 2> Factors;
9186     for (const SCEV *Op : M->operands())
9187       if (!isa<SCEVConstant>(Op))
9188         Factors.push_back(Op);
9189
9190     return SE.getMulExpr(Factors);
9191   }
9192
9193   return T;
9194 }
9195
9196 /// Return the size of an element read or written by Inst.
9197 const SCEV *ScalarEvolution::getElementSize(Instruction *Inst) {
9198   Type *Ty;
9199   if (StoreInst *Store = dyn_cast<StoreInst>(Inst))
9200     Ty = Store->getValueOperand()->getType();
9201   else if (LoadInst *Load = dyn_cast<LoadInst>(Inst))
9202     Ty = Load->getType();
9203   else
9204     return nullptr;
9205
9206   Type *ETy = getEffectiveSCEVType(PointerType::getUnqual(Ty));
9207   return getSizeOfExpr(ETy, Ty);
9208 }
9209
9210 void ScalarEvolution::findArrayDimensions(SmallVectorImpl<const SCEV *> &Terms,
9211                                           SmallVectorImpl<const SCEV *> &Sizes,
9212                                           const SCEV *ElementSize) const {
9213   if (Terms.size() < 1 || !ElementSize)
9214     return;
9215
9216   // Early return when Terms do not contain parameters: we do not delinearize
9217   // non parametric SCEVs.
9218   if (!containsParameters(Terms))
9219     return;
9220
9221   DEBUG({
9222       dbgs() << "Terms:\n";
9223       for (const SCEV *T : Terms)
9224         dbgs() << *T << "\n";
9225     });
9226
9227   // Remove duplicates.
9228   std::sort(Terms.begin(), Terms.end());
9229   Terms.erase(std::unique(Terms.begin(), Terms.end()), Terms.end());
9230
9231   // Put larger terms first.
9232   std::sort(Terms.begin(), Terms.end(), [](const SCEV *LHS, const SCEV *RHS) {
9233     return numberOfTerms(LHS) > numberOfTerms(RHS);
9234   });
9235
9236   ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
9237
9238   // Try to divide all terms by the element size. If term is not divisible by
9239   // element size, proceed with the original term.
9240   for (const SCEV *&Term : Terms) {
9241     const SCEV *Q, *R;
9242     SCEVDivision::divide(SE, Term, ElementSize, &Q, &R);
9243     if (!Q->isZero())
9244       Term = Q;
9245   }
9246
9247   SmallVector<const SCEV *, 4> NewTerms;
9248
9249   // Remove constant factors.
9250   for (const SCEV *T : Terms)
9251     if (const SCEV *NewT = removeConstantFactors(SE, T))
9252       NewTerms.push_back(NewT);
9253
9254   DEBUG({
9255       dbgs() << "Terms after sorting:\n";
9256       for (const SCEV *T : NewTerms)
9257         dbgs() << *T << "\n";
9258     });
9259
9260   if (NewTerms.empty() ||
9261       !findArrayDimensionsRec(SE, NewTerms, Sizes)) {
9262     Sizes.clear();
9263     return;
9264   }
9265
9266   // The last element to be pushed into Sizes is the size of an element.
9267   Sizes.push_back(ElementSize);
9268
9269   DEBUG({
9270       dbgs() << "Sizes:\n";
9271       for (const SCEV *S : Sizes)
9272         dbgs() << *S << "\n";
9273     });
9274 }
9275
9276 void ScalarEvolution::computeAccessFunctions(
9277     const SCEV *Expr, SmallVectorImpl<const SCEV *> &Subscripts,
9278     SmallVectorImpl<const SCEV *> &Sizes) {
9279
9280   // Early exit in case this SCEV is not an affine multivariate function.
9281   if (Sizes.empty())
9282     return;
9283
9284   if (auto *AR = dyn_cast<SCEVAddRecExpr>(Expr))
9285     if (!AR->isAffine())
9286       return;
9287
9288   const SCEV *Res = Expr;
9289   int Last = Sizes.size() - 1;
9290   for (int i = Last; i >= 0; i--) {
9291     const SCEV *Q, *R;
9292     SCEVDivision::divide(*this, Res, Sizes[i], &Q, &R);
9293
9294     DEBUG({
9295         dbgs() << "Res: " << *Res << "\n";
9296         dbgs() << "Sizes[i]: " << *Sizes[i] << "\n";
9297         dbgs() << "Res divided by Sizes[i]:\n";
9298         dbgs() << "Quotient: " << *Q << "\n";
9299         dbgs() << "Remainder: " << *R << "\n";
9300       });
9301
9302     Res = Q;
9303
9304     // Do not record the last subscript corresponding to the size of elements in
9305     // the array.
9306     if (i == Last) {
9307
9308       // Bail out if the remainder is too complex.
9309       if (isa<SCEVAddRecExpr>(R)) {
9310         Subscripts.clear();
9311         Sizes.clear();
9312         return;
9313       }
9314
9315       continue;
9316     }
9317
9318     // Record the access function for the current subscript.
9319     Subscripts.push_back(R);
9320   }
9321
9322   // Also push in last position the remainder of the last division: it will be
9323   // the access function of the innermost dimension.
9324   Subscripts.push_back(Res);
9325
9326   std::reverse(Subscripts.begin(), Subscripts.end());
9327
9328   DEBUG({
9329       dbgs() << "Subscripts:\n";
9330       for (const SCEV *S : Subscripts)
9331         dbgs() << *S << "\n";
9332     });
9333 }
9334
9335 /// Splits the SCEV into two vectors of SCEVs representing the subscripts and
9336 /// sizes of an array access. Returns the remainder of the delinearization that
9337 /// is the offset start of the array.  The SCEV->delinearize algorithm computes
9338 /// the multiples of SCEV coefficients: that is a pattern matching of sub
9339 /// expressions in the stride and base of a SCEV corresponding to the
9340 /// computation of a GCD (greatest common divisor) of base and stride.  When
9341 /// SCEV->delinearize fails, it returns the SCEV unchanged.
9342 ///
9343 /// For example: when analyzing the memory access A[i][j][k] in this loop nest
9344 ///
9345 ///  void foo(long n, long m, long o, double A[n][m][o]) {
9346 ///
9347 ///    for (long i = 0; i < n; i++)
9348 ///      for (long j = 0; j < m; j++)
9349 ///        for (long k = 0; k < o; k++)
9350 ///          A[i][j][k] = 1.0;
9351 ///  }
9352 ///
9353 /// the delinearization input is the following AddRec SCEV:
9354 ///
9355 ///  AddRec: {{{%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
9356 ///
9357 /// From this SCEV, we are able to say that the base offset of the access is %A
9358 /// because it appears as an offset that does not divide any of the strides in
9359 /// the loops:
9360 ///
9361 ///  CHECK: Base offset: %A
9362 ///
9363 /// and then SCEV->delinearize determines the size of some of the dimensions of
9364 /// the array as these are the multiples by which the strides are happening:
9365 ///
9366 ///  CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(double) bytes.
9367 ///
9368 /// Note that the outermost dimension remains of UnknownSize because there are
9369 /// no strides that would help identifying the size of the last dimension: when
9370 /// the array has been statically allocated, one could compute the size of that
9371 /// dimension by dividing the overall size of the array by the size of the known
9372 /// dimensions: %m * %o * 8.
9373 ///
9374 /// Finally delinearize provides the access functions for the array reference
9375 /// that does correspond to A[i][j][k] of the above C testcase:
9376 ///
9377 ///  CHECK: ArrayRef[{0,+,1}<%for.i>][{0,+,1}<%for.j>][{0,+,1}<%for.k>]
9378 ///
9379 /// The testcases are checking the output of a function pass:
9380 /// DelinearizationPass that walks through all loads and stores of a function
9381 /// asking for the SCEV of the memory access with respect to all enclosing
9382 /// loops, calling SCEV->delinearize on that and printing the results.
9383
9384 void ScalarEvolution::delinearize(const SCEV *Expr,
9385                                  SmallVectorImpl<const SCEV *> &Subscripts,
9386                                  SmallVectorImpl<const SCEV *> &Sizes,
9387                                  const SCEV *ElementSize) {
9388   // First step: collect parametric terms.
9389   SmallVector<const SCEV *, 4> Terms;
9390   collectParametricTerms(Expr, Terms);
9391
9392   if (Terms.empty())
9393     return;
9394
9395   // Second step: find subscript sizes.
9396   findArrayDimensions(Terms, Sizes, ElementSize);
9397
9398   if (Sizes.empty())
9399     return;
9400
9401   // Third step: compute the access functions for each subscript.
9402   computeAccessFunctions(Expr, Subscripts, Sizes);
9403
9404   if (Subscripts.empty())
9405     return;
9406
9407   DEBUG({
9408       dbgs() << "succeeded to delinearize " << *Expr << "\n";
9409       dbgs() << "ArrayDecl[UnknownSize]";
9410       for (const SCEV *S : Sizes)
9411         dbgs() << "[" << *S << "]";
9412
9413       dbgs() << "\nArrayRef";
9414       for (const SCEV *S : Subscripts)
9415         dbgs() << "[" << *S << "]";
9416       dbgs() << "\n";
9417     });
9418 }
9419
9420 //===----------------------------------------------------------------------===//
9421 //                   SCEVCallbackVH Class Implementation
9422 //===----------------------------------------------------------------------===//
9423
9424 void ScalarEvolution::SCEVCallbackVH::deleted() {
9425   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
9426   if (PHINode *PN = dyn_cast<PHINode>(getValPtr()))
9427     SE->ConstantEvolutionLoopExitValue.erase(PN);
9428   SE->eraseValueFromMap(getValPtr());
9429   // this now dangles!
9430 }
9431
9432 void ScalarEvolution::SCEVCallbackVH::allUsesReplacedWith(Value *V) {
9433   assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
9434
9435   // Forget all the expressions associated with users of the old value,
9436   // so that future queries will recompute the expressions using the new
9437   // value.
9438   Value *Old = getValPtr();
9439   SmallVector<User *, 16> Worklist(Old->user_begin(), Old->user_end());
9440   SmallPtrSet<User *, 8> Visited;
9441   while (!Worklist.empty()) {
9442     User *U = Worklist.pop_back_val();
9443     // Deleting the Old value will cause this to dangle. Postpone
9444     // that until everything else is done.
9445     if (U == Old)
9446       continue;
9447     if (!Visited.insert(U).second)
9448       continue;
9449     if (PHINode *PN = dyn_cast<PHINode>(U))
9450       SE->ConstantEvolutionLoopExitValue.erase(PN);
9451     SE->eraseValueFromMap(U);
9452     Worklist.insert(Worklist.end(), U->user_begin(), U->user_end());
9453   }
9454   // Delete the Old value.
9455   if (PHINode *PN = dyn_cast<PHINode>(Old))
9456     SE->ConstantEvolutionLoopExitValue.erase(PN);
9457   SE->eraseValueFromMap(Old);
9458   // this now dangles!
9459 }
9460
9461 ScalarEvolution::SCEVCallbackVH::SCEVCallbackVH(Value *V, ScalarEvolution *se)
9462   : CallbackVH(V), SE(se) {}
9463
9464 //===----------------------------------------------------------------------===//
9465 //                   ScalarEvolution Class Implementation
9466 //===----------------------------------------------------------------------===//
9467
9468 ScalarEvolution::ScalarEvolution(Function &F, TargetLibraryInfo &TLI,
9469                                  AssumptionCache &AC, DominatorTree &DT,
9470                                  LoopInfo &LI)
9471     : F(F), TLI(TLI), AC(AC), DT(DT), LI(LI),
9472       CouldNotCompute(new SCEVCouldNotCompute()),
9473       WalkingBEDominatingConds(false), ProvingSplitPredicate(false),
9474       ValuesAtScopes(64), LoopDispositions(64), BlockDispositions(64),
9475       FirstUnknown(nullptr) {
9476
9477   // To use guards for proving predicates, we need to scan every instruction in
9478   // relevant basic blocks, and not just terminators.  Doing this is a waste of
9479   // time if the IR does not actually contain any calls to
9480   // @llvm.experimental.guard, so do a quick check and remember this beforehand.
9481   //
9482   // This pessimizes the case where a pass that preserves ScalarEvolution wants
9483   // to _add_ guards to the module when there weren't any before, and wants
9484   // ScalarEvolution to optimize based on those guards.  For now we prefer to be
9485   // efficient in lieu of being smart in that rather obscure case.
9486
9487   auto *GuardDecl = F.getParent()->getFunction(
9488       Intrinsic::getName(Intrinsic::experimental_guard));
9489   HasGuards = GuardDecl && !GuardDecl->use_empty();
9490 }
9491
9492 ScalarEvolution::ScalarEvolution(ScalarEvolution &&Arg)
9493     : F(Arg.F), HasGuards(Arg.HasGuards), TLI(Arg.TLI), AC(Arg.AC), DT(Arg.DT),
9494       LI(Arg.LI), CouldNotCompute(std::move(Arg.CouldNotCompute)),
9495       ValueExprMap(std::move(Arg.ValueExprMap)),
9496       WalkingBEDominatingConds(false), ProvingSplitPredicate(false),
9497       BackedgeTakenCounts(std::move(Arg.BackedgeTakenCounts)),
9498       PredicatedBackedgeTakenCounts(
9499           std::move(Arg.PredicatedBackedgeTakenCounts)),
9500       ConstantEvolutionLoopExitValue(
9501           std::move(Arg.ConstantEvolutionLoopExitValue)),
9502       ValuesAtScopes(std::move(Arg.ValuesAtScopes)),
9503       LoopDispositions(std::move(Arg.LoopDispositions)),
9504       BlockDispositions(std::move(Arg.BlockDispositions)),
9505       UnsignedRanges(std::move(Arg.UnsignedRanges)),
9506       SignedRanges(std::move(Arg.SignedRanges)),
9507       UniqueSCEVs(std::move(Arg.UniqueSCEVs)),
9508       UniquePreds(std::move(Arg.UniquePreds)),
9509       SCEVAllocator(std::move(Arg.SCEVAllocator)),
9510       FirstUnknown(Arg.FirstUnknown) {
9511   Arg.FirstUnknown = nullptr;
9512 }
9513
9514 ScalarEvolution::~ScalarEvolution() {
9515   // Iterate through all the SCEVUnknown instances and call their
9516   // destructors, so that they release their references to their values.
9517   for (SCEVUnknown *U = FirstUnknown; U;) {
9518     SCEVUnknown *Tmp = U;
9519     U = U->Next;
9520     Tmp->~SCEVUnknown();
9521   }
9522   FirstUnknown = nullptr;
9523
9524   ExprValueMap.clear();
9525   ValueExprMap.clear();
9526   HasRecMap.clear();
9527
9528   // Free any extra memory created for ExitNotTakenInfo in the unlikely event
9529   // that a loop had multiple computable exits.
9530   for (auto &BTCI : BackedgeTakenCounts)
9531     BTCI.second.clear();
9532   for (auto &BTCI : PredicatedBackedgeTakenCounts)
9533     BTCI.second.clear();
9534
9535   assert(PendingLoopPredicates.empty() && "isImpliedCond garbage");
9536   assert(!WalkingBEDominatingConds && "isLoopBackedgeGuardedByCond garbage!");
9537   assert(!ProvingSplitPredicate && "ProvingSplitPredicate garbage!");
9538 }
9539
9540 bool ScalarEvolution::hasLoopInvariantBackedgeTakenCount(const Loop *L) {
9541   return !isa<SCEVCouldNotCompute>(getBackedgeTakenCount(L));
9542 }
9543
9544 static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
9545                           const Loop *L) {
9546   // Print all inner loops first
9547   for (Loop *I : *L)
9548     PrintLoopInfo(OS, SE, I);
9549
9550   OS << "Loop ";
9551   L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
9552   OS << ": ";
9553
9554   SmallVector<BasicBlock *, 8> ExitBlocks;
9555   L->getExitBlocks(ExitBlocks);
9556   if (ExitBlocks.size() != 1)
9557     OS << "<multiple exits> ";
9558
9559   if (SE->hasLoopInvariantBackedgeTakenCount(L)) {
9560     OS << "backedge-taken count is " << *SE->getBackedgeTakenCount(L);
9561   } else {
9562     OS << "Unpredictable backedge-taken count. ";
9563   }
9564
9565   OS << "\n"
9566         "Loop ";
9567   L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
9568   OS << ": ";
9569
9570   if (!isa<SCEVCouldNotCompute>(SE->getMaxBackedgeTakenCount(L))) {
9571     OS << "max backedge-taken count is " << *SE->getMaxBackedgeTakenCount(L);
9572   } else {
9573     OS << "Unpredictable max backedge-taken count. ";
9574   }
9575
9576   OS << "\n"
9577         "Loop ";
9578   L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
9579   OS << ": ";
9580
9581   SCEVUnionPredicate Pred;
9582   auto PBT = SE->getPredicatedBackedgeTakenCount(L, Pred);
9583   if (!isa<SCEVCouldNotCompute>(PBT)) {
9584     OS << "Predicated backedge-taken count is " << *PBT << "\n";
9585     OS << " Predicates:\n";
9586     Pred.print(OS, 4);
9587   } else {
9588     OS << "Unpredictable predicated backedge-taken count. ";
9589   }
9590   OS << "\n";
9591 }
9592
9593 static StringRef loopDispositionToStr(ScalarEvolution::LoopDisposition LD) {
9594   switch (LD) {
9595   case ScalarEvolution::LoopVariant:
9596     return "Variant";
9597   case ScalarEvolution::LoopInvariant:
9598     return "Invariant";
9599   case ScalarEvolution::LoopComputable:
9600     return "Computable";
9601   }
9602   llvm_unreachable("Unknown ScalarEvolution::LoopDisposition kind!");
9603 }
9604
9605 void ScalarEvolution::print(raw_ostream &OS) const {
9606   // ScalarEvolution's implementation of the print method is to print
9607   // out SCEV values of all instructions that are interesting. Doing
9608   // this potentially causes it to create new SCEV objects though,
9609   // which technically conflicts with the const qualifier. This isn't
9610   // observable from outside the class though, so casting away the
9611   // const isn't dangerous.
9612   ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
9613
9614   OS << "Classifying expressions for: ";
9615   F.printAsOperand(OS, /*PrintType=*/false);
9616   OS << "\n";
9617   for (Instruction &I : instructions(F))
9618     if (isSCEVable(I.getType()) && !isa<CmpInst>(I)) {
9619       OS << I << '\n';
9620       OS << "  -->  ";
9621       const SCEV *SV = SE.getSCEV(&I);
9622       SV->print(OS);
9623       if (!isa<SCEVCouldNotCompute>(SV)) {
9624         OS << " U: ";
9625         SE.getUnsignedRange(SV).print(OS);
9626         OS << " S: ";
9627         SE.getSignedRange(SV).print(OS);
9628       }
9629
9630       const Loop *L = LI.getLoopFor(I.getParent());
9631
9632       const SCEV *AtUse = SE.getSCEVAtScope(SV, L);
9633       if (AtUse != SV) {
9634         OS << "  -->  ";
9635         AtUse->print(OS);
9636         if (!isa<SCEVCouldNotCompute>(AtUse)) {
9637           OS << " U: ";
9638           SE.getUnsignedRange(AtUse).print(OS);
9639           OS << " S: ";
9640           SE.getSignedRange(AtUse).print(OS);
9641         }
9642       }
9643
9644       if (L) {
9645         OS << "\t\t" "Exits: ";
9646         const SCEV *ExitValue = SE.getSCEVAtScope(SV, L->getParentLoop());
9647         if (!SE.isLoopInvariant(ExitValue, L)) {
9648           OS << "<<Unknown>>";
9649         } else {
9650           OS << *ExitValue;
9651         }
9652
9653         bool First = true;
9654         for (auto *Iter = L; Iter; Iter = Iter->getParentLoop()) {
9655           if (First) {
9656             OS << "\t\t" "LoopDispositions: { ";
9657             First = false;
9658           } else {
9659             OS << ", ";
9660           }
9661
9662           Iter->getHeader()->printAsOperand(OS, /*PrintType=*/false);
9663           OS << ": " << loopDispositionToStr(SE.getLoopDisposition(SV, Iter));
9664         }
9665
9666         for (auto *InnerL : depth_first(L)) {
9667           if (InnerL == L)
9668             continue;
9669           if (First) {
9670             OS << "\t\t" "LoopDispositions: { ";
9671             First = false;
9672           } else {
9673             OS << ", ";
9674           }
9675
9676           InnerL->getHeader()->printAsOperand(OS, /*PrintType=*/false);
9677           OS << ": " << loopDispositionToStr(SE.getLoopDisposition(SV, InnerL));
9678         }
9679
9680         OS << " }";
9681       }
9682
9683       OS << "\n";
9684     }
9685
9686   OS << "Determining loop execution counts for: ";
9687   F.printAsOperand(OS, /*PrintType=*/false);
9688   OS << "\n";
9689   for (Loop *I : LI)
9690     PrintLoopInfo(OS, &SE, I);
9691 }
9692
9693 ScalarEvolution::LoopDisposition
9694 ScalarEvolution::getLoopDisposition(const SCEV *S, const Loop *L) {
9695   auto &Values = LoopDispositions[S];
9696   for (auto &V : Values) {
9697     if (V.getPointer() == L)
9698       return V.getInt();
9699   }
9700   Values.emplace_back(L, LoopVariant);
9701   LoopDisposition D = computeLoopDisposition(S, L);
9702   auto &Values2 = LoopDispositions[S];
9703   for (auto &V : make_range(Values2.rbegin(), Values2.rend())) {
9704     if (V.getPointer() == L) {
9705       V.setInt(D);
9706       break;
9707     }
9708   }
9709   return D;
9710 }
9711
9712 ScalarEvolution::LoopDisposition
9713 ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
9714   switch (static_cast<SCEVTypes>(S->getSCEVType())) {
9715   case scConstant:
9716     return LoopInvariant;
9717   case scTruncate:
9718   case scZeroExtend:
9719   case scSignExtend:
9720     return getLoopDisposition(cast<SCEVCastExpr>(S)->getOperand(), L);
9721   case scAddRecExpr: {
9722     const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
9723
9724     // If L is the addrec's loop, it's computable.
9725     if (AR->getLoop() == L)
9726       return LoopComputable;
9727
9728     // Add recurrences are never invariant in the function-body (null loop).
9729     if (!L)
9730       return LoopVariant;
9731
9732     // This recurrence is variant w.r.t. L if L contains AR's loop.
9733     if (L->contains(AR->getLoop()))
9734       return LoopVariant;
9735
9736     // This recurrence is invariant w.r.t. L if AR's loop contains L.
9737     if (AR->getLoop()->contains(L))
9738       return LoopInvariant;
9739
9740     // This recurrence is variant w.r.t. L if any of its operands
9741     // are variant.
9742     for (auto *Op : AR->operands())
9743       if (!isLoopInvariant(Op, L))
9744         return LoopVariant;
9745
9746     // Otherwise it's loop-invariant.
9747     return LoopInvariant;
9748   }
9749   case scAddExpr:
9750   case scMulExpr:
9751   case scUMaxExpr:
9752   case scSMaxExpr: {
9753     bool HasVarying = false;
9754     for (auto *Op : cast<SCEVNAryExpr>(S)->operands()) {
9755       LoopDisposition D = getLoopDisposition(Op, L);
9756       if (D == LoopVariant)
9757         return LoopVariant;
9758       if (D == LoopComputable)
9759         HasVarying = true;
9760     }
9761     return HasVarying ? LoopComputable : LoopInvariant;
9762   }
9763   case scUDivExpr: {
9764     const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
9765     LoopDisposition LD = getLoopDisposition(UDiv->getLHS(), L);
9766     if (LD == LoopVariant)
9767       return LoopVariant;
9768     LoopDisposition RD = getLoopDisposition(UDiv->getRHS(), L);
9769     if (RD == LoopVariant)
9770       return LoopVariant;
9771     return (LD == LoopInvariant && RD == LoopInvariant) ?
9772            LoopInvariant : LoopComputable;
9773   }
9774   case scUnknown:
9775     // All non-instruction values are loop invariant.  All instructions are loop
9776     // invariant if they are not contained in the specified loop.
9777     // Instructions are never considered invariant in the function body
9778     // (null loop) because they are defined within the "loop".
9779     if (auto *I = dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue()))
9780       return (L && !L->contains(I)) ? LoopInvariant : LoopVariant;
9781     return LoopInvariant;
9782   case scCouldNotCompute:
9783     llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
9784   }
9785   llvm_unreachable("Unknown SCEV kind!");
9786 }
9787
9788 bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) {
9789   return getLoopDisposition(S, L) == LoopInvariant;
9790 }
9791
9792 bool ScalarEvolution::hasComputableLoopEvolution(const SCEV *S, const Loop *L) {
9793   return getLoopDisposition(S, L) == LoopComputable;
9794 }
9795
9796 ScalarEvolution::BlockDisposition
9797 ScalarEvolution::getBlockDisposition(const SCEV *S, const BasicBlock *BB) {
9798   auto &Values = BlockDispositions[S];
9799   for (auto &V : Values) {
9800     if (V.getPointer() == BB)
9801       return V.getInt();
9802   }
9803   Values.emplace_back(BB, DoesNotDominateBlock);
9804   BlockDisposition D = computeBlockDisposition(S, BB);
9805   auto &Values2 = BlockDispositions[S];
9806   for (auto &V : make_range(Values2.rbegin(), Values2.rend())) {
9807     if (V.getPointer() == BB) {
9808       V.setInt(D);
9809       break;
9810     }
9811   }
9812   return D;
9813 }
9814
9815 ScalarEvolution::BlockDisposition
9816 ScalarEvolution::computeBlockDisposition(const SCEV *S, const BasicBlock *BB) {
9817   switch (static_cast<SCEVTypes>(S->getSCEVType())) {
9818   case scConstant:
9819     return ProperlyDominatesBlock;
9820   case scTruncate:
9821   case scZeroExtend:
9822   case scSignExtend:
9823     return getBlockDisposition(cast<SCEVCastExpr>(S)->getOperand(), BB);
9824   case scAddRecExpr: {
9825     // This uses a "dominates" query instead of "properly dominates" query
9826     // to test for proper dominance too, because the instruction which
9827     // produces the addrec's value is a PHI, and a PHI effectively properly
9828     // dominates its entire containing block.
9829     const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
9830     if (!DT.dominates(AR->getLoop()->getHeader(), BB))
9831       return DoesNotDominateBlock;
9832   }
9833   // FALL THROUGH into SCEVNAryExpr handling.
9834   case scAddExpr:
9835   case scMulExpr:
9836   case scUMaxExpr:
9837   case scSMaxExpr: {
9838     const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
9839     bool Proper = true;
9840     for (const SCEV *NAryOp : NAry->operands()) {
9841       BlockDisposition D = getBlockDisposition(NAryOp, BB);
9842       if (D == DoesNotDominateBlock)
9843         return DoesNotDominateBlock;
9844       if (D == DominatesBlock)
9845         Proper = false;
9846     }
9847     return Proper ? ProperlyDominatesBlock : DominatesBlock;
9848   }
9849   case scUDivExpr: {
9850     const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
9851     const SCEV *LHS = UDiv->getLHS(), *RHS = UDiv->getRHS();
9852     BlockDisposition LD = getBlockDisposition(LHS, BB);
9853     if (LD == DoesNotDominateBlock)
9854       return DoesNotDominateBlock;
9855     BlockDisposition RD = getBlockDisposition(RHS, BB);
9856     if (RD == DoesNotDominateBlock)
9857       return DoesNotDominateBlock;
9858     return (LD == ProperlyDominatesBlock && RD == ProperlyDominatesBlock) ?
9859       ProperlyDominatesBlock : DominatesBlock;
9860   }
9861   case scUnknown:
9862     if (Instruction *I =
9863           dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue())) {
9864       if (I->getParent() == BB)
9865         return DominatesBlock;
9866       if (DT.properlyDominates(I->getParent(), BB))
9867         return ProperlyDominatesBlock;
9868       return DoesNotDominateBlock;
9869     }
9870     return ProperlyDominatesBlock;
9871   case scCouldNotCompute:
9872     llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
9873   }
9874   llvm_unreachable("Unknown SCEV kind!");
9875 }
9876
9877 bool ScalarEvolution::dominates(const SCEV *S, const BasicBlock *BB) {
9878   return getBlockDisposition(S, BB) >= DominatesBlock;
9879 }
9880
9881 bool ScalarEvolution::properlyDominates(const SCEV *S, const BasicBlock *BB) {
9882   return getBlockDisposition(S, BB) == ProperlyDominatesBlock;
9883 }
9884
9885 bool ScalarEvolution::hasOperand(const SCEV *S, const SCEV *Op) const {
9886   // Search for a SCEV expression node within an expression tree.
9887   // Implements SCEVTraversal::Visitor.
9888   struct SCEVSearch {
9889     const SCEV *Node;
9890     bool IsFound;
9891
9892     SCEVSearch(const SCEV *N): Node(N), IsFound(false) {}
9893
9894     bool follow(const SCEV *S) {
9895       IsFound |= (S == Node);
9896       return !IsFound;
9897     }
9898     bool isDone() const { return IsFound; }
9899   };
9900
9901   SCEVSearch Search(Op);
9902   visitAll(S, Search);
9903   return Search.IsFound;
9904 }
9905
9906 void ScalarEvolution::forgetMemoizedResults(const SCEV *S) {
9907   ValuesAtScopes.erase(S);
9908   LoopDispositions.erase(S);
9909   BlockDispositions.erase(S);
9910   UnsignedRanges.erase(S);
9911   SignedRanges.erase(S);
9912   ExprValueMap.erase(S);
9913   HasRecMap.erase(S);
9914
9915   auto RemoveSCEVFromBackedgeMap =
9916       [S, this](DenseMap<const Loop *, BackedgeTakenInfo> &Map) {
9917         for (auto I = Map.begin(), E = Map.end(); I != E;) {
9918           BackedgeTakenInfo &BEInfo = I->second;
9919           if (BEInfo.hasOperand(S, this)) {
9920             BEInfo.clear();
9921             Map.erase(I++);
9922           } else
9923             ++I;
9924         }
9925       };
9926
9927   RemoveSCEVFromBackedgeMap(BackedgeTakenCounts);
9928   RemoveSCEVFromBackedgeMap(PredicatedBackedgeTakenCounts);
9929 }
9930
9931 typedef DenseMap<const Loop *, std::string> VerifyMap;
9932
9933 /// replaceSubString - Replaces all occurrences of From in Str with To.
9934 static void replaceSubString(std::string &Str, StringRef From, StringRef To) {
9935   size_t Pos = 0;
9936   while ((Pos = Str.find(From, Pos)) != std::string::npos) {
9937     Str.replace(Pos, From.size(), To.data(), To.size());
9938     Pos += To.size();
9939   }
9940 }
9941
9942 /// getLoopBackedgeTakenCounts - Helper method for verifyAnalysis.
9943 static void
9944 getLoopBackedgeTakenCounts(Loop *L, VerifyMap &Map, ScalarEvolution &SE) {
9945   std::string &S = Map[L];
9946   if (S.empty()) {
9947     raw_string_ostream OS(S);
9948     SE.getBackedgeTakenCount(L)->print(OS);
9949
9950     // false and 0 are semantically equivalent. This can happen in dead loops.
9951     replaceSubString(OS.str(), "false", "0");
9952     // Remove wrap flags, their use in SCEV is highly fragile.
9953     // FIXME: Remove this when SCEV gets smarter about them.
9954     replaceSubString(OS.str(), "<nw>", "");
9955     replaceSubString(OS.str(), "<nsw>", "");
9956     replaceSubString(OS.str(), "<nuw>", "");
9957   }
9958
9959   for (auto *R : reverse(*L))
9960     getLoopBackedgeTakenCounts(R, Map, SE); // recurse.
9961 }
9962
9963 void ScalarEvolution::verify() const {
9964   ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
9965
9966   // Gather stringified backedge taken counts for all loops using SCEV's caches.
9967   // FIXME: It would be much better to store actual values instead of strings,
9968   //        but SCEV pointers will change if we drop the caches.
9969   VerifyMap BackedgeDumpsOld, BackedgeDumpsNew;
9970   for (LoopInfo::reverse_iterator I = LI.rbegin(), E = LI.rend(); I != E; ++I)
9971     getLoopBackedgeTakenCounts(*I, BackedgeDumpsOld, SE);
9972
9973   // Gather stringified backedge taken counts for all loops using a fresh
9974   // ScalarEvolution object.
9975   ScalarEvolution SE2(F, TLI, AC, DT, LI);
9976   for (LoopInfo::reverse_iterator I = LI.rbegin(), E = LI.rend(); I != E; ++I)
9977     getLoopBackedgeTakenCounts(*I, BackedgeDumpsNew, SE2);
9978
9979   // Now compare whether they're the same with and without caches. This allows
9980   // verifying that no pass changed the cache.
9981   assert(BackedgeDumpsOld.size() == BackedgeDumpsNew.size() &&
9982          "New loops suddenly appeared!");
9983
9984   for (VerifyMap::iterator OldI = BackedgeDumpsOld.begin(),
9985                            OldE = BackedgeDumpsOld.end(),
9986                            NewI = BackedgeDumpsNew.begin();
9987        OldI != OldE; ++OldI, ++NewI) {
9988     assert(OldI->first == NewI->first && "Loop order changed!");
9989
9990     // Compare the stringified SCEVs. We don't care if undef backedgetaken count
9991     // changes.
9992     // FIXME: We currently ignore SCEV changes from/to CouldNotCompute. This
9993     // means that a pass is buggy or SCEV has to learn a new pattern but is
9994     // usually not harmful.
9995     if (OldI->second != NewI->second &&
9996         OldI->second.find("undef") == std::string::npos &&
9997         NewI->second.find("undef") == std::string::npos &&
9998         OldI->second != "***COULDNOTCOMPUTE***" &&
9999         NewI->second != "***COULDNOTCOMPUTE***") {
10000       dbgs() << "SCEVValidator: SCEV for loop '"
10001              << OldI->first->getHeader()->getName()
10002              << "' changed from '" << OldI->second
10003              << "' to '" << NewI->second << "'!\n";
10004       std::abort();
10005     }
10006   }
10007
10008   // TODO: Verify more things.
10009 }
10010
10011 char ScalarEvolutionAnalysis::PassID;
10012
10013 ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
10014                                              AnalysisManager<Function> &AM) {
10015   return ScalarEvolution(F, AM.getResult<TargetLibraryAnalysis>(F),
10016                          AM.getResult<AssumptionAnalysis>(F),
10017                          AM.getResult<DominatorTreeAnalysis>(F),
10018                          AM.getResult<LoopAnalysis>(F));
10019 }
10020
10021 PreservedAnalyses
10022 ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> &AM) {
10023   AM.getResult<ScalarEvolutionAnalysis>(F).print(OS);
10024   return PreservedAnalyses::all();
10025 }
10026
10027 INITIALIZE_PASS_BEGIN(ScalarEvolutionWrapperPass, "scalar-evolution",
10028                       "Scalar Evolution Analysis", false, true)
10029 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
10030 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
10031 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
10032 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
10033 INITIALIZE_PASS_END(ScalarEvolutionWrapperPass, "scalar-evolution",
10034                     "Scalar Evolution Analysis", false, true)
10035 char ScalarEvolutionWrapperPass::ID = 0;
10036
10037 ScalarEvolutionWrapperPass::ScalarEvolutionWrapperPass() : FunctionPass(ID) {
10038   initializeScalarEvolutionWrapperPassPass(*PassRegistry::getPassRegistry());
10039 }
10040
10041 bool ScalarEvolutionWrapperPass::runOnFunction(Function &F) {
10042   SE.reset(new ScalarEvolution(
10043       F, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
10044       getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F),
10045       getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
10046       getAnalysis<LoopInfoWrapperPass>().getLoopInfo()));
10047   return false;
10048 }
10049
10050 void ScalarEvolutionWrapperPass::releaseMemory() { SE.reset(); }
10051
10052 void ScalarEvolutionWrapperPass::print(raw_ostream &OS, const Module *) const {
10053   SE->print(OS);
10054 }
10055
10056 void ScalarEvolutionWrapperPass::verifyAnalysis() const {
10057   if (!VerifySCEV)
10058     return;
10059
10060   SE->verify();
10061 }
10062
10063 void ScalarEvolutionWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
10064   AU.setPreservesAll();
10065   AU.addRequiredTransitive<AssumptionCacheTracker>();
10066   AU.addRequiredTransitive<LoopInfoWrapperPass>();
10067   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
10068   AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
10069 }
10070
10071 const SCEVPredicate *
10072 ScalarEvolution::getEqualPredicate(const SCEVUnknown *LHS,
10073                                    const SCEVConstant *RHS) {
10074   FoldingSetNodeID ID;
10075   // Unique this node based on the arguments
10076   ID.AddInteger(SCEVPredicate::P_Equal);
10077   ID.AddPointer(LHS);
10078   ID.AddPointer(RHS);
10079   void *IP = nullptr;
10080   if (const auto *S = UniquePreds.FindNodeOrInsertPos(ID, IP))
10081     return S;
10082   SCEVEqualPredicate *Eq = new (SCEVAllocator)
10083       SCEVEqualPredicate(ID.Intern(SCEVAllocator), LHS, RHS);
10084   UniquePreds.InsertNode(Eq, IP);
10085   return Eq;
10086 }
10087
10088 const SCEVPredicate *ScalarEvolution::getWrapPredicate(
10089     const SCEVAddRecExpr *AR,
10090     SCEVWrapPredicate::IncrementWrapFlags AddedFlags) {
10091   FoldingSetNodeID ID;
10092   // Unique this node based on the arguments
10093   ID.AddInteger(SCEVPredicate::P_Wrap);
10094   ID.AddPointer(AR);
10095   ID.AddInteger(AddedFlags);
10096   void *IP = nullptr;
10097   if (const auto *S = UniquePreds.FindNodeOrInsertPos(ID, IP))
10098     return S;
10099   auto *OF = new (SCEVAllocator)
10100       SCEVWrapPredicate(ID.Intern(SCEVAllocator), AR, AddedFlags);
10101   UniquePreds.InsertNode(OF, IP);
10102   return OF;
10103 }
10104
10105 namespace {
10106
10107 class SCEVPredicateRewriter : public SCEVRewriteVisitor<SCEVPredicateRewriter> {
10108 public:
10109   // Rewrites \p S in the context of a loop L and the predicate A.
10110   // If Assume is true, rewrite is free to add further predicates to A
10111   // such that the result will be an AddRecExpr.
10112   static const SCEV *rewrite(const SCEV *S, const Loop *L, ScalarEvolution &SE,
10113                              SCEVUnionPredicate &A, bool Assume) {
10114     SCEVPredicateRewriter Rewriter(L, SE, A, Assume);
10115     return Rewriter.visit(S);
10116   }
10117
10118   SCEVPredicateRewriter(const Loop *L, ScalarEvolution &SE,
10119                         SCEVUnionPredicate &P, bool Assume)
10120       : SCEVRewriteVisitor(SE), P(P), L(L), Assume(Assume) {}
10121
10122   const SCEV *visitUnknown(const SCEVUnknown *Expr) {
10123     auto ExprPreds = P.getPredicatesForExpr(Expr);
10124     for (auto *Pred : ExprPreds)
10125       if (const auto *IPred = dyn_cast<SCEVEqualPredicate>(Pred))
10126         if (IPred->getLHS() == Expr)
10127           return IPred->getRHS();
10128
10129     return Expr;
10130   }
10131
10132   const SCEV *visitZeroExtendExpr(const SCEVZeroExtendExpr *Expr) {
10133     const SCEV *Operand = visit(Expr->getOperand());
10134     const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Operand);
10135     if (AR && AR->getLoop() == L && AR->isAffine()) {
10136       // This couldn't be folded because the operand didn't have the nuw
10137       // flag. Add the nusw flag as an assumption that we could make.
10138       const SCEV *Step = AR->getStepRecurrence(SE);
10139       Type *Ty = Expr->getType();
10140       if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNUSW))
10141         return SE.getAddRecExpr(SE.getZeroExtendExpr(AR->getStart(), Ty),
10142                                 SE.getSignExtendExpr(Step, Ty), L,
10143                                 AR->getNoWrapFlags());
10144     }
10145     return SE.getZeroExtendExpr(Operand, Expr->getType());
10146   }
10147
10148   const SCEV *visitSignExtendExpr(const SCEVSignExtendExpr *Expr) {
10149     const SCEV *Operand = visit(Expr->getOperand());
10150     const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Operand);
10151     if (AR && AR->getLoop() == L && AR->isAffine()) {
10152       // This couldn't be folded because the operand didn't have the nsw
10153       // flag. Add the nssw flag as an assumption that we could make.
10154       const SCEV *Step = AR->getStepRecurrence(SE);
10155       Type *Ty = Expr->getType();
10156       if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNSSW))
10157         return SE.getAddRecExpr(SE.getSignExtendExpr(AR->getStart(), Ty),
10158                                 SE.getSignExtendExpr(Step, Ty), L,
10159                                 AR->getNoWrapFlags());
10160     }
10161     return SE.getSignExtendExpr(Operand, Expr->getType());
10162   }
10163
10164 private:
10165   bool addOverflowAssumption(const SCEVAddRecExpr *AR,
10166                              SCEVWrapPredicate::IncrementWrapFlags AddedFlags) {
10167     auto *A = SE.getWrapPredicate(AR, AddedFlags);
10168     if (!Assume) {
10169       // Check if we've already made this assumption.
10170       if (P.implies(A))
10171         return true;
10172       return false;
10173     }
10174     P.add(A);
10175     return true;
10176   }
10177
10178   SCEVUnionPredicate &P;
10179   const Loop *L;
10180   bool Assume;
10181 };
10182 } // end anonymous namespace
10183
10184 const SCEV *ScalarEvolution::rewriteUsingPredicate(const SCEV *S, const Loop *L,
10185                                                    SCEVUnionPredicate &Preds) {
10186   return SCEVPredicateRewriter::rewrite(S, L, *this, Preds, false);
10187 }
10188
10189 const SCEVAddRecExpr *
10190 ScalarEvolution::convertSCEVToAddRecWithPredicates(const SCEV *S, const Loop *L,
10191                                                    SCEVUnionPredicate &Preds) {
10192   SCEVUnionPredicate TransformPreds;
10193   S = SCEVPredicateRewriter::rewrite(S, L, *this, TransformPreds, true);
10194   auto *AddRec = dyn_cast<SCEVAddRecExpr>(S);
10195
10196   if (!AddRec)
10197     return nullptr;
10198
10199   // Since the transformation was successful, we can now transfer the SCEV
10200   // predicates.
10201   Preds.add(&TransformPreds);
10202   return AddRec;
10203 }
10204
10205 /// SCEV predicates
10206 SCEVPredicate::SCEVPredicate(const FoldingSetNodeIDRef ID,
10207                              SCEVPredicateKind Kind)
10208     : FastID(ID), Kind(Kind) {}
10209
10210 SCEVEqualPredicate::SCEVEqualPredicate(const FoldingSetNodeIDRef ID,
10211                                        const SCEVUnknown *LHS,
10212                                        const SCEVConstant *RHS)
10213     : SCEVPredicate(ID, P_Equal), LHS(LHS), RHS(RHS) {}
10214
10215 bool SCEVEqualPredicate::implies(const SCEVPredicate *N) const {
10216   const auto *Op = dyn_cast<SCEVEqualPredicate>(N);
10217
10218   if (!Op)
10219     return false;
10220
10221   return Op->LHS == LHS && Op->RHS == RHS;
10222 }
10223
10224 bool SCEVEqualPredicate::isAlwaysTrue() const { return false; }
10225
10226 const SCEV *SCEVEqualPredicate::getExpr() const { return LHS; }
10227
10228 void SCEVEqualPredicate::print(raw_ostream &OS, unsigned Depth) const {
10229   OS.indent(Depth) << "Equal predicate: " << *LHS << " == " << *RHS << "\n";
10230 }
10231
10232 SCEVWrapPredicate::SCEVWrapPredicate(const FoldingSetNodeIDRef ID,
10233                                      const SCEVAddRecExpr *AR,
10234                                      IncrementWrapFlags Flags)
10235     : SCEVPredicate(ID, P_Wrap), AR(AR), Flags(Flags) {}
10236
10237 const SCEV *SCEVWrapPredicate::getExpr() const { return AR; }
10238
10239 bool SCEVWrapPredicate::implies(const SCEVPredicate *N) const {
10240   const auto *Op = dyn_cast<SCEVWrapPredicate>(N);
10241
10242   return Op && Op->AR == AR && setFlags(Flags, Op->Flags) == Flags;
10243 }
10244
10245 bool SCEVWrapPredicate::isAlwaysTrue() const {
10246   SCEV::NoWrapFlags ScevFlags = AR->getNoWrapFlags();
10247   IncrementWrapFlags IFlags = Flags;
10248
10249   if (ScalarEvolution::setFlags(ScevFlags, SCEV::FlagNSW) == ScevFlags)
10250     IFlags = clearFlags(IFlags, IncrementNSSW);
10251
10252   return IFlags == IncrementAnyWrap;
10253 }
10254
10255 void SCEVWrapPredicate::print(raw_ostream &OS, unsigned Depth) const {
10256   OS.indent(Depth) << *getExpr() << " Added Flags: ";
10257   if (SCEVWrapPredicate::IncrementNUSW & getFlags())
10258     OS << "<nusw>";
10259   if (SCEVWrapPredicate::IncrementNSSW & getFlags())
10260     OS << "<nssw>";
10261   OS << "\n";
10262 }
10263
10264 SCEVWrapPredicate::IncrementWrapFlags
10265 SCEVWrapPredicate::getImpliedFlags(const SCEVAddRecExpr *AR,
10266                                    ScalarEvolution &SE) {
10267   IncrementWrapFlags ImpliedFlags = IncrementAnyWrap;
10268   SCEV::NoWrapFlags StaticFlags = AR->getNoWrapFlags();
10269
10270   // We can safely transfer the NSW flag as NSSW.
10271   if (ScalarEvolution::setFlags(StaticFlags, SCEV::FlagNSW) == StaticFlags)
10272     ImpliedFlags = IncrementNSSW;
10273
10274   if (ScalarEvolution::setFlags(StaticFlags, SCEV::FlagNUW) == StaticFlags) {
10275     // If the increment is positive, the SCEV NUW flag will also imply the
10276     // WrapPredicate NUSW flag.
10277     if (const auto *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(SE)))
10278       if (Step->getValue()->getValue().isNonNegative())
10279         ImpliedFlags = setFlags(ImpliedFlags, IncrementNUSW);
10280   }
10281
10282   return ImpliedFlags;
10283 }
10284
10285 /// Union predicates don't get cached so create a dummy set ID for it.
10286 SCEVUnionPredicate::SCEVUnionPredicate()
10287     : SCEVPredicate(FoldingSetNodeIDRef(nullptr, 0), P_Union) {}
10288
10289 bool SCEVUnionPredicate::isAlwaysTrue() const {
10290   return all_of(Preds,
10291                 [](const SCEVPredicate *I) { return I->isAlwaysTrue(); });
10292 }
10293
10294 ArrayRef<const SCEVPredicate *>
10295 SCEVUnionPredicate::getPredicatesForExpr(const SCEV *Expr) {
10296   auto I = SCEVToPreds.find(Expr);
10297   if (I == SCEVToPreds.end())
10298     return ArrayRef<const SCEVPredicate *>();
10299   return I->second;
10300 }
10301
10302 bool SCEVUnionPredicate::implies(const SCEVPredicate *N) const {
10303   if (const auto *Set = dyn_cast<SCEVUnionPredicate>(N))
10304     return all_of(Set->Preds,
10305                   [this](const SCEVPredicate *I) { return this->implies(I); });
10306
10307   auto ScevPredsIt = SCEVToPreds.find(N->getExpr());
10308   if (ScevPredsIt == SCEVToPreds.end())
10309     return false;
10310   auto &SCEVPreds = ScevPredsIt->second;
10311
10312   return any_of(SCEVPreds,
10313                 [N](const SCEVPredicate *I) { return I->implies(N); });
10314 }
10315
10316 const SCEV *SCEVUnionPredicate::getExpr() const { return nullptr; }
10317
10318 void SCEVUnionPredicate::print(raw_ostream &OS, unsigned Depth) const {
10319   for (auto Pred : Preds)
10320     Pred->print(OS, Depth);
10321 }
10322
10323 void SCEVUnionPredicate::add(const SCEVPredicate *N) {
10324   if (const auto *Set = dyn_cast<SCEVUnionPredicate>(N)) {
10325     for (auto Pred : Set->Preds)
10326       add(Pred);
10327     return;
10328   }
10329
10330   if (implies(N))
10331     return;
10332
10333   const SCEV *Key = N->getExpr();
10334   assert(Key && "Only SCEVUnionPredicate doesn't have an "
10335                 " associated expression!");
10336
10337   SCEVToPreds[Key].push_back(N);
10338   Preds.push_back(N);
10339 }
10340
10341 PredicatedScalarEvolution::PredicatedScalarEvolution(ScalarEvolution &SE,
10342                                                      Loop &L)
10343     : SE(SE), L(L), Generation(0), BackedgeCount(nullptr) {}
10344
10345 const SCEV *PredicatedScalarEvolution::getSCEV(Value *V) {
10346   const SCEV *Expr = SE.getSCEV(V);
10347   RewriteEntry &Entry = RewriteMap[Expr];
10348
10349   // If we already have an entry and the version matches, return it.
10350   if (Entry.second && Generation == Entry.first)
10351     return Entry.second;
10352
10353   // We found an entry but it's stale. Rewrite the stale entry
10354   // acording to the current predicate.
10355   if (Entry.second)
10356     Expr = Entry.second;
10357
10358   const SCEV *NewSCEV = SE.rewriteUsingPredicate(Expr, &L, Preds);
10359   Entry = {Generation, NewSCEV};
10360
10361   return NewSCEV;
10362 }
10363
10364 const SCEV *PredicatedScalarEvolution::getBackedgeTakenCount() {
10365   if (!BackedgeCount) {
10366     SCEVUnionPredicate BackedgePred;
10367     BackedgeCount = SE.getPredicatedBackedgeTakenCount(&L, BackedgePred);
10368     addPredicate(BackedgePred);
10369   }
10370   return BackedgeCount;
10371 }
10372
10373 void PredicatedScalarEvolution::addPredicate(const SCEVPredicate &Pred) {
10374   if (Preds.implies(&Pred))
10375     return;
10376   Preds.add(&Pred);
10377   updateGeneration();
10378 }
10379
10380 const SCEVUnionPredicate &PredicatedScalarEvolution::getUnionPredicate() const {
10381   return Preds;
10382 }
10383
10384 void PredicatedScalarEvolution::updateGeneration() {
10385   // If the generation number wrapped recompute everything.
10386   if (++Generation == 0) {
10387     for (auto &II : RewriteMap) {
10388       const SCEV *Rewritten = II.second.second;
10389       II.second = {Generation, SE.rewriteUsingPredicate(Rewritten, &L, Preds)};
10390     }
10391   }
10392 }
10393
10394 void PredicatedScalarEvolution::setNoOverflow(
10395     Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags) {
10396   const SCEV *Expr = getSCEV(V);
10397   const auto *AR = cast<SCEVAddRecExpr>(Expr);
10398
10399   auto ImpliedFlags = SCEVWrapPredicate::getImpliedFlags(AR, SE);
10400
10401   // Clear the statically implied flags.
10402   Flags = SCEVWrapPredicate::clearFlags(Flags, ImpliedFlags);
10403   addPredicate(*SE.getWrapPredicate(AR, Flags));
10404
10405   auto II = FlagsMap.insert({V, Flags});
10406   if (!II.second)
10407     II.first->second = SCEVWrapPredicate::setFlags(Flags, II.first->second);
10408 }
10409
10410 bool PredicatedScalarEvolution::hasNoOverflow(
10411     Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags) {
10412   const SCEV *Expr = getSCEV(V);
10413   const auto *AR = cast<SCEVAddRecExpr>(Expr);
10414
10415   Flags = SCEVWrapPredicate::clearFlags(
10416       Flags, SCEVWrapPredicate::getImpliedFlags(AR, SE));
10417
10418   auto II = FlagsMap.find(V);
10419
10420   if (II != FlagsMap.end())
10421     Flags = SCEVWrapPredicate::clearFlags(Flags, II->second);
10422
10423   return Flags == SCEVWrapPredicate::IncrementAnyWrap;
10424 }
10425
10426 const SCEVAddRecExpr *PredicatedScalarEvolution::getAsAddRec(Value *V) {
10427   const SCEV *Expr = this->getSCEV(V);
10428   auto *New = SE.convertSCEVToAddRecWithPredicates(Expr, &L, Preds);
10429
10430   if (!New)
10431     return nullptr;
10432
10433   updateGeneration();
10434   RewriteMap[SE.getSCEV(V)] = {Generation, New};
10435   return New;
10436 }
10437
10438 PredicatedScalarEvolution::PredicatedScalarEvolution(
10439     const PredicatedScalarEvolution &Init)
10440     : RewriteMap(Init.RewriteMap), SE(Init.SE), L(Init.L), Preds(Init.Preds),
10441       Generation(Init.Generation), BackedgeCount(Init.BackedgeCount) {
10442   for (const auto &I : Init.FlagsMap)
10443     FlagsMap.insert(I);
10444 }
10445
10446 void PredicatedScalarEvolution::print(raw_ostream &OS, unsigned Depth) const {
10447   // For each block.
10448   for (auto *BB : L.getBlocks())
10449     for (auto &I : *BB) {
10450       if (!SE.isSCEVable(I.getType()))
10451         continue;
10452
10453       auto *Expr = SE.getSCEV(&I);
10454       auto II = RewriteMap.find(Expr);
10455
10456       if (II == RewriteMap.end())
10457         continue;
10458
10459       // Don't print things that are not interesting.
10460       if (II->second.second == Expr)
10461         continue;
10462
10463       OS.indent(Depth) << "[PSE]" << I << ":\n";
10464       OS.indent(Depth + 2) << *Expr << "\n";
10465       OS.indent(Depth + 2) << "--> " << *II->second.second << "\n";
10466     }
10467 }