LLVM  3.7.0
ScalarEvolution.cpp
Go to the documentation of this file.
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 
62 #include "llvm/ADT/Optional.h"
63 #include "llvm/ADT/STLExtras.h"
64 #include "llvm/ADT/SmallPtrSet.h"
65 #include "llvm/ADT/Statistic.h"
69 #include "llvm/Analysis/LoopInfo.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"
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"
87 #include "llvm/Support/Debug.h"
91 #include <algorithm>
92 using namespace llvm;
93 
94 #define DEBUG_TYPE "scalar-evolution"
95 
96 STATISTIC(NumArrayLenItCounts,
97  "Number of trip counts computed with array length");
98 STATISTIC(NumTripCountsComputed,
99  "Number of loops with predictable loop counts");
100 STATISTIC(NumTripCountsNotComputed,
101  "Number of loops without predictable loop counts");
102 STATISTIC(NumBruteForceTripCountsComputed,
103  "Number of loops with trip counts computed by force");
104 
105 static cl::opt<unsigned>
106 MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden,
107  cl::desc("Maximum number of iterations SCEV will "
108  "symbolically execute a constant "
109  "derived loop"),
110  cl::init(100));
111 
112 // FIXME: Enable this with XDEBUG when the test suite is clean.
113 static cl::opt<bool>
114 VerifySCEV("verify-scev",
115  cl::desc("Verify ScalarEvolution's backedge taken counts (slow)"));
116 
117 INITIALIZE_PASS_BEGIN(ScalarEvolution, "scalar-evolution",
118  "Scalar Evolution Analysis", false, true)
124  "Scalar Evolution Analysis", false, true)
125 char ScalarEvolution::ID = 0;
126 
127 //===----------------------------------------------------------------------===//
128 // SCEV class definitions
129 //===----------------------------------------------------------------------===//
130 
131 //===----------------------------------------------------------------------===//
132 // Implementation of the SCEV class.
133 //
134 
135 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
136 void SCEV::dump() const {
137  print(dbgs());
138  dbgs() << '\n';
139 }
140 #endif
141 
142 void SCEV::print(raw_ostream &OS) const {
143  switch (static_cast<SCEVTypes>(getSCEVType())) {
144  case scConstant:
145  cast<SCEVConstant>(this)->getValue()->printAsOperand(OS, false);
146  return;
147  case scTruncate: {
148  const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(this);
149  const SCEV *Op = Trunc->getOperand();
150  OS << "(trunc " << *Op->getType() << " " << *Op << " to "
151  << *Trunc->getType() << ")";
152  return;
153  }
154  case scZeroExtend: {
155  const SCEVZeroExtendExpr *ZExt = cast<SCEVZeroExtendExpr>(this);
156  const SCEV *Op = ZExt->getOperand();
157  OS << "(zext " << *Op->getType() << " " << *Op << " to "
158  << *ZExt->getType() << ")";
159  return;
160  }
161  case scSignExtend: {
162  const SCEVSignExtendExpr *SExt = cast<SCEVSignExtendExpr>(this);
163  const SCEV *Op = SExt->getOperand();
164  OS << "(sext " << *Op->getType() << " " << *Op << " to "
165  << *SExt->getType() << ")";
166  return;
167  }
168  case scAddRecExpr: {
169  const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(this);
170  OS << "{" << *AR->getOperand(0);
171  for (unsigned i = 1, e = AR->getNumOperands(); i != e; ++i)
172  OS << ",+," << *AR->getOperand(i);
173  OS << "}<";
174  if (AR->getNoWrapFlags(FlagNUW))
175  OS << "nuw><";
176  if (AR->getNoWrapFlags(FlagNSW))
177  OS << "nsw><";
178  if (AR->getNoWrapFlags(FlagNW) &&
180  OS << "nw><";
181  AR->getLoop()->getHeader()->printAsOperand(OS, /*PrintType=*/false);
182  OS << ">";
183  return;
184  }
185  case scAddExpr:
186  case scMulExpr:
187  case scUMaxExpr:
188  case scSMaxExpr: {
189  const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(this);
190  const char *OpStr = nullptr;
191  switch (NAry->getSCEVType()) {
192  case scAddExpr: OpStr = " + "; break;
193  case scMulExpr: OpStr = " * "; break;
194  case scUMaxExpr: OpStr = " umax "; break;
195  case scSMaxExpr: OpStr = " smax "; break;
196  }
197  OS << "(";
198  for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
199  I != E; ++I) {
200  OS << **I;
201  if (std::next(I) != E)
202  OS << OpStr;
203  }
204  OS << ")";
205  switch (NAry->getSCEVType()) {
206  case scAddExpr:
207  case scMulExpr:
208  if (NAry->getNoWrapFlags(FlagNUW))
209  OS << "<nuw>";
210  if (NAry->getNoWrapFlags(FlagNSW))
211  OS << "<nsw>";
212  }
213  return;
214  }
215  case scUDivExpr: {
216  const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(this);
217  OS << "(" << *UDiv->getLHS() << " /u " << *UDiv->getRHS() << ")";
218  return;
219  }
220  case scUnknown: {
221  const SCEVUnknown *U = cast<SCEVUnknown>(this);
222  Type *AllocTy;
223  if (U->isSizeOf(AllocTy)) {
224  OS << "sizeof(" << *AllocTy << ")";
225  return;
226  }
227  if (U->isAlignOf(AllocTy)) {
228  OS << "alignof(" << *AllocTy << ")";
229  return;
230  }
231 
232  Type *CTy;
233  Constant *FieldNo;
234  if (U->isOffsetOf(CTy, FieldNo)) {
235  OS << "offsetof(" << *CTy << ", ";
236  FieldNo->printAsOperand(OS, false);
237  OS << ")";
238  return;
239  }
240 
241  // Otherwise just print it normally.
242  U->getValue()->printAsOperand(OS, false);
243  return;
244  }
245  case scCouldNotCompute:
246  OS << "***COULDNOTCOMPUTE***";
247  return;
248  }
249  llvm_unreachable("Unknown SCEV kind!");
250 }
251 
252 Type *SCEV::getType() const {
253  switch (static_cast<SCEVTypes>(getSCEVType())) {
254  case scConstant:
255  return cast<SCEVConstant>(this)->getType();
256  case scTruncate:
257  case scZeroExtend:
258  case scSignExtend:
259  return cast<SCEVCastExpr>(this)->getType();
260  case scAddRecExpr:
261  case scMulExpr:
262  case scUMaxExpr:
263  case scSMaxExpr:
264  return cast<SCEVNAryExpr>(this)->getType();
265  case scAddExpr:
266  return cast<SCEVAddExpr>(this)->getType();
267  case scUDivExpr:
268  return cast<SCEVUDivExpr>(this)->getType();
269  case scUnknown:
270  return cast<SCEVUnknown>(this)->getType();
271  case scCouldNotCompute:
272  llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
273  }
274  llvm_unreachable("Unknown SCEV kind!");
275 }
276 
277 bool SCEV::isZero() const {
278  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
279  return SC->getValue()->isZero();
280  return false;
281 }
282 
283 bool SCEV::isOne() const {
284  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
285  return SC->getValue()->isOne();
286  return false;
287 }
288 
289 bool SCEV::isAllOnesValue() const {
290  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
291  return SC->getValue()->isAllOnesValue();
292  return false;
293 }
294 
295 /// isNonConstantNegative - Return true if the specified scev is negated, but
296 /// not a constant.
298  const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(this);
299  if (!Mul) return false;
300 
301  // If there is a constant factor, it will be first.
302  const SCEVConstant *SC = dyn_cast<SCEVConstant>(Mul->getOperand(0));
303  if (!SC) return false;
304 
305  // Return true if the value is negative, this matches things like (-42 * V).
306  return SC->getValue()->getValue().isNegative();
307 }
308 
311 
313  return S->getSCEVType() == scCouldNotCompute;
314 }
315 
319  ID.AddPointer(V);
320  void *IP = nullptr;
321  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
322  SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
323  UniqueSCEVs.InsertNode(S, IP);
324  return S;
325 }
326 
328  return getConstant(ConstantInt::get(getContext(), Val));
329 }
330 
331 const SCEV *
332 ScalarEvolution::getConstant(Type *Ty, uint64_t V, bool isSigned) {
333  IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
334  return getConstant(ConstantInt::get(ITy, V, isSigned));
335 }
336 
338  unsigned SCEVTy, const SCEV *op, Type *ty)
339  : SCEV(ID, SCEVTy), Op(op), Ty(ty) {}
340 
341 SCEVTruncateExpr::SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
342  const SCEV *op, Type *ty)
343  : SCEVCastExpr(ID, scTruncate, op, ty) {
344  assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
345  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
346  "Cannot truncate non-integer value!");
347 }
348 
349 SCEVZeroExtendExpr::SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
350  const SCEV *op, Type *ty)
351  : SCEVCastExpr(ID, scZeroExtend, op, ty) {
352  assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
353  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
354  "Cannot zero extend non-integer value!");
355 }
356 
357 SCEVSignExtendExpr::SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
358  const SCEV *op, Type *ty)
359  : SCEVCastExpr(ID, scSignExtend, op, ty) {
360  assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
361  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
362  "Cannot sign extend non-integer value!");
363 }
364 
365 void SCEVUnknown::deleted() {
366  // Clear this SCEVUnknown from various maps.
367  SE->forgetMemoizedResults(this);
368 
369  // Remove this SCEVUnknown from the uniquing map.
370  SE->UniqueSCEVs.RemoveNode(this);
371 
372  // Release the value.
373  setValPtr(nullptr);
374 }
375 
376 void SCEVUnknown::allUsesReplacedWith(Value *New) {
377  // Clear this SCEVUnknown from various maps.
378  SE->forgetMemoizedResults(this);
379 
380  // Remove this SCEVUnknown from the uniquing map.
381  SE->UniqueSCEVs.RemoveNode(this);
382 
383  // Update this SCEVUnknown to point to the new value. This is needed
384  // because there may still be outstanding SCEVs which still point to
385  // this SCEVUnknown.
386  setValPtr(New);
387 }
388 
389 bool SCEVUnknown::isSizeOf(Type *&AllocTy) const {
390  if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
391  if (VCE->getOpcode() == Instruction::PtrToInt)
392  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
393  if (CE->getOpcode() == Instruction::GetElementPtr &&
394  CE->getOperand(0)->isNullValue() &&
395  CE->getNumOperands() == 2)
396  if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
397  if (CI->isOne()) {
398  AllocTy = cast<PointerType>(CE->getOperand(0)->getType())
399  ->getElementType();
400  return true;
401  }
402 
403  return false;
404 }
405 
406 bool SCEVUnknown::isAlignOf(Type *&AllocTy) const {
407  if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
408  if (VCE->getOpcode() == Instruction::PtrToInt)
409  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
410  if (CE->getOpcode() == Instruction::GetElementPtr &&
411  CE->getOperand(0)->isNullValue()) {
412  Type *Ty =
413  cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
414  if (StructType *STy = dyn_cast<StructType>(Ty))
415  if (!STy->isPacked() &&
416  CE->getNumOperands() == 3 &&
417  CE->getOperand(1)->isNullValue()) {
418  if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
419  if (CI->isOne() &&
420  STy->getNumElements() == 2 &&
421  STy->getElementType(0)->isIntegerTy(1)) {
422  AllocTy = STy->getElementType(1);
423  return true;
424  }
425  }
426  }
427 
428  return false;
429 }
430 
431 bool SCEVUnknown::isOffsetOf(Type *&CTy, Constant *&FieldNo) const {
432  if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
433  if (VCE->getOpcode() == Instruction::PtrToInt)
434  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
435  if (CE->getOpcode() == Instruction::GetElementPtr &&
436  CE->getNumOperands() == 3 &&
437  CE->getOperand(0)->isNullValue() &&
438  CE->getOperand(1)->isNullValue()) {
439  Type *Ty =
440  cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
441  // Ignore vector types here so that ScalarEvolutionExpander doesn't
442  // emit getelementptrs that index into vectors.
443  if (Ty->isStructTy() || Ty->isArrayTy()) {
444  CTy = Ty;
445  FieldNo = CE->getOperand(2);
446  return true;
447  }
448  }
449 
450  return false;
451 }
452 
453 //===----------------------------------------------------------------------===//
454 // SCEV Utilities
455 //===----------------------------------------------------------------------===//
456 
457 namespace {
458  /// SCEVComplexityCompare - Return true if the complexity of the LHS is less
459  /// than the complexity of the RHS. This comparator is used to canonicalize
460  /// expressions.
461  class SCEVComplexityCompare {
462  const LoopInfo *const LI;
463  public:
464  explicit SCEVComplexityCompare(const LoopInfo *li) : LI(li) {}
465 
466  // Return true or false if LHS is less than, or at least RHS, respectively.
467  bool operator()(const SCEV *LHS, const SCEV *RHS) const {
468  return compare(LHS, RHS) < 0;
469  }
470 
471  // Return negative, zero, or positive, if LHS is less than, equal to, or
472  // greater than RHS, respectively. A three-way result allows recursive
473  // comparisons to be more efficient.
474  int compare(const SCEV *LHS, const SCEV *RHS) const {
475  // Fast-path: SCEVs are uniqued so we can do a quick equality check.
476  if (LHS == RHS)
477  return 0;
478 
479  // Primarily, sort the SCEVs by their getSCEVType().
480  unsigned LType = LHS->getSCEVType(), RType = RHS->getSCEVType();
481  if (LType != RType)
482  return (int)LType - (int)RType;
483 
484  // Aside from the getSCEVType() ordering, the particular ordering
485  // isn't very important except that it's beneficial to be consistent,
486  // so that (a + b) and (b + a) don't end up as different expressions.
487  switch (static_cast<SCEVTypes>(LType)) {
488  case scUnknown: {
489  const SCEVUnknown *LU = cast<SCEVUnknown>(LHS);
490  const SCEVUnknown *RU = cast<SCEVUnknown>(RHS);
491 
492  // Sort SCEVUnknown values with some loose heuristics. TODO: This is
493  // not as complete as it could be.
494  const Value *LV = LU->getValue(), *RV = RU->getValue();
495 
496  // Order pointer values after integer values. This helps SCEVExpander
497  // form GEPs.
498  bool LIsPointer = LV->getType()->isPointerTy(),
499  RIsPointer = RV->getType()->isPointerTy();
500  if (LIsPointer != RIsPointer)
501  return (int)LIsPointer - (int)RIsPointer;
502 
503  // Compare getValueID values.
504  unsigned LID = LV->getValueID(),
505  RID = RV->getValueID();
506  if (LID != RID)
507  return (int)LID - (int)RID;
508 
509  // Sort arguments by their position.
510  if (const Argument *LA = dyn_cast<Argument>(LV)) {
511  const Argument *RA = cast<Argument>(RV);
512  unsigned LArgNo = LA->getArgNo(), RArgNo = RA->getArgNo();
513  return (int)LArgNo - (int)RArgNo;
514  }
515 
516  // For instructions, compare their loop depth, and their operand
517  // count. This is pretty loose.
518  if (const Instruction *LInst = dyn_cast<Instruction>(LV)) {
519  const Instruction *RInst = cast<Instruction>(RV);
520 
521  // Compare loop depths.
522  const BasicBlock *LParent = LInst->getParent(),
523  *RParent = RInst->getParent();
524  if (LParent != RParent) {
525  unsigned LDepth = LI->getLoopDepth(LParent),
526  RDepth = LI->getLoopDepth(RParent);
527  if (LDepth != RDepth)
528  return (int)LDepth - (int)RDepth;
529  }
530 
531  // Compare the number of operands.
532  unsigned LNumOps = LInst->getNumOperands(),
533  RNumOps = RInst->getNumOperands();
534  return (int)LNumOps - (int)RNumOps;
535  }
536 
537  return 0;
538  }
539 
540  case scConstant: {
541  const SCEVConstant *LC = cast<SCEVConstant>(LHS);
542  const SCEVConstant *RC = cast<SCEVConstant>(RHS);
543 
544  // Compare constant values.
545  const APInt &LA = LC->getValue()->getValue();
546  const APInt &RA = RC->getValue()->getValue();
547  unsigned LBitWidth = LA.getBitWidth(), RBitWidth = RA.getBitWidth();
548  if (LBitWidth != RBitWidth)
549  return (int)LBitWidth - (int)RBitWidth;
550  return LA.ult(RA) ? -1 : 1;
551  }
552 
553  case scAddRecExpr: {
554  const SCEVAddRecExpr *LA = cast<SCEVAddRecExpr>(LHS);
555  const SCEVAddRecExpr *RA = cast<SCEVAddRecExpr>(RHS);
556 
557  // Compare addrec loop depths.
558  const Loop *LLoop = LA->getLoop(), *RLoop = RA->getLoop();
559  if (LLoop != RLoop) {
560  unsigned LDepth = LLoop->getLoopDepth(),
561  RDepth = RLoop->getLoopDepth();
562  if (LDepth != RDepth)
563  return (int)LDepth - (int)RDepth;
564  }
565 
566  // Addrec complexity grows with operand count.
567  unsigned LNumOps = LA->getNumOperands(), RNumOps = RA->getNumOperands();
568  if (LNumOps != RNumOps)
569  return (int)LNumOps - (int)RNumOps;
570 
571  // Lexicographically compare.
572  for (unsigned i = 0; i != LNumOps; ++i) {
573  long X = compare(LA->getOperand(i), RA->getOperand(i));
574  if (X != 0)
575  return X;
576  }
577 
578  return 0;
579  }
580 
581  case scAddExpr:
582  case scMulExpr:
583  case scSMaxExpr:
584  case scUMaxExpr: {
585  const SCEVNAryExpr *LC = cast<SCEVNAryExpr>(LHS);
586  const SCEVNAryExpr *RC = cast<SCEVNAryExpr>(RHS);
587 
588  // Lexicographically compare n-ary expressions.
589  unsigned LNumOps = LC->getNumOperands(), RNumOps = RC->getNumOperands();
590  if (LNumOps != RNumOps)
591  return (int)LNumOps - (int)RNumOps;
592 
593  for (unsigned i = 0; i != LNumOps; ++i) {
594  if (i >= RNumOps)
595  return 1;
596  long X = compare(LC->getOperand(i), RC->getOperand(i));
597  if (X != 0)
598  return X;
599  }
600  return (int)LNumOps - (int)RNumOps;
601  }
602 
603  case scUDivExpr: {
604  const SCEVUDivExpr *LC = cast<SCEVUDivExpr>(LHS);
605  const SCEVUDivExpr *RC = cast<SCEVUDivExpr>(RHS);
606 
607  // Lexicographically compare udiv expressions.
608  long X = compare(LC->getLHS(), RC->getLHS());
609  if (X != 0)
610  return X;
611  return compare(LC->getRHS(), RC->getRHS());
612  }
613 
614  case scTruncate:
615  case scZeroExtend:
616  case scSignExtend: {
617  const SCEVCastExpr *LC = cast<SCEVCastExpr>(LHS);
618  const SCEVCastExpr *RC = cast<SCEVCastExpr>(RHS);
619 
620  // Compare cast expressions by operand.
621  return compare(LC->getOperand(), RC->getOperand());
622  }
623 
624  case scCouldNotCompute:
625  llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
626  }
627  llvm_unreachable("Unknown SCEV kind!");
628  }
629  };
630 }
631 
632 /// GroupByComplexity - Given a list of SCEV objects, order them by their
633 /// complexity, and group objects of the same complexity together by value.
634 /// When this routine is finished, we know that any duplicates in the vector are
635 /// consecutive and that complexity is monotonically increasing.
636 ///
637 /// Note that we go take special precautions to ensure that we get deterministic
638 /// results from this routine. In other words, we don't want the results of
639 /// this to depend on where the addresses of various SCEV objects happened to
640 /// land in memory.
641 ///
643  LoopInfo *LI) {
644  if (Ops.size() < 2) return; // Noop
645  if (Ops.size() == 2) {
646  // This is the common case, which also happens to be trivially simple.
647  // Special case it.
648  const SCEV *&LHS = Ops[0], *&RHS = Ops[1];
649  if (SCEVComplexityCompare(LI)(RHS, LHS))
650  std::swap(LHS, RHS);
651  return;
652  }
653 
654  // Do the rough sort by complexity.
655  std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
656 
657  // Now that we are sorted by complexity, group elements of the same
658  // complexity. Note that this is, at worst, N^2, but the vector is likely to
659  // be extremely short in practice. Note that we take this approach because we
660  // do not want to depend on the addresses of the objects we are grouping.
661  for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
662  const SCEV *S = Ops[i];
663  unsigned Complexity = S->getSCEVType();
664 
665  // If there are any objects of the same complexity and same value as this
666  // one, group them.
667  for (unsigned j = i+1; j != e && Ops[j]->getSCEVType() == Complexity; ++j) {
668  if (Ops[j] == S) { // Found a duplicate.
669  // Move it to immediately after i'th element.
670  std::swap(Ops[i+1], Ops[j]);
671  ++i; // no need to rescan it.
672  if (i == e-2) return; // Done!
673  }
674  }
675  }
676 }
677 
678 namespace {
679 struct FindSCEVSize {
680  int Size;
681  FindSCEVSize() : Size(0) {}
682 
683  bool follow(const SCEV *S) {
684  ++Size;
685  // Keep looking at all operands of S.
686  return true;
687  }
688  bool isDone() const {
689  return false;
690  }
691 };
692 }
693 
694 // Returns the size of the SCEV S.
695 static inline int sizeOfSCEV(const SCEV *S) {
696  FindSCEVSize F;
698  ST.visitAll(S);
699  return F.Size;
700 }
701 
702 namespace {
703 
704 struct SCEVDivision : public SCEVVisitor<SCEVDivision, void> {
705 public:
706  // Computes the Quotient and Remainder of the division of Numerator by
707  // Denominator.
708  static void divide(ScalarEvolution &SE, const SCEV *Numerator,
709  const SCEV *Denominator, const SCEV **Quotient,
710  const SCEV **Remainder) {
711  assert(Numerator && Denominator && "Uninitialized SCEV");
712 
713  SCEVDivision D(SE, Numerator, Denominator);
714 
715  // Check for the trivial case here to avoid having to check for it in the
716  // rest of the code.
717  if (Numerator == Denominator) {
718  *Quotient = D.One;
719  *Remainder = D.Zero;
720  return;
721  }
722 
723  if (Numerator->isZero()) {
724  *Quotient = D.Zero;
725  *Remainder = D.Zero;
726  return;
727  }
728 
729  // A simple case when N/1. The quotient is N.
730  if (Denominator->isOne()) {
731  *Quotient = Numerator;
732  *Remainder = D.Zero;
733  return;
734  }
735 
736  // Split the Denominator when it is a product.
737  if (const SCEVMulExpr *T = dyn_cast<const SCEVMulExpr>(Denominator)) {
738  const SCEV *Q, *R;
739  *Quotient = Numerator;
740  for (const SCEV *Op : T->operands()) {
741  divide(SE, *Quotient, Op, &Q, &R);
742  *Quotient = Q;
743 
744  // Bail out when the Numerator is not divisible by one of the terms of
745  // the Denominator.
746  if (!R->isZero()) {
747  *Quotient = D.Zero;
748  *Remainder = Numerator;
749  return;
750  }
751  }
752  *Remainder = D.Zero;
753  return;
754  }
755 
756  D.visit(Numerator);
757  *Quotient = D.Quotient;
758  *Remainder = D.Remainder;
759  }
760 
761  // Except in the trivial case described above, we do not know how to divide
762  // Expr by Denominator for the following functions with empty implementation.
763  void visitTruncateExpr(const SCEVTruncateExpr *Numerator) {}
764  void visitZeroExtendExpr(const SCEVZeroExtendExpr *Numerator) {}
765  void visitSignExtendExpr(const SCEVSignExtendExpr *Numerator) {}
766  void visitUDivExpr(const SCEVUDivExpr *Numerator) {}
767  void visitSMaxExpr(const SCEVSMaxExpr *Numerator) {}
768  void visitUMaxExpr(const SCEVUMaxExpr *Numerator) {}
769  void visitUnknown(const SCEVUnknown *Numerator) {}
770  void visitCouldNotCompute(const SCEVCouldNotCompute *Numerator) {}
771 
772  void visitConstant(const SCEVConstant *Numerator) {
773  if (const SCEVConstant *D = dyn_cast<SCEVConstant>(Denominator)) {
774  APInt NumeratorVal = Numerator->getValue()->getValue();
775  APInt DenominatorVal = D->getValue()->getValue();
776  uint32_t NumeratorBW = NumeratorVal.getBitWidth();
777  uint32_t DenominatorBW = DenominatorVal.getBitWidth();
778 
779  if (NumeratorBW > DenominatorBW)
780  DenominatorVal = DenominatorVal.sext(NumeratorBW);
781  else if (NumeratorBW < DenominatorBW)
782  NumeratorVal = NumeratorVal.sext(DenominatorBW);
783 
784  APInt QuotientVal(NumeratorVal.getBitWidth(), 0);
785  APInt RemainderVal(NumeratorVal.getBitWidth(), 0);
786  APInt::sdivrem(NumeratorVal, DenominatorVal, QuotientVal, RemainderVal);
787  Quotient = SE.getConstant(QuotientVal);
788  Remainder = SE.getConstant(RemainderVal);
789  return;
790  }
791  }
792 
793  void visitAddRecExpr(const SCEVAddRecExpr *Numerator) {
794  const SCEV *StartQ, *StartR, *StepQ, *StepR;
795  assert(Numerator->isAffine() && "Numerator should be affine");
796  divide(SE, Numerator->getStart(), Denominator, &StartQ, &StartR);
797  divide(SE, Numerator->getStepRecurrence(SE), Denominator, &StepQ, &StepR);
798  // Bail out if the types do not match.
799  Type *Ty = Denominator->getType();
800  if (Ty != StartQ->getType() || Ty != StartR->getType() ||
801  Ty != StepQ->getType() || Ty != StepR->getType()) {
802  Quotient = Zero;
803  Remainder = Numerator;
804  return;
805  }
806  Quotient = SE.getAddRecExpr(StartQ, StepQ, Numerator->getLoop(),
807  Numerator->getNoWrapFlags());
808  Remainder = SE.getAddRecExpr(StartR, StepR, Numerator->getLoop(),
809  Numerator->getNoWrapFlags());
810  }
811 
812  void visitAddExpr(const SCEVAddExpr *Numerator) {
814  Type *Ty = Denominator->getType();
815 
816  for (const SCEV *Op : Numerator->operands()) {
817  const SCEV *Q, *R;
818  divide(SE, Op, Denominator, &Q, &R);
819 
820  // Bail out if types do not match.
821  if (Ty != Q->getType() || Ty != R->getType()) {
822  Quotient = Zero;
823  Remainder = Numerator;
824  return;
825  }
826 
827  Qs.push_back(Q);
828  Rs.push_back(R);
829  }
830 
831  if (Qs.size() == 1) {
832  Quotient = Qs[0];
833  Remainder = Rs[0];
834  return;
835  }
836 
837  Quotient = SE.getAddExpr(Qs);
838  Remainder = SE.getAddExpr(Rs);
839  }
840 
841  void visitMulExpr(const SCEVMulExpr *Numerator) {
843  Type *Ty = Denominator->getType();
844 
845  bool FoundDenominatorTerm = false;
846  for (const SCEV *Op : Numerator->operands()) {
847  // Bail out if types do not match.
848  if (Ty != Op->getType()) {
849  Quotient = Zero;
850  Remainder = Numerator;
851  return;
852  }
853 
854  if (FoundDenominatorTerm) {
855  Qs.push_back(Op);
856  continue;
857  }
858 
859  // Check whether Denominator divides one of the product operands.
860  const SCEV *Q, *R;
861  divide(SE, Op, Denominator, &Q, &R);
862  if (!R->isZero()) {
863  Qs.push_back(Op);
864  continue;
865  }
866 
867  // Bail out if types do not match.
868  if (Ty != Q->getType()) {
869  Quotient = Zero;
870  Remainder = Numerator;
871  return;
872  }
873 
874  FoundDenominatorTerm = true;
875  Qs.push_back(Q);
876  }
877 
878  if (FoundDenominatorTerm) {
879  Remainder = Zero;
880  if (Qs.size() == 1)
881  Quotient = Qs[0];
882  else
883  Quotient = SE.getMulExpr(Qs);
884  return;
885  }
886 
887  if (!isa<SCEVUnknown>(Denominator)) {
888  Quotient = Zero;
889  Remainder = Numerator;
890  return;
891  }
892 
893  // The Remainder is obtained by replacing Denominator by 0 in Numerator.
894  ValueToValueMap RewriteMap;
895  RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
896  cast<SCEVConstant>(Zero)->getValue();
897  Remainder = SCEVParameterRewriter::rewrite(Numerator, SE, RewriteMap, true);
898 
899  if (Remainder->isZero()) {
900  // The Quotient is obtained by replacing Denominator by 1 in Numerator.
901  RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
902  cast<SCEVConstant>(One)->getValue();
903  Quotient =
904  SCEVParameterRewriter::rewrite(Numerator, SE, RewriteMap, true);
905  return;
906  }
907 
908  // Quotient is (Numerator - Remainder) divided by Denominator.
909  const SCEV *Q, *R;
910  const SCEV *Diff = SE.getMinusSCEV(Numerator, Remainder);
911  if (sizeOfSCEV(Diff) > sizeOfSCEV(Numerator)) {
912  // This SCEV does not seem to simplify: fail the division here.
913  Quotient = Zero;
914  Remainder = Numerator;
915  return;
916  }
917  divide(SE, Diff, Denominator, &Q, &R);
918  assert(R == Zero &&
919  "(Numerator - Remainder) should evenly divide Denominator");
920  Quotient = Q;
921  }
922 
923 private:
924  SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
925  const SCEV *Denominator)
926  : SE(S), Denominator(Denominator) {
927  Zero = SE.getConstant(Denominator->getType(), 0);
928  One = SE.getConstant(Denominator->getType(), 1);
929 
930  // By default, we don't know how to divide Expr by Denominator.
931  // Providing the default here simplifies the rest of the code.
932  Quotient = Zero;
933  Remainder = Numerator;
934  }
935 
936  ScalarEvolution &SE;
937  const SCEV *Denominator, *Quotient, *Remainder, *Zero, *One;
938 };
939 
940 }
941 
942 //===----------------------------------------------------------------------===//
943 // Simple SCEV method implementations
944 //===----------------------------------------------------------------------===//
945 
946 /// BinomialCoefficient - Compute BC(It, K). The result has width W.
947 /// Assume, K > 0.
948 static const SCEV *BinomialCoefficient(const SCEV *It, unsigned K,
949  ScalarEvolution &SE,
950  Type *ResultTy) {
951  // Handle the simplest case efficiently.
952  if (K == 1)
953  return SE.getTruncateOrZeroExtend(It, ResultTy);
954 
955  // We are using the following formula for BC(It, K):
956  //
957  // BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / K!
958  //
959  // Suppose, W is the bitwidth of the return value. We must be prepared for
960  // overflow. Hence, we must assure that the result of our computation is
961  // equal to the accurate one modulo 2^W. Unfortunately, division isn't
962  // safe in modular arithmetic.
963  //
964  // However, this code doesn't use exactly that formula; the formula it uses
965  // is something like the following, where T is the number of factors of 2 in
966  // K! (i.e. trailing zeros in the binary representation of K!), and ^ is
967  // exponentiation:
968  //
969  // BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / 2^T / (K! / 2^T)
970  //
971  // This formula is trivially equivalent to the previous formula. However,
972  // this formula can be implemented much more efficiently. The trick is that
973  // K! / 2^T is odd, and exact division by an odd number *is* safe in modular
974  // arithmetic. To do exact division in modular arithmetic, all we have
975  // to do is multiply by the inverse. Therefore, this step can be done at
976  // width W.
977  //
978  // The next issue is how to safely do the division by 2^T. The way this
979  // is done is by doing the multiplication step at a width of at least W + T
980  // bits. This way, the bottom W+T bits of the product are accurate. Then,
981  // when we perform the division by 2^T (which is equivalent to a right shift
982  // by T), the bottom W bits are accurate. Extra bits are okay; they'll get
983  // truncated out after the division by 2^T.
984  //
985  // In comparison to just directly using the first formula, this technique
986  // is much more efficient; using the first formula requires W * K bits,
987  // but this formula less than W + K bits. Also, the first formula requires
988  // a division step, whereas this formula only requires multiplies and shifts.
989  //
990  // It doesn't matter whether the subtraction step is done in the calculation
991  // width or the input iteration count's width; if the subtraction overflows,
992  // the result must be zero anyway. We prefer here to do it in the width of
993  // the induction variable because it helps a lot for certain cases; CodeGen
994  // isn't smart enough to ignore the overflow, which leads to much less
995  // efficient code if the width of the subtraction is wider than the native
996  // register width.
997  //
998  // (It's possible to not widen at all by pulling out factors of 2 before
999  // the multiplication; for example, K=2 can be calculated as
1000  // It/2*(It+(It*INT_MIN/INT_MIN)+-1). However, it requires
1001  // extra arithmetic, so it's not an obvious win, and it gets
1002  // much more complicated for K > 3.)
1003 
1004  // Protection from insane SCEVs; this bound is conservative,
1005  // but it probably doesn't matter.
1006  if (K > 1000)
1007  return SE.getCouldNotCompute();
1008 
1009  unsigned W = SE.getTypeSizeInBits(ResultTy);
1010 
1011  // Calculate K! / 2^T and T; we divide out the factors of two before
1012  // multiplying for calculating K! / 2^T to avoid overflow.
1013  // Other overflow doesn't matter because we only care about the bottom
1014  // W bits of the result.
1015  APInt OddFactorial(W, 1);
1016  unsigned T = 1;
1017  for (unsigned i = 3; i <= K; ++i) {
1018  APInt Mult(W, i);
1019  unsigned TwoFactors = Mult.countTrailingZeros();
1020  T += TwoFactors;
1021  Mult = Mult.lshr(TwoFactors);
1022  OddFactorial *= Mult;
1023  }
1024 
1025  // We need at least W + T bits for the multiplication step
1026  unsigned CalculationBits = W + T;
1027 
1028  // Calculate 2^T, at width T+W.
1029  APInt DivFactor = APInt::getOneBitSet(CalculationBits, T);
1030 
1031  // Calculate the multiplicative inverse of K! / 2^T;
1032  // this multiplication factor will perform the exact division by
1033  // K! / 2^T.
1034  APInt Mod = APInt::getSignedMinValue(W+1);
1035  APInt MultiplyFactor = OddFactorial.zext(W+1);
1036  MultiplyFactor = MultiplyFactor.multiplicativeInverse(Mod);
1037  MultiplyFactor = MultiplyFactor.trunc(W);
1038 
1039  // Calculate the product, at width T+W
1040  IntegerType *CalculationTy = IntegerType::get(SE.getContext(),
1041  CalculationBits);
1042  const SCEV *Dividend = SE.getTruncateOrZeroExtend(It, CalculationTy);
1043  for (unsigned i = 1; i != K; ++i) {
1044  const SCEV *S = SE.getMinusSCEV(It, SE.getConstant(It->getType(), i));
1045  Dividend = SE.getMulExpr(Dividend,
1046  SE.getTruncateOrZeroExtend(S, CalculationTy));
1047  }
1048 
1049  // Divide by 2^T
1050  const SCEV *DivResult = SE.getUDivExpr(Dividend, SE.getConstant(DivFactor));
1051 
1052  // Truncate the result, and divide by K! / 2^T.
1053 
1054  return SE.getMulExpr(SE.getConstant(MultiplyFactor),
1055  SE.getTruncateOrZeroExtend(DivResult, ResultTy));
1056 }
1057 
1058 /// evaluateAtIteration - Return the value of this chain of recurrences at
1059 /// the specified iteration number. We can evaluate this recurrence by
1060 /// multiplying each element in the chain by the binomial coefficient
1061 /// corresponding to it. In other words, we can evaluate {A,+,B,+,C,+,D} as:
1062 ///
1063 /// A*BC(It, 0) + B*BC(It, 1) + C*BC(It, 2) + D*BC(It, 3)
1064 ///
1065 /// where BC(It, k) stands for binomial coefficient.
1066 ///
1068  ScalarEvolution &SE) const {
1069  const SCEV *Result = getStart();
1070  for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
1071  // The computation is correct in the face of overflow provided that the
1072  // multiplication is performed _after_ the evaluation of the binomial
1073  // coefficient.
1074  const SCEV *Coeff = BinomialCoefficient(It, i, SE, getType());
1075  if (isa<SCEVCouldNotCompute>(Coeff))
1076  return Coeff;
1077 
1078  Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
1079  }
1080  return Result;
1081 }
1082 
1083 //===----------------------------------------------------------------------===//
1084 // SCEV Expression folder implementations
1085 //===----------------------------------------------------------------------===//
1086 
1088  Type *Ty) {
1089  assert(getTypeSizeInBits(Op->getType()) > getTypeSizeInBits(Ty) &&
1090  "This is not a truncating conversion!");
1091  assert(isSCEVable(Ty) &&
1092  "This is not a conversion to a SCEVable type!");
1093  Ty = getEffectiveSCEVType(Ty);
1094 
1096  ID.AddInteger(scTruncate);
1097  ID.AddPointer(Op);
1098  ID.AddPointer(Ty);
1099  void *IP = nullptr;
1100  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1101 
1102  // Fold if the operand is constant.
1103  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1104  return getConstant(
1105  cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(), Ty)));
1106 
1107  // trunc(trunc(x)) --> trunc(x)
1108  if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op))
1109  return getTruncateExpr(ST->getOperand(), Ty);
1110 
1111  // trunc(sext(x)) --> sext(x) if widening or trunc(x) if narrowing
1112  if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
1113  return getTruncateOrSignExtend(SS->getOperand(), Ty);
1114 
1115  // trunc(zext(x)) --> zext(x) if widening or trunc(x) if narrowing
1116  if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1117  return getTruncateOrZeroExtend(SZ->getOperand(), Ty);
1118 
1119  // trunc(x1+x2+...+xN) --> trunc(x1)+trunc(x2)+...+trunc(xN) if we can
1120  // eliminate all the truncates, or we replace other casts with truncates.
1121  if (const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Op)) {
1123  bool hasTrunc = false;
1124  for (unsigned i = 0, e = SA->getNumOperands(); i != e && !hasTrunc; ++i) {
1125  const SCEV *S = getTruncateExpr(SA->getOperand(i), Ty);
1126  if (!isa<SCEVCastExpr>(SA->getOperand(i)))
1127  hasTrunc = isa<SCEVTruncateExpr>(S);
1128  Operands.push_back(S);
1129  }
1130  if (!hasTrunc)
1131  return getAddExpr(Operands);
1132  UniqueSCEVs.FindNodeOrInsertPos(ID, IP); // Mutates IP, returns NULL.
1133  }
1134 
1135  // trunc(x1*x2*...*xN) --> trunc(x1)*trunc(x2)*...*trunc(xN) if we can
1136  // eliminate all the truncates, or we replace other casts with truncates.
1137  if (const SCEVMulExpr *SM = dyn_cast<SCEVMulExpr>(Op)) {
1139  bool hasTrunc = false;
1140  for (unsigned i = 0, e = SM->getNumOperands(); i != e && !hasTrunc; ++i) {
1141  const SCEV *S = getTruncateExpr(SM->getOperand(i), Ty);
1142  if (!isa<SCEVCastExpr>(SM->getOperand(i)))
1143  hasTrunc = isa<SCEVTruncateExpr>(S);
1144  Operands.push_back(S);
1145  }
1146  if (!hasTrunc)
1147  return getMulExpr(Operands);
1148  UniqueSCEVs.FindNodeOrInsertPos(ID, IP); // Mutates IP, returns NULL.
1149  }
1150 
1151  // If the input value is a chrec scev, truncate the chrec's operands.
1152  if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Op)) {
1154  for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
1155  Operands.push_back(getTruncateExpr(AddRec->getOperand(i), Ty));
1156  return getAddRecExpr(Operands, AddRec->getLoop(), SCEV::FlagAnyWrap);
1157  }
1158 
1159  // The cast wasn't folded; create an explicit cast node. We can reuse
1160  // the existing insert position since if we get here, we won't have
1161  // made any changes which would invalidate it.
1162  SCEV *S = new (SCEVAllocator) SCEVTruncateExpr(ID.Intern(SCEVAllocator),
1163  Op, Ty);
1164  UniqueSCEVs.InsertNode(S, IP);
1165  return S;
1166 }
1167 
1168 // Get the limit of a recurrence such that incrementing by Step cannot cause
1169 // signed overflow as long as the value of the recurrence within the
1170 // loop does not exceed this limit before incrementing.
1171 static const SCEV *getSignedOverflowLimitForStep(const SCEV *Step,
1172  ICmpInst::Predicate *Pred,
1173  ScalarEvolution *SE) {
1174  unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
1175  if (SE->isKnownPositive(Step)) {
1176  *Pred = ICmpInst::ICMP_SLT;
1177  return SE->getConstant(APInt::getSignedMinValue(BitWidth) -
1178  SE->getSignedRange(Step).getSignedMax());
1179  }
1180  if (SE->isKnownNegative(Step)) {
1181  *Pred = ICmpInst::ICMP_SGT;
1182  return SE->getConstant(APInt::getSignedMaxValue(BitWidth) -
1183  SE->getSignedRange(Step).getSignedMin());
1184  }
1185  return nullptr;
1186 }
1187 
1188 // Get the limit of a recurrence such that incrementing by Step cannot cause
1189 // unsigned overflow as long as the value of the recurrence within the loop does
1190 // not exceed this limit before incrementing.
1191 static const SCEV *getUnsignedOverflowLimitForStep(const SCEV *Step,
1192  ICmpInst::Predicate *Pred,
1193  ScalarEvolution *SE) {
1194  unsigned BitWidth = SE->getTypeSizeInBits(Step->getType());
1195  *Pred = ICmpInst::ICMP_ULT;
1196 
1197  return SE->getConstant(APInt::getMinValue(BitWidth) -
1198  SE->getUnsignedRange(Step).getUnsignedMax());
1199 }
1200 
1201 namespace {
1202 
1203 struct ExtendOpTraitsBase {
1204  typedef const SCEV *(ScalarEvolution::*GetExtendExprTy)(const SCEV *, Type *);
1205 };
1206 
1207 // Used to make code generic over signed and unsigned overflow.
1208 template <typename ExtendOp> struct ExtendOpTraits {
1209  // Members present:
1210  //
1211  // static const SCEV::NoWrapFlags WrapType;
1212  //
1213  // static const ExtendOpTraitsBase::GetExtendExprTy GetExtendExpr;
1214  //
1215  // static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1216  // ICmpInst::Predicate *Pred,
1217  // ScalarEvolution *SE);
1218 };
1219 
1220 template <>
1221 struct ExtendOpTraits<SCEVSignExtendExpr> : public ExtendOpTraitsBase {
1222  static const SCEV::NoWrapFlags WrapType = SCEV::FlagNSW;
1223 
1224  static const GetExtendExprTy GetExtendExpr;
1225 
1226  static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1227  ICmpInst::Predicate *Pred,
1228  ScalarEvolution *SE) {
1229  return getSignedOverflowLimitForStep(Step, Pred, SE);
1230  }
1231 };
1232 
1233 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
1235 
1236 template <>
1237 struct ExtendOpTraits<SCEVZeroExtendExpr> : public ExtendOpTraitsBase {
1238  static const SCEV::NoWrapFlags WrapType = SCEV::FlagNUW;
1239 
1240  static const GetExtendExprTy GetExtendExpr;
1241 
1242  static const SCEV *getOverflowLimitForStep(const SCEV *Step,
1243  ICmpInst::Predicate *Pred,
1244  ScalarEvolution *SE) {
1245  return getUnsignedOverflowLimitForStep(Step, Pred, SE);
1246  }
1247 };
1248 
1249 const ExtendOpTraitsBase::GetExtendExprTy ExtendOpTraits<
1251 }
1252 
1253 // The recurrence AR has been shown to have no signed/unsigned wrap or something
1254 // close to it. Typically, if we can prove NSW/NUW for AR, then we can just as
1255 // easily prove NSW/NUW for its preincrement or postincrement sibling. This
1256 // allows normalizing a sign/zero extended AddRec as such: {sext/zext(Step +
1257 // Start),+,Step} => {(Step + sext/zext(Start),+,Step} As a result, the
1258 // expression "Step + sext/zext(PreIncAR)" is congruent with
1259 // "sext/zext(PostIncAR)"
1260 template <typename ExtendOpTy>
1261 static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
1262  ScalarEvolution *SE) {
1263  auto WrapType = ExtendOpTraits<ExtendOpTy>::WrapType;
1264  auto GetExtendExpr = ExtendOpTraits<ExtendOpTy>::GetExtendExpr;
1265 
1266  const Loop *L = AR->getLoop();
1267  const SCEV *Start = AR->getStart();
1268  const SCEV *Step = AR->getStepRecurrence(*SE);
1269 
1270  // Check for a simple looking step prior to loop entry.
1271  const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Start);
1272  if (!SA)
1273  return nullptr;
1274 
1275  // Create an AddExpr for "PreStart" after subtracting Step. Full SCEV
1276  // subtraction is expensive. For this purpose, perform a quick and dirty
1277  // difference, by checking for Step in the operand list.
1279  for (const SCEV *Op : SA->operands())
1280  if (Op != Step)
1281  DiffOps.push_back(Op);
1282 
1283  if (DiffOps.size() == SA->getNumOperands())
1284  return nullptr;
1285 
1286  // Try to prove `WrapType` (SCEV::FlagNSW or SCEV::FlagNUW) on `PreStart` +
1287  // `Step`:
1288 
1289  // 1. NSW/NUW flags on the step increment.
1290  const SCEV *PreStart = SE->getAddExpr(DiffOps, SA->getNoWrapFlags());
1291  const SCEVAddRecExpr *PreAR = dyn_cast<SCEVAddRecExpr>(
1292  SE->getAddRecExpr(PreStart, Step, L, SCEV::FlagAnyWrap));
1293 
1294  // "{S,+,X} is <nsw>/<nuw>" and "the backedge is taken at least once" implies
1295  // "S+X does not sign/unsign-overflow".
1296  //
1297 
1298  const SCEV *BECount = SE->getBackedgeTakenCount(L);
1299  if (PreAR && PreAR->getNoWrapFlags(WrapType) &&
1300  !isa<SCEVCouldNotCompute>(BECount) && SE->isKnownPositive(BECount))
1301  return PreStart;
1302 
1303  // 2. Direct overflow check on the step operation's expression.
1304  unsigned BitWidth = SE->getTypeSizeInBits(AR->getType());
1305  Type *WideTy = IntegerType::get(SE->getContext(), BitWidth * 2);
1306  const SCEV *OperandExtendedStart =
1307  SE->getAddExpr((SE->*GetExtendExpr)(PreStart, WideTy),
1308  (SE->*GetExtendExpr)(Step, WideTy));
1309  if ((SE->*GetExtendExpr)(Start, WideTy) == OperandExtendedStart) {
1310  if (PreAR && AR->getNoWrapFlags(WrapType)) {
1311  // If we know `AR` == {`PreStart`+`Step`,+,`Step`} is `WrapType` (FlagNSW
1312  // or FlagNUW) and that `PreStart` + `Step` is `WrapType` too, then
1313  // `PreAR` == {`PreStart`,+,`Step`} is also `WrapType`. Cache this fact.
1314  const_cast<SCEVAddRecExpr *>(PreAR)->setNoWrapFlags(WrapType);
1315  }
1316  return PreStart;
1317  }
1318 
1319  // 3. Loop precondition.
1320  ICmpInst::Predicate Pred;
1321  const SCEV *OverflowLimit =
1322  ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(Step, &Pred, SE);
1323 
1324  if (OverflowLimit &&
1325  SE->isLoopEntryGuardedByCond(L, Pred, PreStart, OverflowLimit)) {
1326  return PreStart;
1327  }
1328  return nullptr;
1329 }
1330 
1331 // Get the normalized zero or sign extended expression for this AddRec's Start.
1332 template <typename ExtendOpTy>
1333 static const SCEV *getExtendAddRecStart(const SCEVAddRecExpr *AR, Type *Ty,
1334  ScalarEvolution *SE) {
1335  auto GetExtendExpr = ExtendOpTraits<ExtendOpTy>::GetExtendExpr;
1336 
1337  const SCEV *PreStart = getPreStartForExtend<ExtendOpTy>(AR, Ty, SE);
1338  if (!PreStart)
1339  return (SE->*GetExtendExpr)(AR->getStart(), Ty);
1340 
1341  return SE->getAddExpr((SE->*GetExtendExpr)(AR->getStepRecurrence(*SE), Ty),
1342  (SE->*GetExtendExpr)(PreStart, Ty));
1343 }
1344 
1345 // Try to prove away overflow by looking at "nearby" add recurrences. A
1346 // motivating example for this rule: if we know `{0,+,4}` is `ult` `-1` and it
1347 // does not itself wrap then we can conclude that `{1,+,4}` is `nuw`.
1348 //
1349 // Formally:
1350 //
1351 // {S,+,X} == {S-T,+,X} + T
1352 // => Ext({S,+,X}) == Ext({S-T,+,X} + T)
1353 //
1354 // If ({S-T,+,X} + T) does not overflow ... (1)
1355 //
1356 // RHS == Ext({S-T,+,X} + T) == Ext({S-T,+,X}) + Ext(T)
1357 //
1358 // If {S-T,+,X} does not overflow ... (2)
1359 //
1360 // RHS == Ext({S-T,+,X}) + Ext(T) == {Ext(S-T),+,Ext(X)} + Ext(T)
1361 // == {Ext(S-T)+Ext(T),+,Ext(X)}
1362 //
1363 // If (S-T)+T does not overflow ... (3)
1364 //
1365 // RHS == {Ext(S-T)+Ext(T),+,Ext(X)} == {Ext(S-T+T),+,Ext(X)}
1366 // == {Ext(S),+,Ext(X)} == LHS
1367 //
1368 // Thus, if (1), (2) and (3) are true for some T, then
1369 // Ext({S,+,X}) == {Ext(S),+,Ext(X)}
1370 //
1371 // (3) is implied by (1) -- "(S-T)+T does not overflow" is simply "({S-T,+,X}+T)
1372 // does not overflow" restricted to the 0th iteration. Therefore we only need
1373 // to check for (1) and (2).
1374 //
1375 // In the current context, S is `Start`, X is `Step`, Ext is `ExtendOpTy` and T
1376 // is `Delta` (defined below).
1377 //
1378 template <typename ExtendOpTy>
1379 bool ScalarEvolution::proveNoWrapByVaryingStart(const SCEV *Start,
1380  const SCEV *Step,
1381  const Loop *L) {
1382  auto WrapType = ExtendOpTraits<ExtendOpTy>::WrapType;
1383 
1384  // We restrict `Start` to a constant to prevent SCEV from spending too much
1385  // time here. It is correct (but more expensive) to continue with a
1386  // non-constant `Start` and do a general SCEV subtraction to compute
1387  // `PreStart` below.
1388  //
1389  const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start);
1390  if (!StartC)
1391  return false;
1392 
1393  APInt StartAI = StartC->getValue()->getValue();
1394 
1395  for (unsigned Delta : {-2, -1, 1, 2}) {
1396  const SCEV *PreStart = getConstant(StartAI - Delta);
1397 
1398  // Give up if we don't already have the add recurrence we need because
1399  // actually constructing an add recurrence is relatively expensive.
1400  const SCEVAddRecExpr *PreAR = [&]() {
1403  ID.AddPointer(PreStart);
1404  ID.AddPointer(Step);
1405  ID.AddPointer(L);
1406  void *IP = nullptr;
1407  return static_cast<SCEVAddRecExpr *>(
1408  this->UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
1409  }();
1410 
1411  if (PreAR && PreAR->getNoWrapFlags(WrapType)) { // proves (2)
1412  const SCEV *DeltaS = getConstant(StartC->getType(), Delta);
1414  const SCEV *Limit = ExtendOpTraits<ExtendOpTy>::getOverflowLimitForStep(
1415  DeltaS, &Pred, this);
1416  if (Limit && isKnownPredicate(Pred, PreAR, Limit)) // proves (1)
1417  return true;
1418  }
1419  }
1420 
1421  return false;
1422 }
1423 
1425  Type *Ty) {
1426  assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1427  "This is not an extending conversion!");
1428  assert(isSCEVable(Ty) &&
1429  "This is not a conversion to a SCEVable type!");
1430  Ty = getEffectiveSCEVType(Ty);
1431 
1432  // Fold if the operand is constant.
1433  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1434  return getConstant(
1435  cast<ConstantInt>(ConstantExpr::getZExt(SC->getValue(), Ty)));
1436 
1437  // zext(zext(x)) --> zext(x)
1438  if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1439  return getZeroExtendExpr(SZ->getOperand(), Ty);
1440 
1441  // Before doing any expensive analysis, check to see if we've already
1442  // computed a SCEV for this Op and Ty.
1445  ID.AddPointer(Op);
1446  ID.AddPointer(Ty);
1447  void *IP = nullptr;
1448  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1449 
1450  // zext(trunc(x)) --> zext(x) or x or trunc(x)
1451  if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
1452  // It's possible the bits taken off by the truncate were all zero bits. If
1453  // so, we should be able to simplify this further.
1454  const SCEV *X = ST->getOperand();
1456  unsigned TruncBits = getTypeSizeInBits(ST->getType());
1457  unsigned NewBits = getTypeSizeInBits(Ty);
1458  if (CR.truncate(TruncBits).zeroExtend(NewBits).contains(
1459  CR.zextOrTrunc(NewBits)))
1460  return getTruncateOrZeroExtend(X, Ty);
1461  }
1462 
1463  // If the input value is a chrec scev, and we can prove that the value
1464  // did not overflow the old, smaller, value, we can zero extend all of the
1465  // operands (often constants). This allows analysis of something like
1466  // this: for (unsigned char X = 0; X < 100; ++X) { int Y = X; }
1467  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
1468  if (AR->isAffine()) {
1469  const SCEV *Start = AR->getStart();
1470  const SCEV *Step = AR->getStepRecurrence(*this);
1471  unsigned BitWidth = getTypeSizeInBits(AR->getType());
1472  const Loop *L = AR->getLoop();
1473 
1474  // If we have special knowledge that this addrec won't overflow,
1475  // we don't need to do any further analysis.
1476  if (AR->getNoWrapFlags(SCEV::FlagNUW))
1477  return getAddRecExpr(
1478  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1479  getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1480 
1481  // Check whether the backedge-taken count is SCEVCouldNotCompute.
1482  // Note that this serves two purposes: It filters out loops that are
1483  // simply not analyzable, and it covers the case where this code is
1484  // being called from within backedge-taken count analysis, such that
1485  // attempting to ask for the backedge-taken count would likely result
1486  // in infinite recursion. In the later case, the analysis code will
1487  // cope with a conservative value, and it will take care to purge
1488  // that value once it has finished.
1489  const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
1490  if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
1491  // Manually compute the final value for AR, checking for
1492  // overflow.
1493 
1494  // Check whether the backedge-taken count can be losslessly casted to
1495  // the addrec's type. The count is always unsigned.
1496  const SCEV *CastedMaxBECount =
1497  getTruncateOrZeroExtend(MaxBECount, Start->getType());
1498  const SCEV *RecastedMaxBECount =
1499  getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
1500  if (MaxBECount == RecastedMaxBECount) {
1501  Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1502  // Check whether Start+Step*MaxBECount has no unsigned overflow.
1503  const SCEV *ZMul = getMulExpr(CastedMaxBECount, Step);
1504  const SCEV *ZAdd = getZeroExtendExpr(getAddExpr(Start, ZMul), WideTy);
1505  const SCEV *WideStart = getZeroExtendExpr(Start, WideTy);
1506  const SCEV *WideMaxBECount =
1507  getZeroExtendExpr(CastedMaxBECount, WideTy);
1508  const SCEV *OperandExtendedAdd =
1509  getAddExpr(WideStart,
1510  getMulExpr(WideMaxBECount,
1511  getZeroExtendExpr(Step, WideTy)));
1512  if (ZAdd == OperandExtendedAdd) {
1513  // Cache knowledge of AR NUW, which is propagated to this AddRec.
1514  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1515  // Return the expression with the addrec on the outside.
1516  return getAddRecExpr(
1517  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1518  getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1519  }
1520  // Similar to above, only this time treat the step value as signed.
1521  // This covers loops that count down.
1522  OperandExtendedAdd =
1523  getAddExpr(WideStart,
1524  getMulExpr(WideMaxBECount,
1525  getSignExtendExpr(Step, WideTy)));
1526  if (ZAdd == OperandExtendedAdd) {
1527  // Cache knowledge of AR NW, which is propagated to this AddRec.
1528  // Negative step causes unsigned wrap, but it still can't self-wrap.
1529  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1530  // Return the expression with the addrec on the outside.
1531  return getAddRecExpr(
1532  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1533  getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1534  }
1535  }
1536 
1537  // If the backedge is guarded by a comparison with the pre-inc value
1538  // the addrec is safe. Also, if the entry is guarded by a comparison
1539  // with the start value and the backedge is guarded by a comparison
1540  // with the post-inc value, the addrec is safe.
1541  if (isKnownPositive(Step)) {
1542  const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
1543  getUnsignedRange(Step).getUnsignedMax());
1547  AR->getPostIncExpr(*this), N))) {
1548  // Cache knowledge of AR NUW, which is propagated to this AddRec.
1549  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1550  // Return the expression with the addrec on the outside.
1551  return getAddRecExpr(
1552  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1553  getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1554  }
1555  } else if (isKnownNegative(Step)) {
1556  const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
1557  getSignedRange(Step).getSignedMin());
1561  AR->getPostIncExpr(*this), N))) {
1562  // Cache knowledge of AR NW, which is propagated to this AddRec.
1563  // Negative step causes unsigned wrap, but it still can't self-wrap.
1564  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1565  // Return the expression with the addrec on the outside.
1566  return getAddRecExpr(
1567  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1568  getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1569  }
1570  }
1571  }
1572 
1573  if (proveNoWrapByVaryingStart<SCEVZeroExtendExpr>(Start, Step, L)) {
1574  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
1575  return getAddRecExpr(
1576  getExtendAddRecStart<SCEVZeroExtendExpr>(AR, Ty, this),
1577  getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1578  }
1579  }
1580 
1581  // The cast wasn't folded; create an explicit cast node.
1582  // Recompute the insert position, as it may have been invalidated.
1583  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1584  SCEV *S = new (SCEVAllocator) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
1585  Op, Ty);
1586  UniqueSCEVs.InsertNode(S, IP);
1587  return S;
1588 }
1589 
1591  Type *Ty) {
1592  assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1593  "This is not an extending conversion!");
1594  assert(isSCEVable(Ty) &&
1595  "This is not a conversion to a SCEVable type!");
1596  Ty = getEffectiveSCEVType(Ty);
1597 
1598  // Fold if the operand is constant.
1599  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1600  return getConstant(
1601  cast<ConstantInt>(ConstantExpr::getSExt(SC->getValue(), Ty)));
1602 
1603  // sext(sext(x)) --> sext(x)
1604  if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
1605  return getSignExtendExpr(SS->getOperand(), Ty);
1606 
1607  // sext(zext(x)) --> zext(x)
1608  if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
1609  return getZeroExtendExpr(SZ->getOperand(), Ty);
1610 
1611  // Before doing any expensive analysis, check to see if we've already
1612  // computed a SCEV for this Op and Ty.
1615  ID.AddPointer(Op);
1616  ID.AddPointer(Ty);
1617  void *IP = nullptr;
1618  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1619 
1620  // If the input value is provably positive, build a zext instead.
1621  if (isKnownNonNegative(Op))
1622  return getZeroExtendExpr(Op, Ty);
1623 
1624  // sext(trunc(x)) --> sext(x) or x or trunc(x)
1625  if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
1626  // It's possible the bits taken off by the truncate were all sign bits. If
1627  // so, we should be able to simplify this further.
1628  const SCEV *X = ST->getOperand();
1629  ConstantRange CR = getSignedRange(X);
1630  unsigned TruncBits = getTypeSizeInBits(ST->getType());
1631  unsigned NewBits = getTypeSizeInBits(Ty);
1632  if (CR.truncate(TruncBits).signExtend(NewBits).contains(
1633  CR.sextOrTrunc(NewBits)))
1634  return getTruncateOrSignExtend(X, Ty);
1635  }
1636 
1637  // sext(C1 + (C2 * x)) --> C1 + sext(C2 * x) if C1 < C2
1638  if (auto SA = dyn_cast<SCEVAddExpr>(Op)) {
1639  if (SA->getNumOperands() == 2) {
1640  auto SC1 = dyn_cast<SCEVConstant>(SA->getOperand(0));
1641  auto SMul = dyn_cast<SCEVMulExpr>(SA->getOperand(1));
1642  if (SMul && SC1) {
1643  if (auto SC2 = dyn_cast<SCEVConstant>(SMul->getOperand(0))) {
1644  const APInt &C1 = SC1->getValue()->getValue();
1645  const APInt &C2 = SC2->getValue()->getValue();
1646  if (C1.isStrictlyPositive() && C2.isStrictlyPositive() &&
1647  C2.ugt(C1) && C2.isPowerOf2())
1648  return getAddExpr(getSignExtendExpr(SC1, Ty),
1649  getSignExtendExpr(SMul, Ty));
1650  }
1651  }
1652  }
1653  }
1654  // If the input value is a chrec scev, and we can prove that the value
1655  // did not overflow the old, smaller, value, we can sign extend all of the
1656  // operands (often constants). This allows analysis of something like
1657  // this: for (signed char X = 0; X < 100; ++X) { int Y = X; }
1658  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
1659  if (AR->isAffine()) {
1660  const SCEV *Start = AR->getStart();
1661  const SCEV *Step = AR->getStepRecurrence(*this);
1662  unsigned BitWidth = getTypeSizeInBits(AR->getType());
1663  const Loop *L = AR->getLoop();
1664 
1665  // If we have special knowledge that this addrec won't overflow,
1666  // we don't need to do any further analysis.
1667  if (AR->getNoWrapFlags(SCEV::FlagNSW))
1668  return getAddRecExpr(
1669  getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1670  getSignExtendExpr(Step, Ty), L, SCEV::FlagNSW);
1671 
1672  // Check whether the backedge-taken count is SCEVCouldNotCompute.
1673  // Note that this serves two purposes: It filters out loops that are
1674  // simply not analyzable, and it covers the case where this code is
1675  // being called from within backedge-taken count analysis, such that
1676  // attempting to ask for the backedge-taken count would likely result
1677  // in infinite recursion. In the later case, the analysis code will
1678  // cope with a conservative value, and it will take care to purge
1679  // that value once it has finished.
1680  const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
1681  if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
1682  // Manually compute the final value for AR, checking for
1683  // overflow.
1684 
1685  // Check whether the backedge-taken count can be losslessly casted to
1686  // the addrec's type. The count is always unsigned.
1687  const SCEV *CastedMaxBECount =
1688  getTruncateOrZeroExtend(MaxBECount, Start->getType());
1689  const SCEV *RecastedMaxBECount =
1690  getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
1691  if (MaxBECount == RecastedMaxBECount) {
1692  Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1693  // Check whether Start+Step*MaxBECount has no signed overflow.
1694  const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
1695  const SCEV *SAdd = getSignExtendExpr(getAddExpr(Start, SMul), WideTy);
1696  const SCEV *WideStart = getSignExtendExpr(Start, WideTy);
1697  const SCEV *WideMaxBECount =
1698  getZeroExtendExpr(CastedMaxBECount, WideTy);
1699  const SCEV *OperandExtendedAdd =
1700  getAddExpr(WideStart,
1701  getMulExpr(WideMaxBECount,
1702  getSignExtendExpr(Step, WideTy)));
1703  if (SAdd == OperandExtendedAdd) {
1704  // Cache knowledge of AR NSW, which is propagated to this AddRec.
1705  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1706  // Return the expression with the addrec on the outside.
1707  return getAddRecExpr(
1708  getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1709  getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1710  }
1711  // Similar to above, only this time treat the step value as unsigned.
1712  // This covers loops that count up with an unsigned step.
1713  OperandExtendedAdd =
1714  getAddExpr(WideStart,
1715  getMulExpr(WideMaxBECount,
1716  getZeroExtendExpr(Step, WideTy)));
1717  if (SAdd == OperandExtendedAdd) {
1718  // If AR wraps around then
1719  //
1720  // abs(Step) * MaxBECount > unsigned-max(AR->getType())
1721  // => SAdd != OperandExtendedAdd
1722  //
1723  // Thus (AR is not NW => SAdd != OperandExtendedAdd) <=>
1724  // (SAdd == OperandExtendedAdd => AR is NW)
1725 
1726  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
1727 
1728  // Return the expression with the addrec on the outside.
1729  return getAddRecExpr(
1730  getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1731  getZeroExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1732  }
1733  }
1734 
1735  // If the backedge is guarded by a comparison with the pre-inc value
1736  // the addrec is safe. Also, if the entry is guarded by a comparison
1737  // with the start value and the backedge is guarded by a comparison
1738  // with the post-inc value, the addrec is safe.
1739  ICmpInst::Predicate Pred;
1740  const SCEV *OverflowLimit =
1741  getSignedOverflowLimitForStep(Step, &Pred, this);
1742  if (OverflowLimit &&
1743  (isLoopBackedgeGuardedByCond(L, Pred, AR, OverflowLimit) ||
1744  (isLoopEntryGuardedByCond(L, Pred, Start, OverflowLimit) &&
1745  isLoopBackedgeGuardedByCond(L, Pred, AR->getPostIncExpr(*this),
1746  OverflowLimit)))) {
1747  // Cache knowledge of AR NSW, then propagate NSW to the wide AddRec.
1748  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1749  return getAddRecExpr(
1750  getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1751  getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1752  }
1753  }
1754  // If Start and Step are constants, check if we can apply this
1755  // transformation:
1756  // sext{C1,+,C2} --> C1 + sext{0,+,C2} if C1 < C2
1757  auto SC1 = dyn_cast<SCEVConstant>(Start);
1758  auto SC2 = dyn_cast<SCEVConstant>(Step);
1759  if (SC1 && SC2) {
1760  const APInt &C1 = SC1->getValue()->getValue();
1761  const APInt &C2 = SC2->getValue()->getValue();
1762  if (C1.isStrictlyPositive() && C2.isStrictlyPositive() && C2.ugt(C1) &&
1763  C2.isPowerOf2()) {
1764  Start = getSignExtendExpr(Start, Ty);
1765  const SCEV *NewAR = getAddRecExpr(getConstant(AR->getType(), 0), Step,
1766  L, AR->getNoWrapFlags());
1767  return getAddExpr(Start, getSignExtendExpr(NewAR, Ty));
1768  }
1769  }
1770 
1771  if (proveNoWrapByVaryingStart<SCEVSignExtendExpr>(Start, Step, L)) {
1772  const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
1773  return getAddRecExpr(
1774  getExtendAddRecStart<SCEVSignExtendExpr>(AR, Ty, this),
1775  getSignExtendExpr(Step, Ty), L, AR->getNoWrapFlags());
1776  }
1777  }
1778 
1779  // The cast wasn't folded; create an explicit cast node.
1780  // Recompute the insert position, as it may have been invalidated.
1781  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
1782  SCEV *S = new (SCEVAllocator) SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
1783  Op, Ty);
1784  UniqueSCEVs.InsertNode(S, IP);
1785  return S;
1786 }
1787 
1788 /// getAnyExtendExpr - Return a SCEV for the given operand extended with
1789 /// unspecified bits out to the given type.
1790 ///
1792  Type *Ty) {
1793  assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
1794  "This is not an extending conversion!");
1795  assert(isSCEVable(Ty) &&
1796  "This is not a conversion to a SCEVable type!");
1797  Ty = getEffectiveSCEVType(Ty);
1798 
1799  // Sign-extend negative constants.
1800  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
1801  if (SC->getValue()->getValue().isNegative())
1802  return getSignExtendExpr(Op, Ty);
1803 
1804  // Peel off a truncate cast.
1805  if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Op)) {
1806  const SCEV *NewOp = T->getOperand();
1807  if (getTypeSizeInBits(NewOp->getType()) < getTypeSizeInBits(Ty))
1808  return getAnyExtendExpr(NewOp, Ty);
1809  return getTruncateOrNoop(NewOp, Ty);
1810  }
1811 
1812  // Next try a zext cast. If the cast is folded, use it.
1813  const SCEV *ZExt = getZeroExtendExpr(Op, Ty);
1814  if (!isa<SCEVZeroExtendExpr>(ZExt))
1815  return ZExt;
1816 
1817  // Next try a sext cast. If the cast is folded, use it.
1818  const SCEV *SExt = getSignExtendExpr(Op, Ty);
1819  if (!isa<SCEVSignExtendExpr>(SExt))
1820  return SExt;
1821 
1822  // Force the cast to be folded into the operands of an addrec.
1823  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op)) {
1825  for (const SCEV *Op : AR->operands())
1826  Ops.push_back(getAnyExtendExpr(Op, Ty));
1827  return getAddRecExpr(Ops, AR->getLoop(), SCEV::FlagNW);
1828  }
1829 
1830  // If the expression is obviously signed, use the sext cast value.
1831  if (isa<SCEVSMaxExpr>(Op))
1832  return SExt;
1833 
1834  // Absent any other information, use the zext cast value.
1835  return ZExt;
1836 }
1837 
1838 /// CollectAddOperandsWithScales - Process the given Ops list, which is
1839 /// a list of operands to be added under the given scale, update the given
1840 /// map. This is a helper function for getAddRecExpr. As an example of
1841 /// what it does, given a sequence of operands that would form an add
1842 /// expression like this:
1843 ///
1844 /// m + n + 13 + (A * (o + p + (B * (q + m + 29)))) + r + (-1 * r)
1845 ///
1846 /// where A and B are constants, update the map with these values:
1847 ///
1848 /// (m, 1+A*B), (n, 1), (o, A), (p, A), (q, A*B), (r, 0)
1849 ///
1850 /// and add 13 + A*B*29 to AccumulatedConstant.
1851 /// This will allow getAddRecExpr to produce this:
1852 ///
1853 /// 13+A*B*29 + n + (m * (1+A*B)) + ((o + p) * A) + (q * A*B)
1854 ///
1855 /// This form often exposes folding opportunities that are hidden in
1856 /// the original operand list.
1857 ///
1858 /// Return true iff it appears that any interesting folding opportunities
1859 /// may be exposed. This helps getAddRecExpr short-circuit extra work in
1860 /// the common case where no interesting opportunities are present, and
1861 /// is also used as a check to avoid infinite recursion.
1862 ///
1863 static bool
1866  APInt &AccumulatedConstant,
1867  const SCEV *const *Ops, size_t NumOperands,
1868  const APInt &Scale,
1869  ScalarEvolution &SE) {
1870  bool Interesting = false;
1871 
1872  // Iterate over the add operands. They are sorted, with constants first.
1873  unsigned i = 0;
1874  while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
1875  ++i;
1876  // Pull a buried constant out to the outside.
1877  if (Scale != 1 || AccumulatedConstant != 0 || C->getValue()->isZero())
1878  Interesting = true;
1879  AccumulatedConstant += Scale * C->getValue()->getValue();
1880  }
1881 
1882  // Next comes everything else. We're especially interested in multiplies
1883  // here, but they're in the middle, so just visit the rest with one loop.
1884  for (; i != NumOperands; ++i) {
1885  const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[i]);
1886  if (Mul && isa<SCEVConstant>(Mul->getOperand(0))) {
1887  APInt NewScale =
1888  Scale * cast<SCEVConstant>(Mul->getOperand(0))->getValue()->getValue();
1889  if (Mul->getNumOperands() == 2 && isa<SCEVAddExpr>(Mul->getOperand(1))) {
1890  // A multiplication of a constant with another add; recurse.
1891  const SCEVAddExpr *Add = cast<SCEVAddExpr>(Mul->getOperand(1));
1892  Interesting |=
1893  CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
1894  Add->op_begin(), Add->getNumOperands(),
1895  NewScale, SE);
1896  } else {
1897  // A multiplication of a constant with some other value. Update
1898  // the map.
1899  SmallVector<const SCEV *, 4> MulOps(Mul->op_begin()+1, Mul->op_end());
1900  const SCEV *Key = SE.getMulExpr(MulOps);
1901  std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
1902  M.insert(std::make_pair(Key, NewScale));
1903  if (Pair.second) {
1904  NewOps.push_back(Pair.first->first);
1905  } else {
1906  Pair.first->second += NewScale;
1907  // The map already had an entry for this value, which may indicate
1908  // a folding opportunity.
1909  Interesting = true;
1910  }
1911  }
1912  } else {
1913  // An ordinary operand. Update the map.
1914  std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
1915  M.insert(std::make_pair(Ops[i], Scale));
1916  if (Pair.second) {
1917  NewOps.push_back(Pair.first->first);
1918  } else {
1919  Pair.first->second += Scale;
1920  // The map already had an entry for this value, which may indicate
1921  // a folding opportunity.
1922  Interesting = true;
1923  }
1924  }
1925  }
1926 
1927  return Interesting;
1928 }
1929 
1930 namespace {
1931  struct APIntCompare {
1932  bool operator()(const APInt &LHS, const APInt &RHS) const {
1933  return LHS.ult(RHS);
1934  }
1935  };
1936 }
1937 
1938 // We're trying to construct a SCEV of type `Type' with `Ops' as operands and
1939 // `OldFlags' as can't-wrap behavior. Infer a more aggressive set of
1940 // can't-overflow flags for the operation if possible.
1941 static SCEV::NoWrapFlags
1942 StrengthenNoWrapFlags(ScalarEvolution *SE, SCEVTypes Type,
1943  const SmallVectorImpl<const SCEV *> &Ops,
1944  SCEV::NoWrapFlags OldFlags) {
1945  using namespace std::placeholders;
1946 
1947  bool CanAnalyze =
1948  Type == scAddExpr || Type == scAddRecExpr || Type == scMulExpr;
1949  (void)CanAnalyze;
1950  assert(CanAnalyze && "don't call from other places!");
1951 
1952  int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
1953  SCEV::NoWrapFlags SignOrUnsignWrap =
1954  ScalarEvolution::maskFlags(OldFlags, SignOrUnsignMask);
1955 
1956  // If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
1957  auto IsKnownNonNegative =
1958  std::bind(std::mem_fn(&ScalarEvolution::isKnownNonNegative), SE, _1);
1959 
1960  if (SignOrUnsignWrap == SCEV::FlagNSW &&
1961  std::all_of(Ops.begin(), Ops.end(), IsKnownNonNegative))
1962  return ScalarEvolution::setFlags(OldFlags,
1963  (SCEV::NoWrapFlags)SignOrUnsignMask);
1964 
1965  return OldFlags;
1966 }
1967 
1968 /// getAddExpr - Get a canonical add expression, or something simpler if
1969 /// possible.
1972  assert(!(Flags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
1973  "only nuw or nsw allowed");
1974  assert(!Ops.empty() && "Cannot get empty add!");
1975  if (Ops.size() == 1) return Ops[0];
1976 #ifndef NDEBUG
1977  Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
1978  for (unsigned i = 1, e = Ops.size(); i != e; ++i)
1979  assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
1980  "SCEVAddExpr operand types don't match!");
1981 #endif
1982 
1983  Flags = StrengthenNoWrapFlags(this, scAddExpr, Ops, Flags);
1984 
1985  // Sort by complexity, this groups all similar expression types together.
1986  GroupByComplexity(Ops, LI);
1987 
1988  // If there are any constants, fold them together.
1989  unsigned Idx = 0;
1990  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
1991  ++Idx;
1992  assert(Idx < Ops.size());
1993  while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
1994  // We found two constants, fold them together!
1995  Ops[0] = getConstant(LHSC->getValue()->getValue() +
1996  RHSC->getValue()->getValue());
1997  if (Ops.size() == 2) return Ops[0];
1998  Ops.erase(Ops.begin()+1); // Erase the folded element
1999  LHSC = cast<SCEVConstant>(Ops[0]);
2000  }
2001 
2002  // If we are left with a constant zero being added, strip it off.
2003  if (LHSC->getValue()->isZero()) {
2004  Ops.erase(Ops.begin());
2005  --Idx;
2006  }
2007 
2008  if (Ops.size() == 1) return Ops[0];
2009  }
2010 
2011  // Okay, check to see if the same value occurs in the operand list more than
2012  // once. If so, merge them together into an multiply expression. Since we
2013  // sorted the list, these values are required to be adjacent.
2014  Type *Ty = Ops[0]->getType();
2015  bool FoundMatch = false;
2016  for (unsigned i = 0, e = Ops.size(); i != e-1; ++i)
2017  if (Ops[i] == Ops[i+1]) { // X + Y + Y --> X + Y*2
2018  // Scan ahead to count how many equal operands there are.
2019  unsigned Count = 2;
2020  while (i+Count != e && Ops[i+Count] == Ops[i])
2021  ++Count;
2022  // Merge the values into a multiply.
2023  const SCEV *Scale = getConstant(Ty, Count);
2024  const SCEV *Mul = getMulExpr(Scale, Ops[i]);
2025  if (Ops.size() == Count)
2026  return Mul;
2027  Ops[i] = Mul;
2028  Ops.erase(Ops.begin()+i+1, Ops.begin()+i+Count);
2029  --i; e -= Count - 1;
2030  FoundMatch = true;
2031  }
2032  if (FoundMatch)
2033  return getAddExpr(Ops, Flags);
2034 
2035  // Check for truncates. If all the operands are truncated from the same
2036  // type, see if factoring out the truncate would permit the result to be
2037  // folded. eg., trunc(x) + m*trunc(n) --> trunc(x + trunc(m)*n)
2038  // if the contents of the resulting outer trunc fold to something simple.
2039  for (; Idx < Ops.size() && isa<SCEVTruncateExpr>(Ops[Idx]); ++Idx) {
2040  const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(Ops[Idx]);
2041  Type *DstType = Trunc->getType();
2042  Type *SrcType = Trunc->getOperand()->getType();
2044  bool Ok = true;
2045  // Check all the operands to see if they can be represented in the
2046  // source type of the truncate.
2047  for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
2048  if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Ops[i])) {
2049  if (T->getOperand()->getType() != SrcType) {
2050  Ok = false;
2051  break;
2052  }
2053  LargeOps.push_back(T->getOperand());
2054  } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
2055  LargeOps.push_back(getAnyExtendExpr(C, SrcType));
2056  } else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Ops[i])) {
2057  SmallVector<const SCEV *, 8> LargeMulOps;
2058  for (unsigned j = 0, f = M->getNumOperands(); j != f && Ok; ++j) {
2059  if (const SCEVTruncateExpr *T =
2060  dyn_cast<SCEVTruncateExpr>(M->getOperand(j))) {
2061  if (T->getOperand()->getType() != SrcType) {
2062  Ok = false;
2063  break;
2064  }
2065  LargeMulOps.push_back(T->getOperand());
2066  } else if (const SCEVConstant *C =
2067  dyn_cast<SCEVConstant>(M->getOperand(j))) {
2068  LargeMulOps.push_back(getAnyExtendExpr(C, SrcType));
2069  } else {
2070  Ok = false;
2071  break;
2072  }
2073  }
2074  if (Ok)
2075  LargeOps.push_back(getMulExpr(LargeMulOps));
2076  } else {
2077  Ok = false;
2078  break;
2079  }
2080  }
2081  if (Ok) {
2082  // Evaluate the expression in the larger type.
2083  const SCEV *Fold = getAddExpr(LargeOps, Flags);
2084  // If it folds to something simple, use it. Otherwise, don't.
2085  if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
2086  return getTruncateExpr(Fold, DstType);
2087  }
2088  }
2089 
2090  // Skip past any other cast SCEVs.
2091  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
2092  ++Idx;
2093 
2094  // If there are add operands they would be next.
2095  if (Idx < Ops.size()) {
2096  bool DeletedAdd = false;
2097  while (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[Idx])) {
2098  // If we have an add, expand the add operands onto the end of the operands
2099  // list.
2100  Ops.erase(Ops.begin()+Idx);
2101  Ops.append(Add->op_begin(), Add->op_end());
2102  DeletedAdd = true;
2103  }
2104 
2105  // If we deleted at least one add, we added operands to the end of the list,
2106  // and they are not necessarily sorted. Recurse to resort and resimplify
2107  // any operands we just acquired.
2108  if (DeletedAdd)
2109  return getAddExpr(Ops);
2110  }
2111 
2112  // Skip over the add expression until we get to a multiply.
2113  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
2114  ++Idx;
2115 
2116  // Check to see if there are any folding opportunities present with
2117  // operands multiplied by constant values.
2118  if (Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx])) {
2119  uint64_t BitWidth = getTypeSizeInBits(Ty);
2122  APInt AccumulatedConstant(BitWidth, 0);
2123  if (CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
2124  Ops.data(), Ops.size(),
2125  APInt(BitWidth, 1), *this)) {
2126  // Some interesting folding opportunity is present, so its worthwhile to
2127  // re-generate the operands list. Group the operands by constant scale,
2128  // to avoid multiplying by the same constant scale multiple times.
2129  std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare> MulOpLists;
2131  E = NewOps.end(); I != E; ++I)
2132  MulOpLists[M.find(*I)->second].push_back(*I);
2133  // Re-generate the operands list.
2134  Ops.clear();
2135  if (AccumulatedConstant != 0)
2136  Ops.push_back(getConstant(AccumulatedConstant));
2137  for (std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare>::iterator
2138  I = MulOpLists.begin(), E = MulOpLists.end(); I != E; ++I)
2139  if (I->first != 0)
2140  Ops.push_back(getMulExpr(getConstant(I->first),
2141  getAddExpr(I->second)));
2142  if (Ops.empty())
2143  return getConstant(Ty, 0);
2144  if (Ops.size() == 1)
2145  return Ops[0];
2146  return getAddExpr(Ops);
2147  }
2148  }
2149 
2150  // If we are adding something to a multiply expression, make sure the
2151  // something is not already an operand of the multiply. If so, merge it into
2152  // the multiply.
2153  for (; Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx]); ++Idx) {
2154  const SCEVMulExpr *Mul = cast<SCEVMulExpr>(Ops[Idx]);
2155  for (unsigned MulOp = 0, e = Mul->getNumOperands(); MulOp != e; ++MulOp) {
2156  const SCEV *MulOpSCEV = Mul->getOperand(MulOp);
2157  if (isa<SCEVConstant>(MulOpSCEV))
2158  continue;
2159  for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
2160  if (MulOpSCEV == Ops[AddOp]) {
2161  // Fold W + X + (X * Y * Z) --> W + (X * ((Y*Z)+1))
2162  const SCEV *InnerMul = Mul->getOperand(MulOp == 0);
2163  if (Mul->getNumOperands() != 2) {
2164  // If the multiply has more than two operands, we must get the
2165  // Y*Z term.
2166  SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
2167  Mul->op_begin()+MulOp);
2168  MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
2169  InnerMul = getMulExpr(MulOps);
2170  }
2171  const SCEV *One = getConstant(Ty, 1);
2172  const SCEV *AddOne = getAddExpr(One, InnerMul);
2173  const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
2174  if (Ops.size() == 2) return OuterMul;
2175  if (AddOp < Idx) {
2176  Ops.erase(Ops.begin()+AddOp);
2177  Ops.erase(Ops.begin()+Idx-1);
2178  } else {
2179  Ops.erase(Ops.begin()+Idx);
2180  Ops.erase(Ops.begin()+AddOp-1);
2181  }
2182  Ops.push_back(OuterMul);
2183  return getAddExpr(Ops);
2184  }
2185 
2186  // Check this multiply against other multiplies being added together.
2187  for (unsigned OtherMulIdx = Idx+1;
2188  OtherMulIdx < Ops.size() && isa<SCEVMulExpr>(Ops[OtherMulIdx]);
2189  ++OtherMulIdx) {
2190  const SCEVMulExpr *OtherMul = cast<SCEVMulExpr>(Ops[OtherMulIdx]);
2191  // If MulOp occurs in OtherMul, we can fold the two multiplies
2192  // together.
2193  for (unsigned OMulOp = 0, e = OtherMul->getNumOperands();
2194  OMulOp != e; ++OMulOp)
2195  if (OtherMul->getOperand(OMulOp) == MulOpSCEV) {
2196  // Fold X + (A*B*C) + (A*D*E) --> X + (A*(B*C+D*E))
2197  const SCEV *InnerMul1 = Mul->getOperand(MulOp == 0);
2198  if (Mul->getNumOperands() != 2) {
2199  SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
2200  Mul->op_begin()+MulOp);
2201  MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
2202  InnerMul1 = getMulExpr(MulOps);
2203  }
2204  const SCEV *InnerMul2 = OtherMul->getOperand(OMulOp == 0);
2205  if (OtherMul->getNumOperands() != 2) {
2206  SmallVector<const SCEV *, 4> MulOps(OtherMul->op_begin(),
2207  OtherMul->op_begin()+OMulOp);
2208  MulOps.append(OtherMul->op_begin()+OMulOp+1, OtherMul->op_end());
2209  InnerMul2 = getMulExpr(MulOps);
2210  }
2211  const SCEV *InnerMulSum = getAddExpr(InnerMul1,InnerMul2);
2212  const SCEV *OuterMul = getMulExpr(MulOpSCEV, InnerMulSum);
2213  if (Ops.size() == 2) return OuterMul;
2214  Ops.erase(Ops.begin()+Idx);
2215  Ops.erase(Ops.begin()+OtherMulIdx-1);
2216  Ops.push_back(OuterMul);
2217  return getAddExpr(Ops);
2218  }
2219  }
2220  }
2221  }
2222 
2223  // If there are any add recurrences in the operands list, see if any other
2224  // added values are loop invariant. If so, we can fold them into the
2225  // recurrence.
2226  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
2227  ++Idx;
2228 
2229  // Scan over all recurrences, trying to fold loop invariants into them.
2230  for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
2231  // Scan all of the other operands to this add and add them to the vector if
2232  // they are loop invariant w.r.t. the recurrence.
2234  const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
2235  const Loop *AddRecLoop = AddRec->getLoop();
2236  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2237  if (isLoopInvariant(Ops[i], AddRecLoop)) {
2238  LIOps.push_back(Ops[i]);
2239  Ops.erase(Ops.begin()+i);
2240  --i; --e;
2241  }
2242 
2243  // If we found some loop invariants, fold them into the recurrence.
2244  if (!LIOps.empty()) {
2245  // NLI + LI + {Start,+,Step} --> NLI + {LI+Start,+,Step}
2246  LIOps.push_back(AddRec->getStart());
2247 
2248  SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
2249  AddRec->op_end());
2250  AddRecOps[0] = getAddExpr(LIOps);
2251 
2252  // Build the new addrec. Propagate the NUW and NSW flags if both the
2253  // outer add and the inner addrec are guaranteed to have no overflow.
2254  // Always propagate NW.
2255  Flags = AddRec->getNoWrapFlags(setFlags(Flags, SCEV::FlagNW));
2256  const SCEV *NewRec = getAddRecExpr(AddRecOps, AddRecLoop, Flags);
2257 
2258  // If all of the other operands were loop invariant, we are done.
2259  if (Ops.size() == 1) return NewRec;
2260 
2261  // Otherwise, add the folded AddRec by the non-invariant parts.
2262  for (unsigned i = 0;; ++i)
2263  if (Ops[i] == AddRec) {
2264  Ops[i] = NewRec;
2265  break;
2266  }
2267  return getAddExpr(Ops);
2268  }
2269 
2270  // Okay, if there weren't any loop invariants to be folded, check to see if
2271  // there are multiple AddRec's with the same loop induction variable being
2272  // added together. If so, we can fold them.
2273  for (unsigned OtherIdx = Idx+1;
2274  OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2275  ++OtherIdx)
2276  if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
2277  // Other + {A,+,B}<L> + {C,+,D}<L> --> Other + {A+C,+,B+D}<L>
2278  SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
2279  AddRec->op_end());
2280  for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2281  ++OtherIdx)
2282  if (const SCEVAddRecExpr *OtherAddRec =
2283  dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
2284  if (OtherAddRec->getLoop() == AddRecLoop) {
2285  for (unsigned i = 0, e = OtherAddRec->getNumOperands();
2286  i != e; ++i) {
2287  if (i >= AddRecOps.size()) {
2288  AddRecOps.append(OtherAddRec->op_begin()+i,
2289  OtherAddRec->op_end());
2290  break;
2291  }
2292  AddRecOps[i] = getAddExpr(AddRecOps[i],
2293  OtherAddRec->getOperand(i));
2294  }
2295  Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
2296  }
2297  // Step size has changed, so we cannot guarantee no self-wraparound.
2298  Ops[Idx] = getAddRecExpr(AddRecOps, AddRecLoop, SCEV::FlagAnyWrap);
2299  return getAddExpr(Ops);
2300  }
2301 
2302  // Otherwise couldn't fold anything into this recurrence. Move onto the
2303  // next one.
2304  }
2305 
2306  // Okay, it looks like we really DO need an add expr. Check to see if we
2307  // already have one, otherwise create a new one.
2309  ID.AddInteger(scAddExpr);
2310  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2311  ID.AddPointer(Ops[i]);
2312  void *IP = nullptr;
2313  SCEVAddExpr *S =
2314  static_cast<SCEVAddExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2315  if (!S) {
2316  const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2317  std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2318  S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
2319  O, Ops.size());
2320  UniqueSCEVs.InsertNode(S, IP);
2321  }
2322  S->setNoWrapFlags(Flags);
2323  return S;
2324 }
2325 
2326 static uint64_t umul_ov(uint64_t i, uint64_t j, bool &Overflow) {
2327  uint64_t k = i*j;
2328  if (j > 1 && k / j != i) Overflow = true;
2329  return k;
2330 }
2331 
2332 /// Compute the result of "n choose k", the binomial coefficient. If an
2333 /// intermediate computation overflows, Overflow will be set and the return will
2334 /// be garbage. Overflow is not cleared on absence of overflow.
2335 static uint64_t Choose(uint64_t n, uint64_t k, bool &Overflow) {
2336  // We use the multiplicative formula:
2337  // n(n-1)(n-2)...(n-(k-1)) / k(k-1)(k-2)...1 .
2338  // At each iteration, we take the n-th term of the numeral and divide by the
2339  // (k-n)th term of the denominator. This division will always produce an
2340  // integral result, and helps reduce the chance of overflow in the
2341  // intermediate computations. However, we can still overflow even when the
2342  // final result would fit.
2343 
2344  if (n == 0 || n == k) return 1;
2345  if (k > n) return 0;
2346 
2347  if (k > n/2)
2348  k = n-k;
2349 
2350  uint64_t r = 1;
2351  for (uint64_t i = 1; i <= k; ++i) {
2352  r = umul_ov(r, n-(i-1), Overflow);
2353  r /= i;
2354  }
2355  return r;
2356 }
2357 
2358 /// Determine if any of the operands in this SCEV are a constant or if
2359 /// any of the add or multiply expressions in this SCEV contain a constant.
2360 static bool containsConstantSomewhere(const SCEV *StartExpr) {
2362  Ops.push_back(StartExpr);
2363  while (!Ops.empty()) {
2364  const SCEV *CurrentExpr = Ops.pop_back_val();
2365  if (isa<SCEVConstant>(*CurrentExpr))
2366  return true;
2367 
2368  if (isa<SCEVAddExpr>(*CurrentExpr) || isa<SCEVMulExpr>(*CurrentExpr)) {
2369  const auto *CurrentNAry = cast<SCEVNAryExpr>(CurrentExpr);
2370  Ops.append(CurrentNAry->op_begin(), CurrentNAry->op_end());
2371  }
2372  }
2373  return false;
2374 }
2375 
2376 /// getMulExpr - Get a canonical multiply expression, or something simpler if
2377 /// possible.
2380  assert(Flags == maskFlags(Flags, SCEV::FlagNUW | SCEV::FlagNSW) &&
2381  "only nuw or nsw allowed");
2382  assert(!Ops.empty() && "Cannot get empty mul!");
2383  if (Ops.size() == 1) return Ops[0];
2384 #ifndef NDEBUG
2385  Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2386  for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2387  assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2388  "SCEVMulExpr operand types don't match!");
2389 #endif
2390 
2391  Flags = StrengthenNoWrapFlags(this, scMulExpr, Ops, Flags);
2392 
2393  // Sort by complexity, this groups all similar expression types together.
2394  GroupByComplexity(Ops, LI);
2395 
2396  // If there are any constants, fold them together.
2397  unsigned Idx = 0;
2398  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
2399 
2400  // C1*(C2+V) -> C1*C2 + C1*V
2401  if (Ops.size() == 2)
2402  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1]))
2403  // If any of Add's ops are Adds or Muls with a constant,
2404  // apply this transformation as well.
2405  if (Add->getNumOperands() == 2)
2406  if (containsConstantSomewhere(Add))
2407  return getAddExpr(getMulExpr(LHSC, Add->getOperand(0)),
2408  getMulExpr(LHSC, Add->getOperand(1)));
2409 
2410  ++Idx;
2411  while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
2412  // We found two constants, fold them together!
2414  LHSC->getValue()->getValue() *
2415  RHSC->getValue()->getValue());
2416  Ops[0] = getConstant(Fold);
2417  Ops.erase(Ops.begin()+1); // Erase the folded element
2418  if (Ops.size() == 1) return Ops[0];
2419  LHSC = cast<SCEVConstant>(Ops[0]);
2420  }
2421 
2422  // If we are left with a constant one being multiplied, strip it off.
2423  if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
2424  Ops.erase(Ops.begin());
2425  --Idx;
2426  } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
2427  // If we have a multiply of zero, it will always be zero.
2428  return Ops[0];
2429  } else if (Ops[0]->isAllOnesValue()) {
2430  // If we have a mul by -1 of an add, try distributing the -1 among the
2431  // add operands.
2432  if (Ops.size() == 2) {
2433  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1])) {
2435  bool AnyFolded = false;
2436  for (SCEVAddRecExpr::op_iterator I = Add->op_begin(),
2437  E = Add->op_end(); I != E; ++I) {
2438  const SCEV *Mul = getMulExpr(Ops[0], *I);
2439  if (!isa<SCEVMulExpr>(Mul)) AnyFolded = true;
2440  NewOps.push_back(Mul);
2441  }
2442  if (AnyFolded)
2443  return getAddExpr(NewOps);
2444  }
2445  else if (const SCEVAddRecExpr *
2446  AddRec = dyn_cast<SCEVAddRecExpr>(Ops[1])) {
2447  // Negation preserves a recurrence's no self-wrap property.
2449  for (SCEVAddRecExpr::op_iterator I = AddRec->op_begin(),
2450  E = AddRec->op_end(); I != E; ++I) {
2451  Operands.push_back(getMulExpr(Ops[0], *I));
2452  }
2453  return getAddRecExpr(Operands, AddRec->getLoop(),
2454  AddRec->getNoWrapFlags(SCEV::FlagNW));
2455  }
2456  }
2457  }
2458 
2459  if (Ops.size() == 1)
2460  return Ops[0];
2461  }
2462 
2463  // Skip over the add expression until we get to a multiply.
2464  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
2465  ++Idx;
2466 
2467  // If there are mul operands inline them all into this expression.
2468  if (Idx < Ops.size()) {
2469  bool DeletedMul = false;
2470  while (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[Idx])) {
2471  // If we have an mul, expand the mul operands onto the end of the operands
2472  // list.
2473  Ops.erase(Ops.begin()+Idx);
2474  Ops.append(Mul->op_begin(), Mul->op_end());
2475  DeletedMul = true;
2476  }
2477 
2478  // If we deleted at least one mul, we added operands to the end of the list,
2479  // and they are not necessarily sorted. Recurse to resort and resimplify
2480  // any operands we just acquired.
2481  if (DeletedMul)
2482  return getMulExpr(Ops);
2483  }
2484 
2485  // If there are any add recurrences in the operands list, see if any other
2486  // added values are loop invariant. If so, we can fold them into the
2487  // recurrence.
2488  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
2489  ++Idx;
2490 
2491  // Scan over all recurrences, trying to fold loop invariants into them.
2492  for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
2493  // Scan all of the other operands to this mul and add them to the vector if
2494  // they are loop invariant w.r.t. the recurrence.
2496  const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
2497  const Loop *AddRecLoop = AddRec->getLoop();
2498  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2499  if (isLoopInvariant(Ops[i], AddRecLoop)) {
2500  LIOps.push_back(Ops[i]);
2501  Ops.erase(Ops.begin()+i);
2502  --i; --e;
2503  }
2504 
2505  // If we found some loop invariants, fold them into the recurrence.
2506  if (!LIOps.empty()) {
2507  // NLI * LI * {Start,+,Step} --> NLI * {LI*Start,+,LI*Step}
2509  NewOps.reserve(AddRec->getNumOperands());
2510  const SCEV *Scale = getMulExpr(LIOps);
2511  for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
2512  NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i)));
2513 
2514  // Build the new addrec. Propagate the NUW and NSW flags if both the
2515  // outer mul and the inner addrec are guaranteed to have no overflow.
2516  //
2517  // No self-wrap cannot be guaranteed after changing the step size, but
2518  // will be inferred if either NUW or NSW is true.
2519  Flags = AddRec->getNoWrapFlags(clearFlags(Flags, SCEV::FlagNW));
2520  const SCEV *NewRec = getAddRecExpr(NewOps, AddRecLoop, Flags);
2521 
2522  // If all of the other operands were loop invariant, we are done.
2523  if (Ops.size() == 1) return NewRec;
2524 
2525  // Otherwise, multiply the folded AddRec by the non-invariant parts.
2526  for (unsigned i = 0;; ++i)
2527  if (Ops[i] == AddRec) {
2528  Ops[i] = NewRec;
2529  break;
2530  }
2531  return getMulExpr(Ops);
2532  }
2533 
2534  // Okay, if there weren't any loop invariants to be folded, check to see if
2535  // there are multiple AddRec's with the same loop induction variable being
2536  // multiplied together. If so, we can fold them.
2537 
2538  // {A1,+,A2,+,...,+,An}<L> * {B1,+,B2,+,...,+,Bn}<L>
2539  // = {x=1 in [ sum y=x..2x [ sum z=max(y-x, y-n)..min(x,n) [
2540  // choose(x, 2x)*choose(2x-y, x-z)*A_{y-z}*B_z
2541  // ]]],+,...up to x=2n}.
2542  // Note that the arguments to choose() are always integers with values
2543  // known at compile time, never SCEV objects.
2544  //
2545  // The implementation avoids pointless extra computations when the two
2546  // addrec's are of different length (mathematically, it's equivalent to
2547  // an infinite stream of zeros on the right).
2548  bool OpsModified = false;
2549  for (unsigned OtherIdx = Idx+1;
2550  OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
2551  ++OtherIdx) {
2552  const SCEVAddRecExpr *OtherAddRec =
2553  dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]);
2554  if (!OtherAddRec || OtherAddRec->getLoop() != AddRecLoop)
2555  continue;
2556 
2557  bool Overflow = false;
2558  Type *Ty = AddRec->getType();
2559  bool LargerThan64Bits = getTypeSizeInBits(Ty) > 64;
2560  SmallVector<const SCEV*, 7> AddRecOps;
2561  for (int x = 0, xe = AddRec->getNumOperands() +
2562  OtherAddRec->getNumOperands() - 1; x != xe && !Overflow; ++x) {
2563  const SCEV *Term = getConstant(Ty, 0);
2564  for (int y = x, ye = 2*x+1; y != ye && !Overflow; ++y) {
2565  uint64_t Coeff1 = Choose(x, 2*x - y, Overflow);
2566  for (int z = std::max(y-x, y-(int)AddRec->getNumOperands()+1),
2567  ze = std::min(x+1, (int)OtherAddRec->getNumOperands());
2568  z < ze && !Overflow; ++z) {
2569  uint64_t Coeff2 = Choose(2*x - y, x-z, Overflow);
2570  uint64_t Coeff;
2571  if (LargerThan64Bits)
2572  Coeff = umul_ov(Coeff1, Coeff2, Overflow);
2573  else
2574  Coeff = Coeff1*Coeff2;
2575  const SCEV *CoeffTerm = getConstant(Ty, Coeff);
2576  const SCEV *Term1 = AddRec->getOperand(y-z);
2577  const SCEV *Term2 = OtherAddRec->getOperand(z);
2578  Term = getAddExpr(Term, getMulExpr(CoeffTerm, Term1,Term2));
2579  }
2580  }
2581  AddRecOps.push_back(Term);
2582  }
2583  if (!Overflow) {
2584  const SCEV *NewAddRec = getAddRecExpr(AddRecOps, AddRec->getLoop(),
2586  if (Ops.size() == 2) return NewAddRec;
2587  Ops[Idx] = NewAddRec;
2588  Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
2589  OpsModified = true;
2590  AddRec = dyn_cast<SCEVAddRecExpr>(NewAddRec);
2591  if (!AddRec)
2592  break;
2593  }
2594  }
2595  if (OpsModified)
2596  return getMulExpr(Ops);
2597 
2598  // Otherwise couldn't fold anything into this recurrence. Move onto the
2599  // next one.
2600  }
2601 
2602  // Okay, it looks like we really DO need an mul expr. Check to see if we
2603  // already have one, otherwise create a new one.
2605  ID.AddInteger(scMulExpr);
2606  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
2607  ID.AddPointer(Ops[i]);
2608  void *IP = nullptr;
2609  SCEVMulExpr *S =
2610  static_cast<SCEVMulExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2611  if (!S) {
2612  const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
2613  std::uninitialized_copy(Ops.begin(), Ops.end(), O);
2614  S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
2615  O, Ops.size());
2616  UniqueSCEVs.InsertNode(S, IP);
2617  }
2618  S->setNoWrapFlags(Flags);
2619  return S;
2620 }
2621 
2622 /// getUDivExpr - Get a canonical unsigned division expression, or something
2623 /// simpler if possible.
2625  const SCEV *RHS) {
2626  assert(getEffectiveSCEVType(LHS->getType()) ==
2627  getEffectiveSCEVType(RHS->getType()) &&
2628  "SCEVUDivExpr operand types don't match!");
2629 
2630  if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
2631  if (RHSC->getValue()->equalsInt(1))
2632  return LHS; // X udiv 1 --> x
2633  // If the denominator is zero, the result of the udiv is undefined. Don't
2634  // try to analyze it, because the resolution chosen here may differ from
2635  // the resolution chosen in other parts of the compiler.
2636  if (!RHSC->getValue()->isZero()) {
2637  // Determine if the division can be folded into the operands of
2638  // its operands.
2639  // TODO: Generalize this to non-constants by using known-bits information.
2640  Type *Ty = LHS->getType();
2641  unsigned LZ = RHSC->getValue()->getValue().countLeadingZeros();
2642  unsigned MaxShiftAmt = getTypeSizeInBits(Ty) - LZ - 1;
2643  // For non-power-of-two values, effectively round the value up to the
2644  // nearest power of two.
2645  if (!RHSC->getValue()->getValue().isPowerOf2())
2646  ++MaxShiftAmt;
2647  IntegerType *ExtTy =
2648  IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
2649  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
2650  if (const SCEVConstant *Step =
2651  dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this))) {
2652  // {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
2653  const APInt &StepInt = Step->getValue()->getValue();
2654  const APInt &DivInt = RHSC->getValue()->getValue();
2655  if (!StepInt.urem(DivInt) &&
2656  getZeroExtendExpr(AR, ExtTy) ==
2657  getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
2658  getZeroExtendExpr(Step, ExtTy),
2659  AR->getLoop(), SCEV::FlagAnyWrap)) {
2661  for (unsigned i = 0, e = AR->getNumOperands(); i != e; ++i)
2662  Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
2663  return getAddRecExpr(Operands, AR->getLoop(),
2664  SCEV::FlagNW);
2665  }
2666  /// Get a canonical UDivExpr for a recurrence.
2667  /// {X,+,N}/C => {Y,+,N}/C where Y=X-(X%N). Safe when C%N=0.
2668  // We can currently only fold X%N if X is constant.
2669  const SCEVConstant *StartC = dyn_cast<SCEVConstant>(AR->getStart());
2670  if (StartC && !DivInt.urem(StepInt) &&
2671  getZeroExtendExpr(AR, ExtTy) ==
2672  getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
2673  getZeroExtendExpr(Step, ExtTy),
2674  AR->getLoop(), SCEV::FlagAnyWrap)) {
2675  const APInt &StartInt = StartC->getValue()->getValue();
2676  const APInt &StartRem = StartInt.urem(StepInt);
2677  if (StartRem != 0)
2678  LHS = getAddRecExpr(getConstant(StartInt - StartRem), Step,
2679  AR->getLoop(), SCEV::FlagNW);
2680  }
2681  }
2682  // (A*B)/C --> A*(B/C) if safe and B/C can be folded.
2683  if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
2685  for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i)
2686  Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
2687  if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
2688  // Find an operand that's safely divisible.
2689  for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
2690  const SCEV *Op = M->getOperand(i);
2691  const SCEV *Div = getUDivExpr(Op, RHSC);
2692  if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
2693  Operands = SmallVector<const SCEV *, 4>(M->op_begin(),
2694  M->op_end());
2695  Operands[i] = Div;
2696  return getMulExpr(Operands);
2697  }
2698  }
2699  }
2700  // (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
2701  if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(LHS)) {
2703  for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i)
2704  Operands.push_back(getZeroExtendExpr(A->getOperand(i), ExtTy));
2705  if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
2706  Operands.clear();
2707  for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
2708  const SCEV *Op = getUDivExpr(A->getOperand(i), RHS);
2709  if (isa<SCEVUDivExpr>(Op) ||
2710  getMulExpr(Op, RHS) != A->getOperand(i))
2711  break;
2712  Operands.push_back(Op);
2713  }
2714  if (Operands.size() == A->getNumOperands())
2715  return getAddExpr(Operands);
2716  }
2717  }
2718 
2719  // Fold if both operands are constant.
2720  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
2721  Constant *LHSCV = LHSC->getValue();
2722  Constant *RHSCV = RHSC->getValue();
2723  return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
2724  RHSCV)));
2725  }
2726  }
2727  }
2728 
2730  ID.AddInteger(scUDivExpr);
2731  ID.AddPointer(LHS);
2732  ID.AddPointer(RHS);
2733  void *IP = nullptr;
2734  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
2735  SCEV *S = new (SCEVAllocator) SCEVUDivExpr(ID.Intern(SCEVAllocator),
2736  LHS, RHS);
2737  UniqueSCEVs.InsertNode(S, IP);
2738  return S;
2739 }
2740 
2741 static const APInt gcd(const SCEVConstant *C1, const SCEVConstant *C2) {
2742  APInt A = C1->getValue()->getValue().abs();
2743  APInt B = C2->getValue()->getValue().abs();
2744  uint32_t ABW = A.getBitWidth();
2745  uint32_t BBW = B.getBitWidth();
2746 
2747  if (ABW > BBW)
2748  B = B.zext(ABW);
2749  else if (ABW < BBW)
2750  A = A.zext(BBW);
2751 
2752  return APIntOps::GreatestCommonDivisor(A, B);
2753 }
2754 
2755 /// getUDivExactExpr - Get a canonical unsigned division expression, or
2756 /// something simpler if possible. There is no representation for an exact udiv
2757 /// in SCEV IR, but we can attempt to remove factors from the LHS and RHS.
2758 /// We can't do this when it's not exact because the udiv may be clearing bits.
2760  const SCEV *RHS) {
2761  // TODO: we could try to find factors in all sorts of things, but for now we
2762  // just deal with u/exact (multiply, constant). See SCEVDivision towards the
2763  // end of this file for inspiration.
2764 
2765  const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(LHS);
2766  if (!Mul)
2767  return getUDivExpr(LHS, RHS);
2768 
2769  if (const SCEVConstant *RHSCst = dyn_cast<SCEVConstant>(RHS)) {
2770  // If the mulexpr multiplies by a constant, then that constant must be the
2771  // first element of the mulexpr.
2772  if (const SCEVConstant *LHSCst =
2773  dyn_cast<SCEVConstant>(Mul->getOperand(0))) {
2774  if (LHSCst == RHSCst) {
2776  Operands.append(Mul->op_begin() + 1, Mul->op_end());
2777  return getMulExpr(Operands);
2778  }
2779 
2780  // We can't just assume that LHSCst divides RHSCst cleanly, it could be
2781  // that there's a factor provided by one of the other terms. We need to
2782  // check.
2783  APInt Factor = gcd(LHSCst, RHSCst);
2784  if (!Factor.isIntN(1)) {
2785  LHSCst = cast<SCEVConstant>(
2786  getConstant(LHSCst->getValue()->getValue().udiv(Factor)));
2787  RHSCst = cast<SCEVConstant>(
2788  getConstant(RHSCst->getValue()->getValue().udiv(Factor)));
2790  Operands.push_back(LHSCst);
2791  Operands.append(Mul->op_begin() + 1, Mul->op_end());
2792  LHS = getMulExpr(Operands);
2793  RHS = RHSCst;
2794  Mul = dyn_cast<SCEVMulExpr>(LHS);
2795  if (!Mul)
2796  return getUDivExactExpr(LHS, RHS);
2797  }
2798  }
2799  }
2800 
2801  for (int i = 0, e = Mul->getNumOperands(); i != e; ++i) {
2802  if (Mul->getOperand(i) == RHS) {
2804  Operands.append(Mul->op_begin(), Mul->op_begin() + i);
2805  Operands.append(Mul->op_begin() + i + 1, Mul->op_end());
2806  return getMulExpr(Operands);
2807  }
2808  }
2809 
2810  return getUDivExpr(LHS, RHS);
2811 }
2812 
2813 /// getAddRecExpr - Get an add recurrence expression for the specified loop.
2814 /// Simplify the expression as much as possible.
2815 const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start, const SCEV *Step,
2816  const Loop *L,
2819  Operands.push_back(Start);
2820  if (const SCEVAddRecExpr *StepChrec = dyn_cast<SCEVAddRecExpr>(Step))
2821  if (StepChrec->getLoop() == L) {
2822  Operands.append(StepChrec->op_begin(), StepChrec->op_end());
2823  return getAddRecExpr(Operands, L, maskFlags(Flags, SCEV::FlagNW));
2824  }
2825 
2826  Operands.push_back(Step);
2827  return getAddRecExpr(Operands, L, Flags);
2828 }
2829 
2830 /// getAddRecExpr - Get an add recurrence expression for the specified loop.
2831 /// Simplify the expression as much as possible.
2832 const SCEV *
2834  const Loop *L, SCEV::NoWrapFlags Flags) {
2835  if (Operands.size() == 1) return Operands[0];
2836 #ifndef NDEBUG
2837  Type *ETy = getEffectiveSCEVType(Operands[0]->getType());
2838  for (unsigned i = 1, e = Operands.size(); i != e; ++i)
2839  assert(getEffectiveSCEVType(Operands[i]->getType()) == ETy &&
2840  "SCEVAddRecExpr operand types don't match!");
2841  for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2842  assert(isLoopInvariant(Operands[i], L) &&
2843  "SCEVAddRecExpr operand is not loop-invariant!");
2844 #endif
2845 
2846  if (Operands.back()->isZero()) {
2847  Operands.pop_back();
2848  return getAddRecExpr(Operands, L, SCEV::FlagAnyWrap); // {X,+,0} --> X
2849  }
2850 
2851  // It's tempting to want to call getMaxBackedgeTakenCount count here and
2852  // use that information to infer NUW and NSW flags. However, computing a
2853  // BE count requires calling getAddRecExpr, so we may not yet have a
2854  // meaningful BE count at this point (and if we don't, we'd be stuck
2855  // with a SCEVCouldNotCompute as the cached BE count).
2856 
2857  Flags = StrengthenNoWrapFlags(this, scAddRecExpr, Operands, Flags);
2858 
2859  // Canonicalize nested AddRecs in by nesting them in order of loop depth.
2860  if (const SCEVAddRecExpr *NestedAR = dyn_cast<SCEVAddRecExpr>(Operands[0])) {
2861  const Loop *NestedLoop = NestedAR->getLoop();
2862  if (L->contains(NestedLoop) ?
2863  (L->getLoopDepth() < NestedLoop->getLoopDepth()) :
2864  (!NestedLoop->contains(L) &&
2865  DT->dominates(L->getHeader(), NestedLoop->getHeader()))) {
2866  SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
2867  NestedAR->op_end());
2868  Operands[0] = NestedAR->getStart();
2869  // AddRecs require their operands be loop-invariant with respect to their
2870  // loops. Don't perform this transformation if it would break this
2871  // requirement.
2872  bool AllInvariant = true;
2873  for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2874  if (!isLoopInvariant(Operands[i], L)) {
2875  AllInvariant = false;
2876  break;
2877  }
2878  if (AllInvariant) {
2879  // Create a recurrence for the outer loop with the same step size.
2880  //
2881  // The outer recurrence keeps its NW flag but only keeps NUW/NSW if the
2882  // inner recurrence has the same property.
2883  SCEV::NoWrapFlags OuterFlags =
2884  maskFlags(Flags, SCEV::FlagNW | NestedAR->getNoWrapFlags());
2885 
2886  NestedOperands[0] = getAddRecExpr(Operands, L, OuterFlags);
2887  AllInvariant = true;
2888  for (unsigned i = 0, e = NestedOperands.size(); i != e; ++i)
2889  if (!isLoopInvariant(NestedOperands[i], NestedLoop)) {
2890  AllInvariant = false;
2891  break;
2892  }
2893  if (AllInvariant) {
2894  // Ok, both add recurrences are valid after the transformation.
2895  //
2896  // The inner recurrence keeps its NW flag but only keeps NUW/NSW if
2897  // the outer recurrence has the same property.
2898  SCEV::NoWrapFlags InnerFlags =
2899  maskFlags(NestedAR->getNoWrapFlags(), SCEV::FlagNW | Flags);
2900  return getAddRecExpr(NestedOperands, NestedLoop, InnerFlags);
2901  }
2902  }
2903  // Reset Operands to its original state.
2904  Operands[0] = NestedAR;
2905  }
2906  }
2907 
2908  // Okay, it looks like we really DO need an addrec expr. Check to see if we
2909  // already have one, otherwise create a new one.
2912  for (unsigned i = 0, e = Operands.size(); i != e; ++i)
2913  ID.AddPointer(Operands[i]);
2914  ID.AddPointer(L);
2915  void *IP = nullptr;
2916  SCEVAddRecExpr *S =
2917  static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
2918  if (!S) {
2919  const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
2920  std::uninitialized_copy(Operands.begin(), Operands.end(), O);
2921  S = new (SCEVAllocator) SCEVAddRecExpr(ID.Intern(SCEVAllocator),
2922  O, Operands.size(), L);
2923  UniqueSCEVs.InsertNode(S, IP);
2924  }
2925  S->setNoWrapFlags(Flags);
2926  return S;
2927 }
2928 
2929 const SCEV *
2930 ScalarEvolution::getGEPExpr(Type *PointeeType, const SCEV *BaseExpr,
2931  const SmallVectorImpl<const SCEV *> &IndexExprs,
2932  bool InBounds) {
2933  // getSCEV(Base)->getType() has the same address space as Base->getType()
2934  // because SCEV::getType() preserves the address space.
2935  Type *IntPtrTy = getEffectiveSCEVType(BaseExpr->getType());
2936  // FIXME(PR23527): Don't blindly transfer the inbounds flag from the GEP
2937  // instruction to its SCEV, because the Instruction may be guarded by control
2938  // flow and the no-overflow bits may not be valid for the expression in any
2939  // context.
2941 
2942  const SCEV *TotalOffset = getConstant(IntPtrTy, 0);
2943  // The address space is unimportant. The first thing we do on CurTy is getting
2944  // its element type.
2945  Type *CurTy = PointerType::getUnqual(PointeeType);
2946  for (const SCEV *IndexExpr : IndexExprs) {
2947  // Compute the (potentially symbolic) offset in bytes for this index.
2948  if (StructType *STy = dyn_cast<StructType>(CurTy)) {
2949  // For a struct, add the member offset.
2950  ConstantInt *Index = cast<SCEVConstant>(IndexExpr)->getValue();
2951  unsigned FieldNo = Index->getZExtValue();
2952  const SCEV *FieldOffset = getOffsetOfExpr(IntPtrTy, STy, FieldNo);
2953 
2954  // Add the field offset to the running total offset.
2955  TotalOffset = getAddExpr(TotalOffset, FieldOffset);
2956 
2957  // Update CurTy to the type of the field at Index.
2958  CurTy = STy->getTypeAtIndex(Index);
2959  } else {
2960  // Update CurTy to its element type.
2961  CurTy = cast<SequentialType>(CurTy)->getElementType();
2962  // For an array, add the element offset, explicitly scaled.
2963  const SCEV *ElementSize = getSizeOfExpr(IntPtrTy, CurTy);
2964  // Getelementptr indices are signed.
2965  IndexExpr = getTruncateOrSignExtend(IndexExpr, IntPtrTy);
2966 
2967  // Multiply the index by the element size to compute the element offset.
2968  const SCEV *LocalOffset = getMulExpr(IndexExpr, ElementSize, Wrap);
2969 
2970  // Add the element offset to the running total offset.
2971  TotalOffset = getAddExpr(TotalOffset, LocalOffset);
2972  }
2973  }
2974 
2975  // Add the total offset from all the GEP indices to the base.
2976  return getAddExpr(BaseExpr, TotalOffset, Wrap);
2977 }
2978 
2980  const SCEV *RHS) {
2982  Ops.push_back(LHS);
2983  Ops.push_back(RHS);
2984  return getSMaxExpr(Ops);
2985 }
2986 
2987 const SCEV *
2989  assert(!Ops.empty() && "Cannot get empty smax!");
2990  if (Ops.size() == 1) return Ops[0];
2991 #ifndef NDEBUG
2992  Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2993  for (unsigned i = 1, e = Ops.size(); i != e; ++i)
2994  assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
2995  "SCEVSMaxExpr operand types don't match!");
2996 #endif
2997 
2998  // Sort by complexity, this groups all similar expression types together.
2999  GroupByComplexity(Ops, LI);
3000 
3001  // If there are any constants, fold them together.
3002  unsigned Idx = 0;
3003  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3004  ++Idx;
3005  assert(Idx < Ops.size());
3006  while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3007  // We found two constants, fold them together!
3009  APIntOps::smax(LHSC->getValue()->getValue(),
3010  RHSC->getValue()->getValue()));
3011  Ops[0] = getConstant(Fold);
3012  Ops.erase(Ops.begin()+1); // Erase the folded element
3013  if (Ops.size() == 1) return Ops[0];
3014  LHSC = cast<SCEVConstant>(Ops[0]);
3015  }
3016 
3017  // If we are left with a constant minimum-int, strip it off.
3018  if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(true)) {
3019  Ops.erase(Ops.begin());
3020  --Idx;
3021  } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(true)) {
3022  // If we have an smax with a constant maximum-int, it will always be
3023  // maximum-int.
3024  return Ops[0];
3025  }
3026 
3027  if (Ops.size() == 1) return Ops[0];
3028  }
3029 
3030  // Find the first SMax
3031  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scSMaxExpr)
3032  ++Idx;
3033 
3034  // Check to see if one of the operands is an SMax. If so, expand its operands
3035  // onto our operand list, and recurse to simplify.
3036  if (Idx < Ops.size()) {
3037  bool DeletedSMax = false;
3038  while (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(Ops[Idx])) {
3039  Ops.erase(Ops.begin()+Idx);
3040  Ops.append(SMax->op_begin(), SMax->op_end());
3041  DeletedSMax = true;
3042  }
3043 
3044  if (DeletedSMax)
3045  return getSMaxExpr(Ops);
3046  }
3047 
3048  // Okay, check to see if the same value occurs in the operand list twice. If
3049  // so, delete one. Since we sorted the list, these values are required to
3050  // be adjacent.
3051  for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
3052  // X smax Y smax Y --> X smax Y
3053  // X smax Y --> X, if X is always greater than Y
3054  if (Ops[i] == Ops[i+1] ||
3055  isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
3056  Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
3057  --i; --e;
3058  } else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
3059  Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
3060  --i; --e;
3061  }
3062 
3063  if (Ops.size() == 1) return Ops[0];
3064 
3065  assert(!Ops.empty() && "Reduced smax down to nothing!");
3066 
3067  // Okay, it looks like we really DO need an smax expr. Check to see if we
3068  // already have one, otherwise create a new one.
3070  ID.AddInteger(scSMaxExpr);
3071  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
3072  ID.AddPointer(Ops[i]);
3073  void *IP = nullptr;
3074  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
3075  const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
3076  std::uninitialized_copy(Ops.begin(), Ops.end(), O);
3077  SCEV *S = new (SCEVAllocator) SCEVSMaxExpr(ID.Intern(SCEVAllocator),
3078  O, Ops.size());
3079  UniqueSCEVs.InsertNode(S, IP);
3080  return S;
3081 }
3082 
3084  const SCEV *RHS) {
3086  Ops.push_back(LHS);
3087  Ops.push_back(RHS);
3088  return getUMaxExpr(Ops);
3089 }
3090 
3091 const SCEV *
3093  assert(!Ops.empty() && "Cannot get empty umax!");
3094  if (Ops.size() == 1) return Ops[0];
3095 #ifndef NDEBUG
3096  Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
3097  for (unsigned i = 1, e = Ops.size(); i != e; ++i)
3098  assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
3099  "SCEVUMaxExpr operand types don't match!");
3100 #endif
3101 
3102  // Sort by complexity, this groups all similar expression types together.
3103  GroupByComplexity(Ops, LI);
3104 
3105  // If there are any constants, fold them together.
3106  unsigned Idx = 0;
3107  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
3108  ++Idx;
3109  assert(Idx < Ops.size());
3110  while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
3111  // We found two constants, fold them together!
3113  APIntOps::umax(LHSC->getValue()->getValue(),
3114  RHSC->getValue()->getValue()));
3115  Ops[0] = getConstant(Fold);
3116  Ops.erase(Ops.begin()+1); // Erase the folded element
3117  if (Ops.size() == 1) return Ops[0];
3118  LHSC = cast<SCEVConstant>(Ops[0]);
3119  }
3120 
3121  // If we are left with a constant minimum-int, strip it off.
3122  if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(false)) {
3123  Ops.erase(Ops.begin());
3124  --Idx;
3125  } else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(false)) {
3126  // If we have an umax with a constant maximum-int, it will always be
3127  // maximum-int.
3128  return Ops[0];
3129  }
3130 
3131  if (Ops.size() == 1) return Ops[0];
3132  }
3133 
3134  // Find the first UMax
3135  while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scUMaxExpr)
3136  ++Idx;
3137 
3138  // Check to see if one of the operands is a UMax. If so, expand its operands
3139  // onto our operand list, and recurse to simplify.
3140  if (Idx < Ops.size()) {
3141  bool DeletedUMax = false;
3142  while (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(Ops[Idx])) {
3143  Ops.erase(Ops.begin()+Idx);
3144  Ops.append(UMax->op_begin(), UMax->op_end());
3145  DeletedUMax = true;
3146  }
3147 
3148  if (DeletedUMax)
3149  return getUMaxExpr(Ops);
3150  }
3151 
3152  // Okay, check to see if the same value occurs in the operand list twice. If
3153  // so, delete one. Since we sorted the list, these values are required to
3154  // be adjacent.
3155  for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
3156  // X umax Y umax Y --> X umax Y
3157  // X umax Y --> X, if X is always greater than Y
3158  if (Ops[i] == Ops[i+1] ||
3159  isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
3160  Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
3161  --i; --e;
3162  } else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
3163  Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
3164  --i; --e;
3165  }
3166 
3167  if (Ops.size() == 1) return Ops[0];
3168 
3169  assert(!Ops.empty() && "Reduced umax down to nothing!");
3170 
3171  // Okay, it looks like we really DO need a umax expr. Check to see if we
3172  // already have one, otherwise create a new one.
3174  ID.AddInteger(scUMaxExpr);
3175  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
3176  ID.AddPointer(Ops[i]);
3177  void *IP = nullptr;
3178  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
3179  const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
3180  std::uninitialized_copy(Ops.begin(), Ops.end(), O);
3181  SCEV *S = new (SCEVAllocator) SCEVUMaxExpr(ID.Intern(SCEVAllocator),
3182  O, Ops.size());
3183  UniqueSCEVs.InsertNode(S, IP);
3184  return S;
3185 }
3186 
3188  const SCEV *RHS) {
3189  // ~smax(~x, ~y) == smin(x, y).
3190  return getNotSCEV(getSMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
3191 }
3192 
3194  const SCEV *RHS) {
3195  // ~umax(~x, ~y) == umin(x, y)
3196  return getNotSCEV(getUMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
3197 }
3198 
3199 const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
3200  // We can bypass creating a target-independent
3201  // constant expression and then folding it back into a ConstantInt.
3202  // This is just a compile-time optimization.
3203  return getConstant(IntTy,
3204  F->getParent()->getDataLayout().getTypeAllocSize(AllocTy));
3205 }
3206 
3208  StructType *STy,
3209  unsigned FieldNo) {
3210  // We can bypass creating a target-independent
3211  // constant expression and then folding it back into a ConstantInt.
3212  // This is just a compile-time optimization.
3213  return getConstant(
3214  IntTy,
3216  FieldNo));
3217 }
3218 
3220  // Don't attempt to do anything other than create a SCEVUnknown object
3221  // here. createSCEV only calls getUnknown after checking for all other
3222  // interesting possibilities, and any other code that calls getUnknown
3223  // is doing so in order to hide a value from SCEV canonicalization.
3224 
3226  ID.AddInteger(scUnknown);
3227  ID.AddPointer(V);
3228  void *IP = nullptr;
3229  if (SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) {
3230  assert(cast<SCEVUnknown>(S)->getValue() == V &&
3231  "Stale SCEVUnknown in uniquing map!");
3232  return S;
3233  }
3234  SCEV *S = new (SCEVAllocator) SCEVUnknown(ID.Intern(SCEVAllocator), V, this,
3235  FirstUnknown);
3236  FirstUnknown = cast<SCEVUnknown>(S);
3237  UniqueSCEVs.InsertNode(S, IP);
3238  return S;
3239 }
3240 
3241 //===----------------------------------------------------------------------===//
3242 // Basic SCEV Analysis and PHI Idiom Recognition Code
3243 //
3244 
3245 /// isSCEVable - Test if values of the given type are analyzable within
3246 /// the SCEV framework. This primarily includes integer types, and it
3247 /// can optionally include pointer types if the ScalarEvolution class
3248 /// has access to target-specific information.
3250  // Integers and pointers are always SCEVable.
3251  return Ty->isIntegerTy() || Ty->isPointerTy();
3252 }
3253 
3254 /// getTypeSizeInBits - Return the size in bits of the specified type,
3255 /// for which isSCEVable must return true.
3257  assert(isSCEVable(Ty) && "Type is not SCEVable!");
3258  return F->getParent()->getDataLayout().getTypeSizeInBits(Ty);
3259 }
3260 
3261 /// getEffectiveSCEVType - Return a type with the same bitwidth as
3262 /// the given type and which represents how SCEV will treat the given
3263 /// type, for which isSCEVable must return true. For pointer types,
3264 /// this is the pointer-sized integer type.
3266  assert(isSCEVable(Ty) && "Type is not SCEVable!");
3267 
3268  if (Ty->isIntegerTy()) {
3269  return Ty;
3270  }
3271 
3272  // The only other support type is pointer.
3273  assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
3274  return F->getParent()->getDataLayout().getIntPtrType(Ty);
3275 }
3276 
3278  return &CouldNotCompute;
3279 }
3280 
3281 namespace {
3282  // Helper class working with SCEVTraversal to figure out if a SCEV contains
3283  // a SCEVUnknown with null value-pointer. FindInvalidSCEVUnknown::FindOne
3284  // is set iff if find such SCEVUnknown.
3285  //
3286  struct FindInvalidSCEVUnknown {
3287  bool FindOne;
3288  FindInvalidSCEVUnknown() { FindOne = false; }
3289  bool follow(const SCEV *S) {
3290  switch (static_cast<SCEVTypes>(S->getSCEVType())) {
3291  case scConstant:
3292  return false;
3293  case scUnknown:
3294  if (!cast<SCEVUnknown>(S)->getValue())
3295  FindOne = true;
3296  return false;
3297  default:
3298  return true;
3299  }
3300  }
3301  bool isDone() const { return FindOne; }
3302  };
3303 }
3304 
3305 bool ScalarEvolution::checkValidity(const SCEV *S) const {
3306  FindInvalidSCEVUnknown F;
3308  ST.visitAll(S);
3309 
3310  return !F.FindOne;
3311 }
3312 
3313 /// getSCEV - Return an existing SCEV if it exists, otherwise analyze the
3314 /// expression and create a new one.
3316  assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
3317 
3318  ValueExprMapType::iterator I = ValueExprMap.find_as(V);
3319  if (I != ValueExprMap.end()) {
3320  const SCEV *S = I->second;
3321  if (checkValidity(S))
3322  return S;
3323  else
3324  ValueExprMap.erase(I);
3325  }
3326  const SCEV *S = createSCEV(V);
3327 
3328  // The process of creating a SCEV for V may have caused other SCEVs
3329  // to have been created, so it's necessary to insert the new entry
3330  // from scratch, rather than trying to remember the insert position
3331  // above.
3332  ValueExprMap.insert(std::make_pair(SCEVCallbackVH(V, this), S));
3333  return S;
3334 }
3335 
3336 /// getNegativeSCEV - Return a SCEV corresponding to -V = -1*V
3337 ///
3339  if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3340  return getConstant(
3341  cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
3342 
3343  Type *Ty = V->getType();
3344  Ty = getEffectiveSCEVType(Ty);
3345  return getMulExpr(V,
3346  getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty))));
3347 }
3348 
3349 /// getNotSCEV - Return a SCEV corresponding to ~V = -1-V
3351  if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
3352  return getConstant(
3353  cast<ConstantInt>(ConstantExpr::getNot(VC->getValue())));
3354 
3355  Type *Ty = V->getType();
3356  Ty = getEffectiveSCEVType(Ty);
3357  const SCEV *AllOnes =
3358  getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty)));
3359  return getMinusSCEV(AllOnes, V);
3360 }
3361 
3362 /// getMinusSCEV - Return LHS-RHS. Minus is represented in SCEV as A+B*-1.
3363 const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
3365  assert(!maskFlags(Flags, SCEV::FlagNUW) && "subtraction does not have NUW");
3366 
3367  // Fast path: X - X --> 0.
3368  if (LHS == RHS)
3369  return getConstant(LHS->getType(), 0);
3370 
3371  // X - Y --> X + -Y.
3372  // X -(nsw || nuw) Y --> X + -Y.
3373  return getAddExpr(LHS, getNegativeSCEV(RHS));
3374 }
3375 
3376 /// getTruncateOrZeroExtend - Return a SCEV corresponding to a conversion of the
3377 /// input value to the specified type. If the type must be extended, it is zero
3378 /// extended.
3379 const SCEV *
3381  Type *SrcTy = V->getType();
3382  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3383  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3384  "Cannot truncate or zero extend with non-integer arguments!");
3385  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3386  return V; // No conversion
3387  if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
3388  return getTruncateExpr(V, Ty);
3389  return getZeroExtendExpr(V, Ty);
3390 }
3391 
3392 /// getTruncateOrSignExtend - Return a SCEV corresponding to a conversion of the
3393 /// input value to the specified type. If the type must be extended, it is sign
3394 /// extended.
3395 const SCEV *
3397  Type *Ty) {
3398  Type *SrcTy = V->getType();
3399  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3400  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3401  "Cannot truncate or zero extend with non-integer arguments!");
3402  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3403  return V; // No conversion
3404  if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
3405  return getTruncateExpr(V, Ty);
3406  return getSignExtendExpr(V, Ty);
3407 }
3408 
3409 /// getNoopOrZeroExtend - Return a SCEV corresponding to a conversion of the
3410 /// input value to the specified type. If the type must be extended, it is zero
3411 /// extended. The conversion must not be narrowing.
3412 const SCEV *
3414  Type *SrcTy = V->getType();
3415  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3416  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3417  "Cannot noop or zero extend with non-integer arguments!");
3418  assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3419  "getNoopOrZeroExtend cannot truncate!");
3420  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3421  return V; // No conversion
3422  return getZeroExtendExpr(V, Ty);
3423 }
3424 
3425 /// getNoopOrSignExtend - Return a SCEV corresponding to a conversion of the
3426 /// input value to the specified type. If the type must be extended, it is sign
3427 /// extended. The conversion must not be narrowing.
3428 const SCEV *
3430  Type *SrcTy = V->getType();
3431  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3432  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3433  "Cannot noop or sign extend with non-integer arguments!");
3434  assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3435  "getNoopOrSignExtend cannot truncate!");
3436  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3437  return V; // No conversion
3438  return getSignExtendExpr(V, Ty);
3439 }
3440 
3441 /// getNoopOrAnyExtend - Return a SCEV corresponding to a conversion of
3442 /// the input value to the specified type. If the type must be extended,
3443 /// it is extended with unspecified bits. The conversion must not be
3444 /// narrowing.
3445 const SCEV *
3447  Type *SrcTy = V->getType();
3448  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3449  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3450  "Cannot noop or any extend with non-integer arguments!");
3451  assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
3452  "getNoopOrAnyExtend cannot truncate!");
3453  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3454  return V; // No conversion
3455  return getAnyExtendExpr(V, Ty);
3456 }
3457 
3458 /// getTruncateOrNoop - Return a SCEV corresponding to a conversion of the
3459 /// input value to the specified type. The conversion must not be widening.
3460 const SCEV *
3462  Type *SrcTy = V->getType();
3463  assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
3464  (Ty->isIntegerTy() || Ty->isPointerTy()) &&
3465  "Cannot truncate or noop with non-integer arguments!");
3466  assert(getTypeSizeInBits(SrcTy) >= getTypeSizeInBits(Ty) &&
3467  "getTruncateOrNoop cannot extend!");
3468  if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
3469  return V; // No conversion
3470  return getTruncateExpr(V, Ty);
3471 }
3472 
3473 /// getUMaxFromMismatchedTypes - Promote the operands to the wider of
3474 /// the types using zero-extension, and then perform a umax operation
3475 /// with them.
3477  const SCEV *RHS) {
3478  const SCEV *PromotedLHS = LHS;
3479  const SCEV *PromotedRHS = RHS;
3480 
3481  if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
3482  PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
3483  else
3484  PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
3485 
3486  return getUMaxExpr(PromotedLHS, PromotedRHS);
3487 }
3488 
3489 /// getUMinFromMismatchedTypes - Promote the operands to the wider of
3490 /// the types using zero-extension, and then perform a umin operation
3491 /// with them.
3493  const SCEV *RHS) {
3494  const SCEV *PromotedLHS = LHS;
3495  const SCEV *PromotedRHS = RHS;
3496 
3497  if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
3498  PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
3499  else
3500  PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
3501 
3502  return getUMinExpr(PromotedLHS, PromotedRHS);
3503 }
3504 
3505 /// getPointerBase - Transitively follow the chain of pointer-type operands
3506 /// until reaching a SCEV that does not have a single pointer operand. This
3507 /// returns a SCEVUnknown pointer for well-formed pointer-type expressions,
3508 /// but corner cases do exist.
3510  // A pointer operand may evaluate to a nonpointer expression, such as null.
3511  if (!V->getType()->isPointerTy())
3512  return V;
3513 
3514  if (const SCEVCastExpr *Cast = dyn_cast<SCEVCastExpr>(V)) {
3515  return getPointerBase(Cast->getOperand());
3516  }
3517  else if (const SCEVNAryExpr *NAry = dyn_cast<SCEVNAryExpr>(V)) {
3518  const SCEV *PtrOp = nullptr;
3519  for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
3520  I != E; ++I) {
3521  if ((*I)->getType()->isPointerTy()) {
3522  // Cannot find the base of an expression with multiple pointer operands.
3523  if (PtrOp)
3524  return V;
3525  PtrOp = *I;
3526  }
3527  }
3528  if (!PtrOp)
3529  return V;
3530  return getPointerBase(PtrOp);
3531  }
3532  return V;
3533 }
3534 
3535 /// PushDefUseChildren - Push users of the given Instruction
3536 /// onto the given Worklist.
3537 static void
3539  SmallVectorImpl<Instruction *> &Worklist) {
3540  // Push the def-use children onto the Worklist stack.
3541  for (User *U : I->users())
3542  Worklist.push_back(cast<Instruction>(U));
3543 }
3544 
3545 /// ForgetSymbolicValue - This looks up computed SCEV values for all
3546 /// instructions that depend on the given instruction and removes them from
3547 /// the ValueExprMapType map if they reference SymName. This is used during PHI
3548 /// resolution.
3549 void
3550 ScalarEvolution::ForgetSymbolicName(Instruction *PN, const SCEV *SymName) {
3552  PushDefUseChildren(PN, Worklist);
3553 
3555  Visited.insert(PN);
3556  while (!Worklist.empty()) {
3557  Instruction *I = Worklist.pop_back_val();
3558  if (!Visited.insert(I).second)
3559  continue;
3560 
3562  ValueExprMap.find_as(static_cast<Value *>(I));
3563  if (It != ValueExprMap.end()) {
3564  const SCEV *Old = It->second;
3565 
3566  // Short-circuit the def-use traversal if the symbolic name
3567  // ceases to appear in expressions.
3568  if (Old != SymName && !hasOperand(Old, SymName))
3569  continue;
3570 
3571  // SCEVUnknown for a PHI either means that it has an unrecognized
3572  // structure, it's a PHI that's in the progress of being computed
3573  // by createNodeForPHI, or it's a single-value PHI. In the first case,
3574  // additional loop trip count information isn't going to change anything.
3575  // In the second case, createNodeForPHI will perform the necessary
3576  // updates on its own when it gets to that point. In the third, we do
3577  // want to forget the SCEVUnknown.
3578  if (!isa<PHINode>(I) ||
3579  !isa<SCEVUnknown>(Old) ||
3580  (I != PN && Old == SymName)) {
3581  forgetMemoizedResults(Old);
3582  ValueExprMap.erase(It);
3583  }
3584  }
3585 
3586  PushDefUseChildren(I, Worklist);
3587  }
3588 }
3589 
3590 /// createNodeForPHI - PHI nodes have two cases. Either the PHI node exists in
3591 /// a loop header, making it a potential recurrence, or it doesn't.
3592 ///
3593 const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
3594  if (const Loop *L = LI->getLoopFor(PN->getParent()))
3595  if (L->getHeader() == PN->getParent()) {
3596  // The loop may have multiple entrances or multiple exits; we can analyze
3597  // this phi as an addrec if it has a unique entry value and a unique
3598  // backedge value.
3599  Value *BEValueV = nullptr, *StartValueV = nullptr;
3600  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
3601  Value *V = PN->getIncomingValue(i);
3602  if (L->contains(PN->getIncomingBlock(i))) {
3603  if (!BEValueV) {
3604  BEValueV = V;
3605  } else if (BEValueV != V) {
3606  BEValueV = nullptr;
3607  break;
3608  }
3609  } else if (!StartValueV) {
3610  StartValueV = V;
3611  } else if (StartValueV != V) {
3612  StartValueV = nullptr;
3613  break;
3614  }
3615  }
3616  if (BEValueV && StartValueV) {
3617  // While we are analyzing this PHI node, handle its value symbolically.
3618  const SCEV *SymbolicName = getUnknown(PN);
3619  assert(ValueExprMap.find_as(PN) == ValueExprMap.end() &&
3620  "PHI node already processed?");
3621  ValueExprMap.insert(std::make_pair(SCEVCallbackVH(PN, this), SymbolicName));
3622 
3623  // Using this symbolic name for the PHI, analyze the value coming around
3624  // the back-edge.
3625  const SCEV *BEValue = getSCEV(BEValueV);
3626 
3627  // NOTE: If BEValue is loop invariant, we know that the PHI node just
3628  // has a special value for the first iteration of the loop.
3629 
3630  // If the value coming around the backedge is an add with the symbolic
3631  // value we just inserted, then we found a simple induction variable!
3632  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(BEValue)) {
3633  // If there is a single occurrence of the symbolic value, replace it
3634  // with a recurrence.
3635  unsigned FoundIndex = Add->getNumOperands();
3636  for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
3637  if (Add->getOperand(i) == SymbolicName)
3638  if (FoundIndex == e) {
3639  FoundIndex = i;
3640  break;
3641  }
3642 
3643  if (FoundIndex != Add->getNumOperands()) {
3644  // Create an add with everything but the specified operand.
3646  for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
3647  if (i != FoundIndex)
3648  Ops.push_back(Add->getOperand(i));
3649  const SCEV *Accum = getAddExpr(Ops);
3650 
3651  // This is not a valid addrec if the step amount is varying each
3652  // loop iteration, but is not itself an addrec in this loop.
3653  if (isLoopInvariant(Accum, L) ||
3654  (isa<SCEVAddRecExpr>(Accum) &&
3655  cast<SCEVAddRecExpr>(Accum)->getLoop() == L)) {
3657 
3658  // If the increment doesn't overflow, then neither the addrec nor
3659  // the post-increment will overflow.
3660  if (const AddOperator *OBO = dyn_cast<AddOperator>(BEValueV)) {
3661  if (OBO->getOperand(0) == PN) {
3662  if (OBO->hasNoUnsignedWrap())
3663  Flags = setFlags(Flags, SCEV::FlagNUW);
3664  if (OBO->hasNoSignedWrap())
3665  Flags = setFlags(Flags, SCEV::FlagNSW);
3666  }
3667  } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(BEValueV)) {
3668  // If the increment is an inbounds GEP, then we know the address
3669  // space cannot be wrapped around. We cannot make any guarantee
3670  // about signed or unsigned overflow because pointers are
3671  // unsigned but we may have a negative index from the base
3672  // pointer. We can guarantee that no unsigned wrap occurs if the
3673  // indices form a positive value.
3674  if (GEP->isInBounds() && GEP->getOperand(0) == PN) {
3675  Flags = setFlags(Flags, SCEV::FlagNW);
3676 
3677  const SCEV *Ptr = getSCEV(GEP->getPointerOperand());
3679  Flags = setFlags(Flags, SCEV::FlagNUW);
3680  }
3681 
3682  // We cannot transfer nuw and nsw flags from subtraction
3683  // operations -- sub nuw X, Y is not the same as add nuw X, -Y
3684  // for instance.
3685  }
3686 
3687  const SCEV *StartVal = getSCEV(StartValueV);
3688  const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, Flags);
3689 
3690  // Since the no-wrap flags are on the increment, they apply to the
3691  // post-incremented value as well.
3692  if (isLoopInvariant(Accum, L))
3693  (void)getAddRecExpr(getAddExpr(StartVal, Accum),
3694  Accum, L, Flags);
3695 
3696  // Okay, for the entire analysis of this edge we assumed the PHI
3697  // to be symbolic. We now need to go back and purge all of the
3698  // entries for the scalars that use the symbolic expression.
3699  ForgetSymbolicName(PN, SymbolicName);
3700  ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
3701  return PHISCEV;
3702  }
3703  }
3704  } else if (const SCEVAddRecExpr *AddRec =
3705  dyn_cast<SCEVAddRecExpr>(BEValue)) {
3706  // Otherwise, this could be a loop like this:
3707  // i = 0; for (j = 1; ..; ++j) { .... i = j; }
3708  // In this case, j = {1,+,1} and BEValue is j.
3709  // Because the other in-value of i (0) fits the evolution of BEValue
3710  // i really is an addrec evolution.
3711  if (AddRec->getLoop() == L && AddRec->isAffine()) {
3712  const SCEV *StartVal = getSCEV(StartValueV);
3713 
3714  // If StartVal = j.start - j.stride, we can use StartVal as the
3715  // initial step of the addrec evolution.
3716  if (StartVal == getMinusSCEV(AddRec->getOperand(0),
3717  AddRec->getOperand(1))) {
3718  // FIXME: For constant StartVal, we should be able to infer
3719  // no-wrap flags.
3720  const SCEV *PHISCEV =
3721  getAddRecExpr(StartVal, AddRec->getOperand(1), L,
3723 
3724  // Okay, for the entire analysis of this edge we assumed the PHI
3725  // to be symbolic. We now need to go back and purge all of the
3726  // entries for the scalars that use the symbolic expression.
3727  ForgetSymbolicName(PN, SymbolicName);
3728  ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
3729  return PHISCEV;
3730  }
3731  }
3732  }
3733  }
3734  }
3735 
3736  // If the PHI has a single incoming value, follow that value, unless the
3737  // PHI's incoming blocks are in a different loop, in which case doing so
3738  // risks breaking LCSSA form. Instcombine would normally zap these, but
3739  // it doesn't have DominatorTree information, so it may miss cases.
3740  if (Value *V =
3741  SimplifyInstruction(PN, F->getParent()->getDataLayout(), TLI, DT, AC))
3742  if (LI->replacementPreservesLCSSAForm(PN, V))
3743  return getSCEV(V);
3744 
3745  // If it's not a loop phi, we can't handle it yet.
3746  return getUnknown(PN);
3747 }
3748 
3749 /// createNodeForGEP - Expand GEP instructions into add and multiply
3750 /// operations. This allows them to be analyzed by regular SCEV code.
3751 ///
3752 const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
3753  Value *Base = GEP->getOperand(0);
3754  // Don't attempt to analyze GEPs over unsized objects.
3755  if (!Base->getType()->getPointerElementType()->isSized())
3756  return getUnknown(GEP);
3757 
3758  SmallVector<const SCEV *, 4> IndexExprs;
3759  for (auto Index = GEP->idx_begin(); Index != GEP->idx_end(); ++Index)
3760  IndexExprs.push_back(getSCEV(*Index));
3761  return getGEPExpr(GEP->getSourceElementType(), getSCEV(Base), IndexExprs,
3762  GEP->isInBounds());
3763 }
3764 
3765 /// GetMinTrailingZeros - Determine the minimum number of zero bits that S is
3766 /// guaranteed to end in (at every loop iteration). It is, at the same time,
3767 /// the minimum number of times S is divisible by 2. For example, given {4,+,8}
3768 /// it returns 2. If S is guaranteed to be 0, it returns the bitwidth of S.
3769 uint32_t
3771  if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
3772  return C->getValue()->getValue().countTrailingZeros();
3773 
3774  if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(S))
3775  return std::min(GetMinTrailingZeros(T->getOperand()),
3776  (uint32_t)getTypeSizeInBits(T->getType()));
3777 
3778  if (const SCEVZeroExtendExpr *E = dyn_cast<SCEVZeroExtendExpr>(S)) {
3779  uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
3780  return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
3781  getTypeSizeInBits(E->getType()) : OpRes;
3782  }
3783 
3784  if (const SCEVSignExtendExpr *E = dyn_cast<SCEVSignExtendExpr>(S)) {
3785  uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
3786  return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
3787  getTypeSizeInBits(E->getType()) : OpRes;
3788  }
3789 
3790  if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(S)) {
3791  // The result is the min of all operands results.
3792  uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
3793  for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
3794  MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
3795  return MinOpRes;
3796  }
3797 
3798  if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
3799  // The result is the sum of all operands results.
3800  uint32_t SumOpRes = GetMinTrailingZeros(M->getOperand(0));
3801  uint32_t BitWidth = getTypeSizeInBits(M->getType());
3802  for (unsigned i = 1, e = M->getNumOperands();
3803  SumOpRes != BitWidth && i != e; ++i)
3804  SumOpRes = std::min(SumOpRes + GetMinTrailingZeros(M->getOperand(i)),
3805  BitWidth);
3806  return SumOpRes;
3807  }
3808 
3809  if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(S)) {
3810  // The result is the min of all operands results.
3811  uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
3812  for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
3813  MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
3814  return MinOpRes;
3815  }
3816 
3817  if (const SCEVSMaxExpr *M = dyn_cast<SCEVSMaxExpr>(S)) {
3818  // The result is the min of all operands results.
3819  uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
3820  for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
3821  MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
3822  return MinOpRes;
3823  }
3824 
3825  if (const SCEVUMaxExpr *M = dyn_cast<SCEVUMaxExpr>(S)) {
3826  // The result is the min of all operands results.
3827  uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
3828  for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
3829  MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
3830  return MinOpRes;
3831  }
3832 
3833  if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
3834  // For a SCEVUnknown, ask ValueTracking.
3835  unsigned BitWidth = getTypeSizeInBits(U->getType());
3836  APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
3837  computeKnownBits(U->getValue(), Zeros, Ones,
3838  F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
3839  return Zeros.countTrailingOnes();
3840  }
3841 
3842  // SCEVUDivExpr
3843  return 0;
3844 }
3845 
3846 /// GetRangeFromMetadata - Helper method to assign a range to V from
3847 /// metadata present in the IR.
3849  if (Instruction *I = dyn_cast<Instruction>(V)) {
3850  if (MDNode *MD = I->getMetadata(LLVMContext::MD_range)) {
3851  ConstantRange TotalRange(
3852  cast<IntegerType>(I->getType())->getBitWidth(), false);
3853 
3854  unsigned NumRanges = MD->getNumOperands() / 2;
3855  assert(NumRanges >= 1);
3856 
3857  for (unsigned i = 0; i < NumRanges; ++i) {
3858  ConstantInt *Lower =
3859  mdconst::extract<ConstantInt>(MD->getOperand(2 * i + 0));
3860  ConstantInt *Upper =
3861  mdconst::extract<ConstantInt>(MD->getOperand(2 * i + 1));
3862  ConstantRange Range(Lower->getValue(), Upper->getValue());
3863  TotalRange = TotalRange.unionWith(Range);
3864  }
3865 
3866  return TotalRange;
3867  }
3868  }
3869 
3870  return None;
3871 }
3872 
3873 /// getRange - Determine the range for a particular SCEV. If SignHint is
3874 /// HINT_RANGE_UNSIGNED (resp. HINT_RANGE_SIGNED) then getRange prefers ranges
3875 /// with a "cleaner" unsigned (resp. signed) representation.
3876 ///
3878 ScalarEvolution::getRange(const SCEV *S,
3879  ScalarEvolution::RangeSignHint SignHint) {
3881  SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED ? UnsignedRanges
3882  : SignedRanges;
3883 
3884  // See if we've computed this range already.
3886  if (I != Cache.end())
3887  return I->second;
3888 
3889  if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
3890  return setRange(C, SignHint, ConstantRange(C->getValue()->getValue()));
3891 
3892  unsigned BitWidth = getTypeSizeInBits(S->getType());
3893  ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
3894 
3895  // If the value has known zeros, the maximum value will have those known zeros
3896  // as well.
3897  uint32_t TZ = GetMinTrailingZeros(S);
3898  if (TZ != 0) {
3899  if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED)
3900  ConservativeResult =
3902  APInt::getMaxValue(BitWidth).lshr(TZ).shl(TZ) + 1);
3903  else
3904  ConservativeResult = ConstantRange(
3905  APInt::getSignedMinValue(BitWidth),
3906  APInt::getSignedMaxValue(BitWidth).ashr(TZ).shl(TZ) + 1);
3907  }
3908 
3909  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
3910  ConstantRange X = getRange(Add->getOperand(0), SignHint);
3911  for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
3912  X = X.add(getRange(Add->getOperand(i), SignHint));
3913  return setRange(Add, SignHint, ConservativeResult.intersectWith(X));
3914  }
3915 
3916  if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
3917  ConstantRange X = getRange(Mul->getOperand(0), SignHint);
3918  for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
3919  X = X.multiply(getRange(Mul->getOperand(i), SignHint));
3920  return setRange(Mul, SignHint, ConservativeResult.intersectWith(X));
3921  }
3922 
3923  if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
3924  ConstantRange X = getRange(SMax->getOperand(0), SignHint);
3925  for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
3926  X = X.smax(getRange(SMax->getOperand(i), SignHint));
3927  return setRange(SMax, SignHint, ConservativeResult.intersectWith(X));
3928  }
3929 
3930  if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
3931  ConstantRange X = getRange(UMax->getOperand(0), SignHint);
3932  for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
3933  X = X.umax(getRange(UMax->getOperand(i), SignHint));
3934  return setRange(UMax, SignHint, ConservativeResult.intersectWith(X));
3935  }
3936 
3937  if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
3938  ConstantRange X = getRange(UDiv->getLHS(), SignHint);
3939  ConstantRange Y = getRange(UDiv->getRHS(), SignHint);
3940  return setRange(UDiv, SignHint,
3941  ConservativeResult.intersectWith(X.udiv(Y)));
3942  }
3943 
3944  if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
3945  ConstantRange X = getRange(ZExt->getOperand(), SignHint);
3946  return setRange(ZExt, SignHint,
3947  ConservativeResult.intersectWith(X.zeroExtend(BitWidth)));
3948  }
3949 
3950  if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
3951  ConstantRange X = getRange(SExt->getOperand(), SignHint);
3952  return setRange(SExt, SignHint,
3953  ConservativeResult.intersectWith(X.signExtend(BitWidth)));
3954  }
3955 
3956  if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
3957  ConstantRange X = getRange(Trunc->getOperand(), SignHint);
3958  return setRange(Trunc, SignHint,
3959  ConservativeResult.intersectWith(X.truncate(BitWidth)));
3960  }
3961 
3962  if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
3963  // If there's no unsigned wrap, the value will never be less than its
3964  // initial value.
3965  if (AddRec->getNoWrapFlags(SCEV::FlagNUW))
3966  if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
3967  if (!C->getValue()->isZero())
3968  ConservativeResult =
3969  ConservativeResult.intersectWith(
3970  ConstantRange(C->getValue()->getValue(), APInt(BitWidth, 0)));
3971 
3972  // If there's no signed wrap, and all the operands have the same sign or
3973  // zero, the value won't ever change sign.
3974  if (AddRec->getNoWrapFlags(SCEV::FlagNSW)) {
3975  bool AllNonNeg = true;
3976  bool AllNonPos = true;
3977  for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
3978  if (!isKnownNonNegative(AddRec->getOperand(i))) AllNonNeg = false;
3979  if (!isKnownNonPositive(AddRec->getOperand(i))) AllNonPos = false;
3980  }
3981  if (AllNonNeg)
3982  ConservativeResult = ConservativeResult.intersectWith(
3983  ConstantRange(APInt(BitWidth, 0),
3984  APInt::getSignedMinValue(BitWidth)));
3985  else if (AllNonPos)
3986  ConservativeResult = ConservativeResult.intersectWith(
3988  APInt(BitWidth, 1)));
3989  }
3990 
3991  // TODO: non-affine addrec
3992  if (AddRec->isAffine()) {
3993  Type *Ty = AddRec->getType();
3994  const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
3995  if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
3996  getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
3997 
3998  // Check for overflow. This must be done with ConstantRange arithmetic
3999  // because we could be called from within the ScalarEvolution overflow
4000  // checking code.
4001 
4002  MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
4003  ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
4004  ConstantRange ZExtMaxBECountRange =
4005  MaxBECountRange.zextOrTrunc(BitWidth * 2 + 1);
4006 
4007  const SCEV *Start = AddRec->getStart();
4008  const SCEV *Step = AddRec->getStepRecurrence(*this);
4009  ConstantRange StepSRange = getSignedRange(Step);
4010  ConstantRange SExtStepSRange = StepSRange.sextOrTrunc(BitWidth * 2 + 1);
4011 
4012  ConstantRange StartURange = getUnsignedRange(Start);
4013  ConstantRange EndURange =
4014  StartURange.add(MaxBECountRange.multiply(StepSRange));
4015 
4016  // Check for unsigned overflow.
4017  ConstantRange ZExtStartURange =
4018  StartURange.zextOrTrunc(BitWidth * 2 + 1);
4019  ConstantRange ZExtEndURange = EndURange.zextOrTrunc(BitWidth * 2 + 1);
4020  if (ZExtStartURange.add(ZExtMaxBECountRange.multiply(SExtStepSRange)) ==
4021  ZExtEndURange) {
4022  APInt Min = APIntOps::umin(StartURange.getUnsignedMin(),
4023  EndURange.getUnsignedMin());
4024  APInt Max = APIntOps::umax(StartURange.getUnsignedMax(),
4025  EndURange.getUnsignedMax());
4026  bool IsFullRange = Min.isMinValue() && Max.isMaxValue();
4027  if (!IsFullRange)
4028  ConservativeResult =
4029  ConservativeResult.intersectWith(ConstantRange(Min, Max + 1));
4030  }
4031 
4032  ConstantRange StartSRange = getSignedRange(Start);
4033  ConstantRange EndSRange =
4034  StartSRange.add(MaxBECountRange.multiply(StepSRange));
4035 
4036  // Check for signed overflow. This must be done with ConstantRange
4037  // arithmetic because we could be called from within the ScalarEvolution
4038  // overflow checking code.
4039  ConstantRange SExtStartSRange =
4040  StartSRange.sextOrTrunc(BitWidth * 2 + 1);
4041  ConstantRange SExtEndSRange = EndSRange.sextOrTrunc(BitWidth * 2 + 1);
4042  if (SExtStartSRange.add(ZExtMaxBECountRange.multiply(SExtStepSRange)) ==
4043  SExtEndSRange) {
4044  APInt Min = APIntOps::smin(StartSRange.getSignedMin(),
4045  EndSRange.getSignedMin());
4046  APInt Max = APIntOps::smax(StartSRange.getSignedMax(),
4047  EndSRange.getSignedMax());
4048  bool IsFullRange = Min.isMinSignedValue() && Max.isMaxSignedValue();
4049  if (!IsFullRange)
4050  ConservativeResult =
4051  ConservativeResult.intersectWith(ConstantRange(Min, Max + 1));
4052  }
4053  }
4054  }
4055 
4056  return setRange(AddRec, SignHint, ConservativeResult);
4057  }
4058 
4059  if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
4060  // Check if the IR explicitly contains !range metadata.
4061  Optional<ConstantRange> MDRange = GetRangeFromMetadata(U->getValue());
4062  if (MDRange.hasValue())
4063  ConservativeResult = ConservativeResult.intersectWith(MDRange.getValue());
4064 
4065  // Split here to avoid paying the compile-time cost of calling both
4066  // computeKnownBits and ComputeNumSignBits. This restriction can be lifted
4067  // if needed.
4068  const DataLayout &DL = F->getParent()->getDataLayout();
4069  if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED) {
4070  // For a SCEVUnknown, ask ValueTracking.
4071  APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
4072  computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AC, nullptr, DT);
4073  if (Ones != ~Zeros + 1)
4074  ConservativeResult =
4075  ConservativeResult.intersectWith(ConstantRange(Ones, ~Zeros + 1));
4076  } else {
4077  assert(SignHint == ScalarEvolution::HINT_RANGE_SIGNED &&
4078  "generalize as needed!");
4079  unsigned NS = ComputeNumSignBits(U->getValue(), DL, 0, AC, nullptr, DT);
4080  if (NS > 1)
4081  ConservativeResult = ConservativeResult.intersectWith(
4082  ConstantRange(APInt::getSignedMinValue(BitWidth).ashr(NS - 1),
4083  APInt::getSignedMaxValue(BitWidth).ashr(NS - 1) + 1));
4084  }
4085 
4086  return setRange(U, SignHint, ConservativeResult);
4087  }
4088 
4089  return setRange(S, SignHint, ConservativeResult);
4090 }
4091 
4092 /// createSCEV - We know that there is no SCEV for the specified value.
4093 /// Analyze the expression.
4094 ///
4095 const SCEV *ScalarEvolution::createSCEV(Value *V) {
4096  if (!isSCEVable(V->getType()))
4097  return getUnknown(V);
4098 
4099  unsigned Opcode = Instruction::UserOp1;
4100  if (Instruction *I = dyn_cast<Instruction>(V)) {
4101  Opcode = I->getOpcode();
4102 
4103  // Don't attempt to analyze instructions in blocks that aren't
4104  // reachable. Such instructions don't matter, and they aren't required
4105  // to obey basic rules for definitions dominating uses which this
4106  // analysis depends on.
4107  if (!DT->isReachableFromEntry(I->getParent()))
4108  return getUnknown(V);
4109  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
4110  Opcode = CE->getOpcode();
4111  else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
4112  return getConstant(CI);
4113  else if (isa<ConstantPointerNull>(V))
4114  return getConstant(V->getType(), 0);
4115  else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
4116  return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
4117  else
4118  return getUnknown(V);
4119 
4120  Operator *U = cast<Operator>(V);
4121  switch (Opcode) {
4122  case Instruction::Add: {
4123  // The simple thing to do would be to just call getSCEV on both operands
4124  // and call getAddExpr with the result. However if we're looking at a
4125  // bunch of things all added together, this can be quite inefficient,
4126  // because it leads to N-1 getAddExpr calls for N ultimate operands.
4127  // Instead, gather up all the operands and make a single getAddExpr call.
4128  // LLVM IR canonical form means we need only traverse the left operands.
4129  //
4130  // Don't apply this instruction's NSW or NUW flags to the new
4131  // expression. The instruction may be guarded by control flow that the
4132  // no-wrap behavior depends on. Non-control-equivalent instructions can be
4133  // mapped to the same SCEV expression, and it would be incorrect to transfer
4134  // NSW/NUW semantics to those operations.
4136  AddOps.push_back(getSCEV(U->getOperand(1)));
4137  for (Value *Op = U->getOperand(0); ; Op = U->getOperand(0)) {
4138  unsigned Opcode = Op->getValueID() - Value::InstructionVal;
4139  if (Opcode != Instruction::Add && Opcode != Instruction::Sub)
4140  break;
4141  U = cast<Operator>(Op);
4142  const SCEV *Op1 = getSCEV(U->getOperand(1));
4143  if (Opcode == Instruction::Sub)
4144  AddOps.push_back(getNegativeSCEV(Op1));
4145  else
4146  AddOps.push_back(Op1);
4147  }
4148  AddOps.push_back(getSCEV(U->getOperand(0)));
4149  return getAddExpr(AddOps);
4150  }
4151  case Instruction::Mul: {
4152  // Don't transfer NSW/NUW for the same reason as AddExpr.
4154  MulOps.push_back(getSCEV(U->getOperand(1)));
4155  for (Value *Op = U->getOperand(0);
4156  Op->getValueID() == Instruction::Mul + Value::InstructionVal;
4157  Op = U->getOperand(0)) {
4158  U = cast<Operator>(Op);
4159  MulOps.push_back(getSCEV(U->getOperand(1)));
4160  }
4161  MulOps.push_back(getSCEV(U->getOperand(0)));
4162  return getMulExpr(MulOps);
4163  }
4164  case Instruction::UDiv:
4165  return getUDivExpr(getSCEV(U->getOperand(0)),
4166  getSCEV(U->getOperand(1)));
4167  case Instruction::Sub:
4168  return getMinusSCEV(getSCEV(U->getOperand(0)),
4169  getSCEV(U->getOperand(1)));
4170  case Instruction::And:
4171  // For an expression like x&255 that merely masks off the high bits,
4172  // use zext(trunc(x)) as the SCEV expression.
4173  if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
4174  if (CI->isNullValue())
4175  return getSCEV(U->getOperand(1));
4176  if (CI->isAllOnesValue())
4177  return getSCEV(U->getOperand(0));
4178  const APInt &A = CI->getValue();
4179 
4180  // Instcombine's ShrinkDemandedConstant may strip bits out of
4181  // constants, obscuring what would otherwise be a low-bits mask.
4182  // Use computeKnownBits to compute what ShrinkDemandedConstant
4183  // knew about to reconstruct a low-bits mask value.
4184  unsigned LZ = A.countLeadingZeros();
4185  unsigned TZ = A.countTrailingZeros();
4186  unsigned BitWidth = A.getBitWidth();
4187  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
4188  computeKnownBits(U->getOperand(0), KnownZero, KnownOne,
4189  F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
4190 
4191  APInt EffectiveMask =
4192  APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ);
4193  if ((LZ != 0 || TZ != 0) && !((~A & ~KnownZero) & EffectiveMask)) {
4194  const SCEV *MulCount = getConstant(
4195  ConstantInt::get(getContext(), APInt::getOneBitSet(BitWidth, TZ)));
4196  return getMulExpr(
4199  getUDivExactExpr(getSCEV(U->getOperand(0)), MulCount),
4200  IntegerType::get(getContext(), BitWidth - LZ - TZ)),
4201  U->getType()),
4202  MulCount);
4203  }
4204  }
4205  break;
4206 
4207  case Instruction::Or:
4208  // If the RHS of the Or is a constant, we may have something like:
4209  // X*4+1 which got turned into X*4|1. Handle this as an Add so loop
4210  // optimizations will transparently handle this case.
4211  //
4212  // In order for this transformation to be safe, the LHS must be of the
4213  // form X*(2^n) and the Or constant must be less than 2^n.
4214  if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
4215  const SCEV *LHS = getSCEV(U->getOperand(0));
4216  const APInt &CIVal = CI->getValue();
4217  if (GetMinTrailingZeros(LHS) >=
4218  (CIVal.getBitWidth() - CIVal.countLeadingZeros())) {
4219  // Build a plain add SCEV.
4220  const SCEV *S = getAddExpr(LHS, getSCEV(CI));
4221  // If the LHS of the add was an addrec and it has no-wrap flags,
4222  // transfer the no-wrap flags, since an or won't introduce a wrap.
4223  if (const SCEVAddRecExpr *NewAR = dyn_cast<SCEVAddRecExpr>(S)) {
4224  const SCEVAddRecExpr *OldAR = cast<SCEVAddRecExpr>(LHS);
4225  const_cast<SCEVAddRecExpr *>(NewAR)->setNoWrapFlags(
4226  OldAR->getNoWrapFlags());
4227  }
4228  return S;
4229  }
4230  }
4231  break;
4232  case Instruction::Xor:
4233  if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
4234  // If the RHS of the xor is a signbit, then this is just an add.
4235  // Instcombine turns add of signbit into xor as a strength reduction step.
4236  if (CI->getValue().isSignBit())
4237  return getAddExpr(getSCEV(U->getOperand(0)),
4238  getSCEV(U->getOperand(1)));
4239 
4240  // If the RHS of xor is -1, then this is a not operation.
4241  if (CI->isAllOnesValue())
4242  return getNotSCEV(getSCEV(U->getOperand(0)));
4243 
4244  // Model xor(and(x, C), C) as and(~x, C), if C is a low-bits mask.
4245  // This is a variant of the check for xor with -1, and it handles
4246  // the case where instcombine has trimmed non-demanded bits out
4247  // of an xor with -1.
4248  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(U->getOperand(0)))
4249  if (ConstantInt *LCI = dyn_cast<ConstantInt>(BO->getOperand(1)))
4250  if (BO->getOpcode() == Instruction::And &&
4251  LCI->getValue() == CI->getValue())
4252  if (const SCEVZeroExtendExpr *Z =
4253  dyn_cast<SCEVZeroExtendExpr>(getSCEV(U->getOperand(0)))) {
4254  Type *UTy = U->getType();
4255  const SCEV *Z0 = Z->getOperand();
4256  Type *Z0Ty = Z0->getType();
4257  unsigned Z0TySize = getTypeSizeInBits(Z0Ty);
4258 
4259  // If C is a low-bits mask, the zero extend is serving to
4260  // mask off the high bits. Complement the operand and
4261  // re-apply the zext.
4262  if (APIntOps::isMask(Z0TySize, CI->getValue()))
4263  return getZeroExtendExpr(getNotSCEV(Z0), UTy);
4264 
4265  // If C is a single bit, it may be in the sign-bit position
4266  // before the zero-extend. In this case, represent the xor
4267  // using an add, which is equivalent, and re-apply the zext.
4268  APInt Trunc = CI->getValue().trunc(Z0TySize);
4269  if (Trunc.zext(getTypeSizeInBits(UTy)) == CI->getValue() &&
4270  Trunc.isSignBit())
4271  return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
4272  UTy);
4273  }
4274  }
4275  break;
4276 
4277  case Instruction::Shl:
4278  // Turn shift left of a constant amount into a multiply.
4279  if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
4280  uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
4281 
4282  // If the shift count is not less than the bitwidth, the result of
4283  // the shift is undefined. Don't try to analyze it, because the
4284  // resolution chosen here may differ from the resolution chosen in
4285  // other parts of the compiler.
4286  if (SA->getValue().uge(BitWidth))
4287  break;
4288 
4290  APInt::getOneBitSet(BitWidth, SA->getZExtValue()));
4291  return getMulExpr(getSCEV(U->getOperand(0)), getSCEV(X));
4292  }
4293  break;
4294 
4295  case Instruction::LShr:
4296  // Turn logical shift right of a constant into a unsigned divide.
4297  if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
4298  uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
4299 
4300  // If the shift count is not less than the bitwidth, the result of
4301  // the shift is undefined. Don't try to analyze it, because the
4302  // resolution chosen here may differ from the resolution chosen in
4303  // other parts of the compiler.
4304  if (SA->getValue().uge(BitWidth))
4305  break;
4306 
4308  APInt::getOneBitSet(BitWidth, SA->getZExtValue()));
4309  return getUDivExpr(getSCEV(U->getOperand(0)), getSCEV(X));
4310  }
4311  break;
4312 
4313  case Instruction::AShr:
4314  // For a two-shift sext-inreg, use sext(trunc(x)) as the SCEV expression.
4315  if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1)))
4316  if (Operator *L = dyn_cast<Operator>(U->getOperand(0)))
4317  if (L->getOpcode() == Instruction::Shl &&
4318  L->getOperand(1) == U->getOperand(1)) {
4319  uint64_t BitWidth = getTypeSizeInBits(U->getType());
4320 
4321  // If the shift count is not less than the bitwidth, the result of
4322  // the shift is undefined. Don't try to analyze it, because the
4323  // resolution chosen here may differ from the resolution chosen in
4324  // other parts of the compiler.
4325  if (CI->getValue().uge(BitWidth))
4326  break;
4327 
4328  uint64_t Amt = BitWidth - CI->getZExtValue();
4329  if (Amt == BitWidth)
4330  return getSCEV(L->getOperand(0)); // shift by zero --> noop
4331  return
4332  getSignExtendExpr(getTruncateExpr(getSCEV(L->getOperand(0)),
4334  Amt)),
4335  U->getType());
4336  }
4337  break;
4338 
4339  case Instruction::Trunc:
4340  return getTruncateExpr(getSCEV(U->getOperand(0)), U->getType());
4341 
4342  case Instruction::ZExt:
4343  return getZeroExtendExpr(getSCEV(U->getOperand(0)), U->getType());
4344 
4345  case Instruction::SExt:
4346  return getSignExtendExpr(getSCEV(U->getOperand(0)), U->getType());
4347 
4348  case Instruction::BitCast:
4349  // BitCasts are no-op casts so we just eliminate the cast.
4350  if (isSCEVable(U->getType()) && isSCEVable(U->getOperand(0)->getType()))
4351  return getSCEV(U->getOperand(0));
4352  break;
4353 
4354  // It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
4355  // lead to pointer expressions which cannot safely be expanded to GEPs,
4356  // because ScalarEvolution doesn't respect the GEP aliasing rules when
4357  // simplifying integer expressions.
4358 
4359  case Instruction::GetElementPtr:
4360  return createNodeForGEP(cast<GEPOperator>(U));
4361 
4362  case Instruction::PHI:
4363  return createNodeForPHI(cast<PHINode>(U));
4364 
4365  case Instruction::Select:
4366  // This could be a smax or umax that was lowered earlier.
4367  // Try to recover it.
4368  if (ICmpInst *ICI = dyn_cast<ICmpInst>(U->getOperand(0))) {
4369  Value *LHS = ICI->getOperand(0);
4370  Value *RHS = ICI->getOperand(1);
4371  switch (ICI->getPredicate()) {
4372  case ICmpInst::ICMP_SLT:
4373  case ICmpInst::ICMP_SLE:
4374  std::swap(LHS, RHS);
4375  // fall through
4376  case ICmpInst::ICMP_SGT:
4377  case ICmpInst::ICMP_SGE:
4378  // a >s b ? a+x : b+x -> smax(a, b)+x
4379  // a >s b ? b+x : a+x -> smin(a, b)+x
4380  if (getTypeSizeInBits(LHS->getType()) <=
4381  getTypeSizeInBits(U->getType())) {
4382  const SCEV *LS = getNoopOrSignExtend(getSCEV(LHS), U->getType());
4383  const SCEV *RS = getNoopOrSignExtend(getSCEV(RHS), U->getType());
4384  const SCEV *LA = getSCEV(U->getOperand(1));
4385  const SCEV *RA = getSCEV(U->getOperand(2));
4386  const SCEV *LDiff = getMinusSCEV(LA, LS);
4387  const SCEV *RDiff = getMinusSCEV(RA, RS);
4388  if (LDiff == RDiff)
4389  return getAddExpr(getSMaxExpr(LS, RS), LDiff);
4390  LDiff = getMinusSCEV(LA, RS);
4391  RDiff = getMinusSCEV(RA, LS);
4392  if (LDiff == RDiff)
4393  return getAddExpr(getSMinExpr(LS, RS), LDiff);
4394  }
4395  break;
4396  case ICmpInst::ICMP_ULT:
4397  case ICmpInst::ICMP_ULE:
4398  std::swap(LHS, RHS);
4399  // fall through
4400  case ICmpInst::ICMP_UGT:
4401  case ICmpInst::ICMP_UGE:
4402  // a >u b ? a+x : b+x -> umax(a, b)+x
4403  // a >u b ? b+x : a+x -> umin(a, b)+x
4404  if (getTypeSizeInBits(LHS->getType()) <=
4405  getTypeSizeInBits(U->getType())) {
4406  const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
4407  const SCEV *RS = getNoopOrZeroExtend(getSCEV(RHS), U->getType());
4408  const SCEV *LA = getSCEV(U->getOperand(1));
4409  const SCEV *RA = getSCEV(U->getOperand(2));
4410  const SCEV *LDiff = getMinusSCEV(LA, LS);
4411  const SCEV *RDiff = getMinusSCEV(RA, RS);
4412  if (LDiff == RDiff)
4413  return getAddExpr(getUMaxExpr(LS, RS), LDiff);
4414  LDiff = getMinusSCEV(LA, RS);
4415  RDiff = getMinusSCEV(RA, LS);
4416  if (LDiff == RDiff)
4417  return getAddExpr(getUMinExpr(LS, RS), LDiff);
4418  }
4419  break;
4420  case ICmpInst::ICMP_NE:
4421  // n != 0 ? n+x : 1+x -> umax(n, 1)+x
4422  if (getTypeSizeInBits(LHS->getType()) <=
4423  getTypeSizeInBits(U->getType()) &&
4424  isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
4425  const SCEV *One = getConstant(U->getType(), 1);
4426  const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
4427  const SCEV *LA = getSCEV(U->getOperand(1));
4428  const SCEV *RA = getSCEV(U->getOperand(2));
4429  const SCEV *LDiff = getMinusSCEV(LA, LS);
4430  const SCEV *RDiff = getMinusSCEV(RA, One);
4431  if (LDiff == RDiff)
4432  return getAddExpr(getUMaxExpr(One, LS), LDiff);
4433  }
4434  break;
4435  case ICmpInst::ICMP_EQ:
4436  // n == 0 ? 1+x : n+x -> umax(n, 1)+x
4437  if (getTypeSizeInBits(LHS->getType()) <=
4438  getTypeSizeInBits(U->getType()) &&
4439  isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
4440  const SCEV *One = getConstant(U->getType(), 1);
4441  const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
4442  const SCEV *LA = getSCEV(U->getOperand(1));
4443  const SCEV *RA = getSCEV(U->getOperand(2));
4444  const SCEV *LDiff = getMinusSCEV(LA, One);
4445  const SCEV *RDiff = getMinusSCEV(RA, LS);
4446  if (LDiff == RDiff)
4447  return getAddExpr(getUMaxExpr(One, LS), LDiff);
4448  }
4449  break;
4450  default:
4451  break;
4452  }
4453  }
4454 
4455  default: // We cannot analyze this expression.
4456  break;
4457  }
4458 
4459  return getUnknown(V);
4460 }
4461 
4462 
4463 
4464 //===----------------------------------------------------------------------===//
4465 // Iteration Count Computation Code
4466 //
4467 
4469  if (BasicBlock *ExitingBB = L->getExitingBlock())
4470  return getSmallConstantTripCount(L, ExitingBB);
4471 
4472  // No trip count information for multiple exits.
4473  return 0;
4474 }
4475 
4476 /// getSmallConstantTripCount - Returns the maximum trip count of this loop as a
4477 /// normal unsigned value. Returns 0 if the trip count is unknown or not
4478 /// constant. Will also return 0 if the maximum trip count is very large (>=
4479 /// 2^32).
4480 ///
4481 /// This "trip count" assumes that control exits via ExitingBlock. More
4482 /// precisely, it is the number of times that control may reach ExitingBlock
4483 /// before taking the branch. For loops with multiple exits, it may not be the
4484 /// number times that the loop header executes because the loop may exit
4485 /// prematurely via another branch.
4487  BasicBlock *ExitingBlock) {
4488  assert(ExitingBlock && "Must pass a non-null exiting block!");
4489  assert(L->isLoopExiting(ExitingBlock) &&
4490  "Exiting block must actually branch out of the loop!");
4491  const SCEVConstant *ExitCount =
4492  dyn_cast<SCEVConstant>(getExitCount(L, ExitingBlock));
4493  if (!ExitCount)
4494  return 0;
4495 
4496  ConstantInt *ExitConst = ExitCount->getValue();
4497 
4498  // Guard against huge trip counts.
4499  if (ExitConst->getValue().getActiveBits() > 32)
4500  return 0;
4501 
4502  // In case of integer overflow, this returns 0, which is correct.
4503  return ((unsigned)ExitConst->getZExtValue()) + 1;
4504 }
4505 
4507  if (BasicBlock *ExitingBB = L->getExitingBlock())
4508  return getSmallConstantTripMultiple(L, ExitingBB);
4509 
4510  // No trip multiple information for multiple exits.
4511  return 0;
4512 }
4513 
4514 /// getSmallConstantTripMultiple - Returns the largest constant divisor of the
4515 /// trip count of this loop as a normal unsigned value, if possible. This
4516 /// means that the actual trip count is always a multiple of the returned
4517 /// value (don't forget the trip count could very well be zero as well!).
4518 ///
4519 /// Returns 1 if the trip count is unknown or not guaranteed to be the
4520 /// multiple of a constant (which is also the case if the trip count is simply
4521 /// constant, use getSmallConstantTripCount for that case), Will also return 1
4522 /// if the trip count is very large (>= 2^32).
4523 ///
4524 /// As explained in the comments for getSmallConstantTripCount, this assumes
4525 /// that control exits the loop via ExitingBlock.
4526 unsigned
4528  BasicBlock *ExitingBlock) {
4529  assert(ExitingBlock && "Must pass a non-null exiting block!");
4530  assert(L->isLoopExiting(ExitingBlock) &&
4531  "Exiting block must actually branch out of the loop!");
4532  const SCEV *ExitCount = getExitCount(L, ExitingBlock);
4533  if (ExitCount == getCouldNotCompute())
4534  return 1;
4535 
4536  // Get the trip count from the BE count by adding 1.
4537  const SCEV *TCMul = getAddExpr(ExitCount,
4538  getConstant(ExitCount->getType(), 1));
4539  // FIXME: SCEV distributes multiplication as V1*C1 + V2*C1. We could attempt
4540  // to factor simple cases.
4541  if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(TCMul))
4542  TCMul = Mul->getOperand(0);
4543 
4544  const SCEVConstant *MulC = dyn_cast<SCEVConstant>(TCMul);
4545  if (!MulC)
4546  return 1;
4547 
4548  ConstantInt *Result = MulC->getValue();
4549 
4550  // Guard against huge trip counts (this requires checking
4551  // for zero to handle the case where the trip count == -1 and the
4552  // addition wraps).
4553  if (!Result || Result->getValue().getActiveBits() > 32 ||
4554  Result->getValue().getActiveBits() == 0)
4555  return 1;
4556 
4557  return (unsigned)Result->getZExtValue();
4558 }
4559 
4560 // getExitCount - Get the expression for the number of loop iterations for which
4561 // this loop is guaranteed not to exit via ExitingBlock. Otherwise return
4562 // SCEVCouldNotCompute.
4564  return getBackedgeTakenInfo(L).getExact(ExitingBlock, this);
4565 }
4566 
4567 /// getBackedgeTakenCount - If the specified loop has a predictable
4568 /// backedge-taken count, return it, otherwise return a SCEVCouldNotCompute
4569 /// object. The backedge-taken count is the number of times the loop header
4570 /// will be branched to from within the loop. This is one less than the
4571 /// trip count of the loop, since it doesn't count the first iteration,
4572 /// when the header is branched to from outside the loop.
4573 ///
4574 /// Note that it is not valid to call this method on a loop without a
4575 /// loop-invariant backedge-taken count (see
4576 /// hasLoopInvariantBackedgeTakenCount).
4577 ///
4579  return getBackedgeTakenInfo(L).getExact(this);
4580 }
4581 
4582 /// getMaxBackedgeTakenCount - Similar to getBackedgeTakenCount, except
4583 /// return the least SCEV value that is known never to be less than the
4584 /// actual backedge taken count.
4586  return getBackedgeTakenInfo(L).getMax(this);
4587 }
4588 
4589 /// PushLoopPHIs - Push PHI nodes in the header of the given loop
4590 /// onto the given Worklist.
4591 static void
4593  BasicBlock *Header = L->getHeader();
4594 
4595  // Push all Loop-header PHIs onto the Worklist stack.
4596  for (BasicBlock::iterator I = Header->begin();
4597  PHINode *PN = dyn_cast<PHINode>(I); ++I)
4598  Worklist.push_back(PN);
4599 }
4600 
4601 const ScalarEvolution::BackedgeTakenInfo &
4602 ScalarEvolution::getBackedgeTakenInfo(const Loop *L) {
4603  // Initially insert an invalid entry for this loop. If the insertion
4604  // succeeds, proceed to actually compute a backedge-taken count and
4605  // update the value. The temporary CouldNotCompute value tells SCEV
4606  // code elsewhere that it shouldn't attempt to request a new
4607  // backedge-taken count, which could result in infinite recursion.
4608  std::pair<DenseMap<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
4609  BackedgeTakenCounts.insert(std::make_pair(L, BackedgeTakenInfo()));
4610  if (!Pair.second)
4611  return Pair.first->second;
4612 
4613  // ComputeBackedgeTakenCount may allocate memory for its result. Inserting it
4614  // into the BackedgeTakenCounts map transfers ownership. Otherwise, the result
4615  // must be cleared in this scope.
4616  BackedgeTakenInfo Result = ComputeBackedgeTakenCount(L);
4617 
4618  if (Result.getExact(this) != getCouldNotCompute()) {
4619  assert(isLoopInvariant(Result.getExact(this), L) &&
4620  isLoopInvariant(Result.getMax(this), L) &&
4621  "Computed backedge-taken count isn't loop invariant for loop!");
4622  ++NumTripCountsComputed;
4623  }
4624  else if (Result.getMax(this) == getCouldNotCompute() &&
4625  isa<PHINode>(L->getHeader()->begin())) {
4626  // Only count loops that have phi nodes as not being computable.
4627  ++NumTripCountsNotComputed;
4628  }
4629 
4630  // Now that we know more about the trip count for this loop, forget any
4631  // existing SCEV values for PHI nodes in this loop since they are only
4632  // conservative estimates made without the benefit of trip count
4633  // information. This is similar to the code in forgetLoop, except that
4634  // it handles SCEVUnknown PHI nodes specially.
4635  if (Result.hasAnyInfo()) {
4637  PushLoopPHIs(L, Worklist);
4638 
4640  while (!Worklist.empty()) {
4641  Instruction *I = Worklist.pop_back_val();
4642  if (!Visited.insert(I).second)
4643  continue;
4644 
4646  ValueExprMap.find_as(static_cast<Value *>(I));
4647  if (It != ValueExprMap.end()) {
4648  const SCEV *Old = It->second;
4649 
4650  // SCEVUnknown for a PHI either means that it has an unrecognized
4651  // structure, or it's a PHI that's in the progress of being computed
4652  // by createNodeForPHI. In the former case, additional loop trip
4653  // count information isn't going to change anything. In the later
4654  // case, createNodeForPHI will perform the necessary updates on its
4655  // own when it gets to that point.
4656  if (!isa<PHINode>(I) || !isa<SCEVUnknown>(Old)) {
4657  forgetMemoizedResults(Old);
4658  ValueExprMap.erase(It);
4659  }
4660  if (PHINode *PN = dyn_cast<PHINode>(I))
4661  ConstantEvolutionLoopExitValue.erase(PN);
4662  }
4663 
4664  PushDefUseChildren(I, Worklist);
4665  }
4666  }
4667 
4668  // Re-lookup the insert position, since the call to
4669  // ComputeBackedgeTakenCount above could result in a
4670  // recusive call to getBackedgeTakenInfo (on a different
4671  // loop), which would invalidate the iterator computed
4672  // earlier.
4673  return BackedgeTakenCounts.find(L)->second = Result;
4674 }
4675 
4676 /// forgetLoop - This method should be called by the client when it has
4677 /// changed a loop in a way that may effect ScalarEvolution's ability to
4678 /// compute a trip count, or if the loop is deleted.
4680  // Drop any stored trip count value.
4682  BackedgeTakenCounts.find(L);
4683  if (BTCPos != BackedgeTakenCounts.end()) {
4684  BTCPos->second.clear();
4685  BackedgeTakenCounts.erase(BTCPos);
4686  }
4687 
4688  // Drop information about expressions based on loop-header PHIs.
4690  PushLoopPHIs(L, Worklist);
4691 
4693  while (!Worklist.empty()) {
4694  Instruction *I = Worklist.pop_back_val();
4695  if (!Visited.insert(I).second)
4696  continue;
4697 
4699  ValueExprMap.find_as(static_cast<Value *>(I));
4700  if (It != ValueExprMap.end()) {
4701  forgetMemoizedResults(It->second);
4702  ValueExprMap.erase(It);
4703  if (PHINode *PN = dyn_cast<PHINode>(I))
4704  ConstantEvolutionLoopExitValue.erase(PN);
4705  }
4706 
4707  PushDefUseChildren(I, Worklist);
4708  }
4709 
4710  // Forget all contained loops too, to avoid dangling entries in the
4711  // ValuesAtScopes map.
4712  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
4713  forgetLoop(*I);
4714 }
4715 
4716 /// forgetValue - This method should be called by the client when it has
4717 /// changed a value in a way that may effect its value, or which may
4718 /// disconnect it from a def-use chain linking it to a loop.
4720  Instruction *I = dyn_cast<Instruction>(V);
4721  if (!I) return;
4722 
4723  // Drop information about expressions based on loop-header PHIs.
4725  Worklist.push_back(I);
4726 
4728  while (!Worklist.empty()) {
4729  I = Worklist.pop_back_val();
4730  if (!Visited.insert(I).second)
4731  continue;
4732 
4734  ValueExprMap.find_as(static_cast<Value *>(I));
4735  if (It != ValueExprMap.end()) {
4736  forgetMemoizedResults(It->second);
4737  ValueExprMap.erase(It);
4738  if (PHINode *PN = dyn_cast<PHINode>(I))
4739  ConstantEvolutionLoopExitValue.erase(PN);
4740  }
4741 
4742  PushDefUseChildren(I, Worklist);
4743  }
4744 }
4745 
4746 /// getExact - Get the exact loop backedge taken count considering all loop
4747 /// exits. A computable result can only be return for loops with a single exit.
4748 /// Returning the minimum taken count among all exits is incorrect because one
4749 /// of the loop's exit limit's may have been skipped. HowFarToZero assumes that
4750 /// the limit of each loop test is never skipped. This is a valid assumption as
4751 /// long as the loop exits via that test. For precise results, it is the
4752 /// caller's responsibility to specify the relevant loop exit using
4753 /// getExact(ExitingBlock, SE).
4754 const SCEV *
4755 ScalarEvolution::BackedgeTakenInfo::getExact(ScalarEvolution *SE) const {
4756  // If any exits were not computable, the loop is not computable.
4757  if (!ExitNotTaken.isCompleteList()) return SE->getCouldNotCompute();
4758 
4759  // We need exactly one computable exit.
4760  if (!ExitNotTaken.ExitingBlock) return SE->getCouldNotCompute();
4761  assert(ExitNotTaken.ExactNotTaken && "uninitialized not-taken info");
4762 
4763  const SCEV *BECount = nullptr;
4764  for (const ExitNotTakenInfo *ENT = &ExitNotTaken;
4765  ENT != nullptr; ENT = ENT->getNextExit()) {
4766 
4767  assert(ENT->ExactNotTaken != SE->getCouldNotCompute() && "bad exit SCEV");
4768 
4769  if (!BECount)
4770  BECount = ENT->ExactNotTaken;
4771  else if (BECount != ENT->ExactNotTaken)
4772  return SE->getCouldNotCompute();
4773  }
4774  assert(BECount && "Invalid not taken count for loop exit");
4775  return BECount;
4776 }
4777 
4778 /// getExact - Get the exact not taken count for this loop exit.
4779 const SCEV *
4780 ScalarEvolution::BackedgeTakenInfo::getExact(BasicBlock *ExitingBlock,
4781  ScalarEvolution *SE) const {
4782  for (const ExitNotTakenInfo *ENT = &ExitNotTaken;
4783  ENT != nullptr; ENT = ENT->getNextExit()) {
4784 
4785  if (ENT->ExitingBlock == ExitingBlock)
4786  return ENT->ExactNotTaken;
4787  }
4788  return SE->getCouldNotCompute();
4789 }
4790 
4791 /// getMax - Get the max backedge taken count for the loop.
4792 const SCEV *
4793 ScalarEvolution::BackedgeTakenInfo::getMax(ScalarEvolution *SE) const {
4794  return Max ? Max : SE->getCouldNotCompute();
4795 }
4796 
4797 bool ScalarEvolution::BackedgeTakenInfo::hasOperand(const SCEV *S,
4798  ScalarEvolution *SE) const {
4799  if (Max && Max != SE->getCouldNotCompute() && SE->hasOperand(Max, S))
4800  return true;
4801 
4802  if (!ExitNotTaken.ExitingBlock)
4803  return false;
4804 
4805  for (const ExitNotTakenInfo *ENT = &ExitNotTaken;
4806  ENT != nullptr; ENT = ENT->getNextExit()) {
4807 
4808  if (ENT->ExactNotTaken != SE->getCouldNotCompute()
4809  && SE->hasOperand(ENT->ExactNotTaken, S)) {
4810  return true;
4811  }
4812  }
4813  return false;
4814 }
4815 
4816 /// Allocate memory for BackedgeTakenInfo and copy the not-taken count of each
4817 /// computable exit into a persistent ExitNotTakenInfo array.
4818 ScalarEvolution::BackedgeTakenInfo::BackedgeTakenInfo(
4819  SmallVectorImpl< std::pair<BasicBlock *, const SCEV *> > &ExitCounts,
4820  bool Complete, const SCEV *MaxCount) : Max(MaxCount) {
4821 
4822  if (!Complete)
4823  ExitNotTaken.setIncomplete();
4824 
4825  unsigned NumExits = ExitCounts.size();
4826  if (NumExits == 0) return;
4827 
4828  ExitNotTaken.ExitingBlock = ExitCounts[0].first;
4829  ExitNotTaken.ExactNotTaken = ExitCounts[0].second;
4830  if (NumExits == 1) return;
4831 
4832  // Handle the rare case of multiple computable exits.
4833  ExitNotTakenInfo *ENT = new ExitNotTakenInfo[NumExits-1];
4834 
4835  ExitNotTakenInfo *PrevENT = &ExitNotTaken;
4836  for (unsigned i = 1; i < NumExits; ++i, PrevENT = ENT, ++ENT) {
4837  PrevENT->setNextExit(ENT);
4838  ENT->ExitingBlock = ExitCounts[i].first;
4839  ENT->ExactNotTaken = ExitCounts[i].second;
4840  }
4841 }
4842 
4843 /// clear - Invalidate this result and free the ExitNotTakenInfo array.
4844 void ScalarEvolution::BackedgeTakenInfo::clear() {
4845  ExitNotTaken.ExitingBlock = nullptr;
4846  ExitNotTaken.ExactNotTaken = nullptr;
4847  delete[] ExitNotTaken.getNextExit();
4848 }
4849 
4850 /// ComputeBackedgeTakenCount - Compute the number of times the backedge
4851 /// of the specified loop will execute.
4852 ScalarEvolution::BackedgeTakenInfo
4853 ScalarEvolution::ComputeBackedgeTakenCount(const Loop *L) {
4854  SmallVector<BasicBlock *, 8> ExitingBlocks;
4855  L->getExitingBlocks(ExitingBlocks);
4856 
4858  bool CouldComputeBECount = true;
4859  BasicBlock *Latch = L->getLoopLatch(); // may be NULL.
4860  const SCEV *MustExitMaxBECount = nullptr;
4861  const SCEV *MayExitMaxBECount = nullptr;
4862 
4863  // Compute the ExitLimit for each loop exit. Use this to populate ExitCounts
4864  // and compute maxBECount.
4865  for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
4866  BasicBlock *ExitBB = ExitingBlocks[i];
4867  ExitLimit EL = ComputeExitLimit(L, ExitBB);
4868 
4869  // 1. For each exit that can be computed, add an entry to ExitCounts.
4870  // CouldComputeBECount is true only if all exits can be computed.
4871  if (EL.Exact == getCouldNotCompute())
4872  // We couldn't compute an exact value for this exit, so
4873  // we won't be able to compute an exact value for the loop.
4874  CouldComputeBECount = false;
4875  else
4876  ExitCounts.push_back(std::make_pair(ExitBB, EL.Exact));
4877 
4878  // 2. Derive the loop's MaxBECount from each exit's max number of
4879  // non-exiting iterations. Partition the loop exits into two kinds:
4880  // LoopMustExits and LoopMayExits.
4881  //
4882  // If the exit dominates the loop latch, it is a LoopMustExit otherwise it
4883  // is a LoopMayExit. If any computable LoopMustExit is found, then
4884  // MaxBECount is the minimum EL.Max of computable LoopMustExits. Otherwise,
4885  // MaxBECount is conservatively the maximum EL.Max, where CouldNotCompute is
4886  // considered greater than any computable EL.Max.
4887  if (EL.Max != getCouldNotCompute() && Latch &&
4888  DT->dominates(ExitBB, Latch)) {
4889  if (!MustExitMaxBECount)
4890  MustExitMaxBECount = EL.Max;
4891  else {
4892  MustExitMaxBECount =
4893  getUMinFromMismatchedTypes(MustExitMaxBECount, EL.Max);
4894  }
4895  } else if (MayExitMaxBECount != getCouldNotCompute()) {
4896  if (!MayExitMaxBECount || EL.Max == getCouldNotCompute())
4897  MayExitMaxBECount = EL.Max;
4898  else {
4899  MayExitMaxBECount =
4900  getUMaxFromMismatchedTypes(MayExitMaxBECount, EL.Max);
4901  }
4902  }
4903  }
4904  const SCEV *MaxBECount = MustExitMaxBECount ? MustExitMaxBECount :
4905  (MayExitMaxBECount ? MayExitMaxBECount : getCouldNotCompute());
4906  return BackedgeTakenInfo(ExitCounts, CouldComputeBECount, MaxBECount);
4907 }
4908 
4909 /// ComputeExitLimit - Compute the number of times the backedge of the specified
4910 /// loop will execute if it exits via the specified block.
4911 ScalarEvolution::ExitLimit
4912 ScalarEvolution::ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock) {
4913 
4914  // Okay, we've chosen an exiting block. See what condition causes us to
4915  // exit at this block and remember the exit block and whether all other targets
4916  // lead to the loop header.
4917  bool MustExecuteLoopHeader = true;
4918  BasicBlock *Exit = nullptr;
4919  for (succ_iterator SI = succ_begin(ExitingBlock), SE = succ_end(ExitingBlock);
4920  SI != SE; ++SI)
4921  if (!L->contains(*SI)) {
4922  if (Exit) // Multiple exit successors.
4923  return getCouldNotCompute();
4924  Exit = *SI;
4925  } else if (*SI != L->getHeader()) {
4926  MustExecuteLoopHeader = false;
4927  }
4928 
4929  // At this point, we know we have a conditional branch that determines whether
4930  // the loop is exited. However, we don't know if the branch is executed each
4931  // time through the loop. If not, then the execution count of the branch will
4932  // not be equal to the trip count of the loop.
4933  //
4934  // Currently we check for this by checking to see if the Exit branch goes to
4935  // the loop header. If so, we know it will always execute the same number of
4936  // times as the loop. We also handle the case where the exit block *is* the
4937  // loop header. This is common for un-rotated loops.
4938  //
4939  // If both of those tests fail, walk up the unique predecessor chain to the
4940  // header, stopping if there is an edge that doesn't exit the loop. If the
4941  // header is reached, the execution count of the branch will be equal to the
4942  // trip count of the loop.
4943  //
4944  // More extensive analysis could be done to handle more cases here.
4945  //
4946  if (!MustExecuteLoopHeader && ExitingBlock != L->getHeader()) {
4947  // The simple checks failed, try climbing the unique predecessor chain
4948  // up to the header.
4949  bool Ok = false;
4950  for (BasicBlock *BB = ExitingBlock; BB; ) {
4951  BasicBlock *Pred = BB->getUniquePredecessor();
4952  if (!Pred)
4953  return getCouldNotCompute();
4954  TerminatorInst *PredTerm = Pred->getTerminator();
4955  for (unsigned i = 0, e = PredTerm->getNumSuccessors(); i != e; ++i) {
4956  BasicBlock *PredSucc = PredTerm->getSuccessor(i);
4957  if (PredSucc == BB)
4958  continue;
4959  // If the predecessor has a successor that isn't BB and isn't
4960  // outside the loop, assume the worst.
4961  if (L->contains(PredSucc))
4962  return getCouldNotCompute();
4963  }
4964  if (Pred == L->getHeader()) {
4965  Ok = true;
4966  break;
4967  }
4968  BB = Pred;
4969  }
4970  if (!Ok)
4971  return getCouldNotCompute();
4972  }
4973 
4974  bool IsOnlyExit = (L->getExitingBlock() != nullptr);
4975  TerminatorInst *Term = ExitingBlock->getTerminator();
4976  if (BranchInst *BI = dyn_cast<BranchInst>(Term)) {
4977  assert(BI->isConditional() && "If unconditional, it can't be in loop!");
4978  // Proceed to the next level to examine the exit condition expression.
4979  return ComputeExitLimitFromCond(L, BI->getCondition(), BI->getSuccessor(0),
4980  BI->getSuccessor(1),
4981  /*ControlsExit=*/IsOnlyExit);
4982  }
4983 
4984  if (SwitchInst *SI = dyn_cast<SwitchInst>(Term))
4985  return ComputeExitLimitFromSingleExitSwitch(L, SI, Exit,
4986  /*ControlsExit=*/IsOnlyExit);
4987 
4988  return getCouldNotCompute();
4989 }
4990 
4991 /// ComputeExitLimitFromCond - Compute the number of times the
4992 /// backedge of the specified loop will execute if its exit condition
4993 /// were a conditional branch of ExitCond, TBB, and FBB.
4994 ///
4995 /// @param ControlsExit is true if ExitCond directly controls the exit
4996 /// branch. In this case, we can assume that the loop exits only if the
4997 /// condition is true and can infer that failing to meet the condition prior to
4998 /// integer wraparound results in undefined behavior.
4999 ScalarEvolution::ExitLimit
5000 ScalarEvolution::ComputeExitLimitFromCond(const Loop *L,
5001  Value *ExitCond,
5002  BasicBlock *TBB,
5003  BasicBlock *FBB,
5004  bool ControlsExit) {
5005  // Check if the controlling expression for this loop is an And or Or.
5006  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(ExitCond)) {
5007  if (BO->getOpcode() == Instruction::And) {
5008  // Recurse on the operands of the and.
5009  bool EitherMayExit = L->contains(TBB);
5010  ExitLimit EL0 = ComputeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
5011  ControlsExit && !EitherMayExit);
5012  ExitLimit EL1 = ComputeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
5013  ControlsExit && !EitherMayExit);
5014  const SCEV *BECount = getCouldNotCompute();
5015  const SCEV *MaxBECount = getCouldNotCompute();
5016  if (EitherMayExit) {
5017  // Both conditions must be true for the loop to continue executing.
5018  // Choose the less conservative count.
5019  if (EL0.Exact == getCouldNotCompute() ||
5020  EL1.Exact == getCouldNotCompute())
5021  BECount = getCouldNotCompute();
5022  else
5023  BECount = getUMinFromMismatchedTypes(EL0.Exact, EL1.Exact);
5024  if (EL0.Max == getCouldNotCompute())
5025  MaxBECount = EL1.Max;
5026  else if (EL1.Max == getCouldNotCompute())
5027  MaxBECount = EL0.Max;
5028  else
5029  MaxBECount = getUMinFromMismatchedTypes(EL0.Max, EL1.Max);
5030  } else {
5031  // Both conditions must be true at the same time for the loop to exit.
5032  // For now, be conservative.
5033  assert(L->contains(FBB) && "Loop block has no successor in loop!");
5034  if (EL0.Max == EL1.Max)
5035  MaxBECount = EL0.Max;
5036  if (EL0.Exact == EL1.Exact)
5037  BECount = EL0.Exact;
5038  }
5039 
5040  return ExitLimit(BECount, MaxBECount);
5041  }
5042  if (BO->getOpcode() == Instruction::Or) {
5043  // Recurse on the operands of the or.
5044  bool EitherMayExit = L->contains(FBB);
5045  ExitLimit EL0 = ComputeExitLimitFromCond(L, BO->getOperand(0), TBB, FBB,
5046  ControlsExit && !EitherMayExit);
5047  ExitLimit EL1 = ComputeExitLimitFromCond(L, BO->getOperand(1), TBB, FBB,
5048  ControlsExit && !EitherMayExit);
5049  const SCEV *BECount = getCouldNotCompute();
5050  const SCEV *MaxBECount = getCouldNotCompute();
5051  if (EitherMayExit) {
5052  // Both conditions must be false for the loop to continue executing.
5053  // Choose the less conservative count.
5054  if (EL0.Exact == getCouldNotCompute() ||
5055  EL1.Exact == getCouldNotCompute())
5056  BECount = getCouldNotCompute();
5057  else
5058  BECount = getUMinFromMismatchedTypes(EL0.Exact, EL1.Exact);
5059  if (EL0.Max == getCouldNotCompute())
5060  MaxBECount = EL1.Max;
5061  else if (EL1.Max == getCouldNotCompute())
5062  MaxBECount = EL0.Max;
5063  else
5064  MaxBECount = getUMinFromMismatchedTypes(EL0.Max, EL1.Max);
5065  } else {
5066  // Both conditions must be false at the same time for the loop to exit.
5067  // For now, be conservative.
5068  assert(L->contains(TBB) && "Loop block has no successor in loop!");
5069  if (EL0.Max == EL1.Max)
5070  MaxBECount = EL0.Max;
5071  if (EL0.Exact == EL1.Exact)
5072  BECount = EL0.Exact;
5073  }
5074 
5075  return ExitLimit(BECount, MaxBECount);
5076  }
5077  }
5078 
5079  // With an icmp, it may be feasible to compute an exact backedge-taken count.
5080  // Proceed to the next level to examine the icmp.
5081  if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond))
5082  return ComputeExitLimitFromICmp(L, ExitCondICmp, TBB, FBB, ControlsExit);
5083 
5084  // Check for a constant condition. These are normally stripped out by
5085  // SimplifyCFG, but ScalarEvolution may be used by a pass which wishes to
5086  // preserve the CFG and is temporarily leaving constant conditions
5087  // in place.
5088  if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
5089  if (L->contains(FBB) == !CI->getZExtValue())
5090  // The backedge is always taken.
5091  return getCouldNotCompute();
5092  else
5093  // The backedge is never taken.
5094  return getConstant(CI->getType(), 0);
5095  }
5096 
5097  // If it's not an integer or pointer comparison then compute it the hard way.
5098  return ComputeExitCountExhaustively(L, ExitCond, !L->contains(TBB));
5099 }
5100 
5101 /// ComputeExitLimitFromICmp - Compute the number of times the
5102 /// backedge of the specified loop will execute if its exit condition
5103 /// were a conditional branch of the ICmpInst ExitCond, TBB, and FBB.
5104 ScalarEvolution::ExitLimit
5105 ScalarEvolution::ComputeExitLimitFromICmp(const Loop *L,
5106  ICmpInst *ExitCond,
5107  BasicBlock *TBB,
5108  BasicBlock *FBB,
5109  bool ControlsExit) {
5110 
5111  // If the condition was exit on true, convert the condition to exit on false
5112  ICmpInst::Predicate Cond;
5113  if (!L->contains(FBB))
5114  Cond = ExitCond->getPredicate();
5115  else
5116  Cond = ExitCond->getInversePredicate();
5117 
5118  // Handle common loops like: for (X = "string"; *X; ++X)
5119  if (LoadInst *LI = dyn_cast<LoadInst>(ExitCond->getOperand(0)))
5120  if (Constant *RHS = dyn_cast<Constant>(ExitCond->getOperand(1))) {
5121  ExitLimit ItCnt =
5122  ComputeLoadConstantCompareExitLimit(LI, RHS, L, Cond);
5123  if (ItCnt.hasAnyInfo())
5124  return ItCnt;
5125  }
5126 
5127  const SCEV *LHS = getSCEV(ExitCond->getOperand(0));
5128  const SCEV *RHS = getSCEV(ExitCond->getOperand(1));
5129 
5130  // Try to evaluate any dependencies out of the loop.
5131  LHS = getSCEVAtScope(LHS, L);
5132  RHS = getSCEVAtScope(RHS, L);
5133 
5134  // At this point, we would like to compute how many iterations of the
5135  // loop the predicate will return true for these inputs.
5136  if (isLoopInvariant(LHS, L) && !isLoopInvariant(RHS, L)) {
5137  // If there is a loop-invariant, force it into the RHS.
5138  std::swap(LHS, RHS);
5139  Cond = ICmpInst::getSwappedPredicate(Cond);
5140  }
5141 
5142  // Simplify the operands before analyzing them.
5143  (void)SimplifyICmpOperands(Cond, LHS, RHS);
5144 
5145  // If we have a comparison of a chrec against a constant, try to use value
5146  // ranges to answer this query.
5147  if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
5148  if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS))
5149  if (AddRec->getLoop() == L) {
5150  // Form the constant range.
5151  ConstantRange CompRange(
5152  ICmpInst::makeConstantRange(Cond, RHSC->getValue()->getValue()));
5153 
5154  const SCEV *Ret = AddRec->getNumIterationsInRange(CompRange, *this);
5155  if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
5156  }
5157 
5158  switch (Cond) {
5159  case ICmpInst::ICMP_NE: { // while (X != Y)
5160  // Convert to: while (X-Y != 0)
5161  ExitLimit EL = HowFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit);
5162  if (EL.hasAnyInfo()) return EL;
5163  break;
5164  }
5165  case ICmpInst::ICMP_EQ: { // while (X == Y)
5166  // Convert to: while (X-Y == 0)
5167  ExitLimit EL = HowFarToNonZero(getMinusSCEV(LHS, RHS), L);
5168  if (EL.hasAnyInfo()) return EL;
5169  break;
5170  }
5171  case ICmpInst::ICMP_SLT:
5172  case ICmpInst::ICMP_ULT: { // while (X < Y)
5173  bool IsSigned = Cond == ICmpInst::ICMP_SLT;
5174  ExitLimit EL = HowManyLessThans(LHS, RHS, L, IsSigned, ControlsExit);
5175  if (EL.hasAnyInfo()) return EL;
5176  break;
5177  }
5178  case ICmpInst::ICMP_SGT:
5179  case ICmpInst::ICMP_UGT: { // while (X > Y)
5180  bool IsSigned = Cond == ICmpInst::ICMP_SGT;
5181  ExitLimit EL = HowManyGreaterThans(LHS, RHS, L, IsSigned, ControlsExit);
5182  if (EL.hasAnyInfo()) return EL;
5183  break;
5184  }
5185  default:
5186 #if 0
5187  dbgs() << "ComputeBackedgeTakenCount ";
5188  if (ExitCond->getOperand(0)->getType()->isUnsigned())
5189  dbgs() << "[unsigned] ";
5190  dbgs() << *LHS << " "
5191  << Instruction::getOpcodeName(Instruction::ICmp)
5192  << " " << *RHS << "\n";
5193 #endif
5194  break;
5195  }
5196  return ComputeExitCountExhaustively(L, ExitCond, !L->contains(TBB));
5197 }
5198 
5199 ScalarEvolution::ExitLimit
5200 ScalarEvolution::ComputeExitLimitFromSingleExitSwitch(const Loop *L,
5201  SwitchInst *Switch,
5202  BasicBlock *ExitingBlock,
5203  bool ControlsExit) {
5204  assert(!L->contains(ExitingBlock) && "Not an exiting block!");
5205 
5206  // Give up if the exit is the default dest of a switch.
5207  if (Switch->getDefaultDest() == ExitingBlock)
5208  return getCouldNotCompute();
5209 
5210  assert(L->contains(Switch->getDefaultDest()) &&
5211  "Default case must not exit the loop!");
5212  const SCEV *LHS = getSCEVAtScope(Switch->getCondition(), L);
5213  const SCEV *RHS = getConstant(Switch->findCaseDest(ExitingBlock));
5214 
5215  // while (X != Y) --> while (X-Y != 0)
5216  ExitLimit EL = HowFarToZero(getMinusSCEV(LHS, RHS), L, ControlsExit);
5217  if (EL.hasAnyInfo())
5218  return EL;
5219 
5220  return getCouldNotCompute();
5221 }
5222 
5223 static ConstantInt *
5225  ScalarEvolution &SE) {
5226  const SCEV *InVal = SE.getConstant(C);
5227  const SCEV *Val = AddRec->evaluateAtIteration(InVal, SE);
5228  assert(isa<SCEVConstant>(Val) &&
5229  "Evaluation of SCEV at constant didn't fold correctly?");
5230  return cast<SCEVConstant>(Val)->getValue();
5231 }
5232 
5233 /// ComputeLoadConstantCompareExitLimit - Given an exit condition of
5234 /// 'icmp op load X, cst', try to see if we can compute the backedge
5235 /// execution count.
5236 ScalarEvolution::ExitLimit
5237 ScalarEvolution::ComputeLoadConstantCompareExitLimit(
5238  LoadInst *LI,
5239  Constant *RHS,
5240  const Loop *L,
5241  ICmpInst::Predicate predicate) {
5242 
5243  if (LI->isVolatile()) return getCouldNotCompute();
5244 
5245  // Check to see if the loaded pointer is a getelementptr of a global.
5246  // TODO: Use SCEV instead of manually grubbing with GEPs.
5248  if (!GEP) return getCouldNotCompute();
5249 
5250  // Make sure that it is really a constant global we are gepping, with an
5251  // initializer, and make sure the first IDX is really 0.
5253  if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer() ||
5254  GEP->getNumOperands() < 3 || !isa<Constant>(GEP->getOperand(1)) ||
5255  !cast<Constant>(GEP->getOperand(1))->isNullValue())
5256  return getCouldNotCompute();
5257 
5258  // Okay, we allow one non-constant index into the GEP instruction.
5259  Value *VarIdx = nullptr;
5260  std::vector<Constant*> Indexes;
5261  unsigned VarIdxNum = 0;
5262  for (unsigned i = 2, e = GEP->getNumOperands(); i != e; ++i)
5263  if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
5264  Indexes.push_back(CI);
5265  } else if (!isa<ConstantInt>(GEP->getOperand(i))) {
5266  if (VarIdx) return getCouldNotCompute(); // Multiple non-constant idx's.
5267  VarIdx = GEP->getOperand(i);
5268  VarIdxNum = i-2;
5269  Indexes.push_back(nullptr);
5270  }
5271 
5272  // Loop-invariant loads may be a byproduct of loop optimization. Skip them.
5273  if (!VarIdx)
5274  return getCouldNotCompute();
5275 
5276  // Okay, we know we have a (load (gep GV, 0, X)) comparison with a constant.
5277  // Check to see if X is a loop variant variable value now.
5278  const SCEV *Idx = getSCEV(VarIdx);
5279  Idx = getSCEVAtScope(Idx, L);
5280 
5281  // We can only recognize very limited forms of loop index expressions, in
5282  // particular, only affine AddRec's like {C1,+,C2}.
5283  const SCEVAddRecExpr *IdxExpr = dyn_cast<SCEVAddRecExpr>(Idx);
5284  if (!IdxExpr || !IdxExpr->isAffine() || isLoopInvariant(IdxExpr, L) ||
5285  !isa<SCEVConstant>(IdxExpr->getOperand(0)) ||
5286  !isa<SCEVConstant>(IdxExpr->getOperand(1)))
5287  return getCouldNotCompute();
5288 
5289  unsigned MaxSteps = MaxBruteForceIterations;
5290  for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
5291  ConstantInt *ItCst = ConstantInt::get(
5292  cast<IntegerType>(IdxExpr->getType()), IterationNum);
5293  ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst, *this);
5294 
5295  // Form the GEP offset.
5296  Indexes[VarIdxNum] = Val;
5297 
5299  Indexes);
5300  if (!Result) break; // Cannot compute!
5301 
5302  // Evaluate the condition for this iteration.
5303  Result = ConstantExpr::getICmp(predicate, Result, RHS);
5304  if (!isa<ConstantInt>(Result)) break; // Couldn't decide for sure
5305  if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
5306 #if 0
5307  dbgs() << "\n***\n*** Computed loop count " << *ItCst
5308  << "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
5309  << "***\n";
5310 #endif
5311  ++NumArrayLenItCounts;
5312  return getConstant(ItCst); // Found terminating iteration!
5313  }
5314  }
5315  return getCouldNotCompute();
5316 }
5317 
5318 
5319 /// CanConstantFold - Return true if we can constant fold an instruction of the
5320 /// specified type, assuming that all operands were constants.
5321 static bool CanConstantFold(const Instruction *I) {
5322  if (isa<BinaryOperator>(I) || isa<CmpInst>(I) ||
5323  isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I) ||
5324  isa<LoadInst>(I))
5325  return true;
5326 
5327  if (const CallInst *CI = dyn_cast<CallInst>(I))
5328  if (const Function *F = CI->getCalledFunction())
5329  return canConstantFoldCallTo(F);
5330  return false;
5331 }
5332 
5333 /// Determine whether this instruction can constant evolve within this loop
5334 /// assuming its operands can all constant evolve.
5335 static bool canConstantEvolve(Instruction *I, const Loop *L) {
5336  // An instruction outside of the loop can't be derived from a loop PHI.
5337  if (!L->contains(I)) return false;
5338 
5339  if (isa<PHINode>(I)) {
5340  // We don't currently keep track of the control flow needed to evaluate
5341  // PHIs, so we cannot handle PHIs inside of loops.
5342  return L->getHeader() == I->getParent();
5343  }
5344 
5345  // If we won't be able to constant fold this expression even if the operands
5346  // are constants, bail early.
5347  return CanConstantFold(I);
5348 }
5349 
5350 /// getConstantEvolvingPHIOperands - Implement getConstantEvolvingPHI by
5351 /// recursing through each instruction operand until reaching a loop header phi.
5352 static PHINode *
5355 
5356  // Otherwise, we can evaluate this instruction if all of its operands are
5357  // constant or derived from a PHI node themselves.
5358  PHINode *PHI = nullptr;
5359  for (Instruction::op_iterator OpI = UseInst->op_begin(),
5360  OpE = UseInst->op_end(); OpI != OpE; ++OpI) {
5361 
5362  if (isa<Constant>(*OpI)) continue;
5363 
5364  Instruction *OpInst = dyn_cast<Instruction>(*OpI);
5365  if (!OpInst || !canConstantEvolve(OpInst, L)) return nullptr;
5366 
5367  PHINode *P = dyn_cast<PHINode>(OpInst);
5368  if (!P)
5369  // If this operand is already visited, reuse the prior result.
5370  // We may have P != PHI if this is the deepest point at which the
5371  // inconsistent paths meet.
5372  P = PHIMap.lookup(OpInst);
5373  if (!P) {
5374  // Recurse and memoize the results, whether a phi is found or not.
5375  // This recursive call invalidates pointers into PHIMap.
5376  P = getConstantEvolvingPHIOperands(OpInst, L, PHIMap);
5377  PHIMap[OpInst] = P;
5378  }
5379  if (!P)
5380  return nullptr; // Not evolving from PHI
5381  if (PHI && PHI != P)
5382  return nullptr; // Evolving from multiple different PHIs.
5383  PHI = P;
5384  }
5385  // This is a expression evolving from a constant PHI!
5386  return PHI;
5387 }
5388 
5389 /// getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node
5390 /// in the loop that V is derived from. We allow arbitrary operations along the
5391 /// way, but the operands of an operation must either be constants or a value
5392 /// derived from a constant PHI. If this expression does not fit with these
5393 /// constraints, return null.
5394 static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
5395  Instruction *I = dyn_cast<Instruction>(V);
5396  if (!I || !canConstantEvolve(I, L)) return nullptr;
5397 
5398  if (PHINode *PN = dyn_cast<PHINode>(I)) {
5399  return PN;
5400  }
5401 
5402  // Record non-constant instructions contained by the loop.
5404  return getConstantEvolvingPHIOperands(I, L, PHIMap);
5405 }
5406 
5407 /// EvaluateExpression - Given an expression that passes the
5408 /// getConstantEvolvingPHI predicate, evaluate its value assuming the PHI node
5409 /// in the loop has the value PHIVal. If we can't fold this expression for some
5410 /// reason, return null.
5411 static Constant *EvaluateExpression(Value *V, const Loop *L,
5413  const DataLayout &DL,
5414  const TargetLibraryInfo *TLI) {
5415  // Convenient constant check, but redundant for recursive calls.
5416  if (Constant *C = dyn_cast<Constant>(V)) return C;
5417  Instruction *I = dyn_cast<Instruction>(V);
5418  if (!I) return nullptr;
5419 
5420  if (Constant *C = Vals.lookup(I)) return C;
5421 
5422  // An instruction inside the loop depends on a value outside the loop that we
5423  // weren't given a mapping for, or a value such as a call inside the loop.
5424  if (!canConstantEvolve(I, L)) return nullptr;
5425 
5426  // An unmapped PHI can be due to a branch or another loop inside this loop,
5427  // or due to this not being the initial iteration through a loop where we
5428  // couldn't compute the evolution of this particular PHI last time.
5429  if (isa<PHINode>(I)) return nullptr;
5430 
5431  std::vector<Constant*> Operands(I->getNumOperands());
5432 
5433  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
5434  Instruction *Operand = dyn_cast<Instruction>(I->getOperand(i));
5435  if (!Operand) {
5436  Operands[i] = dyn_cast<Constant>(I->getOperand(i));
5437  if (!Operands[i]) return nullptr;
5438  continue;
5439  }
5440  Constant *C = EvaluateExpression(Operand, L, Vals, DL, TLI);
5441  Vals[Operand] = C;
5442  if (!C) return nullptr;
5443  Operands[i] = C;
5444  }
5445 
5446  if (CmpInst *CI = dyn_cast<CmpInst>(I))
5447  return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
5448  Operands[1], DL, TLI);
5449  if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
5450  if (!LI->isVolatile())
5451  return ConstantFoldLoadFromConstPtr(Operands[0], DL);
5452  }
5453  return ConstantFoldInstOperands(I->getOpcode(), I->getType(), Operands, DL,
5454  TLI);
5455 }
5456 
5457 /// getConstantEvolutionLoopExitValue - If we know that the specified Phi is
5458 /// in the header of its containing loop, we know the loop executes a
5459 /// constant number of times, and the PHI node is just a recurrence
5460 /// involving constants, fold it.
5461 Constant *
5462 ScalarEvolution::getConstantEvolutionLoopExitValue(PHINode *PN,
5463  const APInt &BEs,
5464  const Loop *L) {
5466  ConstantEvolutionLoopExitValue.find(PN);
5467  if (I != ConstantEvolutionLoopExitValue.end())
5468  return I->second;
5469 
5471  return ConstantEvolutionLoopExitValue[PN] = nullptr; // Not going to evaluate it.
5472 
5473  Constant *&RetVal = ConstantEvolutionLoopExitValue[PN];
5474 
5475  DenseMap<Instruction *, Constant *> CurrentIterVals;
5476  BasicBlock *Header = L->getHeader();
5477  assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
5478 
5479  // Since the loop is canonicalized, the PHI node must have two entries. One
5480  // entry must be a constant (coming in from outside of the loop), and the
5481  // second must be derived from the same PHI.
5482  bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
5483  PHINode *PHI = nullptr;
5484  for (BasicBlock::iterator I = Header->begin();
5485  (PHI = dyn_cast<PHINode>(I)); ++I) {
5486  Constant *StartCST =
5487  dyn_cast<Constant>(PHI->getIncomingValue(!SecondIsBackedge));
5488  if (!StartCST) continue;
5489  CurrentIterVals[PHI] = StartCST;
5490  }
5491  if (!CurrentIterVals.count(PN))
5492  return RetVal = nullptr;
5493 
5494  Value *BEValue = PN->getIncomingValue(SecondIsBackedge);
5495 
5496  // Execute the loop symbolically to determine the exit value.
5497  if (BEs.getActiveBits() >= 32)
5498  return RetVal = nullptr; // More than 2^32-1 iterations?? Not doing it!
5499 
5500  unsigned NumIterations = BEs.getZExtValue(); // must be in range
5501  unsigned IterationNum = 0;
5502  const DataLayout &DL = F->getParent()->getDataLayout();
5503  for (; ; ++IterationNum) {
5504  if (IterationNum == NumIterations)
5505  return RetVal = CurrentIterVals[PN]; // Got exit value!
5506 
5507  // Compute the value of the PHIs for the next iteration.
5508  // EvaluateExpression adds non-phi values to the CurrentIterVals map.
5510  Constant *NextPHI =
5511  EvaluateExpression(BEValue, L, CurrentIterVals, DL, TLI);
5512  if (!NextPHI)
5513  return nullptr; // Couldn't evaluate!
5514  NextIterVals[PN] = NextPHI;
5515 
5516  bool StoppedEvolving = NextPHI == CurrentIterVals[PN];
5517 
5518  // Also evaluate the other PHI nodes. However, we don't get to stop if we
5519  // cease to be able to evaluate one of them or if they stop evolving,
5520  // because that doesn't necessarily prevent us from computing PN.
5523  I = CurrentIterVals.begin(), E = CurrentIterVals.end(); I != E; ++I){
5524  PHINode *PHI = dyn_cast<PHINode>(I->first);
5525  if (!PHI || PHI == PN || PHI->getParent() != Header) continue;
5526  PHIsToCompute.push_back(std::make_pair(PHI, I->second));
5527  }
5528  // We use two distinct loops because EvaluateExpression may invalidate any
5529  // iterators into CurrentIterVals.
5530  for (SmallVectorImpl<std::pair<PHINode *, Constant*> >::const_iterator
5531  I = PHIsToCompute.begin(), E = PHIsToCompute.end(); I != E; ++I) {
5532  PHINode *PHI = I->first;
5533  Constant *&NextPHI = NextIterVals[PHI];
5534  if (!NextPHI) { // Not already computed.
5535  Value *BEValue = PHI->getIncomingValue(SecondIsBackedge);
5536  NextPHI = EvaluateExpression(BEValue, L, CurrentIterVals, DL, TLI);
5537  }
5538  if (NextPHI != I->second)
5539  StoppedEvolving = false;
5540  }
5541 
5542  // If all entries in CurrentIterVals == NextIterVals then we can stop
5543  // iterating, the loop can't continue to change.
5544  if (StoppedEvolving)
5545  return RetVal = CurrentIterVals[PN];
5546 
5547  CurrentIterVals.swap(NextIterVals);
5548  }
5549 }
5550 
5551 /// ComputeExitCountExhaustively - If the loop is known to execute a
5552 /// constant number of times (the condition evolves only from constants),
5553 /// try to evaluate a few iterations of the loop until we get the exit
5554 /// condition gets a value of ExitWhen (true or false). If we cannot
5555 /// evaluate the trip count of the loop, return getCouldNotCompute().
5556 const SCEV *ScalarEvolution::ComputeExitCountExhaustively(const Loop *L,
5557  Value *Cond,
5558  bool ExitWhen) {
5559  PHINode *PN = getConstantEvolvingPHI(Cond, L);
5560  if (!PN) return getCouldNotCompute();
5561 
5562  // If the loop is canonicalized, the PHI will have exactly two entries.
5563  // That's the only form we support here.
5564  if (PN->getNumIncomingValues() != 2) return getCouldNotCompute();
5565 
5566  DenseMap<Instruction *, Constant *> CurrentIterVals;
5567  BasicBlock *Header = L->getHeader();
5568  assert(PN->getParent() == Header && "Can't evaluate PHI not in loop header!");
5569 
5570  // One entry must be a constant (coming in from outside of the loop), and the
5571  // second must be derived from the same PHI.
5572  bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
5573  PHINode *PHI = nullptr;
5574  for (BasicBlock::iterator I = Header->begin();
5575  (PHI = dyn_cast<PHINode>(I)); ++I) {
5576  Constant *StartCST =
5577  dyn_cast<Constant>(PHI->getIncomingValue(!SecondIsBackedge));
5578  if (!StartCST) continue;
5579  CurrentIterVals[PHI] = StartCST;
5580  }
5581  if (!CurrentIterVals.count(PN))
5582  return getCouldNotCompute();
5583 
5584  // Okay, we find a PHI node that defines the trip count of this loop. Execute
5585  // the loop symbolically to determine when the condition gets a value of
5586  // "ExitWhen".
5587  unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis.
5588  const DataLayout &DL = F->getParent()->getDataLayout();
5589  for (unsigned IterationNum = 0; IterationNum != MaxIterations;++IterationNum){
5590  ConstantInt *CondVal = dyn_cast_or_null<ConstantInt>(
5591  EvaluateExpression(Cond, L, CurrentIterVals, DL, TLI));
5592 
5593  // Couldn't symbolically evaluate.
5594  if (!CondVal) return getCouldNotCompute();
5595 
5596  if (CondVal->getValue() == uint64_t(ExitWhen)) {
5597  ++NumBruteForceTripCountsComputed;
5598  return getConstant(Type::getInt32Ty(getContext()), IterationNum);
5599  }
5600 
5601  // Update all the PHI nodes for the next iteration.
5603 
5604  // Create a list of which PHIs we need to compute. We want to do this before
5605  // calling EvaluateExpression on them because that may invalidate iterators
5606  // into CurrentIterVals.
5607  SmallVector<PHINode *, 8> PHIsToCompute;
5609  I = CurrentIterVals.begin(), E = CurrentIterVals.end(); I != E; ++I){
5610  PHINode *PHI = dyn_cast<PHINode>(I->first);
5611  if (!PHI || PHI->getParent() != Header) continue;
5612  PHIsToCompute.push_back(PHI);
5613  }
5614  for (SmallVectorImpl<PHINode *>::const_iterator I = PHIsToCompute.begin(),
5615  E = PHIsToCompute.end(); I != E; ++I) {
5616  PHINode *PHI = *I;
5617  Constant *&NextPHI = NextIterVals[PHI];
5618  if (NextPHI) continue; // Already computed!
5619 
5620  Value *BEValue = PHI->getIncomingValue(SecondIsBackedge);
5621  NextPHI = EvaluateExpression(BEValue, L, CurrentIterVals, DL, TLI);
5622  }
5623  CurrentIterVals.swap(NextIterVals);
5624  }
5625 
5626  // Too many iterations were needed to evaluate.
5627  return getCouldNotCompute();
5628 }
5629 
5630 /// getSCEVAtScope - Return a SCEV expression for the specified value
5631 /// at the specified scope in the program. The L value specifies a loop
5632 /// nest to evaluate the expression at, where null is the top-level or a
5633 /// specified loop is immediately inside of the loop.
5634 ///
5635 /// This method can be used to compute the exit value for a variable defined
5636 /// in a loop by querying what the value will hold in the parent loop.
5637 ///
5638 /// In the case that a relevant loop exit value cannot be computed, the
5639 /// original value V is returned.
5640 const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
5641  // Check to see if we've folded this expression at this loop before.
5642  SmallVector<std::pair<const Loop *, const SCEV *>, 2> &Values = ValuesAtScopes[V];
5643  for (unsigned u = 0; u < Values.size(); u++) {
5644  if (Values[u].first == L)
5645  return Values[u].second ? Values[u].second : V;
5646  }
5647  Values.push_back(std::make_pair(L, static_cast<const SCEV *>(nullptr)));
5648  // Otherwise compute it.
5649  const SCEV *C = computeSCEVAtScope(V, L);
5650  SmallVector<std::pair<const Loop *, const SCEV *>, 2> &Values2 = ValuesAtScopes[V];
5651  for (unsigned u = Values2.size(); u > 0; u--) {
5652  if (Values2[u - 1].first == L) {
5653  Values2[u - 1].second = C;
5654  break;
5655  }
5656  }
5657  return C;
5658 }
5659 
5660 /// This builds up a Constant using the ConstantExpr interface. That way, we
5661 /// will return Constants for objects which aren't represented by a
5662 /// SCEVConstant, because SCEVConstant is restricted to ConstantInt.
5663 /// Returns NULL if the SCEV isn't representable as a Constant.
5665  switch (static_cast<SCEVTypes>(V->getSCEVType())) {
5666  case scCouldNotCompute:
5667  case scAddRecExpr:
5668  break;
5669  case scConstant:
5670  return cast<SCEVConstant>(V)->getValue();
5671  case scUnknown:
5672  return dyn_cast<Constant>(cast<SCEVUnknown>(V)->getValue());
5673  case scSignExtend: {
5674  const SCEVSignExtendExpr *SS = cast<SCEVSignExtendExpr>(V);
5675  if (Constant *CastOp = BuildConstantFromSCEV(SS->getOperand()))
5676  return ConstantExpr::getSExt(CastOp, SS->getType());
5677  break;
5678  }
5679  case scZeroExtend: {
5680  const SCEVZeroExtendExpr *SZ = cast<SCEVZeroExtendExpr>(V);
5681  if (Constant *CastOp = BuildConstantFromSCEV(SZ->getOperand()))
5682  return ConstantExpr::getZExt(CastOp, SZ->getType());
5683  break;
5684  }
5685  case scTruncate: {
5686  const SCEVTruncateExpr *ST = cast<SCEVTruncateExpr>(V);
5687  if (Constant *CastOp = BuildConstantFromSCEV(ST->getOperand()))
5688  return ConstantExpr::getTrunc(CastOp, ST->getType());
5689  break;
5690  }
5691  case scAddExpr: {
5692  const SCEVAddExpr *SA = cast<SCEVAddExpr>(V);
5693  if (Constant *C = BuildConstantFromSCEV(SA->getOperand(0))) {
5694  if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
5695  unsigned AS = PTy->getAddressSpace();
5696  Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
5697  C = ConstantExpr::getBitCast(C, DestPtrTy);
5698  }
5699  for (unsigned i = 1, e = SA->getNumOperands(); i != e; ++i) {
5701  if (!C2) return nullptr;
5702 
5703  // First pointer!
5704  if (!C->getType()->isPointerTy() && C2->getType()->isPointerTy()) {
5705  unsigned AS = C2->getType()->getPointerAddressSpace();
5706  std::swap(C, C2);
5707  Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
5708  // The offsets have been converted to bytes. We can add bytes to an
5709  // i8* by GEP with the byte count in the first index.
5710  C = ConstantExpr::getBitCast(C, DestPtrTy);
5711  }
5712 
5713  // Don't bother trying to sum two pointers. We probably can't
5714  // statically compute a load that results from it anyway.
5715  if (C2->getType()->isPointerTy())
5716  return nullptr;
5717 
5718  if (PointerType *PTy = dyn_cast<PointerType>(C->getType())) {
5719  if (PTy->getElementType()->isStructTy())
5721  C2, Type::getInt32Ty(C->getContext()), true);
5722  C = ConstantExpr::getGetElementPtr(PTy->getElementType(), C, C2);
5723  } else
5724  C = ConstantExpr::getAdd(C, C2);
5725  }
5726  return C;
5727  }
5728  break;
5729  }
5730  case scMulExpr: {
5731  const SCEVMulExpr *SM = cast<SCEVMulExpr>(V);
5732  if (Constant *C = BuildConstantFromSCEV(SM->getOperand(0))) {
5733  // Don't bother with pointers at all.
5734  if (C->getType()->isPointerTy()) return nullptr;
5735  for (unsigned i = 1, e = SM->getNumOperands(); i != e; ++i) {
5737  if (!C2 || C2->getType()->isPointerTy()) return nullptr;
5738  C = ConstantExpr::getMul(C, C2);
5739  }
5740  return C;
5741  }
5742  break;
5743  }
5744  case scUDivExpr: {
5745  const SCEVUDivExpr *SU = cast<SCEVUDivExpr>(V);
5746  if (Constant *LHS = BuildConstantFromSCEV(SU->getLHS()))
5747  if (Constant *RHS = BuildConstantFromSCEV(SU->getRHS()))
5748  if (LHS->getType() == RHS->getType())
5749  return ConstantExpr::getUDiv(LHS, RHS);
5750  break;
5751  }
5752  case scSMaxExpr:
5753  case scUMaxExpr:
5754  break; // TODO: smax, umax.
5755  }
5756  return nullptr;
5757 }
5758 
5759 const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
5760  if (isa<SCEVConstant>(V)) return V;
5761 
5762  // If this instruction is evolved from a constant-evolving PHI, compute the
5763  // exit value from the loop without using SCEVs.
5764  if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V)) {
5765  if (Instruction *I = dyn_cast<Instruction>(SU->getValue())) {
5766  const Loop *LI = (*this->LI)[I->getParent()];
5767  if (LI && LI->getParentLoop() == L) // Looking for loop exit value.
5768  if (PHINode *PN = dyn_cast<PHINode>(I))
5769  if (PN->getParent() == LI->getHeader()) {
5770  // Okay, there is no closed form solution for the PHI node. Check
5771  // to see if the loop that contains it has a known backedge-taken
5772  // count. If so, we may be able to force computation of the exit
5773  // value.
5774  const SCEV *BackedgeTakenCount = getBackedgeTakenCount(LI);
5775  if (const SCEVConstant *BTCC =
5776  dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
5777  // Okay, we know how many times the containing loop executes. If
5778  // this is a constant evolving PHI node, get the final value at
5779  // the specified iteration number.
5780  Constant *RV = getConstantEvolutionLoopExitValue(PN,
5781  BTCC->getValue()->getValue(),
5782  LI);
5783  if (RV) return getSCEV(RV);
5784  }
5785  }
5786 
5787  // Okay, this is an expression that we cannot symbolically evaluate
5788  // into a SCEV. Check to see if it's possible to symbolically evaluate
5789  // the arguments into constants, and if so, try to constant propagate the
5790  // result. This is particularly useful for computing loop exit values.
5791  if (CanConstantFold(I)) {
5793  bool MadeImprovement = false;
5794  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
5795  Value *Op = I->getOperand(i);
5796  if (Constant *C = dyn_cast<Constant>(Op)) {
5797  Operands.push_back(C);
5798  continue;
5799  }
5800 
5801  // If any of the operands is non-constant and if they are
5802  // non-integer and non-pointer, don't even try to analyze them
5803  // with scev techniques.
5804  if (!isSCEVable(Op->getType()))
5805  return V;
5806 
5807  const SCEV *OrigV = getSCEV(Op);
5808  const SCEV *OpV = getSCEVAtScope(OrigV, L);
5809  MadeImprovement |= OrigV != OpV;
5810 
5812  if (!C) return V;
5813  if (C->getType() != Op->getType())
5815  Op->getType(),
5816  false),
5817  C, Op->getType());
5818  Operands.push_back(C);
5819  }
5820 
5821  // Check to see if getSCEVAtScope actually made an improvement.
5822  if (MadeImprovement) {
5823  Constant *C = nullptr;
5824  const DataLayout &DL = F->getParent()->getDataLayout();
5825  if (const CmpInst *CI = dyn_cast<CmpInst>(I))
5826  C = ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
5827  Operands[1], DL, TLI);
5828  else if (const LoadInst *LI = dyn_cast<LoadInst>(I)) {
5829  if (!LI->isVolatile())
5830  C = ConstantFoldLoadFromConstPtr(Operands[0], DL);
5831  } else
5832  C = ConstantFoldInstOperands(I->getOpcode(), I->getType(), Operands,
5833  DL, TLI);
5834  if (!C) return V;
5835  return getSCEV(C);
5836  }
5837  }
5838  }
5839 
5840  // This is some other type of SCEVUnknown, just return it.
5841  return V;
5842  }
5843 
5844  if (const SCEVCommutativeExpr *Comm = dyn_cast<SCEVCommutativeExpr>(V)) {
5845  // Avoid performing the look-up in the common case where the specified
5846  // expression has no loop-variant portions.
5847  for (unsigned i = 0, e = Comm->getNumOperands(); i != e; ++i) {
5848  const SCEV *OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
5849  if (OpAtScope != Comm->getOperand(i)) {
5850  // Okay, at least one of these operands is loop variant but might be
5851  // foldable. Build a new instance of the folded commutative expression.
5852  SmallVector<const SCEV *, 8> NewOps(Comm->op_begin(),
5853  Comm->op_begin()+i);
5854  NewOps.push_back(OpAtScope);
5855 
5856  for (++i; i != e; ++i) {
5857  OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
5858  NewOps.push_back(OpAtScope);
5859  }
5860  if (isa<SCEVAddExpr>(Comm))
5861  return getAddExpr(NewOps);
5862  if (isa<SCEVMulExpr>(Comm))
5863  return getMulExpr(NewOps);
5864  if (isa<SCEVSMaxExpr>(Comm))
5865  return getSMaxExpr(NewOps);
5866  if (isa<SCEVUMaxExpr>(Comm))
5867  return getUMaxExpr(NewOps);
5868  llvm_unreachable("Unknown commutative SCEV type!");
5869  }
5870  }
5871  // If we got here, all operands are loop invariant.
5872  return Comm;
5873  }
5874 
5875  if (const SCEVUDivExpr *Div = dyn_cast<SCEVUDivExpr>(V)) {
5876  const SCEV *LHS = getSCEVAtScope(Div->getLHS(), L);
5877  const SCEV *RHS = getSCEVAtScope(Div->getRHS(), L);
5878  if (LHS == Div->getLHS() && RHS == Div->getRHS())
5879  return Div; // must be loop invariant
5880  return getUDivExpr(LHS, RHS);
5881  }
5882 
5883  // If this is a loop recurrence for a loop that does not contain L, then we
5884  // are dealing with the final value computed by the loop.
5885  if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V)) {
5886  // First, attempt to evaluate each operand.
5887  // Avoid performing the look-up in the common case where the specified
5888  // expression has no loop-variant portions.
5889  for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
5890  const SCEV *OpAtScope = getSCEVAtScope(AddRec->getOperand(i), L);
5891  if (OpAtScope == AddRec->getOperand(i))
5892  continue;
5893 
5894  // Okay, at least one of these operands is loop variant but might be
5895  // foldable. Build a new instance of the folded commutative expression.
5896  SmallVector<const SCEV *, 8> NewOps(AddRec->op_begin(),
5897  AddRec->op_begin()+i);
5898  NewOps.push_back(OpAtScope);
5899  for (++i; i != e; ++i)
5900  NewOps.push_back(getSCEVAtScope(AddRec->getOperand(i), L));
5901 
5902  const SCEV *FoldedRec =
5903  getAddRecExpr(NewOps, AddRec->getLoop(),
5904  AddRec->getNoWrapFlags(SCEV::FlagNW));
5905  AddRec = dyn_cast<SCEVAddRecExpr>(FoldedRec);
5906  // The addrec may be folded to a nonrecurrence, for example, if the
5907  // induction variable is multiplied by zero after constant folding. Go
5908  // ahead and return the folded value.
5909  if (!AddRec)
5910  return FoldedRec;
5911  break;
5912  }
5913 
5914  // If the scope is outside the addrec's loop, evaluate it by using the
5915  // loop exit value of the addrec.
5916  if (!AddRec->getLoop()->contains(L)) {
5917  // To evaluate this recurrence, we need to know how many times the AddRec
5918  // loop iterates. Compute this now.
5919  const SCEV *BackedgeTakenCount = getBackedgeTakenCount(AddRec->getLoop());
5920  if (BackedgeTakenCount == getCouldNotCompute()) return AddRec;
5921 
5922  // Then, evaluate the AddRec.
5923  return AddRec->evaluateAtIteration(BackedgeTakenCount, *this);
5924  }
5925 
5926  return AddRec;
5927  }
5928 
5929  if (const SCEVZeroExtendExpr *Cast = dyn_cast<SCEVZeroExtendExpr>(V)) {
5930  const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
5931  if (Op == Cast->getOperand())
5932  return Cast; // must be loop invariant
5933  return getZeroExtendExpr(Op, Cast->getType());
5934  }
5935 
5936  if (const SCEVSignExtendExpr *Cast = dyn_cast<SCEVSignExtendExpr>(V)) {
5937  const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
5938  if (Op == Cast->getOperand())
5939  return Cast; // must be loop invariant
5940  return getSignExtendExpr(Op, Cast->getType());
5941  }
5942 
5943  if (const SCEVTruncateExpr *Cast = dyn_cast<SCEVTruncateExpr>(V)) {
5944  const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
5945  if (Op == Cast->getOperand())
5946  return Cast; // must be loop invariant
5947  return getTruncateExpr(Op, Cast->getType());
5948  }
5949 
5950  llvm_unreachable("Unknown SCEV type!");
5951 }
5952 
5953 /// getSCEVAtScope - This is a convenience function which does
5954 /// getSCEVAtScope(getSCEV(V), L).
5956  return getSCEVAtScope(getSCEV(V), L);
5957 }
5958 
5959 /// SolveLinEquationWithOverflow - Finds the minimum unsigned root of the
5960 /// following equation:
5961 ///
5962 /// A * X = B (mod N)
5963 ///
5964 /// where N = 2^BW and BW is the common bit width of A and B. The signedness of
5965 /// A and B isn't important.
5966 ///
5967 /// If the equation does not have a solution, SCEVCouldNotCompute is returned.
5968 static const SCEV *SolveLinEquationWithOverflow(const APInt &A, const APInt &B,
5969  ScalarEvolution &SE) {
5970  uint32_t BW = A.getBitWidth();
5971  assert(BW == B.getBitWidth() && "Bit widths must be the same.");
5972  assert(A != 0 && "A must be non-zero.");
5973 
5974  // 1. D = gcd(A, N)
5975  //
5976  // The gcd of A and N may have only one prime factor: 2. The number of
5977  // trailing zeros in A is its multiplicity
5978  uint32_t Mult2 = A.countTrailingZeros();
5979  // D = 2^Mult2
5980 
5981  // 2. Check if B is divisible by D.
5982  //
5983  // B is divisible by D if and only if the multiplicity of prime factor 2 for B
5984  // is not less than multiplicity of this prime factor for D.
5985  if (B.countTrailingZeros() < Mult2)
5986  return SE.getCouldNotCompute();
5987 
5988  // 3. Compute I: the multiplicative inverse of (A / D) in arithmetic
5989  // modulo (N / D).
5990  //
5991  // (N / D) may need BW+1 bits in its representation. Hence, we'll use this
5992  // bit width during computations.
5993  APInt AD = A.lshr(Mult2).zext(BW + 1); // AD = A / D
5994  APInt Mod(BW + 1, 0);
5995  Mod.setBit(BW - Mult2); // Mod = N / D
5996  APInt I = AD.multiplicativeInverse(Mod);
5997 
5998  // 4. Compute the minimum unsigned root of the equation:
5999  // I * (B / D) mod (N / D)
6000  APInt Result = (I * B.lshr(Mult2).zext(BW + 1)).urem(Mod);
6001 
6002  // The result is guaranteed to be less than 2^BW so we may truncate it to BW
6003  // bits.
6004  return SE.getConstant(Result.trunc(BW));
6005 }
6006 
6007 /// SolveQuadraticEquation - Find the roots of the quadratic equation for the
6008 /// given quadratic chrec {L,+,M,+,N}. This returns either the two roots (which
6009 /// might be the same) or two SCEVCouldNotCompute objects.
6010 ///
6011 static std::pair<const SCEV *,const SCEV *>
6012 SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
6013  assert(AddRec->getNumOperands() == 3 && "This is not a quadratic chrec!");
6014  const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
6015  const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
6016  const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
6017 
6018  // We currently can only solve this if the coefficients are constants.
6019  if (!LC || !MC || !NC) {
6020  const SCEV *CNC = SE.getCouldNotCompute();
6021  return std::make_pair(CNC, CNC);
6022  }
6023 
6024  uint32_t BitWidth = LC->getValue()->getValue().getBitWidth();
6025  const APInt &L = LC->getValue()->getValue();
6026  const APInt &M = MC->getValue()->getValue();
6027  const APInt &N = NC->getValue()->getValue();
6028  APInt Two(BitWidth, 2);
6029  APInt Four(BitWidth, 4);
6030 
6031  {
6032  using namespace APIntOps;
6033  const APInt& C = L;
6034  // Convert from chrec coefficients to polynomial coefficients AX^2+BX+C
6035  // The B coefficient is M-N/2
6036  APInt B(M);
6037  B -= sdiv(N,Two);
6038 
6039  // The A coefficient is N/2
6040  APInt A(N.sdiv(Two));
6041 
6042  // Compute the B^2-4ac term.
6043  APInt SqrtTerm(B);
6044  SqrtTerm *= B;
6045  SqrtTerm -= Four * (A * C);
6046 
6047  if (SqrtTerm.isNegative()) {
6048  // The loop is provably infinite.
6049  const SCEV *CNC = SE.getCouldNotCompute();
6050  return std::make_pair(CNC, CNC);
6051  }
6052 
6053  // Compute sqrt(B^2-4ac). This is guaranteed to be the nearest
6054  // integer value or else APInt::sqrt() will assert.
6055  APInt SqrtVal(SqrtTerm.sqrt());
6056 
6057  // Compute the two solutions for the quadratic formula.
6058  // The divisions must be performed as signed divisions.
6059  APInt NegB(-B);
6060  APInt TwoA(A << 1);
6061  if (TwoA.isMinValue()) {
6062  const SCEV *CNC = SE.getCouldNotCompute();
6063  return std::make_pair(CNC, CNC);
6064  }
6065 
6066  LLVMContext &Context = SE.getContext();
6067 
6068  ConstantInt *Solution1 =
6069  ConstantInt::get(Context, (NegB + SqrtVal).sdiv(TwoA));
6070  ConstantInt *Solution2 =
6071  ConstantInt::get(Context, (NegB - SqrtVal).sdiv(TwoA));
6072 
6073  return std::make_pair(SE.getConstant(Solution1),
6074  SE.getConstant(Solution2));
6075  } // end APIntOps namespace
6076 }
6077 
6078 /// HowFarToZero - Return the number of times a backedge comparing the specified
6079 /// value to zero will execute. If not computable, return CouldNotCompute.
6080 ///
6081 /// This is only used for loops with a "x != y" exit test. The exit condition is
6082 /// now expressed as a single expression, V = x-y. So the exit test is
6083 /// effectively V != 0. We know and take advantage of the fact that this
6084 /// expression only being used in a comparison by zero context.
6085 ScalarEvolution::ExitLimit
6086 ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L, bool ControlsExit) {
6087  // If the value is a constant
6088  if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
6089  // If the value is already zero, the branch will execute zero times.
6090  if (C->getValue()->isZero()) return C;
6091  return getCouldNotCompute(); // Otherwise it will loop infinitely.
6092  }
6093 
6094  const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V);
6095  if (!AddRec || AddRec->getLoop() != L)
6096  return getCouldNotCompute();
6097 
6098  // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
6099  // the quadratic equation to solve it.
6100  if (AddRec->isQuadratic() && AddRec->getType()->isIntegerTy()) {
6101  std::pair<const SCEV *,const SCEV *> Roots =
6102  SolveQuadraticEquation(AddRec, *this);
6103  const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
6104  const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
6105  if (R1 && R2) {
6106 #if 0
6107  dbgs() << "HFTZ: " << *V << " - sol#1: " << *R1
6108  << " sol#2: " << *R2 << "\n";
6109 #endif
6110  // Pick the smallest positive root value.
6111  if (ConstantInt *CB =
6112  dyn_cast<ConstantInt>(ConstantExpr::getICmp(CmpInst::ICMP_ULT,
6113  R1->getValue(),
6114  R2->getValue()))) {
6115  if (!CB->getZExtValue())
6116  std::swap(R1, R2); // R1 is the minimum root now.
6117 
6118  // We can only use this value if the chrec ends up with an exact zero
6119  // value at this index. When solving for "X*X != 5", for example, we
6120  // should not accept a root of 2.
6121  const SCEV *Val = AddRec->evaluateAtIteration(R1, *this);
6122  if (Val->isZero())
6123  return R1; // We found a quadratic root!
6124  }
6125  }
6126  return getCouldNotCompute();
6127  }
6128 
6129  // Otherwise we can only handle this if it is affine.
6130  if (!AddRec->isAffine())
6131  return getCouldNotCompute();
6132 
6133  // If this is an affine expression, the execution count of this branch is
6134  // the minimum unsigned root of the following equation:
6135  //
6136  // Start + Step*N = 0 (mod 2^BW)
6137  //
6138  // equivalent to:
6139  //
6140  // Step*N = -Start (mod 2^BW)
6141  //
6142  // where BW is the common bit width of Start and Step.
6143 
6144  // Get the initial value for the loop.
6145  const SCEV *Start = getSCEVAtScope(AddRec->getStart(), L->getParentLoop());
6146  const SCEV *Step = getSCEVAtScope(AddRec->getOperand(1), L->getParentLoop());
6147 
6148  // For now we handle only constant steps.
6149  //
6150  // TODO: Handle a nonconstant Step given AddRec<NUW>. If the
6151  // AddRec is NUW, then (in an unsigned sense) it cannot be counting up to wrap
6152  // to 0, it must be counting down to equal 0. Consequently, N = Start / -Step.
6153  // We have not yet seen any such cases.
6154  const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
6155  if (!StepC || StepC->getValue()->equalsInt(0))
6156  return getCouldNotCompute();
6157 
6158  // For positive steps (counting up until unsigned overflow):
6159  // N = -Start/Step (as unsigned)
6160  // For negative steps (counting down to zero):
6161  // N = Start/-Step
6162  // First compute the unsigned distance from zero in the direction of Step.
6163  bool CountDown = StepC->getValue()->getValue().isNegative();
6164  const SCEV *Distance = CountDown ? Start : getNegativeSCEV(Start);
6165 
6166  // Handle unitary steps, which cannot wraparound.
6167  // 1*N = -Start; -1*N = Start (mod 2^BW), so:
6168  // N = Distance (as unsigned)
6169  if (StepC->getValue()->equalsInt(1) || StepC->getValue()->isAllOnesValue()) {
6170  ConstantRange CR = getUnsignedRange(Start);
6171  const SCEV *MaxBECount;
6172  if (!CountDown && CR.getUnsignedMin().isMinValue())
6173  // When counting up, the worst starting value is 1, not 0.
6174  MaxBECount = CR.getUnsignedMax().isMinValue()
6177  else
6178  MaxBECount = getConstant(CountDown ? CR.getUnsignedMax()
6179  : -CR.getUnsignedMin());
6180  return ExitLimit(Distance, MaxBECount);
6181  }
6182 
6183  // As a special case, handle the instance where Step is a positive power of
6184  // two. In this case, determining whether Step divides Distance evenly can be
6185  // done by counting and comparing the number of trailing zeros of Step and
6186  // Distance.
6187  if (!CountDown) {
6188  const APInt &StepV = StepC->getValue()->getValue();
6189  // StepV.isPowerOf2() returns true if StepV is an positive power of two. It
6190  // also returns true if StepV is maximally negative (eg, INT_MIN), but that
6191  // case is not handled as this code is guarded by !CountDown.
6192  if (StepV.isPowerOf2() &&
6193  GetMinTrailingZeros(Distance) >= StepV.countTrailingZeros())
6194  return getUDivExactExpr(Distance, Step);
6195  }
6196 
6197  // If the condition controls loop exit (the loop exits only if the expression
6198  // is true) and the addition is no-wrap we can use unsigned divide to
6199  // compute the backedge count. In this case, the step may not divide the
6200  // distance, but we don't care because if the condition is "missed" the loop
6201  // will have undefined behavior due to wrapping.
6202  if (ControlsExit && AddRec->getNoWrapFlags(SCEV::FlagNW)) {
6203  const SCEV *Exact =
6204  getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
6205  return ExitLimit(Exact, Exact);
6206  }
6207 
6208  // Then, try to solve the above equation provided that Start is constant.
6209  if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start))
6210  return SolveLinEquationWithOverflow(StepC->getValue()->getValue(),
6211  -StartC->getValue()->getValue(),
6212  *this);
6213  return getCouldNotCompute();
6214 }
6215 
6216 /// HowFarToNonZero - Return the number of times a backedge checking the
6217 /// specified value for nonzero will execute. If not computable, return
6218 /// CouldNotCompute
6219 ScalarEvolution::ExitLimit
6220 ScalarEvolution::HowFarToNonZero(const SCEV *V, const Loop *L) {
6221  // Loops that look like: while (X == 0) are very strange indeed. We don't
6222  // handle them yet except for the trivial case. This could be expanded in the
6223  // future as needed.
6224 
6225  // If the value is a constant, check to see if it is known to be non-zero
6226  // already. If so, the backedge will execute zero times.
6227  if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
6228  if (!C->getValue()->isNullValue())
6229  return getConstant(C->getType(), 0);
6230  return getCouldNotCompute(); // Otherwise it will loop infinitely.
6231  }
6232 
6233  // We could implement others, but I really doubt anyone writes loops like
6234  // this, and if they did, they would already be constant folded.
6235  return getCouldNotCompute();
6236 }
6237 
6238 /// getPredecessorWithUniqueSuccessorForBB - Return a predecessor of BB
6239 /// (which may not be an immediate predecessor) which has exactly one
6240 /// successor from which BB is reachable, or null if no such block is
6241 /// found.
6242 ///
6243 std::pair<BasicBlock *, BasicBlock *>
6244 ScalarEvolution::getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB) {
6245  // If the block has a unique predecessor, then there is no path from the
6246  // predecessor to the block that does not go through the direct edge
6247  // from the predecessor to the block.
6248  if (BasicBlock *Pred = BB->getSinglePredecessor())
6249  return std::make_pair(Pred, BB);
6250 
6251  // A loop's header is defined to be a block that dominates the loop.
6252  // If the header has a unique predecessor outside the loop, it must be
6253  // a block that has exactly one successor that can reach the loop.
6254  if (Loop *L = LI->getLoopFor(BB))
6255  return std::make_pair(L->getLoopPredecessor(), L->getHeader());
6256 
6257  return std::pair<BasicBlock *, BasicBlock *>();
6258 }
6259 
6260 /// HasSameValue - SCEV structural equivalence is usually sufficient for
6261 /// testing whether two expressions are equal, however for the purposes of
6262 /// looking for a condition guarding a loop, it can be useful to be a little
6263 /// more general, since a front-end may have replicated the controlling
6264 /// expression.
6265 ///
6266 static bool HasSameValue(const SCEV *A, const SCEV *B) {
6267  // Quick check to see if they are the same SCEV.
6268  if (A == B) return true;
6269 
6270  // Otherwise, if they're both SCEVUnknown, it's possible that they hold
6271  // two different instructions with the same value. Check for this case.
6272  if (const SCEVUnknown *AU = dyn_cast<SCEVUnknown>(A))
6273  if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
6274  if (const Instruction *AI = dyn_cast<Instruction>(AU->getValue()))
6275  if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))
6276  if (AI->isIdenticalTo(BI) && !AI->mayReadFromMemory())
6277  return true;
6278 
6279  // Otherwise assume they may have a different value.
6280  return false;
6281 }
6282 
6283 /// SimplifyICmpOperands - Simplify LHS and RHS in a comparison with
6284 /// predicate Pred. Return true iff any changes were made.
6285 ///
6287  const SCEV *&LHS, const SCEV *&RHS,
6288  unsigned Depth) {
6289  bool Changed = false;
6290 
6291  // If we hit the max recursion limit bail out.
6292  if (Depth >= 3)
6293  return false;
6294 
6295  // Canonicalize a constant to the right side.
6296  if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
6297  // Check for both operands constant.
6298  if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
6299  if (ConstantExpr::getICmp(Pred,
6300  LHSC->getValue(),
6301  RHSC->getValue())->isNullValue())
6302  goto trivially_false;
6303  else
6304  goto trivially_true;
6305  }
6306  // Otherwise swap the operands to put the constant on the right.
6307  std::swap(LHS, RHS);
6308  Pred = ICmpInst::getSwappedPredicate(Pred);
6309  Changed = true;
6310  }
6311 
6312  // If we're comparing an addrec with a value which is loop-invariant in the
6313  // addrec's loop, put the addrec on the left. Also make a dominance check,
6314  // as both operands could be addrecs loop-invariant in each other's loop.
6315  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS)) {
6316  const Loop *L = AR->getLoop();
6317  if (isLoopInvariant(LHS, L) && properlyDominates(LHS, L->getHeader())) {
6318  std::swap(LHS, RHS);
6319  Pred = ICmpInst::getSwappedPredicate(Pred);
6320  Changed = true;
6321  }
6322  }
6323 
6324  // If there's a constant operand, canonicalize comparisons with boundary
6325  // cases, and canonicalize *-or-equal comparisons to regular comparisons.
6326  if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
6327  const APInt &RA = RC->getValue()->getValue();
6328  switch (Pred) {
6329  default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
6330  case ICmpInst::ICMP_EQ:
6331  case ICmpInst::ICMP_NE:
6332  // Fold ((-1) * %a) + %b == 0 (equivalent to %b-%a == 0) into %a == %b.
6333  if (!RA)
6334  if (const SCEVAddExpr *AE = dyn_cast<SCEVAddExpr>(LHS))
6335  if (const SCEVMulExpr *ME = dyn_cast<SCEVMulExpr>(AE->getOperand(0)))
6336  if (AE->getNumOperands() == 2 && ME->getNumOperands() == 2 &&
6337  ME->getOperand(0)->isAllOnesValue()) {
6338  RHS = AE->getOperand(1);
6339  LHS = ME->getOperand(1);
6340  Changed = true;
6341  }
6342  break;
6343  case ICmpInst::ICMP_UGE:
6344  if ((RA - 1).isMinValue()) {
6345  Pred = ICmpInst::ICMP_NE;
6346  RHS = getConstant(RA - 1);
6347  Changed = true;
6348  break;
6349  }
6350  if (RA.isMaxValue()) {
6351  Pred = ICmpInst::ICMP_EQ;
6352  Changed = true;
6353  break;
6354  }
6355  if (RA.isMinValue()) goto trivially_true;
6356 
6357  Pred = ICmpInst::ICMP_UGT;
6358  RHS = getConstant(RA - 1);
6359  Changed = true;
6360  break;
6361  case ICmpInst::ICMP_ULE:
6362  if ((RA + 1).isMaxValue()) {
6363  Pred = ICmpInst::ICMP_NE;
6364  RHS = getConstant(RA + 1);
6365  Changed = true;
6366  break;
6367  }
6368  if (RA.isMinValue()) {
6369  Pred = ICmpInst::ICMP_EQ;
6370  Changed = true;
6371  break;
6372  }
6373  if (RA.isMaxValue()) goto trivially_true;
6374 
6375  Pred = ICmpInst::ICMP_ULT;
6376  RHS = getConstant(RA + 1);
6377  Changed = true;
6378  break;
6379  case ICmpInst::ICMP_SGE:
6380  if ((RA - 1).isMinSignedValue()) {
6381  Pred = ICmpInst::ICMP_NE;
6382  RHS = getConstant(RA - 1);
6383  Changed = true;
6384  break;
6385  }
6386  if (RA.isMaxSignedValue()) {
6387  Pred = ICmpInst::ICMP_EQ;
6388  Changed = true;
6389  break;
6390  }
6391  if (RA.isMinSignedValue()) goto trivially_true;
6392 
6393  Pred = ICmpInst::ICMP_SGT;
6394  RHS = getConstant(RA - 1);
6395  Changed = true;
6396  break;
6397  case ICmpInst::ICMP_SLE:
6398  if ((RA + 1).isMaxSignedValue()) {
6399  Pred = ICmpInst::ICMP_NE;
6400  RHS = getConstant(RA + 1);
6401  Changed = true;
6402  break;
6403  }
6404  if (RA.isMinSignedValue()) {
6405  Pred = ICmpInst::ICMP_EQ;
6406  Changed = true;
6407  break;
6408  }
6409  if (RA.isMaxSignedValue()) goto trivially_true;
6410 
6411  Pred = ICmpInst::ICMP_SLT;
6412  RHS = getConstant(RA + 1);
6413  Changed = true;
6414  break;
6415  case ICmpInst::ICMP_UGT:
6416  if (RA.isMinValue()) {
6417  Pred = ICmpInst::ICMP_NE;
6418  Changed = true;
6419  break;
6420  }
6421  if ((RA + 1).isMaxValue()) {
6422  Pred = ICmpInst::ICMP_EQ;
6423  RHS = getConstant(RA + 1);
6424  Changed = true;
6425  break;
6426  }
6427  if (RA.isMaxValue()) goto trivially_false;
6428  break;
6429  case ICmpInst::ICMP_ULT:
6430  if (RA.isMaxValue()) {
6431  Pred = ICmpInst::ICMP_NE;
6432  Changed = true;
6433  break;
6434  }
6435  if ((RA - 1).isMinValue()) {
6436  Pred = ICmpInst::ICMP_EQ;
6437  RHS = getConstant(RA - 1);
6438  Changed = true;
6439  break;
6440  }
6441  if (RA.isMinValue()) goto trivially_false;
6442  break;
6443  case ICmpInst::ICMP_SGT:
6444  if (RA.isMinSignedValue()) {
6445  Pred = ICmpInst::ICMP_NE;
6446  Changed = true;
6447  break;
6448  }
6449  if ((RA + 1).isMaxSignedValue()) {
6450  Pred = ICmpInst::ICMP_EQ;
6451  RHS = getConstant(RA + 1);
6452  Changed = true;
6453  break;
6454  }
6455  if (RA.isMaxSignedValue()) goto trivially_false;
6456  break;
6457  case ICmpInst::ICMP_SLT:
6458  if (RA.isMaxSignedValue()) {
6459  Pred = ICmpInst::ICMP_NE;
6460  Changed = true;
6461  break;
6462  }
6463  if ((RA - 1).isMinSignedValue()) {
6464  Pred = ICmpInst::ICMP_EQ;
6465  RHS = getConstant(RA - 1);
6466  Changed = true;
6467  break;
6468  }
6469  if (RA.isMinSignedValue()) goto trivially_false;
6470  break;
6471  }
6472  }
6473 
6474  // Check for obvious equality.
6475  if (HasSameValue(LHS, RHS)) {
6476  if (ICmpInst::isTrueWhenEqual(Pred))
6477  goto trivially_true;
6478  if (ICmpInst::isFalseWhenEqual(Pred))
6479  goto trivially_false;
6480  }
6481 
6482  // If possible, canonicalize GE/LE comparisons to GT/LT comparisons, by
6483  // adding or subtracting 1 from one of the operands.
6484  switch (Pred) {
6485  case ICmpInst::ICMP_SLE:
6487  RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
6488  SCEV::FlagNSW);
6489  Pred = ICmpInst::ICMP_SLT;
6490  Changed = true;
6491  } else if (!getSignedRange(LHS).getSignedMin().isMinSignedValue()) {
6492  LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
6493  SCEV::FlagNSW);
6494  Pred = ICmpInst::ICMP_SLT;
6495  Changed = true;
6496  }
6497  break;
6498  case ICmpInst::ICMP_SGE:
6500  RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
6501  SCEV::FlagNSW);
6502  Pred = ICmpInst::ICMP_SGT;
6503  Changed = true;
6504  } else if (!getSignedRange(LHS).getSignedMax().isMaxSignedValue()) {
6505  LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
6506  SCEV::FlagNSW);
6507  Pred = ICmpInst::ICMP_SGT;
6508  Changed = true;
6509  }
6510  break;
6511  case ICmpInst::ICMP_ULE:
6512  if (!getUnsignedRange(RHS).getUnsignedMax().isMaxValue()) {
6513  RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
6514  SCEV::FlagNUW);
6515  Pred = ICmpInst::ICMP_ULT;
6516  Changed = true;
6517  } else if (!getUnsignedRange(LHS).getUnsignedMin().isMinValue()) {
6518  LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
6519  SCEV::FlagNUW);
6520  Pred = ICmpInst::ICMP_ULT;
6521  Changed = true;
6522  }
6523  break;
6524  case ICmpInst::ICMP_UGE:
6525  if (!getUnsignedRange(RHS).getUnsignedMin().isMinValue()) {
6526  RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
6527  SCEV::FlagNUW);
6528  Pred = ICmpInst::ICMP_UGT;
6529  Changed = true;
6530  } else if (!getUnsignedRange(LHS).getUnsignedMax().isMaxValue()) {
6531  LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
6532  SCEV::FlagNUW);
6533  Pred = ICmpInst::ICMP_UGT;
6534  Changed = true;
6535  }
6536  break;
6537  default:
6538  break;
6539  }
6540 
6541  // TODO: More simplifications are possible here.
6542 
6543  // Recursively simplify until we either hit a recursion limit or nothing
6544  // changes.
6545  if (Changed)
6546  return SimplifyICmpOperands(Pred, LHS, RHS, Depth+1);
6547 
6548  return Changed;
6549 
6550 trivially_true:
6551  // Return 0 == 0.
6553  Pred = ICmpInst::ICMP_EQ;
6554  return true;
6555 
6556 trivially_false:
6557  // Return 0 != 0.
6559  Pred = ICmpInst::ICMP_NE;
6560  return true;
6561 }
6562 
6564  return getSignedRange(S).getSignedMax().isNegative();
6565 }
6566 
6569 }
6570 
6572  return !getSignedRange(S).getSignedMin().isNegative();
6573 }
6574 
6577 }
6578 
6580  return isKnownNegative(S) || isKnownPositive(S);
6581 }
6582 
6584  const SCEV *LHS, const SCEV *RHS) {
6585  // Canonicalize the inputs first.
6586  (void)SimplifyICmpOperands(Pred, LHS, RHS);
6587 
6588  // If LHS or RHS is an addrec, check to see if the condition is true in
6589  // every iteration of the loop.
6590  // If LHS and RHS are both addrec, both conditions must be true in
6591  // every iteration of the loop.
6592  const SCEVAddRecExpr *LAR = dyn_cast<SCEVAddRecExpr>(LHS);
6593  const SCEVAddRecExpr *RAR = dyn_cast<SCEVAddRecExpr>(RHS);
6594  bool LeftGuarded = false;
6595  bool RightGuarded = false;
6596  if (LAR) {
6597  const Loop *L = LAR->getLoop();
6598  if (isLoopEntryGuardedByCond(L, Pred, LAR->getStart(), RHS) &&
6599  isLoopBackedgeGuardedByCond(L, Pred, LAR->getPostIncExpr(*this), RHS)) {
6600  if (!RAR) return true;
6601  LeftGuarded = true;
6602  }
6603  }
6604  if (RAR) {
6605  const Loop *L = RAR->getLoop();
6606  if (isLoopEntryGuardedByCond(L, Pred, LHS, RAR->getStart()) &&
6607  isLoopBackedgeGuardedByCond(L, Pred, LHS, RAR->getPostIncExpr(*this))) {
6608  if (!LAR) return true;
6609  RightGuarded = true;
6610  }
6611  }
6612  if (LeftGuarded && RightGuarded)
6613  return true;
6614 
6615  // Otherwise see what can be done with known constant ranges.
6616  return isKnownPredicateWithRanges(Pred, LHS, RHS);
6617 }
6618 
6619 bool
6620 ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
6621  const SCEV *LHS, const SCEV *RHS) {
6622  if (HasSameValue(LHS, RHS))
6623  return ICmpInst::isTrueWhenEqual(Pred);
6624 
6625  // This code is split out from isKnownPredicate because it is called from
6626  // within isLoopEntryGuardedByCond.
6627  switch (Pred) {
6628  default:
6629  llvm_unreachable("Unexpected ICmpInst::Predicate value!");
6630  case ICmpInst::ICMP_SGT:
6631  std::swap(LHS, RHS);
6632  case ICmpInst::ICMP_SLT: {
6633  ConstantRange LHSRange = getSignedRange(LHS);
6634  ConstantRange RHSRange = getSignedRange(RHS);
6635  if (LHSRange.getSignedMax().slt(RHSRange.getSignedMin()))
6636  return true;
6637  if (LHSRange.getSignedMin().sge(RHSRange.getSignedMax()))
6638  return false;
6639  break;
6640  }
6641  case ICmpInst::ICMP_SGE:
6642  std::swap(LHS, RHS);
6643  case ICmpInst::ICMP_SLE: {
6644  ConstantRange LHSRange = getSignedRange(LHS);
6645  ConstantRange RHSRange = getSignedRange(RHS);
6646  if (LHSRange.getSignedMax().sle(RHSRange.getSignedMin()))
6647  return true;
6648  if (LHSRange.getSignedMin().sgt(RHSRange.getSignedMax()))
6649  return false;
6650  break;
6651  }
6652  case ICmpInst::ICMP_UGT:
6653  std::swap(LHS, RHS);
6654  case ICmpInst::ICMP_ULT: {
6655  ConstantRange LHSRange = getUnsignedRange(LHS);
6656  ConstantRange RHSRange = getUnsignedRange(RHS);
6657  if (LHSRange.getUnsignedMax().ult(RHSRange.getUnsignedMin()))
6658  return true;
6659  if (LHSRange.getUnsignedMin().uge(RHSRange.getUnsignedMax()))
6660  return false;
6661  break;
6662  }
6663  case ICmpInst::ICMP_UGE:
6664  std::swap(LHS, RHS);
6665  case ICmpInst::ICMP_ULE: {
6666  ConstantRange LHSRange = getUnsignedRange(LHS);
6667  ConstantRange RHSRange = getUnsignedRange(RHS);
6668  if (LHSRange.getUnsignedMax().ule(RHSRange.getUnsignedMin()))
6669  return true;
6670  if (LHSRange.getUnsignedMin().ugt(RHSRange.getUnsignedMax()))
6671  return false;
6672  break;
6673  }
6674  case ICmpInst::ICMP_NE: {
6676  return true;
6678  return true;
6679 
6680  const SCEV *Diff = getMinusSCEV(LHS, RHS);
6681  if (isKnownNonZero(Diff))
6682  return true;
6683  break;
6684  }
6685  case ICmpInst::ICMP_EQ:
6686  // The check at the top of the function catches the case where
6687  // the values are known to be equal.
6688  break;
6689  }
6690  return false;
6691 }
6692 
6693 /// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is
6694 /// protected by a conditional between LHS and RHS. This is used to
6695 /// to eliminate casts.
6696 bool
6698  ICmpInst::Predicate Pred,
6699  const SCEV *LHS, const SCEV *RHS) {
6700  // Interpret a null as meaning no loop, where there is obviously no guard
6701  // (interprocedural conditions notwithstanding).
6702  if (!L) return true;
6703 
6704  if (isKnownPredicateWithRanges(Pred, LHS, RHS)) return true;
6705 
6706  BasicBlock *Latch = L->getLoopLatch();
6707  if (!Latch)
6708  return false;
6709 
6710  BranchInst *LoopContinuePredicate =
6711  dyn_cast<BranchInst>(Latch->getTerminator());
6712  if (LoopContinuePredicate && LoopContinuePredicate->isConditional() &&
6713  isImpliedCond(Pred, LHS, RHS,
6714  LoopContinuePredicate->getCondition(),
6715  LoopContinuePredicate->getSuccessor(0) != L->getHeader()))
6716  return true;
6717 
6718  // Check conditions due to any @llvm.assume intrinsics.
6719  for (auto &AssumeVH : AC->assumptions()) {
6720  if (!AssumeVH)
6721  continue;
6722  auto *CI = cast<CallInst>(AssumeVH);
6723  if (!DT->dominates(CI, Latch->getTerminator()))
6724  continue;
6725 
6726  if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
6727  return true;
6728  }
6729 
6730  struct ClearWalkingBEDominatingCondsOnExit {
6731  ScalarEvolution &SE;
6732 
6733  explicit ClearWalkingBEDominatingCondsOnExit(ScalarEvolution &SE)
6734  : SE(SE){};
6735 
6736  ~ClearWalkingBEDominatingCondsOnExit() {
6737  SE.WalkingBEDominatingConds = false;
6738  }
6739  };
6740 
6741  // We don't want more than one activation of the following loop on the stack
6742  // -- that can lead to O(n!) time complexity.
6743  if (WalkingBEDominatingConds)
6744  return false;
6745 
6746  WalkingBEDominatingConds = true;
6747  ClearWalkingBEDominatingCondsOnExit ClearOnExit(*this);
6748 
6749  // If the loop is not reachable from the entry block, we risk running into an
6750  // infinite loop as we walk up into the dom tree. These loops do not matter
6751  // anyway, so we just return a conservative answer when we see them.
6752  if (!DT->isReachableFromEntry(L->getHeader()))
6753  return false;
6754 
6755  for (DomTreeNode *DTN = (*DT)[Latch], *HeaderDTN = (*DT)[L->getHeader()];
6756  DTN != HeaderDTN;
6757  DTN = DTN->getIDom()) {
6758 
6759  assert(DTN && "should reach the loop header before reaching the root!");
6760 
6761  BasicBlock *BB = DTN->getBlock();
6762  BasicBlock *PBB = BB->getSinglePredecessor();
6763  if (!PBB)
6764  continue;
6765 
6766  BranchInst *ContinuePredicate = dyn_cast<BranchInst>(PBB->getTerminator());
6767  if (!ContinuePredicate || !ContinuePredicate->isConditional())
6768  continue;
6769 
6770  Value *Condition = ContinuePredicate->getCondition();
6771 
6772  // If we have an edge `E` within the loop body that dominates the only
6773  // latch, the condition guarding `E` also guards the backedge. This
6774  // reasoning works only for loops with a single latch.
6775 
6776  BasicBlockEdge DominatingEdge(PBB, BB);
6777  if (DominatingEdge.isSingleEdge()) {
6778  // We're constructively (and conservatively) enumerating edges within the
6779  // loop body that dominate the latch. The dominator tree better agree
6780  // with us on this:
6781  assert(DT->dominates(DominatingEdge, Latch) && "should be!");
6782 
6783  if (isImpliedCond(Pred, LHS, RHS, Condition,
6784  BB != ContinuePredicate->getSuccessor(0)))
6785  return true;
6786  }
6787  }
6788 
6789  return false;
6790 }
6791 
6792 /// isLoopEntryGuardedByCond - Test whether entry to the loop is protected
6793 /// by a conditional between LHS and RHS. This is used to help avoid max
6794 /// expressions in loop trip counts, and to eliminate casts.
6795 bool
6797  ICmpInst::Predicate Pred,
6798  const SCEV *LHS, const SCEV *RHS) {
6799  // Interpret a null as meaning no loop, where there is obviously no guard
6800  // (interprocedural conditions notwithstanding).
6801  if (!L) return false;
6802 
6803  if (isKnownPredicateWithRanges(Pred, LHS, RHS)) return true;
6804 
6805  // Starting at the loop predecessor, climb up the predecessor chain, as long
6806  // as there are predecessors that can be found that have unique successors
6807  // leading to the original header.
6808  for (std::pair<BasicBlock *, BasicBlock *>
6809  Pair(L->getLoopPredecessor(), L->getHeader());
6810  Pair.first;
6811  Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
6812 
6813  BranchInst *LoopEntryPredicate =
6814  dyn_cast<BranchInst>(Pair.first->getTerminator());
6815  if (!LoopEntryPredicate ||
6816  LoopEntryPredicate->isUnconditional())
6817  continue;
6818 
6819  if (isImpliedCond(Pred, LHS, RHS,
6820  LoopEntryPredicate->getCondition(),
6821  LoopEntryPredicate->getSuccessor(0) != Pair.second))
6822  return true;
6823  }
6824 
6825  // Check conditions due to any @llvm.assume intrinsics.
6826  for (auto &AssumeVH : AC->assumptions()) {
6827  if (!AssumeVH)
6828  continue;
6829  auto *CI = cast<CallInst>(AssumeVH);
6830  if (!DT->dominates(CI, L->getHeader()))
6831  continue;
6832 
6833  if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0), false))
6834  return true;
6835  }
6836 
6837  return false;
6838 }
6839 
6840 /// RAII wrapper to prevent recursive application of isImpliedCond.
6841 /// ScalarEvolution's PendingLoopPredicates set must be empty unless we are
6842 /// currently evaluating isImpliedCond.
6846  bool Pending;
6847 
6849  : Cond(C), LoopPreds(LP) {
6850  Pending = !LoopPreds.insert(Cond).second;
6851  }
6853  if (!Pending)
6854  LoopPreds.erase(Cond);
6855  }
6856 };
6857 
6858 /// isImpliedCond - Test whether the condition described by Pred, LHS,
6859 /// and RHS is true whenever the given Cond value evaluates to true.
6860 bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
6861  const SCEV *LHS, const SCEV *RHS,
6862  Value *FoundCondValue,
6863  bool Inverse) {
6864  MarkPendingLoopPredicate Mark(FoundCondValue, PendingLoopPredicates);
6865  if (Mark.Pending)
6866  return false;
6867 
6868  // Recursively handle And and Or conditions.
6869  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FoundCondValue)) {
6870  if (BO->getOpcode() == Instruction::And) {
6871  if (!Inverse)
6872  return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
6873  isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
6874  } else if (BO->getOpcode() == Instruction::Or) {
6875  if (Inverse)
6876  return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
6877  isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
6878  }
6879  }
6880 
6881  ICmpInst *ICI = dyn_cast<ICmpInst>(FoundCondValue);
6882  if (!ICI) return false;
6883 
6884  // Now that we found a conditional branch that dominates the loop or controls
6885  // the loop latch. Check to see if it is the comparison we are looking for.
6886  ICmpInst::Predicate FoundPred;
6887  if (Inverse)
6888  FoundPred = ICI->getInversePredicate();
6889  else
6890  FoundPred = ICI->getPredicate();
6891 
6892  const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
6893  const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
6894 
6895  // Balance the types.
6896  if (getTypeSizeInBits(LHS->getType()) <
6897  getTypeSizeInBits(FoundLHS->getType())) {
6898  if (CmpInst::isSigned(Pred)) {
6899  LHS = getSignExtendExpr(LHS, FoundLHS->getType());
6900  RHS = getSignExtendExpr(RHS, FoundLHS->getType());
6901  } else {
6902  LHS = getZeroExtendExpr(LHS, FoundLHS->getType());
6903  RHS = getZeroExtendExpr(RHS, FoundLHS->getType());
6904  }
6905  } else if (getTypeSizeInBits(LHS->getType()) >
6906  getTypeSizeInBits(FoundLHS->getType())) {
6907  if (CmpInst::isSigned(FoundPred)) {
6908  FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
6909  FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
6910  } else {
6911  FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
6912  FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
6913  }
6914  }
6915 
6916  // Canonicalize the query to match the way instcombine will have
6917  // canonicalized the comparison.
6918  if (SimplifyICmpOperands(Pred, LHS, RHS))
6919  if (LHS == RHS)
6920  return CmpInst::isTrueWhenEqual(Pred);
6921  if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
6922  if (FoundLHS == FoundRHS)
6923  return CmpInst::isFalseWhenEqual(FoundPred);
6924 
6925  // Check to see if we can make the LHS or RHS match.
6926  if (LHS == FoundRHS || RHS == FoundLHS) {
6927  if (isa<SCEVConstant>(RHS)) {
6928  std::swap(FoundLHS, FoundRHS);
6929  FoundPred = ICmpInst::getSwappedPredicate(FoundPred);
6930  } else {
6931  std::swap(LHS, RHS);
6932  Pred = ICmpInst::getSwappedPredicate(Pred);
6933  }
6934  }
6935 
6936  // Check whether the found predicate is the same as the desired predicate.
6937  if (FoundPred == Pred)
6938  return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
6939 
6940  // Check whether swapping the found predicate makes it the same as the
6941  // desired predicate.
6942  if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
6943  if (isa<SCEVConstant>(RHS))
6944  return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
6945  else
6946  return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
6947  RHS, LHS, FoundLHS, FoundRHS);
6948  }
6949 
6950  // Check if we can make progress by sharpening ranges.
6951  if (FoundPred == ICmpInst::ICMP_NE &&
6952  (isa<SCEVConstant>(FoundLHS) || isa<SCEVConstant>(FoundRHS))) {
6953 
6954  const SCEVConstant *C = nullptr;
6955  const SCEV *V = nullptr;
6956 
6957  if (isa<SCEVConstant>(FoundLHS)) {
6958  C = cast<SCEVConstant>(FoundLHS);
6959  V = FoundRHS;
6960  } else {
6961  C = cast<SCEVConstant>(FoundRHS);
6962  V = FoundLHS;
6963  }
6964 
6965  // The guarding predicate tells us that C != V. If the known range
6966  // of V is [C, t), we can sharpen the range to [C + 1, t). The
6967  // range we consider has to correspond to same signedness as the
6968  // predicate we're interested in folding.
6969 
6970  APInt Min = ICmpInst::isSigned(Pred) ?
6972 
6973  if (Min == C->getValue()->getValue()) {
6974  // Given (V >= Min && V != Min) we conclude V >= (Min + 1).
6975  // This is true even if (Min + 1) wraps around -- in case of
6976  // wraparound, (Min + 1) < Min, so (V >= Min => V >= (Min + 1)).
6977 
6978  APInt SharperMin = Min + 1;
6979 
6980  switch (Pred) {
6981  case ICmpInst::ICMP_SGE:
6982  case ICmpInst::ICMP_UGE:
6983  // We know V `Pred` SharperMin. If this implies LHS `Pred`
6984  // RHS, we're done.
6985  if (isImpliedCondOperands(Pred, LHS, RHS, V,
6986  getConstant(SharperMin)))
6987  return true;
6988 
6989  case ICmpInst::ICMP_SGT:
6990  case ICmpInst::ICMP_UGT:
6991  // We know from the range information that (V `Pred` Min ||
6992  // V == Min). We know from the guarding condition that !(V
6993  // == Min). This gives us
6994  //
6995  // V `Pred` Min || V == Min && !(V == Min)
6996  // => V `Pred` Min
6997  //
6998  // If V `Pred` Min implies LHS `Pred` RHS, we're done.
6999 
7000  if (isImpliedCondOperands(Pred, LHS, RHS, V, getConstant(Min)))
7001  return true;
7002 
7003  default:
7004  // No change
7005  break;
7006  }
7007  }
7008  }
7009 
7010  // Check whether the actual condition is beyond sufficient.
7011  if (FoundPred == ICmpInst::ICMP_EQ)
7012  if (ICmpInst::isTrueWhenEqual(Pred))
7013  if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
7014  return true;
7015  if (Pred == ICmpInst::ICMP_NE)
7016  if (!ICmpInst::isTrueWhenEqual(FoundPred))
7017  if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
7018  return true;
7019 
7020  // Otherwise assume the worst.
7021  return false;
7022 }
7023 
7024 /// isImpliedCondOperands - Test whether the condition described by Pred,
7025 /// LHS, and RHS is true whenever the condition described by Pred, FoundLHS,
7026 /// and FoundRHS is true.
7027 bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
7028  const SCEV *LHS, const SCEV *RHS,
7029  const SCEV *FoundLHS,
7030  const SCEV *FoundRHS) {
7031  if (isImpliedCondOperandsViaRanges(Pred, LHS, RHS, FoundLHS, FoundRHS))
7032  return true;
7033 
7034  return isImpliedCondOperandsHelper(Pred, LHS, RHS,
7035  FoundLHS, FoundRHS) ||
7036  // ~x < ~y --> x > y
7037  isImpliedCondOperandsHelper(Pred, LHS, RHS,
7038  getNotSCEV(FoundRHS),
7039  getNotSCEV(FoundLHS));
7040 }
7041 
7042 
7043 /// If Expr computes ~A, return A else return nullptr
7044 static const SCEV *MatchNotExpr(const SCEV *Expr) {
7045  const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Expr);
7046  if (!Add || Add->getNumOperands() != 2) return nullptr;
7047 
7048  const SCEVConstant *AddLHS = dyn_cast<SCEVConstant>(Add->getOperand(0));
7049  if (!(AddLHS && AddLHS->getValue()->getValue().isAllOnesValue()))
7050  return nullptr;
7051 
7052  const SCEVMulExpr *AddRHS = dyn_cast<SCEVMulExpr>(Add->getOperand(1));
7053  if (!AddRHS || AddRHS->getNumOperands() != 2) return nullptr;
7054 
7055  const SCEVConstant *MulLHS = dyn_cast<SCEVConstant>(AddRHS->getOperand(0));
7056  if (!(MulLHS && MulLHS->getValue()->getValue().isAllOnesValue()))
7057  return nullptr;
7058 
7059  return AddRHS->getOperand(1);
7060 }
7061 
7062 
7063 /// Is MaybeMaxExpr an SMax or UMax of Candidate and some other values?
7064 template<typename MaxExprType>
7065 static bool IsMaxConsistingOf(const SCEV *MaybeMaxExpr,
7066  const SCEV *Candidate) {
7067  const MaxExprType *MaxExpr = dyn_cast<MaxExprType>(MaybeMaxExpr);
7068  if (!MaxExpr) return false;
7069 
7070  auto It = std::find(MaxExpr->op_begin(), MaxExpr->op_end(), Candidate);
7071  return It != MaxExpr->op_end();
7072 }
7073 
7074 
7075 /// Is MaybeMinExpr an SMin or UMin of Candidate and some other values?
7076 template<typename MaxExprType>
7077 static bool IsMinConsistingOf(ScalarEvolution &SE,
7078  const SCEV *MaybeMinExpr,
7079  const SCEV *Candidate) {
7080  const SCEV *MaybeMaxExpr = MatchNotExpr(MaybeMinExpr);
7081  if (!MaybeMaxExpr)
7082  return false;
7083 
7084  return IsMaxConsistingOf<MaxExprType>(MaybeMaxExpr, SE.getNotSCEV(Candidate));
7085 }
7086 
7087 
7088 /// Is LHS `Pred` RHS true on the virtue of LHS or RHS being a Min or Max
7089 /// expression?
7090 static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE,
7091  ICmpInst::Predicate Pred,
7092  const SCEV *LHS, const SCEV *RHS) {
7093  switch (Pred) {
7094  default:
7095  return false;
7096 
7097  case ICmpInst::ICMP_SGE:
7098  std::swap(LHS, RHS);
7099  // fall through
7100  case ICmpInst::ICMP_SLE:
7101  return
7102  // min(A, ...) <= A
7103  IsMinConsistingOf<SCEVSMaxExpr>(SE, LHS, RHS) ||
7104  // A <= max(A, ...)
7105  IsMaxConsistingOf<SCEVSMaxExpr>(RHS, LHS);
7106 
7107  case ICmpInst::ICMP_UGE:
7108  std::swap(LHS, RHS);
7109  // fall through
7110  case ICmpInst::ICMP_ULE:
7111  return
7112  // min(A, ...) <= A
7113  IsMinConsistingOf<SCEVUMaxExpr>(SE, LHS, RHS) ||
7114  // A <= max(A, ...)
7115  IsMaxConsistingOf<SCEVUMaxExpr>(RHS, LHS);
7116  }
7117 
7118  llvm_unreachable("covered switch fell through?!");
7119 }
7120 
7121 /// isImpliedCondOperandsHelper - Test whether the condition described by
7122 /// Pred, LHS, and RHS is true whenever the condition described by Pred,
7123 /// FoundLHS, and FoundRHS is true.
7124 bool
7125 ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
7126  const SCEV *LHS, const SCEV *RHS,
7127  const SCEV *FoundLHS,
7128  const SCEV *FoundRHS) {
7129  auto IsKnownPredicateFull =
7130  [this](ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS) {
7131  return isKnownPredicateWithRanges(Pred, LHS, RHS) ||
7132  IsKnownPredicateViaMinOrMax(*this, Pred, LHS, RHS);
7133  };
7134 
7135  switch (Pred) {
7136  default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
7137  case ICmpInst::ICMP_EQ:
7138  case ICmpInst::ICMP_NE:
7139  if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
7140  return true;
7141  break;
7142  case ICmpInst::ICMP_SLT:
7143  case ICmpInst::ICMP_SLE:
7144  if (IsKnownPredicateFull(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
7145  IsKnownPredicateFull(ICmpInst::ICMP_SGE, RHS, FoundRHS))
7146  return true;
7147  break;
7148  case ICmpInst::ICMP_SGT:
7149  case ICmpInst::ICMP_SGE:
7150  if (IsKnownPredicateFull(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
7151  IsKnownPredicateFull(ICmpInst::ICMP_SLE, RHS, FoundRHS))
7152  return true;
7153  break;
7154  case ICmpInst::ICMP_ULT:
7155  case ICmpInst::ICMP_ULE:
7156  if (IsKnownPredicateFull(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
7157  IsKnownPredicateFull(ICmpInst::ICMP_UGE, RHS, FoundRHS))
7158  return true;
7159  break;
7160  case ICmpInst::ICMP_UGT:
7161  case ICmpInst::ICMP_UGE:
7162  if (IsKnownPredicateFull(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
7163  IsKnownPredicateFull(ICmpInst::ICMP_ULE, RHS, FoundRHS))
7164  return true;
7165  break;
7166  }
7167 
7168  return false;
7169 }
7170 
7171 /// isImpliedCondOperandsViaRanges - helper function for isImpliedCondOperands.
7172 /// Tries to get cases like "X `sgt` 0 => X - 1 `sgt` -1".
7173 bool ScalarEvolution::isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
7174  const SCEV *LHS,
7175  const SCEV *RHS,
7176  const SCEV *FoundLHS,
7177  const SCEV *FoundRHS) {
7178  if (!isa<SCEVConstant>(RHS) || !isa<SCEVConstant>(FoundRHS))
7179  // The restriction on `FoundRHS` be lifted easily -- it exists only to
7180  // reduce the compile time impact of this optimization.
7181  return false;
7182 
7183  const SCEVAddExpr *AddLHS = dyn_cast<SCEVAddExpr>(LHS);
7184  if (!AddLHS || AddLHS->getOperand(1) != FoundLHS ||
7185  !isa<SCEVConstant>(AddLHS->getOperand(0)))
7186  return false;
7187 
7188  APInt ConstFoundRHS = cast<SCEVConstant>(FoundRHS)->getValue()->getValue();
7189 
7190  // `FoundLHSRange` is the range we know `FoundLHS` to be in by virtue of the
7191  // antecedent "`FoundLHS` `Pred` `FoundRHS`".
7192  ConstantRange FoundLHSRange =
7193  ConstantRange::makeAllowedICmpRegion(Pred, ConstFoundRHS);
7194 
7195  // Since `LHS` is `FoundLHS` + `AddLHS->getOperand(0)`, we can compute a range
7196  // for `LHS`:
7197  APInt Addend =
7198  cast<SCEVConstant>(AddLHS->getOperand(0))->getValue()->getValue();
7199  ConstantRange LHSRange = FoundLHSRange.add(ConstantRange(Addend));
7200 
7201  // We can also compute the range of values for `LHS` that satisfy the
7202  // consequent, "`LHS` `Pred` `RHS`":
7203  APInt ConstRHS = cast<SCEVConstant>(RHS)->getValue()->getValue();
7204  ConstantRange SatisfyingLHSRange =
7206 
7207  // The antecedent implies the consequent if every value of `LHS` that
7208  // satisfies the antecedent also satisfies the consequent.
7209  return SatisfyingLHSRange.contains(LHSRange);
7210 }
7211 
7212 // Verify if an linear IV with positive stride can overflow when in a
7213 // less-than comparison, knowing the invariant term of the comparison, the
7214 // stride and the knowledge of NSW/NUW flags on the recurrence.
7215 bool ScalarEvolution::doesIVOverflowOnLT(const SCEV *RHS, const SCEV *Stride,
7216  bool IsSigned, bool NoWrap) {
7217  if (NoWrap) return false;
7218 
7219  unsigned BitWidth = getTypeSizeInBits(RHS->getType());
7220  const SCEV *One = getConstant(Stride->getType(), 1);
7221 
7222  if (IsSigned) {
7223  APInt MaxRHS = getSignedRange(RHS).getSignedMax();
7224  APInt MaxValue = APInt::getSignedMaxValue(BitWidth);
7225  APInt MaxStrideMinusOne = getSignedRange(getMinusSCEV(Stride, One))
7226  .getSignedMax();
7227 
7228  // SMaxRHS + SMaxStrideMinusOne > SMaxValue => overflow!
7229  return (MaxValue - MaxStrideMinusOne).slt(MaxRHS);
7230  }
7231 
7232  APInt MaxRHS = getUnsignedRange(RHS).getUnsignedMax();
7233  APInt MaxValue = APInt::getMaxValue(BitWidth);
7234  APInt MaxStrideMinusOne = getUnsignedRange(getMinusSCEV(Stride, One))
7235  .getUnsignedMax();
7236 
7237  // UMaxRHS + UMaxStrideMinusOne > UMaxValue => overflow!
7238  return (MaxValue - MaxStrideMinusOne).ult(MaxRHS);
7239 }
7240 
7241 // Verify if an linear IV with negative stride can overflow when in a
7242 // greater-than comparison, knowing the invariant term of the comparison,
7243 // the stride and the knowledge of NSW/NUW flags on the recurrence.
7244 bool ScalarEvolution::doesIVOverflowOnGT(const SCEV *RHS, const SCEV *Stride,
7245  bool IsSigned, bool NoWrap) {
7246  if (NoWrap) return false;
7247 
7248  unsigned BitWidth = getTypeSizeInBits(RHS->getType());
7249  const SCEV *One = getConstant(Stride->getType(), 1);
7250 
7251  if (IsSigned) {
7252  APInt MinRHS = getSignedRange(RHS).getSignedMin();
7253  APInt MinValue = APInt::getSignedMinValue(BitWidth);
7254  APInt MaxStrideMinusOne = getSignedRange(getMinusSCEV(Stride, One))
7255  .getSignedMax();
7256 
7257  // SMinRHS - SMaxStrideMinusOne < SMinValue => overflow!
7258  return (MinValue + MaxStrideMinusOne).sgt(MinRHS);
7259  }
7260 
7261  APInt MinRHS = getUnsignedRange(RHS).getUnsignedMin();
7262  APInt MinValue = APInt::getMinValue(BitWidth);
7263  APInt MaxStrideMinusOne = getUnsignedRange(getMinusSCEV(Stride, One))
7264  .getUnsignedMax();
7265 
7266  // UMinRHS - UMaxStrideMinusOne < UMinValue => overflow!
7267  return (MinValue + MaxStrideMinusOne).ugt(MinRHS);
7268 }
7269 
7270 // Compute the backedge taken count knowing the interval difference, the
7271 // stride and presence of the equality in the comparison.
7272 const SCEV *ScalarEvolution::computeBECount(const SCEV *Delta, const SCEV *Step,
7273  bool Equality) {
7274  const SCEV *One = getConstant(Step->getType(), 1);
7275  Delta = Equality ? getAddExpr(Delta, Step)
7276  : getAddExpr(Delta, getMinusSCEV(Step, One));
7277  return getUDivExpr(Delta, Step);
7278 }
7279 
7280 /// HowManyLessThans - Return the number of times a backedge containing the
7281 /// specified less-than comparison will execute. If not computable, return
7282 /// CouldNotCompute.
7283 ///
7284 /// @param ControlsExit is true when the LHS < RHS condition directly controls
7285 /// the branch (loops exits only if condition is true). In this case, we can use
7286 /// NoWrapFlags to skip overflow checks.
7287 ScalarEvolution::ExitLimit
7288 ScalarEvolution::HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
7289  const Loop *L, bool IsSigned,
7290  bool ControlsExit) {
7291  // We handle only IV < Invariant
7292  if (!isLoopInvariant(RHS, L))
7293  return getCouldNotCompute();
7294 
7295  const SCEVAddRecExpr *IV = dyn_cast<SCEVAddRecExpr>(LHS);
7296 
7297  // Avoid weird loops
7298  if (!IV || IV->getLoop() != L || !IV->isAffine())
7299  return getCouldNotCompute();
7300 
7301  bool NoWrap = ControlsExit &&
7302  IV->getNoWrapFlags(IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW);
7303 
7304  const SCEV *Stride = IV->getStepRecurrence(*this);
7305 
7306  // Avoid negative or zero stride values
7307  if (!isKnownPositive(Stride))
7308  return getCouldNotCompute();
7309 
7310  // Avoid proven overflow cases: this will ensure that the backedge taken count
7311  // will not generate any unsigned overflow. Relaxed no-overflow conditions
7312  // exploit NoWrapFlags, allowing to optimize in presence of undefined
7313  // behaviors like the case of C language.
7314  if (!Stride->isOne() && doesIVOverflowOnLT(RHS, Stride, IsSigned, NoWrap))
7315  return getCouldNotCompute();
7316 
7317  ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SLT
7319  const SCEV *Start = IV->getStart();
7320  const SCEV *End = RHS;
7321  if (!isLoopEntryGuardedByCond(L, Cond, getMinusSCEV(Start, Stride), RHS)) {
7322  const SCEV *Diff = getMinusSCEV(RHS, Start);
7323  // If we have NoWrap set, then we can assume that the increment won't
7324  // overflow, in which case if RHS - Start is a constant, we don't need to
7325  // do a max operation since we can just figure it out statically
7326  if (NoWrap && isa<SCEVConstant>(Diff)) {
7327  APInt D = dyn_cast<const SCEVConstant>(Diff)->getValue()->getValue();
7328  if (D.isNegative())
7329  End = Start;
7330  } else
7331  End = IsSigned ? getSMaxExpr(RHS, Start)
7332  : getUMaxExpr(RHS, Start);
7333  }
7334 
7335  const SCEV *BECount = computeBECount(getMinusSCEV(End, Start), Stride, false);
7336 
7337  APInt MinStart = IsSigned ? getSignedRange(Start).getSignedMin()
7338  : getUnsignedRange(Start).getUnsignedMin();
7339 
7340  APInt MinStride = IsSigned ? getSignedRange(Stride).getSignedMin()
7341  : getUnsignedRange(Stride).getUnsignedMin();
7342 
7343  unsigned BitWidth = getTypeSizeInBits(LHS->getType());
7344  APInt Limit = IsSigned ? APInt::getSignedMaxValue(BitWidth) - (MinStride - 1)
7345  : APInt::getMaxValue(BitWidth) - (MinStride - 1);
7346 
7347  // Although End can be a MAX expression we estimate MaxEnd considering only
7348  // the case End = RHS. This is safe because in the other case (End - Start)
7349  // is zero, leading to a zero maximum backedge taken count.
7350  APInt MaxEnd =
7351  IsSigned ? APIntOps::smin(getSignedRange(RHS).getSignedMax(), Limit)
7352  : APIntOps::umin(getUnsignedRange(RHS).getUnsignedMax(), Limit);
7353 
7354  const SCEV *MaxBECount;
7355  if (isa<SCEVConstant>(BECount))
7356  MaxBECount = BECount;
7357  else
7358  MaxBECount = computeBECount(getConstant(MaxEnd - MinStart),
7359  getConstant(MinStride), false);
7360 
7361  if (isa<SCEVCouldNotCompute>(MaxBECount))
7362  MaxBECount = BECount;
7363 
7364  return ExitLimit(BECount, MaxBECount);
7365 }
7366 
7367 ScalarEvolution::ExitLimit
7368 ScalarEvolution::HowManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
7369  const Loop *L, bool IsSigned,
7370  bool ControlsExit) {
7371  // We handle only IV > Invariant
7372  if (!isLoopInvariant(RHS, L))
7373  return getCouldNotCompute();
7374 
7375  const SCEVAddRecExpr *IV = dyn_cast<SCEVAddRecExpr>(LHS);
7376 
7377  // Avoid weird loops
7378  if (!IV || IV->getLoop() != L || !IV->isAffine())
7379  return getCouldNotCompute();
7380 
7381  bool NoWrap = ControlsExit &&
7382  IV->getNoWrapFlags(IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW);
7383 
7384  const SCEV *Stride = getNegativeSCEV(IV->getStepRecurrence(*this));
7385 
7386  // Avoid negative or zero stride values
7387  if (!isKnownPositive(Stride))
7388  return getCouldNotCompute();
7389 
7390  // Avoid proven overflow cases: this will ensure that the backedge taken count
7391  // will not generate any unsigned overflow. Relaxed no-overflow conditions
7392  // exploit NoWrapFlags, allowing to optimize in presence of undefined
7393  // behaviors like the case of C language.
7394  if (!Stride->isOne() && doesIVOverflowOnGT(RHS, Stride, IsSigned, NoWrap))
7395  return getCouldNotCompute();
7396 
7397  ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SGT
7399 
7400  const SCEV *Start = IV->getStart();
7401  const SCEV *End = RHS;
7402  if (!isLoopEntryGuardedByCond(L, Cond, getAddExpr(Start, Stride), RHS)) {
7403  const SCEV *Diff = getMinusSCEV(RHS, Start);
7404  // If we have NoWrap set, then we can assume that the increment won't
7405  // overflow, in which case if RHS - Start is a constant, we don't need to
7406  // do a max operation since we can just figure it out statically
7407  if (NoWrap && isa<SCEVConstant>(Diff)) {
7408  APInt D = dyn_cast<const SCEVConstant>(Diff)->getValue()->getValue();
7409  if (!D.isNegative())
7410  End = Start;
7411  } else
7412  End = IsSigned ? getSMinExpr(RHS, Start)
7413  : getUMinExpr(RHS, Start);
7414  }
7415 
7416  const SCEV *BECount = computeBECount(getMinusSCEV(Start, End), Stride, false);
7417 
7418  APInt MaxStart = IsSigned ? getSignedRange(Start).getSignedMax()
7419  : getUnsignedRange(Start).getUnsignedMax();
7420 
7421  APInt MinStride = IsSigned ? getSignedRange(Stride).getSignedMin()
7422  : getUnsignedRange(Stride).getUnsignedMin();
7423 
7424  unsigned BitWidth = getTypeSizeInBits(LHS->getType());
7425  APInt Limit = IsSigned ? APInt::getSignedMinValue(BitWidth) + (MinStride - 1)
7426  : APInt::getMinValue(BitWidth) + (MinStride - 1);
7427 
7428  // Although End can be a MIN expression we estimate MinEnd considering only
7429  // the case End = RHS. This is safe because in the other case (Start - End)
7430  // is zero, leading to a zero maximum backedge taken count.
7431  APInt MinEnd =
7432  IsSigned ? APIntOps::smax(getSignedRange(RHS).getSignedMin(), Limit)
7433  : APIntOps::umax(getUnsignedRange(RHS).getUnsignedMin(), Limit);
7434 
7435 
7436  const SCEV *MaxBECount = getCouldNotCompute();
7437  if (isa<SCEVConstant>(BECount))
7438  MaxBECount = BECount;
7439  else
7440  MaxBECount = computeBECount(getConstant(MaxStart - MinEnd),
7441  getConstant(MinStride), false);
7442 
7443  if (isa<SCEVCouldNotCompute>(MaxBECount))
7444  MaxBECount = BECount;
7445 
7446  return ExitLimit(BECount, MaxBECount);
7447 }
7448 
7449 /// getNumIterationsInRange - Return the number of iterations of this loop that
7450 /// produce values in the specified constant range. Another way of looking at
7451 /// this is that it returns the first iteration number where the value is not in
7452 /// the condition, thus computing the exit count. If the iteration count can't
7453 /// be computed, an instance of SCEVCouldNotCompute is returned.
7455  ScalarEvolution &SE) const {
7456  if (Range.isFullSet()) // Infinite loop.
7457  return SE.getCouldNotCompute();
7458 
7459  // If the start is a non-zero constant, shift the range to simplify things.
7460  if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
7461  if (!SC->getValue()->isZero()) {
7463  Operands[0] = SE.getConstant(SC->getType(), 0);
7464  const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
7466  if (const SCEVAddRecExpr *ShiftedAddRec =
7467  dyn_cast<SCEVAddRecExpr>(Shifted))
7468  return ShiftedAddRec->getNumIterationsInRange(
7469  Range.subtract(SC->getValue()->getValue()), SE);
7470  // This is strange and shouldn't happen.
7471  return SE.getCouldNotCompute();
7472  }
7473 
7474  // The only time we can solve this is when we have all constant indices.
7475  // Otherwise, we cannot determine the overflow conditions.
7476  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
7477  if (!isa<SCEVConstant>(getOperand(i)))
7478  return SE.getCouldNotCompute();
7479 
7480 
7481  // Okay at this point we know that all elements of the chrec are constants and
7482  // that the start element is zero.
7483 
7484  // First check to see if the range contains zero. If not, the first
7485  // iteration exits.
7486  unsigned BitWidth = SE.getTypeSizeInBits(getType());
7487  if (!Range.contains(APInt(BitWidth, 0)))
7488  return SE.getConstant(getType(), 0);
7489 
7490  if (isAffine()) {
7491  // If this is an affine expression then we have this situation:
7492  // Solve {0,+,A} in Range === Ax in Range
7493 
7494  // We know that zero is in the range. If A is positive then we know that
7495  // the upper value of the range must be the first possible exit value.
7496  // If A is negative then the lower of the range is the last possible loop
7497  // value. Also note that we already checked for a full range.
7498  APInt One(BitWidth,1);
7499  APInt A = cast<SCEVConstant>(getOperand(1))->getValue()->getValue();
7500  APInt End = A.sge(One) ? (Range.getUpper() - One) : Range.getLower();
7501 
7502  // The exit value should be (End+A)/A.
7503  APInt ExitVal = (End + A).udiv(A);
7504  ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
7505 
7506  // Evaluate at the exit value. If we really did fall out of the valid
7507  // range, then we computed our trip count, otherwise wrap around or other
7508  // things must have happened.
7509  ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue, SE);
7510  if (Range.contains(Val->getValue()))
7511  return SE.getCouldNotCompute(); // Something strange happened
7512 
7513  // Ensure that the previous value is in the range. This is a sanity check.
7514  assert(Range.contains(
7516  ConstantInt::get(SE.getContext(), ExitVal - One), SE)->getValue()) &&
7517  "Linear scev computation is off in a bad way!");
7518  return SE.getConstant(ExitValue);
7519  } else if (isQuadratic()) {
7520  // If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of the
7521  // quadratic equation to solve it. To do this, we must frame our problem in
7522  // terms of figuring out when zero is crossed, instead of when
7523  // Range.getUpper() is crossed.
7525  NewOps[0] = SE.getNegativeSCEV(SE.getConstant(Range.getUpper()));
7526  const SCEV *NewAddRec = SE.getAddRecExpr(NewOps, getLoop(),
7527  // getNoWrapFlags(FlagNW)
7528  FlagAnyWrap);
7529 
7530  // Next, solve the constructed addrec
7531  std::pair<const SCEV *,const SCEV *> Roots =
7532  SolveQuadraticEquation(cast<SCEVAddRecExpr>(NewAddRec), SE);
7533  const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
7534  const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
7535  if (R1) {
7536  // Pick the smallest positive root value.
7537  if (ConstantInt *CB =
7538  dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
7539  R1->getValue(), R2->getValue()))) {
7540  if (!CB->getZExtValue())
7541  std::swap(R1, R2); // R1 is the minimum root now.
7542 
7543  // Make sure the root is not off by one. The returned iteration should
7544  // not be in the range, but the previous one should be. When solving
7545  // for "X*X < 5", for example, we should not return a root of 2.
7547  R1->getValue(),
7548  SE);
7549  if (Range.contains(R1Val->getValue())) {
7550  // The next iteration must be out of the range...
7551  ConstantInt *NextVal =
7552  ConstantInt::get(SE.getContext(), R1->getValue()->getValue()+1);
7553 
7554  R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
7555  if (!Range.contains(R1Val->getValue()))
7556  return SE.getConstant(NextVal);
7557  return SE.getCouldNotCompute(); // Something strange happened
7558  }
7559 
7560  // If R1 was not in the range, then it is a good return value. Make
7561  // sure that R1-1 WAS in the range though, just in case.
7562  ConstantInt *NextVal =
7563  ConstantInt::get(SE.getContext(), R1->getValue()->getValue()-1);
7564  R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
7565  if (Range.contains(R1Val->getValue()))
7566  return R1;
7567  return SE.getCouldNotCompute(); // Something strange happened
7568  }
7569  }
7570  }
7571 
7572  return SE.getCouldNotCompute();
7573 }
7574 
7575 namespace {
7576 struct FindUndefs {
7577  bool Found;
7578  FindUndefs() : Found(false) {}
7579 
7580  bool follow(const SCEV *S) {
7581  if (const SCEVUnknown *C = dyn_cast<SCEVUnknown>(S)) {
7582  if (isa<UndefValue>(C->getValue()))
7583  Found = true;
7584  } else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S)) {
7585  if (isa<UndefValue>(C->getValue()))
7586  Found = true;
7587  }
7588 
7589  // Keep looking if we haven't found it yet.
7590  return !Found;
7591  }
7592  bool isDone() const {
7593  // Stop recursion if we have found an undef.
7594  return Found;
7595  }
7596 };
7597 }
7598 
7599 // Return true when S contains at least an undef value.
7600 static inline bool
7602  FindUndefs F;
7604  ST.visitAll(S);
7605 
7606  return F.Found;
7607 }
7608 
7609 namespace {
7610 // Collect all steps of SCEV expressions.
7611 struct SCEVCollectStrides {
7612  ScalarEvolution &SE;
7614 
7615  SCEVCollectStrides(ScalarEvolution &SE, SmallVectorImpl<const SCEV *> &S)
7616  : SE(SE), Strides(S) {}
7617 
7618  bool follow(const SCEV *S) {
7619  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S))
7620  Strides.push_back(AR->getStepRecurrence(SE));
7621  return true;
7622  }
7623  bool isDone() const { return false; }
7624 };
7625 
7626 // Collect all SCEVUnknown and SCEVMulExpr expressions.
7627 struct SCEVCollectTerms {
7629 
7630  SCEVCollectTerms(SmallVectorImpl<const SCEV *> &T)
7631  : Terms(T) {}
7632 
7633  bool follow(const SCEV *S) {
7634  if (isa<SCEVUnknown>(S) || isa<SCEVMulExpr>(S)) {
7635  if (!containsUndefs(S))
7636  Terms.push_back(S);
7637 
7638  // Stop recursion: once we collected a term, do not walk its operands.
7639  return false;
7640  }
7641 
7642  // Keep looking.
7643  return true;
7644  }
7645  bool isDone() const { return false; }
7646 };
7647 }
7648 
7649 /// Find parametric terms in this SCEVAddRecExpr.
7653  SCEVCollectStrides StrideCollector(*this, Strides);
7654  visitAll(Expr, StrideCollector);
7655 
7656  DEBUG({
7657  dbgs() << "Strides:\n";
7658  for (const SCEV *S : Strides)
7659  dbgs() << *S << "\n";
7660  });
7661 
7662  for (const SCEV *S : Strides) {
7663  SCEVCollectTerms TermCollector(Terms);
7664  visitAll(S, TermCollector);
7665  }
7666 
7667  DEBUG({
7668  dbgs() << "Terms:\n";
7669  for (const SCEV *T : Terms)
7670  dbgs() << *T << "\n";
7671  });
7672 }
7673 
7674 static bool findArrayDimensionsRec(ScalarEvolution &SE,
7677  int Last = Terms.size() - 1;
7678  const SCEV *Step = Terms[Last];
7679 
7680  // End of recursion.
7681  if (Last == 0) {
7682  if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Step)) {
7684  for (const SCEV *Op : M->operands())
7685  if (!isa<SCEVConstant>(Op))
7686  Qs.push_back(Op);
7687 
7688  Step = SE.getMulExpr(Qs);
7689  }
7690 
7691  Sizes.push_back(Step);
7692  return true;
7693  }
7694 
7695  for (const SCEV *&Term : Terms) {
7696  // Normalize the terms before the next call to findArrayDimensionsRec.
7697  const SCEV *Q, *R;
7698  SCEVDivision::divide(SE, Term, Step, &Q, &R);
7699 
7700  // Bail out when GCD does not evenly divide one of the terms.
7701  if (!R->isZero())
7702  return false;
7703 
7704  Term = Q;
7705  }
7706 
7707  // Remove all SCEVConstants.
7708  Terms.erase(std::remove_if(Terms.begin(), Terms.end(), [](const SCEV *E) {
7709  return isa<SCEVConstant>(E);
7710  }),
7711  Terms.end());
7712 
7713  if (Terms.size() > 0)
7714  if (!findArrayDimensionsRec(SE, Terms, Sizes))
7715  return false;
7716 
7717  Sizes.push_back(Step);
7718  return true;
7719 }
7720 
7721 namespace {
7722 struct FindParameter {
7723  bool FoundParameter;
7724  FindParameter() : FoundParameter(false) {}
7725 
7726  bool follow(const SCEV *S) {
7727  if (isa<SCEVUnknown>(S)) {
7728  FoundParameter = true;
7729  // Stop recursion: we found a parameter.
7730  return false;
7731  }
7732  // Keep looking.
7733  return true;
7734  }
7735  bool isDone() const {
7736  // Stop recursion if we have found a parameter.
7737  return FoundParameter;
7738  }
7739 };
7740 }
7741 
7742 // Returns true when S contains at least a SCEVUnknown parameter.
7743 static inline bool
7745  FindParameter F;
7747  ST.visitAll(S);
7748 
7749  return F.FoundParameter;
7750 }
7751 
7752 // Returns true when one of the SCEVs of Terms contains a SCEVUnknown parameter.
7753 static inline bool
7755  for (const SCEV *T : Terms)
7756  if (containsParameters(T))
7757  return true;
7758  return false;
7759 }
7760 
7761 // Return the number of product terms in S.
7762 static inline int numberOfTerms(const SCEV *S) {
7763  if (const SCEVMulExpr *Expr = dyn_cast<SCEVMulExpr>(S))
7764  return Expr->getNumOperands();
7765  return 1;
7766 }
7767 
7768 static const SCEV *removeConstantFactors(ScalarEvolution &SE, const SCEV *T) {
7769  if (isa<SCEVConstant>(T))
7770  return nullptr;
7771 
7772  if (isa<SCEVUnknown>(T))
7773  return T;
7774 
7775  if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(T)) {
7777  for (const SCEV *Op : M->operands())
7778  if (!isa<SCEVConstant>(Op))
7779  Factors.push_back(Op);
7780 
7781  return SE.getMulExpr(Factors);
7782  }
7783 
7784  return T;
7785 }
7786 
7787 /// Return the size of an element read or written by Inst.
7789  Type *Ty;
7790  if (StoreInst *Store = dyn_cast<StoreInst>(Inst))
7791  Ty = Store->getValueOperand()->getType();
7792  else if (LoadInst *Load = dyn_cast<LoadInst>(Inst))
7793  Ty = Load->getType();
7794  else
7795  return nullptr;
7796 
7798  return getSizeOfExpr(ETy, Ty);
7799 }
7800 
7801 /// Second step of delinearization: compute the array dimensions Sizes from the
7802 /// set of Terms extracted from the memory access function of this SCEVAddRec.
7805  const SCEV *ElementSize) const {
7806 
7807  if (Terms.size() < 1 || !ElementSize)
7808  return;
7809 
7810  // Early return when Terms do not contain parameters: we do not delinearize
7811  // non parametric SCEVs.
7812  if (!containsParameters(Terms))
7813  return;
7814 
7815  DEBUG({
7816  dbgs() << "Terms:\n";
7817  for (const SCEV *T : Terms)
7818  dbgs() << *T << "\n";
7819  });
7820 
7821  // Remove duplicates.
7822  std::sort(Terms.begin(), Terms.end());
7823  Terms.erase(std::unique(Terms.begin(), Terms.end()), Terms.end());
7824 
7825  // Put larger terms first.
7826  std::sort(Terms.begin(), Terms.end(), [](const SCEV *LHS, const SCEV *RHS) {
7827  return numberOfTerms(LHS) > numberOfTerms(RHS);
7828  });
7829 
7830  ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
7831 
7832  // Divide all terms by the element size.
7833  for (const SCEV *&Term : Terms) {
7834  const SCEV *Q, *R;
7835  SCEVDivision::divide(SE, Term, ElementSize, &Q, &R);
7836  Term = Q;
7837  }
7838 
7840 
7841  // Remove constant factors.
7842  for (const SCEV *T : Terms)
7843  if (const SCEV *NewT = removeConstantFactors(SE, T))
7844  NewTerms.push_back(NewT);
7845 
7846  DEBUG({
7847  dbgs() << "Terms after sorting:\n";
7848  for (const SCEV *T : NewTerms)
7849  dbgs() << *T << "\n";
7850  });
7851 
7852  if (NewTerms.empty() ||
7853  !findArrayDimensionsRec(SE, NewTerms, Sizes)) {
7854  Sizes.clear();
7855  return;
7856  }
7857 
7858  // The last element to be pushed into Sizes is the size of an element.
7859  Sizes.push_back(ElementSize);
7860 
7861  DEBUG({
7862  dbgs() << "Sizes:\n";
7863  for (const SCEV *S : Sizes)
7864  dbgs() << *S << "\n";
7865  });
7866 }
7867 
7868 /// Third step of delinearization: compute the access functions for the
7869 /// Subscripts based on the dimensions in Sizes.
7871  const SCEV *Expr, SmallVectorImpl<const SCEV *> &Subscripts,
7873 
7874  // Early exit in case this SCEV is not an affine multivariate function.
7875  if (Sizes.empty())
7876  return;
7877 
7878  if (auto AR = dyn_cast<SCEVAddRecExpr>(Expr))
7879  if (!AR->isAffine())
7880  return;
7881 
7882  const SCEV *Res = Expr;
7883  int Last = Sizes.size() - 1;
7884  for (int i = Last; i >= 0; i--) {
7885  const SCEV *Q, *R;
7886  SCEVDivision::divide(*this, Res, Sizes[i], &Q, &R);
7887 
7888  DEBUG({
7889  dbgs() << "Res: " << *Res << "\n";
7890  dbgs() << "Sizes[i]: " << *Sizes[i] << "\n";
7891  dbgs() << "Res divided by Sizes[i]:\n";
7892  dbgs() << "Quotient: " << *Q << "\n";
7893  dbgs() << "Remainder: " << *R << "\n";
7894  });
7895 
7896  Res = Q;
7897 
7898  // Do not record the last subscript corresponding to the size of elements in
7899  // the array.
7900  if (i == Last) {
7901 
7902  // Bail out if the remainder is too complex.
7903  if (isa<SCEVAddRecExpr>(R)) {
7904  Subscripts.clear();
7905  Sizes.clear();
7906  return;
7907  }
7908 
7909  continue;
7910  }
7911 
7912  // Record the access function for the current subscript.
7913  Subscripts.push_back(R);
7914  }
7915 
7916  // Also push in last position the remainder of the last division: it will be
7917  // the access function of the innermost dimension.
7918  Subscripts.push_back(Res);
7919 
7920  std::reverse(Subscripts.begin(), Subscripts.end());
7921 
7922  DEBUG({
7923  dbgs() << "Subscripts:\n";
7924  for (const SCEV *S : Subscripts)
7925  dbgs() << *S << "\n";
7926  });
7927 }
7928 
7929 /// Splits the SCEV into two vectors of SCEVs representing the subscripts and
7930 /// sizes of an array access. Returns the remainder of the delinearization that
7931 /// is the offset start of the array. The SCEV->delinearize algorithm computes
7932 /// the multiples of SCEV coefficients: that is a pattern matching of sub
7933 /// expressions in the stride and base of a SCEV corresponding to the
7934 /// computation of a GCD (greatest common divisor) of base and stride. When
7935 /// SCEV->delinearize fails, it returns the SCEV unchanged.
7936 ///
7937 /// For example: when analyzing the memory access A[i][j][k] in this loop nest
7938 ///
7939 /// void foo(long n, long m, long o, double A[n][m][o]) {
7940 ///
7941 /// for (long i = 0; i < n; i++)
7942 /// for (long j = 0; j < m; j++)
7943 /// for (long k = 0; k < o; k++)
7944 /// A[i][j][k] = 1.0;
7945 /// }
7946 ///
7947 /// the delinearization input is the following AddRec SCEV:
7948 ///
7949 /// AddRec: {{{%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
7950 ///
7951 /// From this SCEV, we are able to say that the base offset of the access is %A
7952 /// because it appears as an offset that does not divide any of the strides in
7953 /// the loops:
7954 ///
7955 /// CHECK: Base offset: %A
7956 ///
7957 /// and then SCEV->delinearize determines the size of some of the dimensions of
7958 /// the array as these are the multiples by which the strides are happening:
7959 ///
7960 /// CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(double) bytes.
7961 ///
7962 /// Note that the outermost dimension remains of UnknownSize because there are
7963 /// no strides that would help identifying the size of the last dimension: when
7964 /// the array has been statically allocated, one could compute the size of that
7965 /// dimension by dividing the overall size of the array by the size of the known
7966 /// dimensions: %m * %o * 8.
7967 ///
7968 /// Finally delinearize provides the access functions for the array reference
7969 /// that does correspond to A[i][j][k] of the above C testcase:
7970 ///
7971 /// CHECK: ArrayRef[{0,+,1}<%for.i>][{0,+,1}<%for.j>][{0,+,1}<%for.k>]
7972 ///
7973 /// The testcases are checking the output of a function pass:
7974 /// DelinearizationPass that walks through all loads and stores of a function
7975 /// asking for the SCEV of the memory access with respect to all enclosing
7976 /// loops, calling SCEV->delinearize on that and printing the results.
7977 
7979  SmallVectorImpl<const SCEV *> &Subscripts,
7981  const SCEV *ElementSize) {
7982  // First step: collect parametric terms.
7984  collectParametricTerms(Expr, Terms);
7985 
7986  if (Terms.empty())
7987  return;
7988 
7989  // Second step: find subscript sizes.
7990  findArrayDimensions(Terms, Sizes, ElementSize);
7991 
7992  if (Sizes.empty())
7993  return;
7994 
7995  // Third step: compute the access functions for each subscript.
7996  computeAccessFunctions(Expr, Subscripts, Sizes);
7997 
7998  if (Subscripts.empty())
7999  return;
8000 
8001  DEBUG({
8002  dbgs() << "succeeded to delinearize " << *Expr << "\n";
8003  dbgs() << "ArrayDecl[UnknownSize]";
8004  for (const SCEV *S : Sizes)
8005  dbgs() << "[" << *S << "]";
8006 
8007  dbgs() << "\nArrayRef";
8008  for (const SCEV *S : Subscripts)
8009  dbgs() << "[" << *S << "]";
8010  dbgs() << "\n";
8011  });
8012 }
8013 
8014 //===----------------------------------------------------------------------===//
8015 // SCEVCallbackVH Class Implementation
8016 //===----------------------------------------------------------------------===//
8017 
8018 void ScalarEvolution::SCEVCallbackVH::deleted() {
8019  assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
8020  if (PHINode *PN = dyn_cast<PHINode>(getValPtr()))
8021  SE->ConstantEvolutionLoopExitValue.erase(PN);
8022  SE->ValueExprMap.erase(getValPtr());
8023  // this now dangles!
8024 }
8025 
8026 void ScalarEvolution::SCEVCallbackVH::allUsesReplacedWith(Value *V) {
8027  assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
8028 
8029  // Forget all the expressions associated with users of the old value,
8030  // so that future queries will recompute the expressions using the new
8031  // value.
8032  Value *Old = getValPtr();
8033  SmallVector<User *, 16> Worklist(Old->user_begin(), Old->user_end());
8034  SmallPtrSet<User *, 8> Visited;
8035  while (!Worklist.empty()) {
8036  User *U = Worklist.pop_back_val();
8037  // Deleting the Old value will cause this to dangle. Postpone
8038  // that until everything else is done.
8039  if (U == Old)
8040  continue;
8041  if (!Visited.insert(U).second)
8042  continue;
8043  if (PHINode *PN = dyn_cast<PHINode>(U))
8044  SE->ConstantEvolutionLoopExitValue.erase(PN);
8045  SE->ValueExprMap.erase(U);
8046  Worklist.insert(Worklist.end(), U->user_begin(), U->user_end());
8047  }
8048  // Delete the Old value.
8049  if (PHINode *PN = dyn_cast<PHINode>(Old))
8050  SE->ConstantEvolutionLoopExitValue.erase(PN);
8051  SE->ValueExprMap.erase(Old);
8052  // this now dangles!
8053 }
8054 
8055 ScalarEvolution::SCEVCallbackVH::SCEVCallbackVH(Value *V, ScalarEvolution *se)
8056  : CallbackVH(V), SE(se) {}
8057 
8058 //===----------------------------------------------------------------------===//
8059 // ScalarEvolution Class Implementation
8060 //===----------------------------------------------------------------------===//
8061 
8063  : FunctionPass(ID), WalkingBEDominatingConds(false), ValuesAtScopes(64),
8064  LoopDispositions(64), BlockDispositions(64), FirstUnknown(nullptr) {
8066 }
8067 
8069  this->F = &F;
8070  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
8071  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
8072  TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
8073  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
8074  return false;
8075 }
8076 
8078  // Iterate through all the SCEVUnknown instances and call their
8079  // destructors, so that they release their references to their values.
8080  for (SCEVUnknown *U = FirstUnknown; U; U = U->Next)
8081  U->~SCEVUnknown();
8082  FirstUnknown = nullptr;
8083 
8084  ValueExprMap.clear();
8085 
8086  // Free any extra memory created for ExitNotTakenInfo in the unlikely event
8087  // that a loop had multiple computable exits.
8089  BackedgeTakenCounts.begin(), E = BackedgeTakenCounts.end();
8090  I != E; ++I) {
8091  I->second.clear();
8092  }
8093 
8094  assert(PendingLoopPredicates.empty() && "isImpliedCond garbage");
8095  assert(!WalkingBEDominatingConds && "isLoopBackedgeGuardedByCond garbage!");
8096 
8097  BackedgeTakenCounts.clear();
8098  ConstantEvolutionLoopExitValue.clear();
8099  ValuesAtScopes.clear();
8100  LoopDispositions.clear();
8101  BlockDispositions.clear();
8102  UnsignedRanges.clear();
8103  SignedRanges.clear();
8104  UniqueSCEVs.clear();
8105  SCEVAllocator.Reset();
8106 }
8107 
8109  AU.setPreservesAll();
8114 }
8115 
8117  return !isa<SCEVCouldNotCompute>(getBackedgeTakenCount(L));
8118 }
8119 
8120 static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
8121  const Loop *L) {
8122  // Print all inner loops first
8123  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
8124  PrintLoopInfo(OS, SE, *I);
8125 
8126  OS << "Loop ";
8127  L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
8128  OS << ": ";
8129 
8130  SmallVector<BasicBlock *, 8> ExitBlocks;
8131  L->getExitBlocks(ExitBlocks);
8132  if (ExitBlocks.size() != 1)
8133  OS << "<multiple exits> ";
8134 
8136  OS << "backedge-taken count is " << *SE->getBackedgeTakenCount(L);
8137  } else {
8138  OS << "Unpredictable backedge-taken count. ";
8139  }
8140 
8141  OS << "\n"
8142  "Loop ";
8143  L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
8144  OS << ": ";
8145 
8146  if (!isa<SCEVCouldNotCompute>(SE->getMaxBackedgeTakenCount(L))) {
8147  OS << "max backedge-taken count is " << *SE->getMaxBackedgeTakenCount(L);
8148  } else {
8149  OS << "Unpredictable max backedge-taken count. ";
8150  }
8151 
8152  OS << "\n";
8153 }
8154 
8155 void ScalarEvolution::print(raw_ostream &OS, const Module *) const {
8156  // ScalarEvolution's implementation of the print method is to print
8157  // out SCEV values of all instructions that are interesting. Doing
8158  // this potentially causes it to create new SCEV objects though,
8159  // which technically conflicts with the const qualifier. This isn't
8160  // observable from outside the class though, so casting away the
8161  // const isn't dangerous.
8162  ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
8163 
8164  OS << "Classifying expressions for: ";
8165  F->printAsOperand(OS, /*PrintType=*/false);
8166  OS << "\n";
8167  for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
8168  if (isSCEVable(I->getType()) && !isa<CmpInst>(*I)) {
8169  OS << *I << '\n';
8170  OS << " --> ";
8171  const SCEV *SV = SE.getSCEV(&*I);
8172  SV->print(OS);
8173  if (!isa<SCEVCouldNotCompute>(SV)) {
8174  OS << " U: ";
8175  SE.getUnsignedRange(SV).print(OS);
8176  OS << " S: ";
8177  SE.getSignedRange(SV).print(OS);
8178  }
8179 
8180  const Loop *L = LI->getLoopFor((*I).getParent());
8181 
8182  const SCEV *AtUse = SE.getSCEVAtScope(SV, L);
8183  if (AtUse != SV) {
8184  OS << " --> ";
8185  AtUse->print(OS);
8186  if (!isa<SCEVCouldNotCompute>(AtUse)) {
8187  OS << " U: ";
8188  SE.getUnsignedRange(AtUse).print(OS);
8189  OS << " S: ";
8190  SE.getSignedRange(AtUse).print(OS);
8191  }
8192  }
8193 
8194  if (L) {
8195  OS << "\t\t" "Exits: ";
8196  const SCEV *ExitValue = SE.getSCEVAtScope(SV, L->getParentLoop());
8197  if (!SE.isLoopInvariant(ExitValue, L)) {
8198  OS << "<<Unknown>>";
8199  } else {
8200  OS << *ExitValue;
8201  }
8202  }
8203 
8204  OS << "\n";
8205  }
8206 
8207  OS << "Determining loop execution counts for: ";
8208  F->printAsOperand(OS, /*PrintType=*/false);
8209  OS << "\n";
8210  for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
8211  PrintLoopInfo(OS, &SE, *I);
8212 }
8213 
8216  auto &Values = LoopDispositions[S];
8217  for (auto &V : Values) {
8218  if (V.getPointer() == L)
8219  return V.getInt();
8220  }
8221  Values.emplace_back(L, LoopVariant);
8222  LoopDisposition D = computeLoopDisposition(S, L);
8223  auto &Values2 = LoopDispositions[S];
8224  for (auto &V : make_range(Values2.rbegin(), Values2.rend())) {
8225  if (V.getPointer() == L) {
8226  V.setInt(D);
8227  break;
8228  }
8229  }
8230  return D;
8231 }
8232 
8234 ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
8235  switch (static_cast<SCEVTypes>(S->getSCEVType())) {
8236  case scConstant:
8237  return LoopInvariant;
8238  case scTruncate:
8239  case scZeroExtend:
8240  case scSignExtend:
8241  return getLoopDisposition(cast<SCEVCastExpr>(S)->getOperand(), L);
8242  case scAddRecExpr: {
8243  const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
8244 
8245  // If L is the addrec's loop, it's computable.
8246  if (AR->getLoop() == L)
8247  return LoopComputable;
8248 
8249  // Add recurrences are never invariant in the function-body (null loop).
8250  if (!L)
8251  return LoopVariant;
8252 
8253  // This recurrence is variant w.r.t. L if L contains AR's loop.
8254  if (L->contains(AR->getLoop()))
8255  return LoopVariant;
8256 
8257  // This recurrence is invariant w.r.t. L if AR's loop contains L.
8258  if (AR->getLoop()->contains(L))
8259  return LoopInvariant;
8260 
8261  // This recurrence is variant w.r.t. L if any of its operands
8262  // are variant.
8263  for (SCEVAddRecExpr::op_iterator I = AR->op_begin(), E = AR->op_end();
8264  I != E; ++I)
8265  if (!isLoopInvariant(*I, L))
8266  return LoopVariant;
8267 
8268  // Otherwise it's loop-invariant.
8269  return LoopInvariant;
8270  }
8271  case scAddExpr:
8272  case scMulExpr:
8273  case scUMaxExpr:
8274  case scSMaxExpr: {
8275  const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
8276  bool HasVarying = false;
8277  for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
8278  I != E; ++I) {
8280  if (D == LoopVariant)
8281  return LoopVariant;
8282  if (D == LoopComputable)
8283  HasVarying = true;
8284  }
8285  return HasVarying ? LoopComputable : LoopInvariant;
8286  }
8287  case scUDivExpr: {
8288  const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
8290  if (LD == LoopVariant)
8291  return LoopVariant;
8292  LoopDisposition RD = getLoopDisposition(UDiv->getRHS(), L);
8293  if (RD == LoopVariant)
8294  return LoopVariant;
8295  return (LD == LoopInvariant && RD == LoopInvariant) ?
8297  }
8298  case scUnknown:
8299  // All non-instruction values are loop invariant. All instructions are loop
8300  // invariant if they are not contained in the specified loop.
8301  // Instructions are never considered invariant in the function body
8302  // (null loop) because they are defined within the "loop".
8303  if (Instruction *I = dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue()))
8304  return (L && !L->contains(I)) ? LoopInvariant : LoopVariant;
8305  return LoopInvariant;
8306  case scCouldNotCompute:
8307  llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
8308  }
8309  llvm_unreachable("Unknown SCEV kind!");
8310 }
8311 
8312 bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) {
8313  return getLoopDisposition(S, L) == LoopInvariant;
8314 }
8315 
8317  return getLoopDisposition(S, L) == LoopComputable;
8318 }
8319 
8322  auto &Values = BlockDispositions[S];
8323  for (auto &V : Values) {
8324  if (V.getPointer() == BB)
8325  return V.getInt();
8326  }
8327  Values.emplace_back(BB, DoesNotDominateBlock);
8328  BlockDisposition D = computeBlockDisposition(S, BB);
8329  auto &Values2 = BlockDispositions[S];
8330  for (auto &V : make_range(Values2.rbegin(), Values2.rend())) {
8331  if (V.getPointer() == BB) {
8332  V.setInt(D);
8333  break;
8334  }
8335  }
8336  return D;
8337 }
8338 
8340 ScalarEvolution::computeBlockDisposition(const SCEV *S, const BasicBlock *BB) {
8341  switch (static_cast<SCEVTypes>(S->getSCEVType())) {
8342  case scConstant:
8343  return ProperlyDominatesBlock;
8344  case scTruncate:
8345  case scZeroExtend:
8346  case scSignExtend:
8347  return getBlockDisposition(cast<SCEVCastExpr>(S)->getOperand(), BB);
8348  case scAddRecExpr: {
8349  // This uses a "dominates" query instead of "properly dominates" query
8350  // to test for proper dominance too, because the instruction which
8351  // produces the addrec's value is a PHI, and a PHI effectively properly
8352  // dominates its entire containing block.
8353  const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
8354  if (!DT->dominates(AR->getLoop()->getHeader(), BB))
8355  return DoesNotDominateBlock;
8356  }
8357  // FALL THROUGH into SCEVNAryExpr handling.
8358  case scAddExpr:
8359  case scMulExpr:
8360  case scUMaxExpr:
8361  case scSMaxExpr: {
8362  const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
8363  bool Proper = true;
8364  for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
8365  I != E; ++I) {
8367  if (D == DoesNotDominateBlock)
8368  return DoesNotDominateBlock;
8369  if (D == DominatesBlock)
8370  Proper = false;
8371  }
8372  return Proper ? ProperlyDominatesBlock : DominatesBlock;
8373  }
8374  case scUDivExpr: {
8375  const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
8376  const SCEV *LHS = UDiv->getLHS(), *RHS = UDiv->getRHS();
8377  BlockDisposition LD = getBlockDisposition(LHS, BB);
8378  if (LD == DoesNotDominateBlock)
8379  return DoesNotDominateBlock;
8380  BlockDisposition RD = getBlockDisposition(RHS, BB);
8381  if (RD == DoesNotDominateBlock)
8382  return DoesNotDominateBlock;
8383  return (LD == ProperlyDominatesBlock && RD == ProperlyDominatesBlock) ?
8385  }
8386  case scUnknown:
8387  if (Instruction *I =
8388  dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue())) {
8389  if (I->getParent() == BB)
8390  return DominatesBlock;
8391  if (DT->properlyDominates(I->getParent(), BB))
8392  return ProperlyDominatesBlock;
8393  return DoesNotDominateBlock;
8394  }
8395  return ProperlyDominatesBlock;
8396  case scCouldNotCompute:
8397  llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
8398  }
8399  llvm_unreachable("Unknown SCEV kind!");
8400 }
8401 
8402 bool ScalarEvolution::dominates(const SCEV *S, const BasicBlock *BB) {
8403  return getBlockDisposition(S, BB) >= DominatesBlock;
8404 }
8405 
8408 }
8409 
8410 namespace {
8411 // Search for a SCEV expression node within an expression tree.
8412 // Implements SCEVTraversal::Visitor.
8413 struct SCEVSearch {
8414  const SCEV *Node;
8415  bool IsFound;
8416 
8417  SCEVSearch(const SCEV *N): Node(N), IsFound(false) {}
8418 
8419  bool follow(const SCEV *S) {
8420  IsFound |= (S == Node);
8421  return !IsFound;
8422  }
8423  bool isDone() const { return IsFound; }
8424 };
8425 }
8426 
8427 bool ScalarEvolution::hasOperand(const SCEV *S, const SCEV *Op) const {
8428  SCEVSearch Search(Op);
8429  visitAll(S, Search);
8430  return Search.IsFound;
8431 }
8432 
8433 void ScalarEvolution::forgetMemoizedResults(const SCEV *S) {
8434  ValuesAtScopes.erase(S);
8435  LoopDispositions.erase(S);
8436  BlockDispositions.erase(S);
8437  UnsignedRanges.erase(S);
8438  SignedRanges.erase(S);
8439 
8441  BackedgeTakenCounts.begin(), E = BackedgeTakenCounts.end(); I != E; ) {
8442  BackedgeTakenInfo &BEInfo = I->second;
8443  if (BEInfo.hasOperand(S, this)) {
8444  BEInfo.clear();
8445  BackedgeTakenCounts.erase(I++);
8446  }
8447  else
8448  ++I;
8449  }
8450 }
8451 
8453 
8454 /// replaceSubString - Replaces all occurrences of From in Str with To.
8455 static void replaceSubString(std::string &Str, StringRef From, StringRef To) {
8456  size_t Pos = 0;
8457  while ((Pos = Str.find(From, Pos)) != std::string::npos) {
8458  Str.replace(Pos, From.size(), To.data(), To.size());
8459  Pos += To.size();
8460  }
8461 }
8462 
8463 /// getLoopBackedgeTakenCounts - Helper method for verifyAnalysis.
8464 static void
8465 getLoopBackedgeTakenCounts(Loop *L, VerifyMap &Map, ScalarEvolution &SE) {
8466  for (Loop::reverse_iterator I = L->rbegin(), E = L->rend(); I != E; ++I) {
8467  getLoopBackedgeTakenCounts(*I, Map, SE); // recurse.
8468 
8469  std::string &S = Map[L];
8470  if (S.empty()) {
8471  raw_string_ostream OS(S);
8472  SE.getBackedgeTakenCount(L)->print(OS);
8473 
8474  // false and 0 are semantically equivalent. This can happen in dead loops.
8475  replaceSubString(OS.str(), "false", "0");
8476  // Remove wrap flags, their use in SCEV is highly fragile.
8477  // FIXME: Remove this when SCEV gets smarter about them.
8478  replaceSubString(OS.str(), "<nw>", "");
8479  replaceSubString(OS.str(), "<nsw>", "");
8480  replaceSubString(OS.str(), "<nuw>", "");
8481  }
8482  }
8483 }
8484 
8486  if (!VerifySCEV)
8487  return;
8488 
8489  ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
8490 
8491  // Gather stringified backedge taken counts for all loops using SCEV's caches.
8492  // FIXME: It would be much better to store actual values instead of strings,
8493  // but SCEV pointers will change if we drop the caches.
8494  VerifyMap BackedgeDumpsOld, BackedgeDumpsNew;
8495  for (LoopInfo::reverse_iterator I = LI->rbegin(), E = LI->rend(); I != E; ++I)
8496  getLoopBackedgeTakenCounts(*I, BackedgeDumpsOld, SE);
8497 
8498  // Gather stringified backedge taken counts for all loops without using
8499  // SCEV's caches.
8500  SE.releaseMemory();
8501  for (LoopInfo::reverse_iterator I = LI->rbegin(), E = LI->rend(); I != E; ++I)
8502  getLoopBackedgeTakenCounts(*I, BackedgeDumpsNew, SE);
8503 
8504  // Now compare whether they're the same with and without caches. This allows
8505  // verifying that no pass changed the cache.
8506  assert(BackedgeDumpsOld.size() == BackedgeDumpsNew.size() &&
8507  "New loops suddenly appeared!");
8508 
8509  for (VerifyMap::iterator OldI = BackedgeDumpsOld.begin(),
8510  OldE = BackedgeDumpsOld.end(),
8511  NewI = BackedgeDumpsNew.begin();
8512  OldI != OldE; ++OldI, ++NewI) {
8513  assert(OldI->first == NewI->first && "Loop order changed!");
8514 
8515  // Compare the stringified SCEVs. We don't care if undef backedgetaken count
8516  // changes.
8517  // FIXME: We currently ignore SCEV changes from/to CouldNotCompute. This
8518  // means that a pass is buggy or SCEV has to learn a new pattern but is
8519  // usually not harmful.
8520  if (OldI->second != NewI->second &&
8521  OldI->second.find("undef") == std::string::npos &&
8522  NewI->second.find("undef") == std::string::npos &&
8523  OldI->second != "***COULDNOTCOMPUTE***" &&
8524  NewI->second != "***COULDNOTCOMPUTE***") {
8525  dbgs() << "SCEVValidator: SCEV for loop '"
8526  << OldI->first->getHeader()->getName()
8527  << "' changed from '" << OldI->second
8528  << "' to '" << NewI->second << "'!\n";
8529  std::abort();
8530  }
8531  }
8532 
8533  // TODO: Verify more things.
8534 }
NoWrapFlags getNoWrapFlags(NoWrapFlags Mask=NoWrapMask) const
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
const SCEV * getTruncateOrNoop(const SCEV *V, Type *Ty)
getTruncateOrNoop - Return a SCEV corresponding to a conversion of the input value to the specified t...
const NoneType None
Definition: None.h:23
const SCEV * evaluateAtIteration(const SCEV *It, ScalarEvolution &SE) const
evaluateAtIteration - Return the value of this chain of recurrences at the specified iteration number...
void AddPointer(const void *Ptr)
Add* - Add various data types to Bit data.
Definition: FoldingSet.cpp:52
APInt multiplicativeInverse(const APInt &modulo) const
Computes the multiplicative inverse of this APInt for a given modulo.
Definition: APInt.cpp:1374
Type * getSourceElementType() const
Definition: Operator.cpp:9
APInt getSignedMin() const
Return the smallest signed value contained in the ConstantRange.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static cl::opt< bool > VerifySCEV("verify-scev", cl::desc("Verify ScalarEvolution's backedge taken counts (slow)"))
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:537
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
The SCEV properly dominates the block.
BasicBlock * getUniquePredecessor()
Return the predecessor of this block if it has a unique predecessor block.
Definition: BasicBlock.cpp:224
APInt LLVM_ATTRIBUTE_UNUSED_RESULT abs() const
Get the absolute value;.
Definition: APInt.h:1571
static const SCEV * SolveLinEquationWithOverflow(const APInt &A, const APInt &B, ScalarEvolution &SE)
SolveLinEquationWithOverflow - Finds the minimum unsigned root of the following equation: ...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
SCEVCastExpr(const FoldingSetNodeIDRef ID, unsigned SCEVTy, const SCEV *op, Type *ty)
LLVM Argument representation.
Definition: Argument.h:35
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
bool isOne() const
isOne - Return true if the expression is a constant one.
const SCEV * getExitCount(Loop *L, BasicBlock *ExitingBlock)
const SCEV * getConstant(ConstantInt *V)
STATISTIC(NumFunctions,"Total number of functions")
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
bool hasValue() const
Definition: Optional.h:125
static const SCEV * getExtendAddRecStart(const SCEVAddRecExpr *AR, Type *Ty, ScalarEvolution *SE)
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:159
ConstantRange sextOrTrunc(uint32_t BitWidth) const
Make this range have the bit width given by BitWidth.
static void Found()
APInt GreatestCommonDivisor(const APInt &Val1, const APInt &Val2)
Compute GCD of two APInt values.
Definition: APInt.cpp:817
static const SCEV * removeConstantFactors(ScalarEvolution &SE, const SCEV *T)
bool canConstantFoldCallTo(const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
LLVMContext & getContext() const
static void PushDefUseChildren(Instruction *I, SmallVectorImpl< Instruction * > &Worklist)
PushDefUseChildren - Push users of the given Instruction onto the given Worklist. ...
bool isZero() const
isZero - Return true if the expression is a constant zero.
void setBit(unsigned bitPosition)
Set a given bit to 1.
Definition: APInt.cpp:588
unsigned getNumOperands() const
Definition: User.h:138
static uint64_t Choose(uint64_t n, uint64_t k, bool &Overflow)
Compute the result of "n choose k", the binomial coefficient.
const SCEV * getPointerBase(const SCEV *V)
getPointerBase - Transitively follow the chain of pointer-type operands until reaching a SCEV that do...
ScalarEvolution - This class is the main scalar evolution driver.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
Definition: ConstantRange.h:95
CallInst - This class represents a function call, abstracting a target machine's calling convention...
This file contains the declarations for metadata subclasses.
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Get a value with low bits set.
Definition: APInt.h:531
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:783
An immutable pass that tracks lazily created AssumptionCache objects.
scalar Scalar Evolution false
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
bool isKnownNonNegative(const SCEV *S)
isKnownNonNegative - Test if the given expression is known to be non-negative.
static const SCEV * getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty, ScalarEvolution *SE)
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
std::vector< LoopT * >::const_reverse_iterator reverse_iterator
Definition: LoopInfo.h:530
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1092
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:826
static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Definition: APInt.cpp:1987
bool properlyDominates(const SCEV *S, const BasicBlock *BB)
properlyDominates - Return true if elements that makes up the given SCEV properly dominate the specif...
static void PushLoopPHIs(const Loop *L, SmallVectorImpl< Instruction * > &Worklist)
PushLoopPHIs - Push PHI nodes in the header of the given loop onto the given Worklist.
uint32_t GetMinTrailingZeros(const SCEV *S)
GetMinTrailingZeros - Determine the minimum number of zero bits that S is guaranteed to end in (at ev...
const SCEV * getStepRecurrence(ScalarEvolution &SE) const
getStepRecurrence - This method constructs and returns the recurrence indicating how much this expres...
APInt getSignedMax() const
Return the largest signed value contained in the ConstantRange.
bool isLoopExiting(const BlockT *BB) const
isLoopExiting - True if terminator in the block can branch to another block that is outside of the cu...
Definition: LoopInfo.h:152
SCEVTruncateExpr - This class represents a truncation of an integer value to a smaller integer value...
bool isMask(unsigned numBits, const APInt &APIVal)
Definition: APInt.h:1767
bool isLoopInvariant(const SCEV *S, const Loop *L)
isLoopInvariant - Return true if the value of the given SCEV is unchanging in the specified loop...
static ConstantInt * EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C, ScalarEvolution &SE)
LoopT * getParentLoop() const
Definition: LoopInfo.h:97
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
static const SCEV * getSignedOverflowLimitForStep(const SCEV *Step, ICmpInst::Predicate *Pred, ScalarEvolution *SE)
Metadata node.
Definition: Metadata.h:740
bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS)
isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is protected by a conditional bet...
const SCEV *const * Operands
F(f)
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
static int getMaxValue(uint64_t TSFlags)
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
RAII wrapper to prevent recursive application of isImpliedCond.
Hexagon Common GEP
#define R2(n)
LoopT * getLoopFor(const BlockT *BB) const
getLoopFor - Return the inner most loop that BB lives in.
Definition: LoopInfo.h:540
static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the smallest range such that all values that may satisfy the given predicate with any value c...
SCEVCouldNotCompute - An object of this class is returned by queries that could not be answered...
#define op(i)
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: Type.cpp:216
void reserve(size_type N)
Definition: SmallVector.h:401
static bool HasSameValue(const SCEV *A, const SCEV *B)
HasSameValue - SCEV structural equivalence is usually sufficient for testing whether two expressions ...
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
op_iterator idx_end()
Definition: Operator.h:385
const SCEV * getUMaxFromMismatchedTypes(const SCEV *LHS, const SCEV *RHS)
getUMaxFromMismatchedTypes - Promote the operands to the wider of the types using zero-extension...
static Optional< ConstantRange > GetRangeFromMetadata(Value *V)
GetRangeFromMetadata - Helper method to assign a range to V from metadata present in the IR...
op_iterator op_begin()
Definition: User.h:183
BlockT * getHeader() const
Definition: LoopInfo.h:96
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:426
ConstantInt * findCaseDest(BasicBlock *BB)
findCaseDest - Finds the unique case value for a given successor.
SCEVCastExpr - This is the base class for unary cast operator classes.
ConstantRange smax(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a signed maximum of a value in thi...
bool isOffsetOf(Type *&STy, Constant *&FieldNo) const
Type * getPointerElementType() const
Definition: Type.h:366
const SCEV * getStart() const
std::vector< LoopT * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
Definition: LoopInfo.h:528
BlockT * getLoopLatch() const
getLoopLatch - If there is a single latch block for this loop, return it.
Definition: LoopInfoImpl.h:156
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2258
bool isKnownNonPositive(const SCEV *S)
isKnownNonPositive - Test if the given expression is known to be non-positive.
static void getLoopBackedgeTakenCounts(Loop *L, VerifyMap &Map, ScalarEvolution &SE)
getLoopBackedgeTakenCounts - Helper method for verifyAnalysis.
bool isNegative() const
Determine sign of this APInt.
Definition: APInt.h:319
The SCEV is loop-invariant.
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:169
const SCEV * getGEPExpr(Type *PointeeType, const SCEV *BaseExpr, const SmallVectorImpl< const SCEV * > &IndexExprs, bool InBounds=false)
Returns an expression for a GEP.
APInt LLVM_ATTRIBUTE_UNUSED_RESULT urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1887
AnalysisUsage & addRequired()
void setValPtr(Value *P)
Definition: ValueHandle.h:352
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
void computeAccessFunctions(const SCEV *Expr, SmallVectorImpl< const SCEV * > &Subscripts, SmallVectorImpl< const SCEV * > &Sizes)
Return in Subscripts the access functions for each dimension in Sizes.
bool isUnconditional() const
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1674
bool isAlignOf(Type *&AllocTy) const
inst_iterator inst_begin(Function *F)
Definition: InstIterator.h:127
MarkPendingLoopPredicate(Value *C, DenseSet< Value * > &LP)
ConstantRange truncate(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly smaller than the current typ...
void Reset()
Deallocate all but the current slab and reset the current pointer to the beginning of it...
Definition: Allocator.h:189
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:551
APInt urem(const APInt &LHS, const APInt &RHS)
Function for unsigned remainder operation.
Definition: APInt.h:1869
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:406
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
APInt LLVM_ATTRIBUTE_UNUSED_RESULT lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.cpp:1142
Constant * ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL)
ConstantFoldLoadFromConstPtr - Return the value that a load from C would produce if it is constant an...
const SCEV *const * op_iterator
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
static Constant * AddOne(Constant *C)
Add one to a Constant.
void getExitingBlocks(SmallVectorImpl< BlockT * > &ExitingBlocks) const
getExitingBlocks - Return all blocks inside the loop that have successors outside of the loop...
Definition: LoopInfoImpl.h:35
uint64_t getTypeSizeInBits(Type *Ty) const
getTypeSizeInBits - Return the size in bits of the specified type, for which isSCEVable must return t...
bool isSized(SmallPtrSetImpl< const Type * > *Visited=nullptr) const
isSized - Return true if it makes sense to take the size of this type.
Definition: Type.h:268
void AddInteger(signed I)
Definition: FoldingSet.cpp:60
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1713
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
Windows NT (Windows on ARM)
SCEVCommutativeExpr - This node is the base class for n'ary commutative operators.
APInt umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:1755
bool isIntN(unsigned N) const
Check if this APInt has an N-bits unsigned integer value.
Definition: APInt.h:372
void print(raw_ostream &OS, const Module *=nullptr) const override
print - Print out the internal state of the pass.
bool empty() const
Definition: DenseSet.h:52
ConstantRange signExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
op_iterator op_begin() const
void setNoWrapFlags(NoWrapFlags Flags)
Set flags for a non-recurrence without clearing previously set flags.
SCEVMulExpr - This node represents multiplication of some number of SCEVs.
static SCEV::NoWrapFlags LLVM_ATTRIBUTE_UNUSED_RESULT clearFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OffFlags)
ConstantRange multiply(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a multiplication of a value in thi...
APInt lshr(const APInt &LHS, unsigned shiftAmt)
Logical right-shift function.
Definition: APInt.h:1840
void getExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const
getExitBlocks - Return all of the successor blocks of this loop.
Definition: LoopInfoImpl.h:64
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:104
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
static const SCEV * BinomialCoefficient(const SCEV *It, unsigned K, ScalarEvolution &SE, Type *ResultTy)
BinomialCoefficient - Compute BC(It, K).
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1727
bool isKnownPredicate(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS)
isKnownPredicate - Test if the given expression is known to satisfy the condition described by Pred...
reverse_iterator rbegin() const
Definition: LoopInfo.h:133
ConstantExpr - a constant value that is initialized with an expression using other constant values...
Definition: Constants.h:852
const SCEV * getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo)
getOffsetOfExpr - Return an expression for offsetof on the given field with type IntTy ...
ConstantRange getSignedRange(const SCEV *S)
getSignedRange - Determine the signed range for a particular SCEV.
SCEVAddRecExpr - This node represents a polynomial recurrence on the trip count of the specified loop...
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:107
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3287
#define T
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:121
APInt udiv(const APInt &LHS, const APInt &RHS)
Unsigned division function for APInt.
Definition: APInt.h:1859
bool sgt(const APInt &RHS) const
Signed greather than comparison.
Definition: APInt.h:1119
BasicBlock * getSuccessor(unsigned i) const
ConstantRange unionWith(const ConstantRange &CR) const
Return the range that results from the union of this range with another range.
const SCEV * getSizeOfExpr(Type *IntTy, Type *AllocTy)
getSizeOfExpr - Return an expression for sizeof AllocTy that is type IntTy
Base class for the actual dominator tree node.
unsigned getActiveBits() const
Compute the number of active bits in the value.
Definition: APInt.h:1297
APInt sdiv(const APInt &LHS, const APInt &RHS)
Signed division function for APInt.
Definition: APInt.h:1854
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
APInt LLVM_ATTRIBUTE_UNUSED_RESULT shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:868
static cl::opt< unsigned > MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden, cl::desc("Maximum number of iterations SCEV will ""symbolically execute a constant ""derived loop"), cl::init(100))
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
bool isArrayTy() const
isArrayTy - True if this is an instance of ArrayType.
Definition: Type.h:213
static Constant * getUDiv(Constant *C1, Constant *C2, bool isExact=false)
Definition: Constants.cpp:2291
APInt ashr(const APInt &LHS, unsigned shiftAmt)
Arithmetic right-shift function.
Definition: APInt.h:1833
Type * getEffectiveSCEVType(Type *Ty) const
getEffectiveSCEVType - Return a type with the same bitwidth as the given type and which represents ho...
ConstantRange subtract(const APInt &CI) const
Subtract the specified constant from the endpoints of this constant range.
const char * getOpcodeName() const
Definition: Instruction.h:114
const SCEV * getAddRecExpr(const SCEV *Start, const SCEV *Step, const Loop *L, SCEV::NoWrapFlags Flags)
getAddRecExpr - Get an add recurrence expression for the specified loop.
static std::pair< const SCEV *, const SCEV * > SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE)
SolveQuadraticEquation - Find the roots of the quadratic equation for the given quadratic chrec {L...
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.cpp:520
static ConstantRange makeSatisfyingICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the largest range such that all values in the returned range satisfy the given predicate with...
static cl::opt< unsigned > MaxIterations("max-cg-scc-iterations", cl::ReallyHidden, cl::init(4))
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:107
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
std::vector< LoopT * >::const_reverse_iterator reverse_iterator
Definition: LoopInfo.h:130
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:491
bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS)
isLoopEntryGuardedByCond - Test whether entry to the loop is protected by a conditional between LHS a...
static const SCEV * MatchNotExpr(const SCEV *Expr)
If Expr computes ~A, return A else return nullptr.
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1835
const SCEV * getNumIterationsInRange(ConstantRange Range, ScalarEvolution &SE) const
getNumIterationsInRange - Return the number of iterations of this loop that produce values in the spe...
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:297
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
const SCEV * getCouldNotCompute()
Visit all nodes in the expression tree using worklist traversal.
#define P(N)
SCEVUnknown - This means that we are dealing with an entirely unknown SCEV value, and only represent ...
#define true
Definition: ConvertUTF.c:66
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
bool erase(const KeyT &Val)
Definition: DenseMap.h:206
iterator begin() const
Definition: LoopInfo.h:131
bool isAffine() const
isAffine - Return true if this represents an expression A + B*x where A and B are loop invariant valu...
bool isSCEVable(Type *Ty) const
isSCEVable - Test if values of the given type are analyzable within the SCEV framework.
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
ConstantRange intersectWith(const ConstantRange &CR) const
Return the range that results from the intersection of this range with another range.
SCEVVisitor - This class defines a simple visitor class that may be used for various SCEV analysis pu...
bool isSizeOf(Type *&AllocTy) const
isSizeOf, isAlignOf, isOffsetOf - Test whether this is a special constant representing a type size...
APInt LLVM_ATTRIBUTE_UNUSED_RESULT trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:932
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type. ...
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
static const SCEV * rewrite(const SCEV *Scev, ScalarEvolution &SE, ValueToValueMap &Map, bool InterpretConsts=false)
SCEVUDivExpr - This class represents a binary unsigned division operation.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:62
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
static volatile int One
Definition: InfiniteTest.cpp:9
Type * getType() const
getType - Return the LLVM type of this SCEV expression.
LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L)
getLoopDisposition - Return the "disposition" of the given SCEV with respect to the given loop...
static void GroupByComplexity(SmallVectorImpl< const SCEV * > &Ops, LoopInfo *LI)
GroupByComplexity - Given a list of SCEV objects, order them by their complexity, and group objects o...
BranchInst - Conditional or Unconditional Branch instruction.
static bool IsMinConsistingOf(ScalarEvolution &SE, const SCEV *MaybeMinExpr, const SCEV *Candidate)
Is MaybeMinExpr an SMin or UMin of Candidate and some other values?
bool sge(const APInt &RHS) const
Signed greather or equal comparison.
Definition: APInt.h:1153
This is an important base class in LLVM.
Definition: Constant.h:41
bool isMaxSignedValue() const
Determine if this is the largest signed value.
Definition: APInt.h:353
void dump() const
dump - This method is used for debugging.
const SCEV * getOperand(unsigned i) const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, size_t Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:208
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
static bool canConstantEvolve(Instruction *I, const Loop *L)
Determine whether this instruction can constant evolve within this loop assuming its operands can all...
void visitAll(const SCEV *Root)
scalar evolution
const SCEV * getSMaxExpr(const SCEV *LHS, const SCEV *RHS)
static APInt getOneBitSet(unsigned numBits, unsigned BitNo)
Return an APInt with exactly one bit set in the result.
Definition: APInt.h:479
APInt LLVM_ATTRIBUTE_UNUSED_RESULT sext(unsigned width) const
Sign extend to a new width.
Definition: APInt.cpp:955
bool sle(const APInt &RHS) const
Signed less or equal comparison.
Definition: APInt.h:1085
iterator end() const
Definition: LoopInfo.h:132
const SCEV * getSCEVAtScope(const SCEV *S, const Loop *L)
getSCEVAtScope - Return a SCEV expression for the specified value at the specified scope in the progr...
Represent the analysis usage information of a pass.
ConstantRange udiv(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an unsigned division of a value in...
op_iterator op_end()
Definition: User.h:185
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
bool contains(const LoopT *L) const
contains - Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:105
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:844
bool hasOperand(const SCEV *S, const SCEV *Op) const
hasOperand - Test whether the given SCEV has Op as a direct or indirect operand.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
This instruction compares its operands according to the predicate given to the constructor.
const SCEV * getMinusSCEV(const SCEV *LHS, const SCEV *RHS, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
getMinusSCEV - Return LHS-RHS. Minus is represented in SCEV as A+B*-1.
const SCEV * getMaxBackedgeTakenCount(const Loop *L)
getMaxBackedgeTakenCount - Similar to getBackedgeTakenCount, except return the least SCEV value that ...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:362
bool uge(const APInt &RHS) const
Unsigned greater or equal comparison.
Definition: APInt.h:1137
const SCEVAddRecExpr * getPostIncExpr(ScalarEvolution &SE) const
getPostIncExpr - Return an expression representing the value of this expression one iteration of the ...
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
BlockT * getExitingBlock() const
getExitingBlock - If getExitingBlocks would return exactly one block, return that block...
Definition: LoopInfoImpl.h:51
bool isMaxValue() const
Determine if this is the largest unsigned value.
Definition: APInt.h:347
APInt LLVM_ATTRIBUTE_UNUSED_RESULT sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1876
Value * getOperand(unsigned i) const
Definition: User.h:118
unsigned getSmallConstantTripCount(Loop *L)
Returns the maximum trip count of the loop if it is a single-exit loop and we can compute a small max...
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2074
SI Fold Operands
void print(raw_ostream &OS) const
Print out the bounds to a stream.
Class to represent integer types.
Definition: DerivedTypes.h:37
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
ConstantRange zeroExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
bool isKnownNegative(const SCEV *S)
isKnownNegative - Test if the given expression is known to be negative.
static Constant * getNot(Constant *C)
Definition: Constants.cpp:2252
void forgetValue(Value *V)
forgetValue - This method should be called by the client when it has changed a value in a way that ma...
void setNoWrapFlags(NoWrapFlags Flags)
Set flags for a recurrence without clearing any previously set flags.
static SCEV::NoWrapFlags LLVM_ATTRIBUTE_UNUSED_RESULT setFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OnFlags)
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:230
const SCEV * getLHS() const
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
void findArrayDimensions(SmallVectorImpl< const SCEV * > &Terms, SmallVectorImpl< const SCEV * > &Sizes, const SCEV *ElementSize) const
Compute the array dimensions Sizes from the set of Terms extracted from the memory access function of...
bool isEmptySet() const
Return true if this set contains no members.
const SCEV * getUMinFromMismatchedTypes(const SCEV *LHS, const SCEV *RHS)
getUMinFromMismatchedTypes - Promote the operands to the wider of the types using zero-extension...
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
iterator erase(iterator I)
Definition: SmallVector.h:455
bool isNonConstantNegative() const
isNonConstantNegative - Return true if the specified scev is negated, but not a constant.
static uint64_t umul_ov(uint64_t i, uint64_t j, bool &Overflow)
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:283
const SCEV * getNoopOrZeroExtend(const SCEV *V, Type *Ty)
getNoopOrZeroExtend - Return a SCEV corresponding to a conversion of the input value to the specified...
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCompareInstOperands - Attempt to constant fold a compare instruction (icmp/fcmp) with the...
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:386
ConstantRange add(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an addition of a value in this ran...
op_iterator idx_begin()
Definition: Operator.h:383
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
Definition: raw_ostream.h:480
const SCEV * getRHS() const
const SCEV * getUDivExactExpr(const SCEV *LHS, const SCEV *RHS)
getUDivExactExpr - Get a canonical unsigned division expression, or something simpler if possible...
signed greater than
Definition: InstrTypes.h:724
The SCEV is loop-variant (unknown).
static Constant * EvaluateExpression(Value *V, const Loop *L, DenseMap< Instruction *, Constant * > &Vals, const DataLayout &DL, const TargetLibraryInfo *TLI)
EvaluateExpression - Given an expression that passes the getConstantEvolvingPHI predicate, evaluate its value assuming the PHI node in the loop has the value PHIVal.
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:214
bool isConditional() const
const SCEV * getSMinExpr(const SCEV *LHS, const SCEV *RHS)
bool ugt(const APInt &RHS) const
Unsigned greather than comparison.
Definition: APInt.h:1101
unsigned countTrailingZeros() const
Count the number of trailing zero bits.
Definition: APInt.cpp:749
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:694
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static int numberOfTerms(const SCEV *S)
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:304
static PHINode * getConstantEvolvingPHI(Value *V, const Loop *L)
getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node in the loop that V is deri...
DomTreeNodeBase< NodeT > * getIDom() const
static const APInt gcd(const SCEVConstant *C1, const SCEVConstant *C2)
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
static PointerType * getUnqual(Type *ElementType)
PointerType::getUnqual - This constructs a pointer to an object of the specified type in the generic ...
Definition: DerivedTypes.h:460
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
bool isKnownPositive(const SCEV *S)
isKnownPositive - Test if the given expression is known to be positive.
bool slt(const APInt &RHS) const
Signed less than comparison.
Definition: APInt.cpp:552
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
reverse_iterator rend() const
Definition: LoopInfo.h:134
const SCEV * getTruncateExpr(const SCEV *Op, Type *Ty)
const SCEV * getTruncateOrSignExtend(const SCEV *V, Type *Ty)
getTruncateOrSignExtend - Return a SCEV corresponding to a conversion of the input value to the speci...
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
void delinearize(const SCEV *Expr, SmallVectorImpl< const SCEV * > &Subscripts, SmallVectorImpl< const SCEV * > &Sizes, const SCEV *ElementSize)
Split this SCEVAddRecExpr into two vectors of SCEVs representing the subscripts and sizes of an array...
DenseSet< Value * > & LoopPreds
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Constant * ConstantFoldInstOperands(unsigned Opcode, Type *DestTy, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands...
bool isAllOnesValue() const
isAllOnesValue - Return true if the expression is a constant all-ones value.
This is a utility class that provides an abstraction for the common functionality between Instruction...
Definition: Operator.h:32
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
The SCEV dominates the block.
MDNode * getMetadata(unsigned KindID) const
getMetadata - Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:167
unsigned getSmallConstantTripMultiple(Loop *L)
Returns the largest constant divisor of the trip count of the loop if it is a single-exit loop and we...
static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE, SCEVTypes Type, const SmallVectorImpl< const SCEV * > &Ops, SCEV::NoWrapFlags OldFlags)
This class represents a range of values.
Definition: ConstantRange.h:43
bool isVolatile() const
isVolatile - Return true if this is a load from a volatile memory location.
Definition: Instructions.h:232
const SCEV * getNoopOrSignExtend(const SCEV *V, Type *Ty)
getNoopOrSignExtend - Return a SCEV corresponding to a conversion of the input value to the specified...
unsigned ComputeNumSignBits(Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeNumSignBits - Return the number of times the sign bit of the register is replicated into the o...
signed less than
Definition: InstrTypes.h:726
const APInt & getLower() const
Return the lower value for this range.
Definition: ConstantRange.h:87
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:838
CHAIN = SC CHAIN, Imm128 - System call.
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
Definition: APInt.h:332
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:799
static APInt getMinValue(unsigned numBits)
Gets minimum unsigned value of APInt for a specific bit width.
Definition: APInt.h:433
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1699
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
ConstantInt * getValue() const
const SCEV * getUMaxExpr(const SCEV *LHS, const SCEV *RHS)
#define NC
Definition: regutils.h:42
bool isNullValue() const
isNullValue - Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:75
APInt umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:1752
static SCEV::NoWrapFlags LLVM_ATTRIBUTE_UNUSED_RESULT maskFlags(SCEV::NoWrapFlags Flags, int Mask)
Convenient NoWrapFlags manipulation that hides enum casts and is visible in the ScalarEvolution name ...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:119
scalar Scalar Evolution Analysis
APInt smax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be signed.
Definition: APInt.h:1749
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
signed less or equal
Definition: InstrTypes.h:727
LoopDisposition
LoopDisposition - An enum describing the relationship between a SCEV and a loop.
Class for arbitrary precision integers.
Definition: APInt.h:73
SCEVAddExpr - This node represents an addition of some number of SCEVs.
const SCEV * getSignExtendExpr(const SCEV *Op, Type *Ty)
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
void setPreservesAll()
Set by analyses that do not transform their input at all.
SCEVSMaxExpr - This class represents a signed maximum selection.
iterator_range< user_iterator > users()
Definition: Value.h:300
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:211
static const SCEV * getUnsignedOverflowLimitForStep(const SCEV *Step, ICmpInst::Predicate *Pred, ScalarEvolution *SE)
DenseMap< const Loop *, std::string > VerifyMap
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1591
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
const SCEV * getAddExpr(SmallVectorImpl< const SCEV * > &Ops, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
getAddExpr - Get a canonical add expression, or something simpler if possible.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
void visitAll(const SCEV *Root, SV &Visitor)
Use SCEVTraversal to visit all nodes in the given expression tree.
Value * getCondition() const
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:481
static APInt getMaxValue(unsigned numBits)
Gets maximum unsigned value of APInt for specific bit width.
Definition: APInt.h:421
bool isMinValue() const
Determine if this is the smallest unsigned value.
Definition: APInt.h:361
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
static Constant * BuildConstantFromSCEV(const SCEV *V)
This builds up a Constant using the ConstantExpr interface.
bool isStructTy() const
isStructTy - True if this is an instance of StructType.
Definition: Type.h:209
ConstantRange umax(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an unsigned maximum of a value in ...
SCEVZeroExtendExpr - This class represents a zero extension of a small integer value to a larger inte...
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2239
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:337
static void replaceSubString(std::string &Str, StringRef From, StringRef To)
replaceSubString - Replaces all occurrences of From in Str with To.
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
Definition: Lint.cpp:697
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
void collectParametricTerms(const SCEV *Expr, SmallVectorImpl< const SCEV * > &Terms)
Collect parametric terms occurring in step expressions.
Value * getCondition() const
BasicBlock * getDefaultDest() const
unsigned size() const
Definition: DenseMap.h:82
The SCEV does not dominate the block.
FoldingSetNodeIDRef - This class describes a reference to an interned FoldingSetNodeID, which can be a useful to store node id data rather than using plain FoldingSetNodeIDs, since the 32-element SmallVector is often much larger than necessary, and the possibility of heap allocation means it requires a non-trivial destructor call.
Definition: FoldingSet.h:269
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:367
void forgetLoop(const Loop *L)
forgetLoop - This method should be called by the client when it has changed a loop in a way that may ...
pointer data()
Return a pointer to the vector's buffer, even if empty().
Definition: SmallVector.h:134
SCEV - This class represents an analyzed expression in the program.
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
Definition: Operator.h:379
unsigned greater or equal
Definition: InstrTypes.h:721
static PHINode * getConstantEvolvingPHIOperands(Instruction *UseInst, const Loop *L, DenseMap< Instruction *, PHINode * > &PHIMap)
getConstantEvolvingPHIOperands - Implement getConstantEvolvingPHI by recursing through each instructi...
static Instruction::CastOps getCastOpcode(const Value *Val, bool SrcIsSigned, Type *Ty, bool DstIsSigned)
Returns the opcode necessary to cast Val into Ty using usual casting rules.
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
static bool containsParameters(const SCEV *S)
iterator end()
Definition: DenseMap.h:68
SCEVSignExtendExpr - This class represents a sign extension of a small integer value to a larger inte...
bool isSignBit() const
Check if the APInt's value is returned by getSignBit.
Definition: APInt.h:395
BlockDisposition
BlockDisposition - An enum describing the relationship between a SCEV and a basic block...
bool isKnownNonZero(const SCEV *S)
isKnownNonZero - Test if the given expression is known to be non-zero.
BlockT * getLoopPredecessor() const
getLoopPredecessor - If the given loop's header has exactly one unique predecessor outside the loop...
Definition: LoopInfoImpl.h:130
APInt smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:1746
SCEVUMaxExpr - This class represents an unsigned maximum selection.
static ConstantRange makeConstantRange(Predicate pred, const APInt &C)
Initialize a set of values that all satisfy the predicate with C.
static bool CollectAddOperandsWithScales(DenseMap< const SCEV *, APInt > &M, SmallVectorImpl< const SCEV * > &NewOps, APInt &AccumulatedConstant, const SCEV *const *Ops, size_t NumOperands, const APInt &Scale, ScalarEvolution &SE)
CollectAddOperandsWithScales - Process the given Ops list, which is a list of operands to be added un...
AnalysisUsage & addRequiredTransitive()
const Loop * getLoop() const
void swap(DenseMap &RHS)
Definition: DenseMap.h:578
bool all_of(R &&Range, UnaryPredicate &&P)
Provide wrappers to std::all_of which take ranges instead of having to pass being/end explicitly...
Definition: STLExtras.h:334
iterator find_as(const LookupKeyT &Val)
Alternate version of find() which allows a different, and possibly less expensive, key type.
Definition: DenseMap.h:143
INITIALIZE_PASS_BEGIN(ScalarEvolution,"scalar-evolution","Scalar Evolution Analysis", false, true) INITIALIZE_PASS_END(ScalarEvolution
int compare(DigitsT LDigits, int16_t LScale, DigitsT RDigits, int16_t RScale)
Compare two scaled numbers.
Definition: ScaledNumber.h:252
ConstantRange getUnsignedRange(const SCEV *S)
getUnsignedRange - Determine the unsigned range for a particular SCEV.
SwitchInst - Multiway switch.
const SCEV * getBackedgeTakenCount(const Loop *L)
getBackedgeTakenCount - If the specified loop has a predictable backedge-taken count, return it, otherwise return a SCEVCouldNotCompute object.
const APInt & getUpper() const
Return the upper value for this range.
Definition: ConstantRange.h:91
bool isSingleEdge() const
Definition: Dominators.cpp:42
bool SimplifyICmpOperands(ICmpInst::Predicate &Pred, const SCEV *&LHS, const SCEV *&RHS, unsigned Depth=0)
SimplifyICmpOperands - Simplify LHS and RHS in a comparison with predicate Pred.
user_iterator user_begin()
Definition: Value.h:294
Use * op_iterator
Definition: User.h:178
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:436
void initializeScalarEvolutionPass(PassRegistry &)
unsigned getSCEVType() const
const SCEV * getUMinExpr(const SCEV *LHS, const SCEV *RHS)
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:465
void print(raw_ostream &OS) const
print - Print out the internal representation of this scalar to the specified stream.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
const SCEV * getSCEV(Value *V)
getSCEV - Return a SCEV expression for the full generality of the specified expression.
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE, const Loop *L)
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Function.cpp:62
APInt shl(const APInt &LHS, unsigned shiftAmt)
Left-shift function.
Definition: APInt.h:1847
ConstantRange zextOrTrunc(uint32_t BitWidth) const
Make this range have the bit width given by BitWidth.
uint64_t getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:507
static bool containsConstantSomewhere(const SCEV *StartExpr)
Determine if any of the operands in this SCEV are a constant or if any of the add or multiply express...
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
#define DEBUG(X)
Definition: Debug.h:92
const SCEV * getUDivExpr(const SCEV *LHS, const SCEV *RHS)
getUDivExpr - Get a canonical unsigned division expression, or something simpler if possible...
unsigned countLeadingZeros() const
The APInt version of the countLeadingZeros functions in MathExtras.h.
Definition: APInt.h:1361
const SCEV * getUnknown(Value *V)
FoldingSetNodeIDRef Intern(BumpPtrAllocator &Allocator) const
Intern - Copy this node's data to a memory region allocated from the given allocator and return a Fol...
Definition: FoldingSet.cpp:176
The SCEV varies predictably with the loop.
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:737
static bool findArrayDimensionsRec(ScalarEvolution &SE, SmallVectorImpl< const SCEV * > &Terms, SmallVectorImpl< const SCEV * > &Sizes)
bool dominates(const SCEV *S, const BasicBlock *BB)
dominates - Return true if elements that makes up the given SCEV dominate the specified basic block...
op_iterator op_end() const
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:344
unsigned greater than
Definition: InstrTypes.h:720
static int sizeOfSCEV(const SCEV *S)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
inst_iterator inst_end(Function *F)
Definition: InstIterator.h:128
APInt LLVM_ATTRIBUTE_UNUSED_RESULT zext(unsigned width) const
Zero extend to a new width.
Definition: APInt.cpp:996
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
SimplifyInstruction - See if we can compute a simplified version of this instruction.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
BlockDisposition getBlockDisposition(const SCEV *S, const BasicBlock *BB)
getLoopDisposition - Return the "disposition" of the given SCEV with respect to the given block...
const SCEV * getTruncateOrZeroExtend(const SCEV *V, Type *Ty)
getTruncateOrZeroExtend - Return a SCEV corresponding to a conversion of the input value to the speci...
bool replacementPreservesLCSSAForm(Instruction *From, Value *To)
replacementPreservesLCSSAForm - Returns true if replacing From with To everywhere is guaranteed to pr...
Definition: LoopInfo.h:662
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
static bool IsMaxConsistingOf(const SCEV *MaybeMaxExpr, const SCEV *Candidate)
Is MaybeMaxExpr an SMax or UMax of Candidate and some other values?
std::vector< LoopT * >::const_iterator iterator
Definition: LoopInfo.h:128
const SCEV * getNegativeSCEV(const SCEV *V)
getNegativeSCEV - Return the SCEV object corresponding to -V.
const SCEV * getElementSize(Instruction *Inst)
Return the size of an element read or written by Inst.
static bool CanConstantFold(const Instruction *I)
CanConstantFold - Return true if we can constant fold an instruction of the specified type...
Constant * ConstantFoldLoadThroughGEPIndices(Constant *C, ArrayRef< Constant * > Indices)
ConstantFoldLoadThroughGEPIndices - Given a constant and getelementptr indices (with an implied zero ...
const SCEV * getZeroExtendExpr(const SCEV *Op, Type *Ty)
static bool containsUndefs(const SCEV *S)
bool hasComputableLoopEvolution(const SCEV *S, const Loop *L)
hasComputableLoopEvolution - Return true if the given SCEV changes value in a known way in the specif...
SCEVNAryExpr - This node is a base class providing common functionality for n'ary operators...
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2280
APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
const SCEV * getNoopOrAnyExtend(const SCEV *V, Type *Ty)
getNoopOrAnyExtend - Return a SCEV corresponding to a conversion of the input value to the specified ...
NoWrapFlags
NoWrapFlags are bitfield indices into SubclassData.
friend class SCEVCallbackVH
const SCEV * getOperand() const
unsigned getLoopDepth() const
getLoopDepth - Return the nesting level of this loop.
Definition: LoopInfo.h:89
const SCEV * getNotSCEV(const SCEV *V)
getNotSCEV - Return the SCEV object corresponding to ~V.
const SCEV * getMulExpr(SmallVectorImpl< const SCEV * > &Ops, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
getMulExpr - Get a canonical multiply expression, or something simpler if possible.
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1069
bool hasLoopInvariantBackedgeTakenCount(const Loop *L)
hasLoopInvariantBackedgeTakenCount - Return true if the specified loop has an analyzable loop-invaria...
const BasicBlock * getParent() const
Definition: Instruction.h:72
static bool classof(const SCEV *S)
Methods for support type inquiry through isa, cast, and dyn_cast:
bool isQuadratic() const
isQuadratic - Return true if this represents an expression A + B*x + C*x^2 where A, B and C are loop invariant values.
signed greater or equal
Definition: InstrTypes.h:725
SCEVConstant - This class represents a constant integer value.
const SCEV * getAnyExtendExpr(const SCEV *Op, Type *Ty)
getAnyExtendExpr - Return a SCEV for the given operand extended with unspecified bits out to the give...
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
APInt getUnsignedMin() const
Return the smallest unsigned value contained in the ConstantRange.
user_iterator user_end()
Definition: Value.h:296
static bool IsKnownPredicateViaMinOrMax(ScalarEvolution &SE, ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS)
Is LHS Pred RHS true on the virtue of LHS or RHS being a Min or Max expression?