LLVM  4.0.0
ScalarEvolution.h
Go to the documentation of this file.
1 //===- llvm/Analysis/ScalarEvolution.h - Scalar Evolution -------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // The ScalarEvolution class is an LLVM pass which can be used to analyze and
11 // categorize scalar expressions in loops. It specializes in recognizing
12 // general induction variables, representing them with the abstract and opaque
13 // SCEV class. Given this analysis, trip counts of loops and other important
14 // properties can be obtained.
15 //
16 // This analysis is primarily useful for induction variable substitution and
17 // strength reduction.
18 //
19 //===----------------------------------------------------------------------===//
20 
21 #ifndef LLVM_ANALYSIS_SCALAREVOLUTION_H
22 #define LLVM_ANALYSIS_SCALAREVOLUTION_H
23 
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/FoldingSet.h"
26 #include "llvm/ADT/SetVector.h"
27 #include "llvm/Analysis/LoopInfo.h"
28 #include "llvm/IR/ConstantRange.h"
29 #include "llvm/IR/Instructions.h"
30 #include "llvm/IR/Operator.h"
31 #include "llvm/IR/PassManager.h"
32 #include "llvm/IR/ValueHandle.h"
33 #include "llvm/IR/ValueMap.h"
34 #include "llvm/Pass.h"
35 #include "llvm/Support/Allocator.h"
36 #include "llvm/Support/DataTypes.h"
37 
38 namespace llvm {
39 class APInt;
40 class AssumptionCache;
41 class Constant;
42 class ConstantInt;
43 class DominatorTree;
44 class Type;
45 class ScalarEvolution;
46 class DataLayout;
47 class TargetLibraryInfo;
48 class LLVMContext;
49 class Operator;
50 class SCEV;
51 class SCEVAddRecExpr;
52 class SCEVConstant;
53 class SCEVExpander;
54 class SCEVPredicate;
55 class SCEVUnknown;
56 class Function;
57 
58 template <> struct FoldingSetTrait<SCEV>;
59 template <> struct FoldingSetTrait<SCEVPredicate>;
60 
61 /// This class represents an analyzed expression in the program. These are
62 /// opaque objects that the client is not allowed to do much with directly.
63 ///
64 class SCEV : public FoldingSetNode {
65  friend struct FoldingSetTrait<SCEV>;
66 
67  /// A reference to an Interned FoldingSetNodeID for this node. The
68  /// ScalarEvolution's BumpPtrAllocator holds the data.
69  FoldingSetNodeIDRef FastID;
70 
71  // The SCEV baseclass this node corresponds to
72  const unsigned short SCEVType;
73 
74 protected:
75  /// This field is initialized to zero and may be used in subclasses to store
76  /// miscellaneous information.
77  unsigned short SubclassData;
78 
79 private:
80  SCEV(const SCEV &) = delete;
81  void operator=(const SCEV &) = delete;
82 
83 public:
84  /// NoWrapFlags are bitfield indices into SubclassData.
85  ///
86  /// Add and Mul expressions may have no-unsigned-wrap <NUW> or
87  /// no-signed-wrap <NSW> properties, which are derived from the IR
88  /// operator. NSW is a misnomer that we use to mean no signed overflow or
89  /// underflow.
90  ///
91  /// AddRec expressions may have a no-self-wraparound <NW> property if, in
92  /// the integer domain, abs(step) * max-iteration(loop) <=
93  /// unsigned-max(bitwidth). This means that the recurrence will never reach
94  /// its start value if the step is non-zero. Computing the same value on
95  /// each iteration is not considered wrapping, and recurrences with step = 0
96  /// are trivially <NW>. <NW> is independent of the sign of step and the
97  /// value the add recurrence starts with.
98  ///
99  /// Note that NUW and NSW are also valid properties of a recurrence, and
100  /// either implies NW. For convenience, NW will be set for a recurrence
101  /// whenever either NUW or NSW are set.
102  enum NoWrapFlags {
103  FlagAnyWrap = 0, // No guarantee.
104  FlagNW = (1 << 0), // No self-wrap.
105  FlagNUW = (1 << 1), // No unsigned wrap.
106  FlagNSW = (1 << 2), // No signed wrap.
107  NoWrapMask = (1 << 3) - 1
108  };
109 
110  explicit SCEV(const FoldingSetNodeIDRef ID, unsigned SCEVTy)
111  : FastID(ID), SCEVType(SCEVTy), SubclassData(0) {}
112 
113  unsigned getSCEVType() const { return SCEVType; }
114 
115  /// Return the LLVM type of this SCEV expression.
116  ///
117  Type *getType() const;
118 
119  /// Return true if the expression is a constant zero.
120  ///
121  bool isZero() const;
122 
123  /// Return true if the expression is a constant one.
124  ///
125  bool isOne() const;
126 
127  /// Return true if the expression is a constant all-ones value.
128  ///
129  bool isAllOnesValue() const;
130 
131  /// Return true if the specified scev is negated, but not a constant.
132  bool isNonConstantNegative() const;
133 
134  /// Print out the internal representation of this scalar to the specified
135  /// stream. This should really only be used for debugging purposes.
136  void print(raw_ostream &OS) const;
137 
138  /// This method is used for debugging.
139  ///
140  void dump() const;
141 };
142 
143 // Specialize FoldingSetTrait for SCEV to avoid needing to compute
144 // temporary FoldingSetNodeID values.
145 template <> struct FoldingSetTrait<SCEV> : DefaultFoldingSetTrait<SCEV> {
146  static void Profile(const SCEV &X, FoldingSetNodeID &ID) { ID = X.FastID; }
147  static bool Equals(const SCEV &X, const FoldingSetNodeID &ID, unsigned IDHash,
148  FoldingSetNodeID &TempID) {
149  return ID == X.FastID;
150  }
151  static unsigned ComputeHash(const SCEV &X, FoldingSetNodeID &TempID) {
152  return X.FastID.ComputeHash();
153  }
154 };
155 
156 inline raw_ostream &operator<<(raw_ostream &OS, const SCEV &S) {
157  S.print(OS);
158  return OS;
159 }
160 
161 /// An object of this class is returned by queries that could not be answered.
162 /// For example, if you ask for the number of iterations of a linked-list
163 /// traversal loop, you will get one of these. None of the standard SCEV
164 /// operations are valid on this class, it is just a marker.
165 struct SCEVCouldNotCompute : public SCEV {
167 
168  /// Methods for support type inquiry through isa, cast, and dyn_cast:
169  static bool classof(const SCEV *S);
170 };
171 
172 /// This class represents an assumption made using SCEV expressions which can
173 /// be checked at run-time.
176 
177  /// A reference to an Interned FoldingSetNodeID for this node. The
178  /// ScalarEvolution's BumpPtrAllocator holds the data.
179  FoldingSetNodeIDRef FastID;
180 
181 public:
183 
184 protected:
186  ~SCEVPredicate() = default;
187  SCEVPredicate(const SCEVPredicate &) = default;
188  SCEVPredicate &operator=(const SCEVPredicate &) = default;
189 
190 public:
192 
193  SCEVPredicateKind getKind() const { return Kind; }
194 
195  /// Returns the estimated complexity of this predicate. This is roughly
196  /// measured in the number of run-time checks required.
197  virtual unsigned getComplexity() const { return 1; }
198 
199  /// Returns true if the predicate is always true. This means that no
200  /// assumptions were made and nothing needs to be checked at run-time.
201  virtual bool isAlwaysTrue() const = 0;
202 
203  /// Returns true if this predicate implies \p N.
204  virtual bool implies(const SCEVPredicate *N) const = 0;
205 
206  /// Prints a textual representation of this predicate with an indentation of
207  /// \p Depth.
208  virtual void print(raw_ostream &OS, unsigned Depth = 0) const = 0;
209 
210  /// Returns the SCEV to which this predicate applies, or nullptr if this is
211  /// a SCEVUnionPredicate.
212  virtual const SCEV *getExpr() const = 0;
213 };
214 
216  P.print(OS);
217  return OS;
218 }
219 
220 // Specialize FoldingSetTrait for SCEVPredicate to avoid needing to compute
221 // temporary FoldingSetNodeID values.
222 template <>
224 
225  static void Profile(const SCEVPredicate &X, FoldingSetNodeID &ID) {
226  ID = X.FastID;
227  }
228 
229  static bool Equals(const SCEVPredicate &X, const FoldingSetNodeID &ID,
230  unsigned IDHash, FoldingSetNodeID &TempID) {
231  return ID == X.FastID;
232  }
233  static unsigned ComputeHash(const SCEVPredicate &X,
234  FoldingSetNodeID &TempID) {
235  return X.FastID.ComputeHash();
236  }
237 };
238 
239 /// This class represents an assumption that two SCEV expressions are equal,
240 /// and this can be checked at run-time. We assume that the left hand side is
241 /// a SCEVUnknown and the right hand side a constant.
242 class SCEVEqualPredicate final : public SCEVPredicate {
243  /// We assume that LHS == RHS, where LHS is a SCEVUnknown and RHS a
244  /// constant.
245  const SCEVUnknown *LHS;
246  const SCEVConstant *RHS;
247 
248 public:
250  const SCEVConstant *RHS);
251 
252  /// Implementation of the SCEVPredicate interface
253  bool implies(const SCEVPredicate *N) const override;
254  void print(raw_ostream &OS, unsigned Depth = 0) const override;
255  bool isAlwaysTrue() const override;
256  const SCEV *getExpr() const override;
257 
258  /// Returns the left hand side of the equality.
259  const SCEVUnknown *getLHS() const { return LHS; }
260 
261  /// Returns the right hand side of the equality.
262  const SCEVConstant *getRHS() const { return RHS; }
263 
264  /// Methods for support type inquiry through isa, cast, and dyn_cast:
265  static inline bool classof(const SCEVPredicate *P) {
266  return P->getKind() == P_Equal;
267  }
268 };
269 
270 /// This class represents an assumption made on an AddRec expression. Given an
271 /// affine AddRec expression {a,+,b}, we assume that it has the nssw or nusw
272 /// flags (defined below) in the first X iterations of the loop, where X is a
273 /// SCEV expression returned by getPredicatedBackedgeTakenCount).
274 ///
275 /// Note that this does not imply that X is equal to the backedge taken
276 /// count. This means that if we have a nusw predicate for i32 {0,+,1} with a
277 /// predicated backedge taken count of X, we only guarantee that {0,+,1} has
278 /// nusw in the first X iterations. {0,+,1} may still wrap in the loop if we
279 /// have more than X iterations.
280 class SCEVWrapPredicate final : public SCEVPredicate {
281 public:
282  /// Similar to SCEV::NoWrapFlags, but with slightly different semantics
283  /// for FlagNUSW. The increment is considered to be signed, and a + b
284  /// (where b is the increment) is considered to wrap if:
285  /// zext(a + b) != zext(a) + sext(b)
286  ///
287  /// If Signed is a function that takes an n-bit tuple and maps to the
288  /// integer domain as the tuples value interpreted as twos complement,
289  /// and Unsigned a function that takes an n-bit tuple and maps to the
290  /// integer domain as as the base two value of input tuple, then a + b
291  /// has IncrementNUSW iff:
292  ///
293  /// 0 <= Unsigned(a) + Signed(b) < 2^n
294  ///
295  /// The IncrementNSSW flag has identical semantics with SCEV::FlagNSW.
296  ///
297  /// Note that the IncrementNUSW flag is not commutative: if base + inc
298  /// has IncrementNUSW, then inc + base doesn't neccessarily have this
299  /// property. The reason for this is that this is used for sign/zero
300  /// extending affine AddRec SCEV expressions when a SCEVWrapPredicate is
301  /// assumed. A {base,+,inc} expression is already non-commutative with
302  /// regards to base and inc, since it is interpreted as:
303  /// (((base + inc) + inc) + inc) ...
305  IncrementAnyWrap = 0, // No guarantee.
306  IncrementNUSW = (1 << 0), // No unsigned with signed increment wrap.
307  IncrementNSSW = (1 << 1), // No signed with signed increment wrap
308  // (equivalent with SCEV::NSW)
309  IncrementNoWrapMask = (1 << 2) - 1
310  };
311 
312  /// Convenient IncrementWrapFlags manipulation methods.
316  assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
317  assert((OffFlags & IncrementNoWrapMask) == OffFlags &&
318  "Invalid flags value!");
319  return (SCEVWrapPredicate::IncrementWrapFlags)(Flags & ~OffFlags);
320  }
321 
324  assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
325  assert((Mask & IncrementNoWrapMask) == Mask && "Invalid mask value!");
326 
328  }
329 
333  assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
334  assert((OnFlags & IncrementNoWrapMask) == OnFlags &&
335  "Invalid flags value!");
336 
337  return (SCEVWrapPredicate::IncrementWrapFlags)(Flags | OnFlags);
338  }
339 
340  /// Returns the set of SCEVWrapPredicate no wrap flags implied by a
341  /// SCEVAddRecExpr.
344 
345 private:
346  const SCEVAddRecExpr *AR;
347  IncrementWrapFlags Flags;
348 
349 public:
351  const SCEVAddRecExpr *AR,
352  IncrementWrapFlags Flags);
353 
354  /// Returns the set assumed no overflow flags.
355  IncrementWrapFlags getFlags() const { return Flags; }
356  /// Implementation of the SCEVPredicate interface
357  const SCEV *getExpr() const override;
358  bool implies(const SCEVPredicate *N) const override;
359  void print(raw_ostream &OS, unsigned Depth = 0) const override;
360  bool isAlwaysTrue() const override;
361 
362  /// Methods for support type inquiry through isa, cast, and dyn_cast:
363  static inline bool classof(const SCEVPredicate *P) {
364  return P->getKind() == P_Wrap;
365  }
366 };
367 
368 /// This class represents a composition of other SCEV predicates, and is the
369 /// class that most clients will interact with. This is equivalent to a
370 /// logical "AND" of all the predicates in the union.
371 ///
372 /// NB! Unlike other SCEVPredicate sub-classes this class does not live in the
373 /// ScalarEvolution::Preds folding set. This is why the \c add function is sound.
374 class SCEVUnionPredicate final : public SCEVPredicate {
375 private:
377  PredicateMap;
378 
379  /// Vector with references to all predicates in this union.
381  /// Maps SCEVs to predicates for quick look-ups.
382  PredicateMap SCEVToPreds;
383 
384 public:
386 
388  return Preds;
389  }
390 
391  /// Adds a predicate to this union.
392  void add(const SCEVPredicate *N);
393 
394  /// Returns a reference to a vector containing all predicates which apply to
395  /// \p Expr.
396  ArrayRef<const SCEVPredicate *> getPredicatesForExpr(const SCEV *Expr);
397 
398  /// Implementation of the SCEVPredicate interface
399  bool isAlwaysTrue() const override;
400  bool implies(const SCEVPredicate *N) const override;
401  void print(raw_ostream &OS, unsigned Depth) const override;
402  const SCEV *getExpr() const override;
403 
404  /// We estimate the complexity of a union predicate as the size number of
405  /// predicates in the union.
406  unsigned getComplexity() const override { return Preds.size(); }
407 
408  /// Methods for support type inquiry through isa, cast, and dyn_cast:
409  static inline bool classof(const SCEVPredicate *P) {
410  return P->getKind() == P_Union;
411  }
412 };
413 
414 /// The main scalar evolution driver. Because client code (intentionally)
415 /// can't do much with the SCEV objects directly, they must ask this class
416 /// for services.
418 public:
419  /// An enum describing the relationship between a SCEV and a loop.
421  LoopVariant, ///< The SCEV is loop-variant (unknown).
422  LoopInvariant, ///< The SCEV is loop-invariant.
423  LoopComputable ///< The SCEV varies predictably with the loop.
424  };
425 
426  /// An enum describing the relationship between a SCEV and a basic block.
428  DoesNotDominateBlock, ///< The SCEV does not dominate the block.
429  DominatesBlock, ///< The SCEV dominates the block.
430  ProperlyDominatesBlock ///< The SCEV properly dominates the block.
431  };
432 
433  /// Convenient NoWrapFlags manipulation that hides enum casts and is
434  /// visible in the ScalarEvolution name space.
436  int Mask) {
437  return (SCEV::NoWrapFlags)(Flags & Mask);
438  }
440  SCEV::NoWrapFlags OnFlags) {
441  return (SCEV::NoWrapFlags)(Flags | OnFlags);
442  }
445  return (SCEV::NoWrapFlags)(Flags & ~OffFlags);
446  }
447 
448 private:
449  /// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
450  /// Value is deleted.
451  class SCEVCallbackVH final : public CallbackVH {
452  ScalarEvolution *SE;
453  void deleted() override;
454  void allUsesReplacedWith(Value *New) override;
455 
456  public:
457  SCEVCallbackVH(Value *V, ScalarEvolution *SE = nullptr);
458  };
459 
460  friend class SCEVCallbackVH;
461  friend class SCEVExpander;
462  friend class SCEVUnknown;
463 
464  /// The function we are analyzing.
465  ///
466  Function &F;
467 
468  /// Does the module have any calls to the llvm.experimental.guard intrinsic
469  /// at all? If this is false, we avoid doing work that will only help if
470  /// thare are guards present in the IR.
471  ///
472  bool HasGuards;
473 
474  /// The target library information for the target we are targeting.
475  ///
476  TargetLibraryInfo &TLI;
477 
478  /// The tracker for @llvm.assume intrinsics in this function.
479  AssumptionCache &AC;
480 
481  /// The dominator tree.
482  ///
483  DominatorTree &DT;
484 
485  /// The loop information for the function we are currently analyzing.
486  ///
487  LoopInfo &LI;
488 
489  /// This SCEV is used to represent unknown trip counts and things.
490  std::unique_ptr<SCEVCouldNotCompute> CouldNotCompute;
491 
492  /// The typedef for HasRecMap.
493  ///
495 
496  /// This is a cache to record whether a SCEV contains any scAddRecExpr.
497  HasRecMapType HasRecMap;
498 
499  /// The typedef for ExprValueMap.
500  ///
501  typedef std::pair<Value *, ConstantInt *> ValueOffsetPair;
503 
504  /// ExprValueMap -- This map records the original values from which
505  /// the SCEV expr is generated from.
506  ///
507  /// We want to represent the mapping as SCEV -> ValueOffsetPair instead
508  /// of SCEV -> Value:
509  /// Suppose we know S1 expands to V1, and
510  /// S1 = S2 + C_a
511  /// S3 = S2 + C_b
512  /// where C_a and C_b are different SCEVConstants. Then we'd like to
513  /// expand S3 as V1 - C_a + C_b instead of expanding S2 literally.
514  /// It is helpful when S2 is a complex SCEV expr.
515  ///
516  /// In order to do that, we represent ExprValueMap as a mapping from
517  /// SCEV to ValueOffsetPair. We will save both S1->{V1, 0} and
518  /// S2->{V1, C_a} into the map when we create SCEV for V1. When S3
519  /// is expanded, it will first expand S2 to V1 - C_a because of
520  /// S2->{V1, C_a} in the map, then expand S3 to V1 - C_a + C_b.
521  ///
522  /// Note: S->{V, Offset} in the ExprValueMap means S can be expanded
523  /// to V - Offset.
524  ExprValueMapType ExprValueMap;
525 
526  /// The typedef for ValueExprMap.
527  ///
530 
531  /// This is a cache of the values we have analyzed so far.
532  ///
533  ValueExprMapType ValueExprMap;
534 
535  /// Mark predicate values currently being processed by isImpliedCond.
536  SmallPtrSet<Value *, 6> PendingLoopPredicates;
537 
538  /// Set to true by isLoopBackedgeGuardedByCond when we're walking the set of
539  /// conditions dominating the backedge of a loop.
540  bool WalkingBEDominatingConds;
541 
542  /// Set to true by isKnownPredicateViaSplitting when we're trying to prove a
543  /// predicate by splitting it into a set of independent predicates.
544  bool ProvingSplitPredicate;
545 
546  /// Information about the number of loop iterations for which a loop exit's
547  /// branch condition evaluates to the not-taken path. This is a temporary
548  /// pair of exact and max expressions that are eventually summarized in
549  /// ExitNotTakenInfo and BackedgeTakenInfo.
550  struct ExitLimit {
551  const SCEV *ExactNotTaken; // The exit is not taken exactly this many times
552  const SCEV *MaxNotTaken; // The exit is not taken at most this many times
553  bool MaxOrZero; // Not taken either exactly MaxNotTaken or zero times
554 
555  /// A set of predicate guards for this ExitLimit. The result is only valid
556  /// if all of the predicates in \c Predicates evaluate to 'true' at
557  /// run-time.
559 
560  void addPredicate(const SCEVPredicate *P) {
561  assert(!isa<SCEVUnionPredicate>(P) && "Only add leaf predicates here!");
562  Predicates.insert(P);
563  }
564 
565  /*implicit*/ ExitLimit(const SCEV *E)
566  : ExactNotTaken(E), MaxNotTaken(E), MaxOrZero(false) {}
567 
568  ExitLimit(
569  const SCEV *E, const SCEV *M, bool MaxOrZero,
570  ArrayRef<const SmallPtrSetImpl<const SCEVPredicate *> *> PredSetList)
571  : ExactNotTaken(E), MaxNotTaken(M), MaxOrZero(MaxOrZero) {
572  assert((isa<SCEVCouldNotCompute>(ExactNotTaken) ||
573  !isa<SCEVCouldNotCompute>(MaxNotTaken)) &&
574  "Exact is not allowed to be less precise than Max");
575  for (auto *PredSet : PredSetList)
576  for (auto *P : *PredSet)
577  addPredicate(P);
578  }
579 
580  ExitLimit(const SCEV *E, const SCEV *M, bool MaxOrZero,
581  const SmallPtrSetImpl<const SCEVPredicate *> &PredSet)
582  : ExitLimit(E, M, MaxOrZero, {&PredSet}) {}
583 
584  ExitLimit(const SCEV *E, const SCEV *M, bool MaxOrZero)
585  : ExitLimit(E, M, MaxOrZero, None) {}
586 
587  /// Test whether this ExitLimit contains any computed information, or
588  /// whether it's all SCEVCouldNotCompute values.
589  bool hasAnyInfo() const {
590  return !isa<SCEVCouldNotCompute>(ExactNotTaken) ||
591  !isa<SCEVCouldNotCompute>(MaxNotTaken);
592  }
593 
594  /// Test whether this ExitLimit contains all information.
595  bool hasFullInfo() const {
596  return !isa<SCEVCouldNotCompute>(ExactNotTaken);
597  }
598  };
599 
600  /// Information about the number of times a particular loop exit may be
601  /// reached before exiting the loop.
602  struct ExitNotTakenInfo {
603  AssertingVH<BasicBlock> ExitingBlock;
604  const SCEV *ExactNotTaken;
605  std::unique_ptr<SCEVUnionPredicate> Predicate;
606  bool hasAlwaysTruePredicate() const {
607  return !Predicate || Predicate->isAlwaysTrue();
608  }
609 
610  explicit ExitNotTakenInfo(AssertingVH<BasicBlock> ExitingBlock,
611  const SCEV *ExactNotTaken,
612  std::unique_ptr<SCEVUnionPredicate> Predicate)
613  : ExitingBlock(ExitingBlock), ExactNotTaken(ExactNotTaken),
614  Predicate(std::move(Predicate)) {}
615  };
616 
617  /// Information about the backedge-taken count of a loop. This currently
618  /// includes an exact count and a maximum count.
619  ///
620  class BackedgeTakenInfo {
621  /// A list of computable exits and their not-taken counts. Loops almost
622  /// never have more than one computable exit.
623  SmallVector<ExitNotTakenInfo, 1> ExitNotTaken;
624 
625  /// The pointer part of \c MaxAndComplete is an expression indicating the
626  /// least maximum backedge-taken count of the loop that is known, or a
627  /// SCEVCouldNotCompute. This expression is only valid if the predicates
628  /// associated with all loop exits are true.
629  ///
630  /// The integer part of \c MaxAndComplete is a boolean indicating if \c
631  /// ExitNotTaken has an element for every exiting block in the loop.
632  PointerIntPair<const SCEV *, 1> MaxAndComplete;
633 
634  /// True iff the backedge is taken either exactly Max or zero times.
635  bool MaxOrZero;
636 
637  /// \name Helper projection functions on \c MaxAndComplete.
638  /// @{
639  bool isComplete() const { return MaxAndComplete.getInt(); }
640  const SCEV *getMax() const { return MaxAndComplete.getPointer(); }
641  /// @}
642 
643  public:
644  BackedgeTakenInfo() : MaxAndComplete(nullptr, 0) {}
645 
646  BackedgeTakenInfo(BackedgeTakenInfo &&) = default;
647  BackedgeTakenInfo &operator=(BackedgeTakenInfo &&) = default;
648 
649  typedef std::pair<BasicBlock *, ExitLimit> EdgeExitInfo;
650 
651  /// Initialize BackedgeTakenInfo from a list of exact exit counts.
652  BackedgeTakenInfo(SmallVectorImpl<EdgeExitInfo> &&ExitCounts, bool Complete,
653  const SCEV *MaxCount, bool MaxOrZero);
654 
655  /// Test whether this BackedgeTakenInfo contains any computed information,
656  /// or whether it's all SCEVCouldNotCompute values.
657  bool hasAnyInfo() const {
658  return !ExitNotTaken.empty() || !isa<SCEVCouldNotCompute>(getMax());
659  }
660 
661  /// Test whether this BackedgeTakenInfo contains complete information.
662  bool hasFullInfo() const { return isComplete(); }
663 
664  /// Return an expression indicating the exact backedge-taken count of the
665  /// loop if it is known or SCEVCouldNotCompute otherwise. This is the
666  /// number of times the loop header can be guaranteed to execute, minus
667  /// one.
668  ///
669  /// If the SCEV predicate associated with the answer can be different
670  /// from AlwaysTrue, we must add a (non null) Predicates argument.
671  /// The SCEV predicate associated with the answer will be added to
672  /// Predicates. A run-time check needs to be emitted for the SCEV
673  /// predicate in order for the answer to be valid.
674  ///
675  /// Note that we should always know if we need to pass a predicate
676  /// argument or not from the way the ExitCounts vector was computed.
677  /// If we allowed SCEV predicates to be generated when populating this
678  /// vector, this information can contain them and therefore a
679  /// SCEVPredicate argument should be added to getExact.
680  const SCEV *getExact(ScalarEvolution *SE,
681  SCEVUnionPredicate *Predicates = nullptr) const;
682 
683  /// Return the number of times this loop exit may fall through to the back
684  /// edge, or SCEVCouldNotCompute. The loop is guaranteed not to exit via
685  /// this block before this number of iterations, but may exit via another
686  /// block.
687  const SCEV *getExact(BasicBlock *ExitingBlock, ScalarEvolution *SE) const;
688 
689  /// Get the max backedge taken count for the loop.
690  const SCEV *getMax(ScalarEvolution *SE) const;
691 
692  /// Return true if the number of times this backedge is taken is either the
693  /// value returned by getMax or zero.
694  bool isMaxOrZero(ScalarEvolution *SE) const;
695 
696  /// Return true if any backedge taken count expressions refer to the given
697  /// subexpression.
698  bool hasOperand(const SCEV *S, ScalarEvolution *SE) const;
699 
700  /// Invalidate this result and free associated memory.
701  void clear();
702  };
703 
704  /// Cache the backedge-taken count of the loops for this function as they
705  /// are computed.
706  DenseMap<const Loop *, BackedgeTakenInfo> BackedgeTakenCounts;
707 
708  /// Cache the predicated backedge-taken count of the loops for this
709  /// function as they are computed.
710  DenseMap<const Loop *, BackedgeTakenInfo> PredicatedBackedgeTakenCounts;
711 
712  /// This map contains entries for all of the PHI instructions that we
713  /// attempt to compute constant evolutions for. This allows us to avoid
714  /// potentially expensive recomputation of these properties. An instruction
715  /// maps to null if we are unable to compute its exit value.
716  DenseMap<PHINode *, Constant *> ConstantEvolutionLoopExitValue;
717 
718  /// This map contains entries for all the expressions that we attempt to
719  /// compute getSCEVAtScope information for, which can be expensive in
720  /// extreme cases.
721  DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
722  ValuesAtScopes;
723 
724  /// Memoized computeLoopDisposition results.
725  DenseMap<const SCEV *,
726  SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>>
727  LoopDispositions;
728 
729  struct LoopProperties {
730  /// Set to true if the loop contains no instruction that can have side
731  /// effects (i.e. via throwing an exception, volatile or atomic access).
732  bool HasNoAbnormalExits;
733 
734  /// Set to true if the loop contains no instruction that can abnormally exit
735  /// the loop (i.e. via throwing an exception, by terminating the thread
736  /// cleanly or by infinite looping in a called function). Strictly
737  /// speaking, the last one is not leaving the loop, but is identical to
738  /// leaving the loop for reasoning about undefined behavior.
739  bool HasNoSideEffects;
740  };
741 
742  /// Cache for \c getLoopProperties.
743  DenseMap<const Loop *, LoopProperties> LoopPropertiesCache;
744 
745  /// Return a \c LoopProperties instance for \p L, creating one if necessary.
746  LoopProperties getLoopProperties(const Loop *L);
747 
748  bool loopHasNoSideEffects(const Loop *L) {
749  return getLoopProperties(L).HasNoSideEffects;
750  }
751 
752  bool loopHasNoAbnormalExits(const Loop *L) {
753  return getLoopProperties(L).HasNoAbnormalExits;
754  }
755 
756  /// Compute a LoopDisposition value.
757  LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L);
758 
759  /// Memoized computeBlockDisposition results.
760  DenseMap<
761  const SCEV *,
762  SmallVector<PointerIntPair<const BasicBlock *, 2, BlockDisposition>, 2>>
763  BlockDispositions;
764 
765  /// Compute a BlockDisposition value.
766  BlockDisposition computeBlockDisposition(const SCEV *S, const BasicBlock *BB);
767 
768  /// Memoized results from getRange
769  DenseMap<const SCEV *, ConstantRange> UnsignedRanges;
770 
771  /// Memoized results from getRange
772  DenseMap<const SCEV *, ConstantRange> SignedRanges;
773 
774  /// Used to parameterize getRange
775  enum RangeSignHint { HINT_RANGE_UNSIGNED, HINT_RANGE_SIGNED };
776 
777  /// Set the memoized range for the given SCEV.
778  const ConstantRange &setRange(const SCEV *S, RangeSignHint Hint,
779  const ConstantRange &CR) {
780  DenseMap<const SCEV *, ConstantRange> &Cache =
781  Hint == HINT_RANGE_UNSIGNED ? UnsignedRanges : SignedRanges;
782 
783  auto Pair = Cache.insert({S, CR});
784  if (!Pair.second)
785  Pair.first->second = CR;
786  return Pair.first->second;
787  }
788 
789  /// Determine the range for a particular SCEV.
790  ConstantRange getRange(const SCEV *S, RangeSignHint Hint);
791 
792  /// Determines the range for the affine SCEVAddRecExpr {\p Start,+,\p Stop}.
793  /// Helper for \c getRange.
794  ConstantRange getRangeForAffineAR(const SCEV *Start, const SCEV *Stop,
795  const SCEV *MaxBECount, unsigned BitWidth);
796 
797  /// Try to compute a range for the affine SCEVAddRecExpr {\p Start,+,\p
798  /// Stop} by "factoring out" a ternary expression from the add recurrence.
799  /// Helper called by \c getRange.
800  ConstantRange getRangeViaFactoring(const SCEV *Start, const SCEV *Stop,
801  const SCEV *MaxBECount, unsigned BitWidth);
802 
803  /// We know that there is no SCEV for the specified value. Analyze the
804  /// expression.
805  const SCEV *createSCEV(Value *V);
806 
807  /// Provide the special handling we need to analyze PHI SCEVs.
808  const SCEV *createNodeForPHI(PHINode *PN);
809 
810  /// Helper function called from createNodeForPHI.
811  const SCEV *createAddRecFromPHI(PHINode *PN);
812 
813  /// Helper function called from createNodeForPHI.
814  const SCEV *createNodeFromSelectLikePHI(PHINode *PN);
815 
816  /// Provide special handling for a select-like instruction (currently this
817  /// is either a select instruction or a phi node). \p I is the instruction
818  /// being processed, and it is assumed equivalent to "Cond ? TrueVal :
819  /// FalseVal".
820  const SCEV *createNodeForSelectOrPHI(Instruction *I, Value *Cond,
821  Value *TrueVal, Value *FalseVal);
822 
823  /// Provide the special handling we need to analyze GEP SCEVs.
824  const SCEV *createNodeForGEP(GEPOperator *GEP);
825 
826  /// Implementation code for getSCEVAtScope; called at most once for each
827  /// SCEV+Loop pair.
828  ///
829  const SCEV *computeSCEVAtScope(const SCEV *S, const Loop *L);
830 
831  /// This looks up computed SCEV values for all instructions that depend on
832  /// the given instruction and removes them from the ValueExprMap map if they
833  /// reference SymName. This is used during PHI resolution.
834  void forgetSymbolicName(Instruction *I, const SCEV *SymName);
835 
836  /// Return the BackedgeTakenInfo for the given loop, lazily computing new
837  /// values if the loop hasn't been analyzed yet. The returned result is
838  /// guaranteed not to be predicated.
839  const BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L);
840 
841  /// Similar to getBackedgeTakenInfo, but will add predicates as required
842  /// with the purpose of returning complete information.
843  const BackedgeTakenInfo &getPredicatedBackedgeTakenInfo(const Loop *L);
844 
845  /// Compute the number of times the specified loop will iterate.
846  /// If AllowPredicates is set, we will create new SCEV predicates as
847  /// necessary in order to return an exact answer.
848  BackedgeTakenInfo computeBackedgeTakenCount(const Loop *L,
849  bool AllowPredicates = false);
850 
851  /// Compute the number of times the backedge of the specified loop will
852  /// execute if it exits via the specified block. If AllowPredicates is set,
853  /// this call will try to use a minimal set of SCEV predicates in order to
854  /// return an exact answer.
855  ExitLimit computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
856  bool AllowPredicates = false);
857 
858  /// Compute the number of times the backedge of the specified loop will
859  /// execute if its exit condition were a conditional branch of ExitCond,
860  /// TBB, and FBB.
861  ///
862  /// \p ControlsExit is true if ExitCond directly controls the exit
863  /// branch. In this case, we can assume that the loop exits only if the
864  /// condition is true and can infer that failing to meet the condition prior
865  /// to integer wraparound results in undefined behavior.
866  ///
867  /// If \p AllowPredicates is set, this call will try to use a minimal set of
868  /// SCEV predicates in order to return an exact answer.
869  ExitLimit computeExitLimitFromCond(const Loop *L, Value *ExitCond,
870  BasicBlock *TBB, BasicBlock *FBB,
871  bool ControlsExit,
872  bool AllowPredicates = false);
873 
874  /// Compute the number of times the backedge of the specified loop will
875  /// execute if its exit condition were a conditional branch of the ICmpInst
876  /// ExitCond, TBB, and FBB. If AllowPredicates is set, this call will try
877  /// to use a minimal set of SCEV predicates in order to return an exact
878  /// answer.
879  ExitLimit computeExitLimitFromICmp(const Loop *L, ICmpInst *ExitCond,
880  BasicBlock *TBB, BasicBlock *FBB,
881  bool IsSubExpr,
882  bool AllowPredicates = false);
883 
884  /// Compute the number of times the backedge of the specified loop will
885  /// execute if its exit condition were a switch with a single exiting case
886  /// to ExitingBB.
887  ExitLimit computeExitLimitFromSingleExitSwitch(const Loop *L,
888  SwitchInst *Switch,
889  BasicBlock *ExitingBB,
890  bool IsSubExpr);
891 
892  /// Given an exit condition of 'icmp op load X, cst', try to see if we can
893  /// compute the backedge-taken count.
894  ExitLimit computeLoadConstantCompareExitLimit(LoadInst *LI, Constant *RHS,
895  const Loop *L,
897 
898  /// Compute the exit limit of a loop that is controlled by a
899  /// "(IV >> 1) != 0" type comparison. We cannot compute the exact trip
900  /// count in these cases (since SCEV has no way of expressing them), but we
901  /// can still sometimes compute an upper bound.
902  ///
903  /// Return an ExitLimit for a loop whose backedge is guarded by `LHS Pred
904  /// RHS`.
905  ExitLimit computeShiftCompareExitLimit(Value *LHS, Value *RHS, const Loop *L,
906  ICmpInst::Predicate Pred);
907 
908  /// If the loop is known to execute a constant number of times (the
909  /// condition evolves only from constants), try to evaluate a few iterations
910  /// of the loop until we get the exit condition gets a value of ExitWhen
911  /// (true or false). If we cannot evaluate the exit count of the loop,
912  /// return CouldNotCompute.
913  const SCEV *computeExitCountExhaustively(const Loop *L, Value *Cond,
914  bool ExitWhen);
915 
916  /// Return the number of times an exit condition comparing the specified
917  /// value to zero will execute. If not computable, return CouldNotCompute.
918  /// If AllowPredicates is set, this call will try to use a minimal set of
919  /// SCEV predicates in order to return an exact answer.
920  ExitLimit howFarToZero(const SCEV *V, const Loop *L, bool IsSubExpr,
921  bool AllowPredicates = false);
922 
923  /// Return the number of times an exit condition checking the specified
924  /// value for nonzero will execute. If not computable, return
925  /// CouldNotCompute.
926  ExitLimit howFarToNonZero(const SCEV *V, const Loop *L);
927 
928  /// Return the number of times an exit condition containing the specified
929  /// less-than comparison will execute. If not computable, return
930  /// CouldNotCompute.
931  ///
932  /// \p isSigned specifies whether the less-than is signed.
933  ///
934  /// \p ControlsExit is true when the LHS < RHS condition directly controls
935  /// the branch (loops exits only if condition is true). In this case, we can
936  /// use NoWrapFlags to skip overflow checks.
937  ///
938  /// If \p AllowPredicates is set, this call will try to use a minimal set of
939  /// SCEV predicates in order to return an exact answer.
940  ExitLimit howManyLessThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
941  bool isSigned, bool ControlsExit,
942  bool AllowPredicates = false);
943 
944  ExitLimit howManyGreaterThans(const SCEV *LHS, const SCEV *RHS, const Loop *L,
945  bool isSigned, bool IsSubExpr,
946  bool AllowPredicates = false);
947 
948  /// Return a predecessor of BB (which may not be an immediate predecessor)
949  /// which has exactly one successor from which BB is reachable, or null if
950  /// no such block is found.
951  std::pair<BasicBlock *, BasicBlock *>
952  getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB);
953 
954  /// Test whether the condition described by Pred, LHS, and RHS is true
955  /// whenever the given FoundCondValue value evaluates to true.
956  bool isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
957  Value *FoundCondValue, bool Inverse);
958 
959  /// Test whether the condition described by Pred, LHS, and RHS is true
960  /// whenever the condition described by FoundPred, FoundLHS, FoundRHS is
961  /// true.
962  bool isImpliedCond(ICmpInst::Predicate Pred, const SCEV *LHS, const SCEV *RHS,
963  ICmpInst::Predicate FoundPred, const SCEV *FoundLHS,
964  const SCEV *FoundRHS);
965 
966  /// Test whether the condition described by Pred, LHS, and RHS is true
967  /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
968  /// true.
969  bool isImpliedCondOperands(ICmpInst::Predicate Pred, const SCEV *LHS,
970  const SCEV *RHS, const SCEV *FoundLHS,
971  const SCEV *FoundRHS);
972 
973  /// Test whether the condition described by Pred, LHS, and RHS is true
974  /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
975  /// true.
976  bool isImpliedCondOperandsHelper(ICmpInst::Predicate Pred, const SCEV *LHS,
977  const SCEV *RHS, const SCEV *FoundLHS,
978  const SCEV *FoundRHS);
979 
980  /// Test whether the condition described by Pred, LHS, and RHS is true
981  /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
982  /// true. Utility function used by isImpliedCondOperands. Tries to get
983  /// cases like "X `sgt` 0 => X - 1 `sgt` -1".
984  bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred, const SCEV *LHS,
985  const SCEV *RHS, const SCEV *FoundLHS,
986  const SCEV *FoundRHS);
987 
988  /// Return true if the condition denoted by \p LHS \p Pred \p RHS is implied
989  /// by a call to \c @llvm.experimental.guard in \p BB.
990  bool isImpliedViaGuard(BasicBlock *BB, ICmpInst::Predicate Pred,
991  const SCEV *LHS, const SCEV *RHS);
992 
993  /// Test whether the condition described by Pred, LHS, and RHS is true
994  /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
995  /// true.
996  ///
997  /// This routine tries to rule out certain kinds of integer overflow, and
998  /// then tries to reason about arithmetic properties of the predicates.
999  bool isImpliedCondOperandsViaNoOverflow(ICmpInst::Predicate Pred,
1000  const SCEV *LHS, const SCEV *RHS,
1001  const SCEV *FoundLHS,
1002  const SCEV *FoundRHS);
1003 
1004  /// If we know that the specified Phi is in the header of its containing
1005  /// loop, we know the loop executes a constant number of times, and the PHI
1006  /// node is just a recurrence involving constants, fold it.
1007  Constant *getConstantEvolutionLoopExitValue(PHINode *PN, const APInt &BEs,
1008  const Loop *L);
1009 
1010  /// Test if the given expression is known to satisfy the condition described
1011  /// by Pred and the known constant ranges of LHS and RHS.
1012  ///
1013  bool isKnownPredicateViaConstantRanges(ICmpInst::Predicate Pred,
1014  const SCEV *LHS, const SCEV *RHS);
1015 
1016  /// Try to prove the condition described by "LHS Pred RHS" by ruling out
1017  /// integer overflow.
1018  ///
1019  /// For instance, this will return true for "A s< (A + C)<nsw>" if C is
1020  /// positive.
1021  bool isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred, const SCEV *LHS,
1022  const SCEV *RHS);
1023 
1024  /// Try to split Pred LHS RHS into logical conjunctions (and's) and try to
1025  /// prove them individually.
1026  bool isKnownPredicateViaSplitting(ICmpInst::Predicate Pred, const SCEV *LHS,
1027  const SCEV *RHS);
1028 
1029  /// Try to match the Expr as "(L + R)<Flags>".
1030  bool splitBinaryAdd(const SCEV *Expr, const SCEV *&L, const SCEV *&R,
1031  SCEV::NoWrapFlags &Flags);
1032 
1033  /// Compute \p LHS - \p RHS and returns the result as an APInt if it is a
1034  /// constant, and None if it isn't.
1035  ///
1036  /// This is intended to be a cheaper version of getMinusSCEV. We can be
1037  /// frugal here since we just bail out of actually constructing and
1038  /// canonicalizing an expression in the cases where the result isn't going
1039  /// to be a constant.
1040  Optional<APInt> computeConstantDifference(const SCEV *LHS, const SCEV *RHS);
1041 
1042  /// Drop memoized information computed for S.
1043  void forgetMemoizedResults(const SCEV *S);
1044 
1045  /// Return an existing SCEV for V if there is one, otherwise return nullptr.
1046  const SCEV *getExistingSCEV(Value *V);
1047 
1048  /// Return false iff given SCEV contains a SCEVUnknown with NULL value-
1049  /// pointer.
1050  bool checkValidity(const SCEV *S) const;
1051 
1052  /// Return true if `ExtendOpTy`({`Start`,+,`Step`}) can be proved to be
1053  /// equal to {`ExtendOpTy`(`Start`),+,`ExtendOpTy`(`Step`)}. This is
1054  /// equivalent to proving no signed (resp. unsigned) wrap in
1055  /// {`Start`,+,`Step`} if `ExtendOpTy` is `SCEVSignExtendExpr`
1056  /// (resp. `SCEVZeroExtendExpr`).
1057  ///
1058  template <typename ExtendOpTy>
1059  bool proveNoWrapByVaryingStart(const SCEV *Start, const SCEV *Step,
1060  const Loop *L);
1061 
1062  /// Try to prove NSW or NUW on \p AR relying on ConstantRange manipulation.
1063  SCEV::NoWrapFlags proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR);
1064 
1065  bool isMonotonicPredicateImpl(const SCEVAddRecExpr *LHS,
1066  ICmpInst::Predicate Pred, bool &Increasing);
1067 
1068  /// Return true if, for all loop invariant X, the predicate "LHS `Pred` X"
1069  /// is monotonically increasing or decreasing. In the former case set
1070  /// `Increasing` to true and in the latter case set `Increasing` to false.
1071  ///
1072  /// A predicate is said to be monotonically increasing if may go from being
1073  /// false to being true as the loop iterates, but never the other way
1074  /// around. A predicate is said to be monotonically decreasing if may go
1075  /// from being true to being false as the loop iterates, but never the other
1076  /// way around.
1077  bool isMonotonicPredicate(const SCEVAddRecExpr *LHS, ICmpInst::Predicate Pred,
1078  bool &Increasing);
1079 
1080  /// Return SCEV no-wrap flags that can be proven based on reasoning about
1081  /// how poison produced from no-wrap flags on this value (e.g. a nuw add)
1082  /// would trigger undefined behavior on overflow.
1083  SCEV::NoWrapFlags getNoWrapFlagsFromUB(const Value *V);
1084 
1085  /// Return true if the SCEV corresponding to \p I is never poison. Proving
1086  /// this is more complex than proving that just \p I is never poison, since
1087  /// SCEV commons expressions across control flow, and you can have cases
1088  /// like:
1089  ///
1090  /// idx0 = a + b;
1091  /// ptr[idx0] = 100;
1092  /// if (<condition>) {
1093  /// idx1 = a +nsw b;
1094  /// ptr[idx1] = 200;
1095  /// }
1096  ///
1097  /// where the SCEV expression (+ a b) is guaranteed to not be poison (and
1098  /// hence not sign-overflow) only if "<condition>" is true. Since both
1099  /// `idx0` and `idx1` will be mapped to the same SCEV expression, (+ a b),
1100  /// it is not okay to annotate (+ a b) with <nsw> in the above example.
1101  bool isSCEVExprNeverPoison(const Instruction *I);
1102 
1103  /// This is like \c isSCEVExprNeverPoison but it specifically works for
1104  /// instructions that will get mapped to SCEV add recurrences. Return true
1105  /// if \p I will never generate poison under the assumption that \p I is an
1106  /// add recurrence on the loop \p L.
1107  bool isAddRecNeverPoison(const Instruction *I, const Loop *L);
1108 
1109 public:
1110  ScalarEvolution(Function &F, TargetLibraryInfo &TLI, AssumptionCache &AC,
1111  DominatorTree &DT, LoopInfo &LI);
1112  ~ScalarEvolution();
1113  ScalarEvolution(ScalarEvolution &&Arg);
1114 
1115  LLVMContext &getContext() const { return F.getContext(); }
1116 
1117  /// Test if values of the given type are analyzable within the SCEV
1118  /// framework. This primarily includes integer types, and it can optionally
1119  /// include pointer types if the ScalarEvolution class has access to
1120  /// target-specific information.
1121  bool isSCEVable(Type *Ty) const;
1122 
1123  /// Return the size in bits of the specified type, for which isSCEVable must
1124  /// return true.
1125  uint64_t getTypeSizeInBits(Type *Ty) const;
1126 
1127  /// Return a type with the same bitwidth as the given type and which
1128  /// represents how SCEV will treat the given type, for which isSCEVable must
1129  /// return true. For pointer types, this is the pointer-sized integer type.
1130  Type *getEffectiveSCEVType(Type *Ty) const;
1131 
1132  /// Return true if the SCEV is a scAddRecExpr or it contains
1133  /// scAddRecExpr. The result will be cached in HasRecMap.
1134  ///
1135  bool containsAddRecurrence(const SCEV *S);
1136 
1137  /// Return the Value set from which the SCEV expr is generated.
1138  SetVector<ValueOffsetPair> *getSCEVValues(const SCEV *S);
1139 
1140  /// Erase Value from ValueExprMap and ExprValueMap.
1141  void eraseValueFromMap(Value *V);
1142 
1143  /// Return a SCEV expression for the full generality of the specified
1144  /// expression.
1145  const SCEV *getSCEV(Value *V);
1146 
1147  const SCEV *getConstant(ConstantInt *V);
1148  const SCEV *getConstant(const APInt &Val);
1149  const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
1150  const SCEV *getTruncateExpr(const SCEV *Op, Type *Ty);
1151  const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty);
1152  const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty);
1153  const SCEV *getAnyExtendExpr(const SCEV *Op, Type *Ty);
1154  const SCEV *getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
1156  const SCEV *getAddExpr(const SCEV *LHS, const SCEV *RHS,
1158  SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
1159  return getAddExpr(Ops, Flags);
1160  }
1161  const SCEV *getAddExpr(const SCEV *Op0, const SCEV *Op1, const SCEV *Op2,
1163  SmallVector<const SCEV *, 3> Ops = {Op0, Op1, Op2};
1164  return getAddExpr(Ops, Flags);
1165  }
1166  const SCEV *getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
1168  const SCEV *getMulExpr(const SCEV *LHS, const SCEV *RHS,
1170  SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
1171  return getMulExpr(Ops, Flags);
1172  }
1173  const SCEV *getMulExpr(const SCEV *Op0, const SCEV *Op1, const SCEV *Op2,
1175  SmallVector<const SCEV *, 3> Ops = {Op0, Op1, Op2};
1176  return getMulExpr(Ops, Flags);
1177  }
1178  const SCEV *getUDivExpr(const SCEV *LHS, const SCEV *RHS);
1179  const SCEV *getUDivExactExpr(const SCEV *LHS, const SCEV *RHS);
1180  const SCEV *getAddRecExpr(const SCEV *Start, const SCEV *Step, const Loop *L,
1181  SCEV::NoWrapFlags Flags);
1182  const SCEV *getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
1183  const Loop *L, SCEV::NoWrapFlags Flags);
1185  const Loop *L, SCEV::NoWrapFlags Flags) {
1186  SmallVector<const SCEV *, 4> NewOp(Operands.begin(), Operands.end());
1187  return getAddRecExpr(NewOp, L, Flags);
1188  }
1189  /// Returns an expression for a GEP
1190  ///
1191  /// \p GEP The GEP. The indices contained in the GEP itself are ignored,
1192  /// instead we use IndexExprs.
1193  /// \p IndexExprs The expressions for the indices.
1194  const SCEV *getGEPExpr(GEPOperator *GEP,
1195  const SmallVectorImpl<const SCEV *> &IndexExprs);
1196  const SCEV *getSMaxExpr(const SCEV *LHS, const SCEV *RHS);
1197  const SCEV *getSMaxExpr(SmallVectorImpl<const SCEV *> &Operands);
1198  const SCEV *getUMaxExpr(const SCEV *LHS, const SCEV *RHS);
1199  const SCEV *getUMaxExpr(SmallVectorImpl<const SCEV *> &Operands);
1200  const SCEV *getSMinExpr(const SCEV *LHS, const SCEV *RHS);
1201  const SCEV *getUMinExpr(const SCEV *LHS, const SCEV *RHS);
1202  const SCEV *getUnknown(Value *V);
1203  const SCEV *getCouldNotCompute();
1204 
1205  /// Return a SCEV for the constant 0 of a specific type.
1206  const SCEV *getZero(Type *Ty) { return getConstant(Ty, 0); }
1207 
1208  /// Return a SCEV for the constant 1 of a specific type.
1209  const SCEV *getOne(Type *Ty) { return getConstant(Ty, 1); }
1210 
1211  /// Return an expression for sizeof AllocTy that is type IntTy
1212  ///
1213  const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
1214 
1215  /// Return an expression for offsetof on the given field with type IntTy
1216  ///
1217  const SCEV *getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo);
1218 
1219  /// Return the SCEV object corresponding to -V.
1220  ///
1221  const SCEV *getNegativeSCEV(const SCEV *V,
1223 
1224  /// Return the SCEV object corresponding to ~V.
1225  ///
1226  const SCEV *getNotSCEV(const SCEV *V);
1227 
1228  /// Return LHS-RHS. Minus is represented in SCEV as A+B*-1.
1229  const SCEV *getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
1231 
1232  /// Return a SCEV corresponding to a conversion of the input value to the
1233  /// specified type. If the type must be extended, it is zero extended.
1234  const SCEV *getTruncateOrZeroExtend(const SCEV *V, Type *Ty);
1235 
1236  /// Return a SCEV corresponding to a conversion of the input value to the
1237  /// specified type. If the type must be extended, it is sign extended.
1238  const SCEV *getTruncateOrSignExtend(const SCEV *V, Type *Ty);
1239 
1240  /// Return a SCEV corresponding to a conversion of the input value to the
1241  /// specified type. If the type must be extended, it is zero extended. The
1242  /// conversion must not be narrowing.
1243  const SCEV *getNoopOrZeroExtend(const SCEV *V, Type *Ty);
1244 
1245  /// Return a SCEV corresponding to a conversion of the input value to the
1246  /// specified type. If the type must be extended, it is sign extended. The
1247  /// conversion must not be narrowing.
1248  const SCEV *getNoopOrSignExtend(const SCEV *V, Type *Ty);
1249 
1250  /// Return a SCEV corresponding to a conversion of the input value to the
1251  /// specified type. If the type must be extended, it is extended with
1252  /// unspecified bits. The conversion must not be narrowing.
1253  const SCEV *getNoopOrAnyExtend(const SCEV *V, Type *Ty);
1254 
1255  /// Return a SCEV corresponding to a conversion of the input value to the
1256  /// specified type. The conversion must not be widening.
1257  const SCEV *getTruncateOrNoop(const SCEV *V, Type *Ty);
1258 
1259  /// Promote the operands to the wider of the types using zero-extension, and
1260  /// then perform a umax operation with them.
1261  const SCEV *getUMaxFromMismatchedTypes(const SCEV *LHS, const SCEV *RHS);
1262 
1263  /// Promote the operands to the wider of the types using zero-extension, and
1264  /// then perform a umin operation with them.
1265  const SCEV *getUMinFromMismatchedTypes(const SCEV *LHS, const SCEV *RHS);
1266 
1267  /// Transitively follow the chain of pointer-type operands until reaching a
1268  /// SCEV that does not have a single pointer operand. This returns a
1269  /// SCEVUnknown pointer for well-formed pointer-type expressions, but corner
1270  /// cases do exist.
1271  const SCEV *getPointerBase(const SCEV *V);
1272 
1273  /// Return a SCEV expression for the specified value at the specified scope
1274  /// in the program. The L value specifies a loop nest to evaluate the
1275  /// expression at, where null is the top-level or a specified loop is
1276  /// immediately inside of the loop.
1277  ///
1278  /// This method can be used to compute the exit value for a variable defined
1279  /// in a loop by querying what the value will hold in the parent loop.
1280  ///
1281  /// In the case that a relevant loop exit value cannot be computed, the
1282  /// original value V is returned.
1283  const SCEV *getSCEVAtScope(const SCEV *S, const Loop *L);
1284 
1285  /// This is a convenience function which does getSCEVAtScope(getSCEV(V), L).
1286  const SCEV *getSCEVAtScope(Value *V, const Loop *L);
1287 
1288  /// Test whether entry to the loop is protected by a conditional between LHS
1289  /// and RHS. This is used to help avoid max expressions in loop trip
1290  /// counts, and to eliminate casts.
1291  bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
1292  const SCEV *LHS, const SCEV *RHS);
1293 
1294  /// Test whether the backedge of the loop is protected by a conditional
1295  /// between LHS and RHS. This is used to to eliminate casts.
1296  bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
1297  const SCEV *LHS, const SCEV *RHS);
1298 
1299  /// Returns the maximum trip count of the loop if it is a single-exit
1300  /// loop and we can compute a small maximum for that loop.
1301  ///
1302  /// Implemented in terms of the \c getSmallConstantTripCount overload with
1303  /// the single exiting block passed to it. See that routine for details.
1304  unsigned getSmallConstantTripCount(Loop *L);
1305 
1306  /// Returns the maximum trip count of this loop as a normal unsigned
1307  /// value. Returns 0 if the trip count is unknown or not constant. This
1308  /// "trip count" assumes that control exits via ExitingBlock. More
1309  /// precisely, it is the number of times that control may reach ExitingBlock
1310  /// before taking the branch. For loops with multiple exits, it may not be
1311  /// the number times that the loop header executes if the loop exits
1312  /// prematurely via another branch.
1313  unsigned getSmallConstantTripCount(Loop *L, BasicBlock *ExitingBlock);
1314 
1315  /// Returns the upper bound of the loop trip count as a normal unsigned
1316  /// value.
1317  /// Returns 0 if the trip count is unknown or not constant.
1318  unsigned getSmallConstantMaxTripCount(Loop *L);
1319 
1320  /// Returns the largest constant divisor of the trip count of the
1321  /// loop if it is a single-exit loop and we can compute a small maximum for
1322  /// that loop.
1323  ///
1324  /// Implemented in terms of the \c getSmallConstantTripMultiple overload with
1325  /// the single exiting block passed to it. See that routine for details.
1326  unsigned getSmallConstantTripMultiple(Loop *L);
1327 
1328  /// Returns the largest constant divisor of the trip count of this loop as a
1329  /// normal unsigned value, if possible. This means that the actual trip
1330  /// count is always a multiple of the returned value (don't forget the trip
1331  /// count could very well be zero as well!). As explained in the comments
1332  /// for getSmallConstantTripCount, this assumes that control exits the loop
1333  /// via ExitingBlock.
1334  unsigned getSmallConstantTripMultiple(Loop *L, BasicBlock *ExitingBlock);
1335 
1336  /// Get the expression for the number of loop iterations for which this loop
1337  /// is guaranteed not to exit via ExitingBlock. Otherwise return
1338  /// SCEVCouldNotCompute.
1339  const SCEV *getExitCount(Loop *L, BasicBlock *ExitingBlock);
1340 
1341  /// If the specified loop has a predictable backedge-taken count, return it,
1342  /// otherwise return a SCEVCouldNotCompute object. The backedge-taken count
1343  /// is the number of times the loop header will be branched to from within
1344  /// the loop. This is one less than the trip count of the loop, since it
1345  /// doesn't count the first iteration, when the header is branched to from
1346  /// outside the loop.
1347  ///
1348  /// Note that it is not valid to call this method on a loop without a
1349  /// loop-invariant backedge-taken count (see
1350  /// hasLoopInvariantBackedgeTakenCount).
1351  ///
1352  const SCEV *getBackedgeTakenCount(const Loop *L);
1353 
1354  /// Similar to getBackedgeTakenCount, except it will add a set of
1355  /// SCEV predicates to Predicates that are required to be true in order for
1356  /// the answer to be correct. Predicates can be checked with run-time
1357  /// checks and can be used to perform loop versioning.
1358  const SCEV *getPredicatedBackedgeTakenCount(const Loop *L,
1359  SCEVUnionPredicate &Predicates);
1360 
1361  /// Similar to getBackedgeTakenCount, except return the least SCEV value
1362  /// that is known never to be less than the actual backedge taken count.
1363  const SCEV *getMaxBackedgeTakenCount(const Loop *L);
1364 
1365  /// Return true if the backedge taken count is either the value returned by
1366  /// getMaxBackedgeTakenCount or zero.
1367  bool isBackedgeTakenCountMaxOrZero(const Loop *L);
1368 
1369  /// Return true if the specified loop has an analyzable loop-invariant
1370  /// backedge-taken count.
1371  bool hasLoopInvariantBackedgeTakenCount(const Loop *L);
1372 
1373  /// This method should be called by the client when it has changed a loop in
1374  /// a way that may effect ScalarEvolution's ability to compute a trip count,
1375  /// or if the loop is deleted. This call is potentially expensive for large
1376  /// loop bodies.
1377  void forgetLoop(const Loop *L);
1378 
1379  /// This method should be called by the client when it has changed a value
1380  /// in a way that may effect its value, or which may disconnect it from a
1381  /// def-use chain linking it to a loop.
1382  void forgetValue(Value *V);
1383 
1384  /// Called when the client has changed the disposition of values in
1385  /// this loop.
1386  ///
1387  /// We don't have a way to invalidate per-loop dispositions. Clear and
1388  /// recompute is simpler.
1389  void forgetLoopDispositions(const Loop *L) { LoopDispositions.clear(); }
1390 
1391  /// Determine the minimum number of zero bits that S is guaranteed to end in
1392  /// (at every loop iteration). It is, at the same time, the minimum number
1393  /// of times S is divisible by 2. For example, given {4,+,8} it returns 2.
1394  /// If S is guaranteed to be 0, it returns the bitwidth of S.
1395  uint32_t GetMinTrailingZeros(const SCEV *S);
1396 
1397  /// Determine the unsigned range for a particular SCEV.
1398  ///
1400  return getRange(S, HINT_RANGE_UNSIGNED);
1401  }
1402 
1403  /// Determine the signed range for a particular SCEV.
1404  ///
1406  return getRange(S, HINT_RANGE_SIGNED);
1407  }
1408 
1409  /// Test if the given expression is known to be negative.
1410  ///
1411  bool isKnownNegative(const SCEV *S);
1412 
1413  /// Test if the given expression is known to be positive.
1414  ///
1415  bool isKnownPositive(const SCEV *S);
1416 
1417  /// Test if the given expression is known to be non-negative.
1418  ///
1419  bool isKnownNonNegative(const SCEV *S);
1420 
1421  /// Test if the given expression is known to be non-positive.
1422  ///
1423  bool isKnownNonPositive(const SCEV *S);
1424 
1425  /// Test if the given expression is known to be non-zero.
1426  ///
1427  bool isKnownNonZero(const SCEV *S);
1428 
1429  /// Test if the given expression is known to satisfy the condition described
1430  /// by Pred, LHS, and RHS.
1431  ///
1432  bool isKnownPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
1433  const SCEV *RHS);
1434 
1435  /// Return true if the result of the predicate LHS `Pred` RHS is loop
1436  /// invariant with respect to L. Set InvariantPred, InvariantLHS and
1437  /// InvariantLHS so that InvariantLHS `InvariantPred` InvariantRHS is the
1438  /// loop invariant form of LHS `Pred` RHS.
1439  bool isLoopInvariantPredicate(ICmpInst::Predicate Pred, const SCEV *LHS,
1440  const SCEV *RHS, const Loop *L,
1441  ICmpInst::Predicate &InvariantPred,
1442  const SCEV *&InvariantLHS,
1443  const SCEV *&InvariantRHS);
1444 
1445  /// Simplify LHS and RHS in a comparison with predicate Pred. Return true
1446  /// iff any changes were made. If the operands are provably equal or
1447  /// unequal, LHS and RHS are set to the same value and Pred is set to either
1448  /// ICMP_EQ or ICMP_NE.
1449  ///
1450  bool SimplifyICmpOperands(ICmpInst::Predicate &Pred, const SCEV *&LHS,
1451  const SCEV *&RHS, unsigned Depth = 0);
1452 
1453  /// Return the "disposition" of the given SCEV with respect to the given
1454  /// loop.
1455  LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L);
1456 
1457  /// Return true if the value of the given SCEV is unchanging in the
1458  /// specified loop.
1459  bool isLoopInvariant(const SCEV *S, const Loop *L);
1460 
1461  /// Return true if the given SCEV changes value in a known way in the
1462  /// specified loop. This property being true implies that the value is
1463  /// variant in the loop AND that we can emit an expression to compute the
1464  /// value of the expression at any particular loop iteration.
1465  bool hasComputableLoopEvolution(const SCEV *S, const Loop *L);
1466 
1467  /// Return the "disposition" of the given SCEV with respect to the given
1468  /// block.
1469  BlockDisposition getBlockDisposition(const SCEV *S, const BasicBlock *BB);
1470 
1471  /// Return true if elements that makes up the given SCEV dominate the
1472  /// specified basic block.
1473  bool dominates(const SCEV *S, const BasicBlock *BB);
1474 
1475  /// Return true if elements that makes up the given SCEV properly dominate
1476  /// the specified basic block.
1477  bool properlyDominates(const SCEV *S, const BasicBlock *BB);
1478 
1479  /// Test whether the given SCEV has Op as a direct or indirect operand.
1480  bool hasOperand(const SCEV *S, const SCEV *Op) const;
1481 
1482  /// Return the size of an element read or written by Inst.
1483  const SCEV *getElementSize(Instruction *Inst);
1484 
1485  /// Compute the array dimensions Sizes from the set of Terms extracted from
1486  /// the memory access function of this SCEVAddRecExpr (second step of
1487  /// delinearization).
1488  void findArrayDimensions(SmallVectorImpl<const SCEV *> &Terms,
1490  const SCEV *ElementSize) const;
1491 
1492  void print(raw_ostream &OS) const;
1493  void verify() const;
1494  bool invalidate(Function &F, const PreservedAnalyses &PA,
1496 
1497  /// Collect parametric terms occurring in step expressions (first step of
1498  /// delinearization).
1499  void collectParametricTerms(const SCEV *Expr,
1501 
1502  /// Return in Subscripts the access functions for each dimension in Sizes
1503  /// (third step of delinearization).
1504  void computeAccessFunctions(const SCEV *Expr,
1505  SmallVectorImpl<const SCEV *> &Subscripts,
1507 
1508  /// Split this SCEVAddRecExpr into two vectors of SCEVs representing the
1509  /// subscripts and sizes of an array access.
1510  ///
1511  /// The delinearization is a 3 step process: the first two steps compute the
1512  /// sizes of each subscript and the third step computes the access functions
1513  /// for the delinearized array:
1514  ///
1515  /// 1. Find the terms in the step functions
1516  /// 2. Compute the array size
1517  /// 3. Compute the access function: divide the SCEV by the array size
1518  /// starting with the innermost dimensions found in step 2. The Quotient
1519  /// is the SCEV to be divided in the next step of the recursion. The
1520  /// Remainder is the subscript of the innermost dimension. Loop over all
1521  /// array dimensions computed in step 2.
1522  ///
1523  /// To compute a uniform array size for several memory accesses to the same
1524  /// object, one can collect in step 1 all the step terms for all the memory
1525  /// accesses, and compute in step 2 a unique array shape. This guarantees
1526  /// that the array shape will be the same across all memory accesses.
1527  ///
1528  /// FIXME: We could derive the result of steps 1 and 2 from a description of
1529  /// the array shape given in metadata.
1530  ///
1531  /// Example:
1532  ///
1533  /// A[][n][m]
1534  ///
1535  /// for i
1536  /// for j
1537  /// for k
1538  /// A[j+k][2i][5i] =
1539  ///
1540  /// The initial SCEV:
1541  ///
1542  /// A[{{{0,+,2*m+5}_i, +, n*m}_j, +, n*m}_k]
1543  ///
1544  /// 1. Find the different terms in the step functions:
1545  /// -> [2*m, 5, n*m, n*m]
1546  ///
1547  /// 2. Compute the array size: sort and unique them
1548  /// -> [n*m, 2*m, 5]
1549  /// find the GCD of all the terms = 1
1550  /// divide by the GCD and erase constant terms
1551  /// -> [n*m, 2*m]
1552  /// GCD = m
1553  /// divide by GCD -> [n, 2]
1554  /// remove constant terms
1555  /// -> [n]
1556  /// size of the array is A[unknown][n][m]
1557  ///
1558  /// 3. Compute the access function
1559  /// a. Divide {{{0,+,2*m+5}_i, +, n*m}_j, +, n*m}_k by the innermost size m
1560  /// Quotient: {{{0,+,2}_i, +, n}_j, +, n}_k
1561  /// Remainder: {{{0,+,5}_i, +, 0}_j, +, 0}_k
1562  /// The remainder is the subscript of the innermost array dimension: [5i].
1563  ///
1564  /// b. Divide Quotient: {{{0,+,2}_i, +, n}_j, +, n}_k by next outer size n
1565  /// Quotient: {{{0,+,0}_i, +, 1}_j, +, 1}_k
1566  /// Remainder: {{{0,+,2}_i, +, 0}_j, +, 0}_k
1567  /// The Remainder is the subscript of the next array dimension: [2i].
1568  ///
1569  /// The subscript of the outermost dimension is the Quotient: [j+k].
1570  ///
1571  /// Overall, we have: A[][n][m], and the access function: A[j+k][2i][5i].
1572  void delinearize(const SCEV *Expr, SmallVectorImpl<const SCEV *> &Subscripts,
1574  const SCEV *ElementSize);
1575 
1576  /// Return the DataLayout associated with the module this SCEV instance is
1577  /// operating on.
1578  const DataLayout &getDataLayout() const {
1579  return F.getParent()->getDataLayout();
1580  }
1581 
1582  const SCEVPredicate *getEqualPredicate(const SCEVUnknown *LHS,
1583  const SCEVConstant *RHS);
1584 
1585  const SCEVPredicate *
1586  getWrapPredicate(const SCEVAddRecExpr *AR,
1588 
1589  /// Re-writes the SCEV according to the Predicates in \p A.
1590  const SCEV *rewriteUsingPredicate(const SCEV *S, const Loop *L,
1592  /// Tries to convert the \p S expression to an AddRec expression,
1593  /// adding additional predicates to \p Preds as required.
1594  const SCEVAddRecExpr *convertSCEVToAddRecWithPredicates(
1595  const SCEV *S, const Loop *L,
1597 
1598 private:
1599  /// Compute the backedge taken count knowing the interval difference, the
1600  /// stride and presence of the equality in the comparison.
1601  const SCEV *computeBECount(const SCEV *Delta, const SCEV *Stride,
1602  bool Equality);
1603 
1604  /// Verify if an linear IV with positive stride can overflow when in a
1605  /// less-than comparison, knowing the invariant term of the comparison,
1606  /// the stride and the knowledge of NSW/NUW flags on the recurrence.
1607  bool doesIVOverflowOnLT(const SCEV *RHS, const SCEV *Stride, bool IsSigned,
1608  bool NoWrap);
1609 
1610  /// Verify if an linear IV with negative stride can overflow when in a
1611  /// greater-than comparison, knowing the invariant term of the comparison,
1612  /// the stride and the knowledge of NSW/NUW flags on the recurrence.
1613  bool doesIVOverflowOnGT(const SCEV *RHS, const SCEV *Stride, bool IsSigned,
1614  bool NoWrap);
1615 
1616 private:
1617  FoldingSet<SCEV> UniqueSCEVs;
1618  FoldingSet<SCEVPredicate> UniquePreds;
1619  BumpPtrAllocator SCEVAllocator;
1620 
1621  /// The head of a linked list of all SCEVUnknown values that have been
1622  /// allocated. This is used by releaseMemory to locate them all and call
1623  /// their destructors.
1624  SCEVUnknown *FirstUnknown;
1625 };
1626 
1627 /// Analysis pass that exposes the \c ScalarEvolution for a function.
1629  : public AnalysisInfoMixin<ScalarEvolutionAnalysis> {
1631  static AnalysisKey Key;
1632 
1633 public:
1635 
1637 };
1638 
1639 /// Printer pass for the \c ScalarEvolutionAnalysis results.
1641  : public PassInfoMixin<ScalarEvolutionPrinterPass> {
1642  raw_ostream &OS;
1643 
1644 public:
1645  explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {}
1647 };
1648 
1650  std::unique_ptr<ScalarEvolution> SE;
1651 
1652 public:
1653  static char ID;
1654 
1656 
1657  ScalarEvolution &getSE() { return *SE; }
1658  const ScalarEvolution &getSE() const { return *SE; }
1659 
1660  bool runOnFunction(Function &F) override;
1661  void releaseMemory() override;
1662  void getAnalysisUsage(AnalysisUsage &AU) const override;
1663  void print(raw_ostream &OS, const Module * = nullptr) const override;
1664  void verifyAnalysis() const override;
1665 };
1666 
1667 /// An interface layer with SCEV used to manage how we see SCEV expressions
1668 /// for values in the context of existing predicates. We can add new
1669 /// predicates, but we cannot remove them.
1670 ///
1671 /// This layer has multiple purposes:
1672 /// - provides a simple interface for SCEV versioning.
1673 /// - guarantees that the order of transformations applied on a SCEV
1674 /// expression for a single Value is consistent across two different
1675 /// getSCEV calls. This means that, for example, once we've obtained
1676 /// an AddRec expression for a certain value through expression
1677 /// rewriting, we will continue to get an AddRec expression for that
1678 /// Value.
1679 /// - lowers the number of expression rewrites.
1681 public:
1683  const SCEVUnionPredicate &getUnionPredicate() const;
1684 
1685  /// Returns the SCEV expression of V, in the context of the current SCEV
1686  /// predicate. The order of transformations applied on the expression of V
1687  /// returned by ScalarEvolution is guaranteed to be preserved, even when
1688  /// adding new predicates.
1689  const SCEV *getSCEV(Value *V);
1690 
1691  /// Get the (predicated) backedge count for the analyzed loop.
1692  const SCEV *getBackedgeTakenCount();
1693 
1694  /// Adds a new predicate.
1695  void addPredicate(const SCEVPredicate &Pred);
1696 
1697  /// Attempts to produce an AddRecExpr for V by adding additional SCEV
1698  /// predicates. If we can't transform the expression into an AddRecExpr we
1699  /// return nullptr and not add additional SCEV predicates to the current
1700  /// context.
1701  const SCEVAddRecExpr *getAsAddRec(Value *V);
1702 
1703  /// Proves that V doesn't overflow by adding SCEV predicate.
1704  void setNoOverflow(Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags);
1705 
1706  /// Returns true if we've proved that V doesn't wrap by means of a SCEV
1707  /// predicate.
1708  bool hasNoOverflow(Value *V, SCEVWrapPredicate::IncrementWrapFlags Flags);
1709 
1710  /// Returns the ScalarEvolution analysis used.
1711  ScalarEvolution *getSE() const { return &SE; }
1712 
1713  /// We need to explicitly define the copy constructor because of FlagsMap.
1715 
1716  /// Print the SCEV mappings done by the Predicated Scalar Evolution.
1717  /// The printed text is indented by \p Depth.
1718  void print(raw_ostream &OS, unsigned Depth) const;
1719 
1720 private:
1721  /// Increments the version number of the predicate. This needs to be called
1722  /// every time the SCEV predicate changes.
1723  void updateGeneration();
1724 
1725  /// Holds a SCEV and the version number of the SCEV predicate used to
1726  /// perform the rewrite of the expression.
1727  typedef std::pair<unsigned, const SCEV *> RewriteEntry;
1728 
1729  /// Maps a SCEV to the rewrite result of that SCEV at a certain version
1730  /// number. If this number doesn't match the current Generation, we will
1731  /// need to do a rewrite. To preserve the transformation order of previous
1732  /// rewrites, we will rewrite the previous result instead of the original
1733  /// SCEV.
1735 
1736  /// Records what NoWrap flags we've added to a Value *.
1738 
1739  /// The ScalarEvolution analysis.
1740  ScalarEvolution &SE;
1741 
1742  /// The analyzed Loop.
1743  const Loop &L;
1744 
1745  /// The SCEVPredicate that forms our context. We will rewrite all
1746  /// expressions assuming that this predicate true.
1747  SCEVUnionPredicate Preds;
1748 
1749  /// Marks the version of the SCEV predicate used. When rewriting a SCEV
1750  /// expression we mark it with the version of the predicate. We use this to
1751  /// figure out if the predicate has changed from the last rewrite of the
1752  /// SCEV. If so, we need to perform a new rewrite.
1753  unsigned Generation;
1754 
1755  /// The backedge taken count.
1756  const SCEV *BackedgeCount;
1757 };
1758 }
1759 
1760 #endif
MachineLoop * L
virtual const SCEV * getExpr() const =0
Returns the SCEV to which this predicate applies, or nullptr if this is a SCEVUnionPredicate.
IncrementWrapFlags getFlags() const
Returns the set assumed no overflow flags.
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
static bool isLoopInvariant(Value *V, const Loop *L, const DominatorTree *DT)
Perform a quick domtree based check for loop invariance assuming that V is used within the loop...
bool isOne() const
Return true if the expression is a constant one.
Various leaf nodes.
Definition: ISDOpcodes.h:60
static unsigned ComputeHash(const SCEVPredicate &X, FoldingSetNodeID &TempID)
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
LLVMContext & getContext() const
bool isZero() const
Return true if the expression is a constant zero.
virtual bool implies(const SCEVPredicate *N) const =0
Returns true if this predicate implies N.
const SCEV * getMulExpr(const SCEV *Op0, const SCEV *Op1, const SCEV *Op2, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
The main scalar evolution driver.
IncrementWrapFlags
Similar to SCEV::NoWrapFlags, but with slightly different semantics for FlagNUSW. ...
static LLVM_NODISCARD SCEV::NoWrapFlags setFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OnFlags)
static bool Equals(const SCEVPredicate &X, const FoldingSetNodeID &ID, unsigned IDHash, FoldingSetNodeID &TempID)
const SCEV * getMulExpr(const SCEV *LHS, const SCEV *RHS, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
const SCEV * getAddExpr(const SCEV *Op0, const SCEV *Op1, const SCEV *Op2, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
A cache of .assume calls within a function.
Hexagon Common GEP
An object of this class is returned by queries that could not be answered.
const SCEV * getExpr() const override
Returns the SCEV to which this predicate applies, or nullptr if this is a SCEVUnionPredicate.
This file defines the MallocAllocator and BumpPtrAllocator interfaces.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
const SCEV * getZero(Type *Ty)
Return a SCEV for the constant 0 of a specific type.
The SCEV is loop-invariant.
const SCEV * getAddExpr(const SCEV *LHS, const SCEV *RHS, SCEV::NoWrapFlags Flags=SCEV::FlagAnyWrap)
static LLVM_NODISCARD SCEVWrapPredicate::IncrementWrapFlags setFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, SCEVWrapPredicate::IncrementWrapFlags OnFlags)
bool isAlwaysTrue() const override
Returns true if the predicate is always true.
const DataLayout & getDataLayout() const
Return the DataLayout associated with the module this SCEV instance is operating on.
unsigned ComputeHash() const
ComputeHash - Compute a strong hash value for this FoldingSetNodeIDRef, used to lookup the node in th...
Definition: FoldingSet.cpp:30
virtual unsigned getComplexity() const
Returns the estimated complexity of this predicate.
Class to represent struct types.
Definition: DerivedTypes.h:199
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
unsigned short SubclassData
This field is initialized to zero and may be used in subclasses to store miscellaneous information...
#define F(x, y, z)
Definition: MD5.cpp:51
ConstantRange getSignedRange(const SCEV *S)
Determine the signed range for a particular SCEV.
This node represents a polynomial recurrence on the trip count of the specified loop.
bool implies(const SCEVPredicate *N) const override
Implementation of the SCEVPredicate interface.
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:311
Function Alias Analysis false
static bool add(uint64_t *dest, const uint64_t *x, const uint64_t *y, unsigned len)
This function adds the integer array x to the integer array Y and places the result in dest...
Definition: APInt.cpp:239
static bool classof(const SCEVPredicate *P)
Methods for support type inquiry through isa, cast, and dyn_cast:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
static Optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS, const DataLayout &DL, unsigned Depth, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred ALHS ARHS" is true.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
int Switch(int a)
Definition: Switch2Test.cpp:11
const SCEV * getAddRecExpr(const SmallVectorImpl< const SCEV * > &Operands, const Loop *L, SCEV::NoWrapFlags Flags)
void forgetLoopDispositions(const Loop *L)
Called when the client has changed the disposition of values in this loop.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:316
Printer pass for the ScalarEvolutionAnalysis results.
virtual bool isAlwaysTrue() const =0
Returns true if the predicate is always true.
bool verify(const TargetRegisterInfo &TRI) const
Check that information hold by this instance make sense for the given TRI.
#define P(N)
This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM...
FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet ...
Definition: FoldingSet.h:259
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
const SCEV * getOne(Type *Ty)
Return a SCEV for the constant 1 of a specific type.
static bool Equals(const SCEV &X, const FoldingSetNodeID &ID, unsigned IDHash, FoldingSetNodeID &TempID)
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
Type * getType() const
Return the LLVM type of this SCEV expression.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:138
bool isKnownNonNegative(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the give value is known to be non-negative.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
void print(raw_ostream &OS, unsigned Depth=0) const override
Prints a textual representation of this predicate with an indentation of Depth.
SCEVWrapPredicate(const FoldingSetNodeIDRef ID, const SCEVAddRecExpr *AR, IncrementWrapFlags Flags)
const SCEV * getExpr() const override
Implementation of the SCEVPredicate interface.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:328
ScalarEvolutionPrinterPass(raw_ostream &OS)
Represent the analysis usage information of a pass.
const SCEVUnknown * getLHS() const
Returns the left hand side of the equality.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:880
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
static LLVM_NODISCARD SCEV::NoWrapFlags clearFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OffFlags)
bool isNonConstantNegative() const
Return true if the specified scev is negated, but not a constant.
SCEVPredicateKind getKind() const
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:419
static unsigned ComputeHash(const SCEV &X, FoldingSetNodeID &TempID)
The SCEV is loop-variant (unknown).
This class represents an assumption made using SCEV expressions which can be checked at run-time...
void dump() const
This method is used for debugging.
const SCEVConstant * getRHS() const
Returns the right hand side of the equality.
See the file comment.
Definition: ValueMap.h:87
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
static LLVM_NODISCARD SCEVWrapPredicate::IncrementWrapFlags clearFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, SCEVWrapPredicate::IncrementWrapFlags OffFlags)
Convenient IncrementWrapFlags manipulation methods.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
bool isAllOnesValue() const
Return true if the expression is a constant all-ones value.
Provides information about what library functions are available for the current target.
The SCEV dominates the block.
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:27
This class represents a range of values.
Definition: ConstantRange.h:45
An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of ...
static LLVM_NODISCARD SCEVWrapPredicate::IncrementWrapFlags getImpliedFlags(const SCEVAddRecExpr *AR, ScalarEvolution &SE)
Returns the set of SCEVWrapPredicate no wrap flags implied by a SCEVAddRecExpr.
static LLVM_NODISCARD SCEVWrapPredicate::IncrementWrapFlags maskFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask)
static void Profile(const SCEV &X, FoldingSetNodeID &ID)
SCEVPredicate & operator=(const SCEVPredicate &)=default
static void Profile(const SCEVPredicate &X, FoldingSetNodeID &ID)
Node - This class is used to maintain the singly linked bucket list in a folding set.
Definition: FoldingSet.h:139
LoopDisposition
An enum describing the relationship between a SCEV and a loop.
Class for arbitrary precision integers.
Definition: APInt.h:77
virtual void print(raw_ostream &OS, unsigned Depth=0) const =0
Prints a textual representation of this predicate with an indentation of Depth.
This class uses information about analyze scalars to rewrite expressions in canonical form...
static void clear(coro::Shape &Shape)
Definition: Coroutines.cpp:191
static bool classof(const SCEVPredicate *P)
Methods for support type inquiry through isa, cast, and dyn_cast:
SCEVPredicate(const SCEVPredicate &)=default
Analysis pass that exposes the ScalarEvolution for a function.
bool isKnownNegative(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the given value is known be negative (i.e.
unsigned getComplexity() const override
We estimate the complexity of a union predicate as the size number of predicates in the union...
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
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:287
This class represents an analyzed expression in the program.
const ScalarEvolution & getSE() const
SCEV(const FoldingSetNodeIDRef ID, unsigned SCEVTy)
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:368
ScalarEvolution * getSE() const
Returns the ScalarEvolution analysis used.
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
BlockDisposition
An enum describing the relationship between a SCEV and a basic block.
static LLVM_NODISCARD SCEV::NoWrapFlags maskFlags(SCEV::NoWrapFlags Flags, int Mask)
Convenient NoWrapFlags manipulation that hides enum casts and is visible in the ScalarEvolution name ...
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:1726
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:132
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:525
ConstantRange getUnsignedRange(const SCEV *S)
Determine the unsigned range for a particular SCEV.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This class represents a composition of other SCEV predicates, and is the class that most clients will...
unsigned getSCEVType() const
void print(raw_ostream &OS) const
Print out the internal representation of this scalar to the specified stream.
LLVM Value Representation.
Definition: Value.h:71
A vector that has set insertion semantics.
Definition: SetVector.h:41
SCEVEqualPredicate(const FoldingSetNodeIDRef ID, const SCEVUnknown *LHS, const SCEVConstant *RHS)
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
bool isKnownPositive(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the given value is known be positive (i.e.
DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementati...
Definition: FoldingSet.h:230
SCEVPredicateKind Kind
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
bool implies(const SCEVPredicate *N) const override
Returns true if this predicate implies N.
bool isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if the given value is known to be non-zero when defined.
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:333
A container for analyses that lazily runs them and caches their results.
bool isAlwaysTrue() const override
Returns true if the predicate is always true.
This header defines various interfaces for pass management in LLVM.
This class represents an assumption made on an AddRec expression.
~SCEVPredicate()=default
static bool classof(const SCEVPredicate *P)
Methods for support type inquiry through isa, cast, and dyn_cast:
NoWrapFlags
NoWrapFlags are bitfield indices into SubclassData.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
This class represents an assumption that two SCEV expressions are equal, and this can be checked at r...
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:64
static bool classof(const SCEV *S)
Methods for support type inquiry through isa, cast, and dyn_cast:
const SmallVectorImpl< const SCEVPredicate * > & getPredicates() const
void print(raw_ostream &OS, unsigned Depth=0) const override
Prints a textual representation of this predicate with an indentation of Depth.
This class represents a constant integer value.