IVDescriptors.h

Go to the documentation of this file.

//===- llvm/Analysis/IVDescriptors.h - IndVar Descriptors -------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file "describes" induction and recurrence variables.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_ANALYSIS_IVDESCRIPTORS_H
#define LLVM_ANALYSIS_IVDESCRIPTORS_H
 
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/Compiler.h"
 
namespace llvm {
 
class AssumptionCache;
class DemandedBits;
class DominatorTree;
class Loop;
class PredicatedScalarEvolution;
class ScalarEvolution;
class SCEV;
class SCEVPredicate;
class StoreInst;
enum class SCEVNoWrapFlags;
 
/// These are the kinds of recurrences that we support.
enum class RecurKind {
  // clang-format off
  None,     ///< Not a recurrence.
  Add,      ///< Sum of integers.
  Sub,      ///< Subtraction of integers
  AddChainWithSubs, ///< A chain of adds and subs
  Mul,      ///< Product of integers.
  Or,       ///< Bitwise or logical OR of integers.
  And,      ///< Bitwise or logical AND of integers.
  Xor,      ///< Bitwise or logical XOR of integers.
  SMin,     ///< Signed integer min implemented in terms of select(cmp()).
  SMax,     ///< Signed integer max implemented in terms of select(cmp()).
  UMin,     ///< Unsigned integer min implemented in terms of select(cmp()).
  UMax,     ///< Unsigned integer max implemented in terms of select(cmp()).
  FAdd,     ///< Sum of floats.
  FAddChainWithSubs, ///< A chain of fadds and fsubs.
  FSub,     ///< Subtraction of floats.
  FMul,     ///< Product of floats.
  FMin,     ///< FP min implemented in terms of select(cmp()).
  FMax,     ///< FP max implemented in terms of select(cmp()).
  FMinNum,  ///< FP min with llvm.minnum semantics including NaNs.
  FMaxNum,  ///< FP max with llvm.maxnum semantics including NaNs.
  FMinimum, ///< FP min with llvm.minimum semantics
  FMaximum, ///< FP max with llvm.maximum semantics
  FMinimumNum, ///< FP min with llvm.minimumnum semantics
  FMaximumNum, ///< FP max with llvm.maximumnum semantics
  FMulAdd,  ///< Sum of float products with llvm.fmuladd(a * b + sum).
  AnyOf,    ///< AnyOf reduction with select(cmp(),x,y) where one of (x,y) is
            ///< loop invariant, and both x and y are integer type.
  FindIV,   ///< FindIV reduction with select(icmp(),x,y) where one of (x,y) is
            ///< a loop induction variable (increasing or decreasing), and both
            ///< x and y are integer type. The signedness and direction are
            ///< stored separately.
  FindLast, ///< FindLast reduction with select(cmp(),x,y) where x and y
                  ///< are an integer type, one is the current recurrence value,
                  ///< and the other is an arbitrary value.
  // clang-format on
  // TODO: Any_of and FindLast reduction need not be restricted to integer type
  // only.
};
 
/// The RecurrenceDescriptor is used to identify recurrences variables in a
/// loop. Reduction is a special case of recurrence that has uses of the
/// recurrence variable outside the loop. The method isReductionPHI identifies
/// reductions that are basic recurrences.
///
/// Basic recurrences are defined as the summation, product, OR, AND, XOR, min,
/// or max of a set of terms. For example: for(i=0; i<n; i++) { total +=
/// array[i]; } is a summation of array elements. Basic recurrences are a
/// special case of chains of recurrences (CR). See ScalarEvolution for CR
/// references.
 
/// This struct holds information about recurrence variables.
class RecurrenceDescriptor {
public:
  RecurrenceDescriptor() = default;
 
  RecurrenceDescriptor(Value *Start, Instruction *Exit, StoreInst *Store,
                       RecurKind K, FastMathFlags FMF, Instruction *ExactFP,
                       Type *RT, bool Signed, bool Ordered,
                       SmallPtrSetImpl<Instruction *> &CI,
                       unsigned MinWidthCastToRecurTy,
                       bool PhiHasUsesOutsideReductionChain = false)
      : IntermediateStore(Store), StartValue(Start), LoopExitInstr(Exit),
        Kind(K), FMF(FMF), ExactFPMathInst(ExactFP), RecurrenceType(RT),
        IsSigned(Signed), IsOrdered(Ordered),
        PhiHasUsesOutsideReductionChain(PhiHasUsesOutsideReductionChain),
        MinWidthCastToRecurrenceType(MinWidthCastToRecurTy) {
    CastInsts.insert_range(CI);
    assert(
        (!PhiHasUsesOutsideReductionChain || isMinMaxRecurrenceKind(K)) &&
        "Only min/max recurrences are allowed to have multiple uses currently");
  }
 
  /// Simpler constructor for min/max recurrences that don't track cast
  /// instructions.
  RecurrenceDescriptor(Value *Start, Instruction *Exit, StoreInst *Store,
                       RecurKind K, FastMathFlags FMF, Instruction *ExactFP,
                       Type *RT, bool IsMultiUse = false)
      : IntermediateStore(Store), StartValue(Start), LoopExitInstr(Exit),
        Kind(K), FMF(FMF), ExactFPMathInst(ExactFP), RecurrenceType(RT),
        PhiHasUsesOutsideReductionChain(IsMultiUse) {}
 
  /// This POD struct holds information about a potential recurrence operation.
  class InstDesc {
  public:
    InstDesc(bool IsRecur, Instruction *I, Instruction *ExactFP = nullptr)
        : IsRecurrence(IsRecur), PatternLastInst(I),
          RecKind(RecurKind::None), ExactFPMathInst(ExactFP) {}
 
    InstDesc(Instruction *I, RecurKind K, Instruction *ExactFP = nullptr)
        : IsRecurrence(true), PatternLastInst(I), RecKind(K),
          ExactFPMathInst(ExactFP) {}
 
    bool isRecurrence() const { return IsRecurrence; }
 
    bool needsExactFPMath() const { return ExactFPMathInst != nullptr; }
 
    Instruction *getExactFPMathInst() const { return ExactFPMathInst; }
 
    RecurKind getRecKind() const { return RecKind; }
 
    Instruction *getPatternInst() const { return PatternLastInst; }
 
  private:
    // Is this instruction a recurrence candidate.
    bool IsRecurrence;
    // The last instruction in a min/max pattern (select of the select(icmp())
    // pattern), or the current recurrence instruction otherwise.
    Instruction *PatternLastInst;
    // If this is a min/max pattern.
    RecurKind RecKind;
    // Recurrence does not allow floating-point reassociation.
    Instruction *ExactFPMathInst;
  };
 
  /// Returns a struct describing if the instruction 'I' can be a recurrence
  /// variable of type 'Kind' for a Loop \p L and reduction PHI \p Phi.
  /// If the recurrence is a min/max pattern of select(icmp()) this function
  /// advances the instruction pointer 'I' from the compare instruction to the
  /// select instruction and stores this pointer in 'PatternLastInst' member of
  /// the returned struct.
  LLVM_ABI static InstDesc isRecurrenceInstr(Loop *L, PHINode *Phi,
                                             Instruction *I, RecurKind Kind,
                                             InstDesc &Prev,
                                             ScalarEvolution *SE);
 
  /// Returns true if instruction I has multiple uses in Insts
  LLVM_ABI static bool hasMultipleUsesOf(Instruction *I,
                                         SmallPtrSetImpl<Instruction *> &Insts,
                                         unsigned MaxNumUses);
 
  /// Returns true if all uses of the instruction I is within the Set.
  LLVM_ABI static bool areAllUsesIn(Instruction *I,
                                    SmallPtrSetImpl<Instruction *> &Set);
 
  /// Returns a struct describing whether the instruction is either a
  ///   Select(ICmp(A, B), X, Y), or
  ///   Select(FCmp(A, B), X, Y)
  /// where one of (X, Y) is a loop invariant integer and the other is a PHI
  /// value. \p Prev specifies the description of an already processed select
  /// instruction, so its corresponding cmp can be matched to it.
  LLVM_ABI static InstDesc isAnyOfPattern(Loop *Loop, PHINode *OrigPhi,
                                          Instruction *I, InstDesc &Prev);
 
  /// Returns a struct describing whether the instruction is either a
  ///   Select(ICmp(A, B), X, Y), or
  ///   Select(FCmp(A, B), X, Y)
  /// where one of (X, Y) is an increasing (FindLastIV) or decreasing
  /// (FindFirstIV) loop induction variable, or an arbitrary integer value
  /// (FindLast), and the other is a PHI value.
  LLVM_ABI static InstDesc isFindPattern(Loop *TheLoop, PHINode *OrigPhi,
                                         Instruction *I, ScalarEvolution &SE);
 
  /// Returns a struct describing if the instruction is a
  /// Select(FCmp(X, Y), (Z = X op PHINode), PHINode) instruction pattern.
  LLVM_ABI static InstDesc isConditionalRdxPattern(Instruction *I);
 
  /// Returns the opcode corresponding to the RecurrenceKind.
  LLVM_ABI static unsigned getOpcode(RecurKind Kind);
 
  /// Returns true if Phi is a reduction of type Kind and adds it to the
  /// RecurrenceDescriptor. If either \p DB is non-null or \p AC and \p DT are
  /// non-null, the minimal bit width needed to compute the reduction will be
  /// computed.
  LLVM_ABI static bool
  AddReductionVar(PHINode *Phi, RecurKind Kind, Loop *TheLoop,
                  RecurrenceDescriptor &RedDes, DemandedBits *DB = nullptr,
                  AssumptionCache *AC = nullptr, DominatorTree *DT = nullptr,
                  ScalarEvolution *SE = nullptr);
 
  /// Returns true if Phi is a reduction in TheLoop. The RecurrenceDescriptor
  /// is returned in RedDes. If either \p DB is non-null or \p AC and \p DT are
  /// non-null, the minimal bit width needed to compute the reduction will be
  /// computed. If \p SE is non-null, store instructions to loop invariant
  /// addresses are processed.
  LLVM_ABI static bool
  isReductionPHI(PHINode *Phi, Loop *TheLoop, RecurrenceDescriptor &RedDes,
                 DemandedBits *DB = nullptr, AssumptionCache *AC = nullptr,
                 DominatorTree *DT = nullptr, ScalarEvolution *SE = nullptr);
 
  /// Returns true if Phi is a fixed-order recurrence. A fixed-order recurrence
  /// is a non-reduction recurrence relation in which the value of the
  /// recurrence in the current loop iteration equals a value defined in a
  /// previous iteration (e.g. if the value is defined in the previous
  /// iteration, we refer to it as first-order recurrence, if it is defined in
  /// the iteration before the previous, we refer to it as second-order
  /// recurrence and so on). Note that this function optimistically assumes that
  /// uses of the recurrence can be re-ordered if necessary and users need to
  /// check and perform the re-ordering.
  LLVM_ABI static bool isFixedOrderRecurrence(PHINode *Phi, Loop *TheLoop,
                                              DominatorTree *DT);
 
  RecurKind getRecurrenceKind() const { return Kind; }
 
  unsigned getOpcode() const { return getOpcode(getRecurrenceKind()); }
 
  FastMathFlags getFastMathFlags() const { return FMF; }
 
  TrackingVH<Value> getRecurrenceStartValue() const { return StartValue; }
 
  Instruction *getLoopExitInstr() const { return LoopExitInstr; }
 
  /// Returns true if the recurrence has floating-point math that requires
  /// precise (ordered) operations.
  bool hasExactFPMath() const { return ExactFPMathInst != nullptr; }
 
  /// Returns 1st non-reassociative FP instruction in the PHI node's use-chain.
  Instruction *getExactFPMathInst() const { return ExactFPMathInst; }
 
  /// Returns true if the recurrence kind is an integer kind.
  LLVM_ABI static bool isIntegerRecurrenceKind(RecurKind Kind);
 
  /// Returns true if the recurrence kind is a floating point kind.
  LLVM_ABI static bool isFloatingPointRecurrenceKind(RecurKind Kind);
 
  /// Returns true if the recurrence kind is for a sub operation.
  LLVM_ABI static bool isSubRecurrenceKind(RecurKind Kind);
 
  /// Returns true if the recurrence kind is an integer min/max kind.
  static bool isIntMinMaxRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::UMin || Kind == RecurKind::UMax ||
           Kind == RecurKind::SMin || Kind == RecurKind::SMax;
  }
 
  /// Returns true if the recurrence kind is a floating-point minnum/maxnum
  /// kind.
  static bool isFPMinMaxNumRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::FMinNum || Kind == RecurKind::FMaxNum;
  }
 
  /// Returns true if the recurrence kind is a floating-point min/max kind.
  static bool isFPMinMaxRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::FMin || Kind == RecurKind::FMax ||
           Kind == RecurKind::FMinimum || Kind == RecurKind::FMaximum ||
           Kind == RecurKind::FMinimumNum || Kind == RecurKind::FMaximumNum ||
           isFPMinMaxNumRecurrenceKind(Kind);
  }
 
  /// Returns true if the recurrence kind is any min/max kind.
  static bool isMinMaxRecurrenceKind(RecurKind Kind) {
    return isIntMinMaxRecurrenceKind(Kind) || isFPMinMaxRecurrenceKind(Kind);
  }
 
  /// Returns true if the recurrence kind is of the form
  ///   select(cmp(),x,y) where one of (x,y) is loop invariant.
  static bool isAnyOfRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::AnyOf;
  }
 
  /// Returns true if the recurrence kind is of the form
  ///   select(cmp(),x,y) where one of (x,y) is a loop induction variable.
  static bool isFindIVRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::FindIV;
  }
 
  /// Returns true if the recurrence kind is of the form
  ///   select(cmp(),x,y) where one of (x,y) is an arbitrary value and the
  ///   other is a recurrence.
  static bool isFindLastRecurrenceKind(RecurKind Kind) {
    return Kind == RecurKind::FindLast;
  }
 
  static bool isFindRecurrenceKind(RecurKind Kind) {
    return isFindLastRecurrenceKind(Kind) || isFindIVRecurrenceKind(Kind);
  }
 
  /// Returns the type of the recurrence. This type can be narrower than the
  /// actual type of the Phi if the recurrence has been type-promoted.
  Type *getRecurrenceType() const { return RecurrenceType; }
 
  /// Returns a reference to the instructions used for type-promoting the
  /// recurrence.
  const SmallPtrSet<Instruction *, 8> &getCastInsts() const { return CastInsts; }
 
  /// Returns the minimum width used by the recurrence in bits.
  unsigned getMinWidthCastToRecurrenceTypeInBits() const {
    return MinWidthCastToRecurrenceType;
  }
 
  /// Returns true if all source operands of the recurrence are SExtInsts.
  bool isSigned() const { return IsSigned; }
 
  /// Expose an ordered FP reduction to the instance users.
  bool isOrdered() const { return IsOrdered; }
 
  /// Returns true if the reduction PHI has any uses outside the reduction
  /// chain. This is relevant for min/max reductions that are part of a FindIV
  /// pattern.
  bool hasUsesOutsideReductionChain() const {
    return PhiHasUsesOutsideReductionChain;
  }
 
  /// Attempts to find a chain of operations from Phi to LoopExitInst that can
  /// be treated as a set of reductions instructions for in-loop reductions.
  LLVM_ABI SmallVector<Instruction *, 4> getReductionOpChain(PHINode *Phi,
                                                             Loop *L) const;
 
  /// Returns true if the instruction is a call to the llvm.fmuladd intrinsic.
  static bool isFMulAddIntrinsic(Instruction *I) {
    return isa<IntrinsicInst>(I) &&
           cast<IntrinsicInst>(I)->getIntrinsicID() == Intrinsic::fmuladd;
  }
 
  /// Reductions may store temporary or final result to an invariant address.
  /// If there is such a store in the loop then, after successfull run of
  /// AddReductionVar method, this field will be assigned the last met store.
  StoreInst *IntermediateStore = nullptr;
 
private:
  // The starting value of the recurrence.
  // It does not have to be zero!
  TrackingVH<Value> StartValue;
  // The instruction who's value is used outside the loop.
  Instruction *LoopExitInstr = nullptr;
  // The kind of the recurrence.
  RecurKind Kind = RecurKind::None;
  // The fast-math flags on the recurrent instructions.  We propagate these
  // fast-math flags into the vectorized FP instructions we generate.
  FastMathFlags FMF;
  // First instance of non-reassociative floating-point in the PHI's use-chain.
  Instruction *ExactFPMathInst = nullptr;
  // The type of the recurrence.
  Type *RecurrenceType = nullptr;
  // True if all source operands of the recurrence are SExtInsts.
  bool IsSigned = false;
  // True if this recurrence can be treated as an in-order reduction.
  // Currently only a non-reassociative FAdd can be considered in-order,
  // if it is also the only FAdd in the PHI's use chain.
  bool IsOrdered = false;
  // True if the reduction PHI has in-loop users outside the reduction chain.
  // This is relevant for min/max reductions that are part of a FindIV pattern.
  bool PhiHasUsesOutsideReductionChain = false;
  // Instructions used for type-promoting the recurrence.
  SmallPtrSet<Instruction *, 8> CastInsts;
  // The minimum width used by the recurrence.
  unsigned MinWidthCastToRecurrenceType;
};
 
/// A struct for saving information about induction variables.
class InductionDescriptor {
public:
  /// This enum represents the kinds of inductions that we support.
  enum InductionKind {
    IK_NoInduction,  ///< Not an induction variable.
    IK_IntInduction, ///< Integer induction variable. Step = C.
    IK_PtrInduction, ///< Pointer induction var. Step = C.
    IK_FpInduction   ///< Floating point induction variable.
  };
 
public:
  /// Default constructor - creates an invalid induction.
  InductionDescriptor() = default;
 
  /// Returns the canonical integer induction for type \p Ty with start = 0
  /// and step = 1.
  LLVM_ABI static InductionDescriptor
  getCanonicalIntInduction(Type *Ty, ScalarEvolution &SE);
 
  Value *getStartValue() const { return StartValue; }
  InductionKind getKind() const { return IK; }
  const SCEV *getStep() const { return Step; }
  BinaryOperator *getInductionBinOp() const { return InductionBinOp; }
  LLVM_ABI ConstantInt *getConstIntStepValue() const;
 
  /// Returns true if \p Phi is an induction in the loop \p L. If \p Phi is an
  /// induction, the induction descriptor \p D will contain the data describing
  /// this induction. Since Induction Phis can only be present inside loop
  /// headers, the function will assert if it is passed a Phi whose parent is
  /// not the loop header. If by some other means the caller has a better SCEV
  /// expression for \p Phi than the one returned by the ScalarEvolution
  /// analysis, it can be passed through \p Expr. If the def-use chain
  /// associated with the phi includes casts (that we know we can ignore
  /// under proper runtime checks), they are passed through \p CastsToIgnore.
  /// SCEV predicates checking potential overflow for \p Phi to be an induction,
  /// if any, are passed via \p NoWrapPreds and recorded.
  LLVM_ABI static bool
  isInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE,
                 InductionDescriptor &D,
                 ArrayRef<const SCEVPredicate *> NoWrapPreds = {},
                 const SCEV *Expr = nullptr,
                 SmallVectorImpl<Instruction *> *CastsToIgnore = nullptr);
 
  /// Returns true if \p Phi is a floating point induction in the loop \p L.
  /// If \p Phi is an induction, the induction descriptor \p D will contain
  /// the data describing this induction.
  LLVM_ABI static bool isFPInductionPHI(PHINode *Phi, const Loop *L,
                                        ScalarEvolution *SE,
                                        InductionDescriptor &D);
 
  /// Returns true if \p Phi is a loop \p L induction, in the context associated
  /// with the run-time predicate of PSE. If \p Assume is true, this can add
  /// further SCEV predicates to \p PSE in order to prove that \p Phi is an
  /// induction.
  /// If \p Phi is an induction, \p D will contain the data describing this
  /// induction.
  LLVM_ABI static bool isInductionPHI(PHINode *Phi, const Loop *L,
                                      PredicatedScalarEvolution &PSE,
                                      InductionDescriptor &D,
                                      bool Assume = false);
 
  /// Returns floating-point induction operator that does not allow
  /// reassociation (transforming the induction requires an override of normal
  /// floating-point rules).
  Instruction *getExactFPMathInst() {
    if (IK == IK_FpInduction && InductionBinOp &&
        !InductionBinOp->hasAllowReassoc())
      return InductionBinOp;
    return nullptr;
  }
 
  /// Returns binary opcode of the induction operator.
  Instruction::BinaryOps getInductionOpcode() const {
    return InductionBinOp ? InductionBinOp->getOpcode()
                          : Instruction::BinaryOpsEnd;
  }
 
  /// Returns an ArrayRef to the type cast instructions in the induction
  /// update chain, that are redundant when guarded with a runtime
  /// SCEV overflow check.
  ArrayRef<Instruction *> getCastInsts() const { return RedundantCasts; }
 
  /// Returns the SCEV predicates associated with this induction.
  ArrayRef<const SCEVPredicate *> getNoWrapPredicates() const {
    return NoWrapPredicates;
  }
 
private:
  /// Private constructor - used by \c isInductionPHI and
  /// \c getCanonicalIntInduction.
  InductionDescriptor(Value *Start, InductionKind K, const SCEV *Step,
                      BinaryOperator *InductionBinOp = nullptr,
                      SmallVectorImpl<Instruction *> *Casts = nullptr,
                      ArrayRef<const SCEVPredicate *> NoWrapPreds = {});
 
  /// Start value.
  TrackingVH<Value> StartValue;
  /// Induction kind.
  InductionKind IK = IK_NoInduction;
  /// Step value.
  const SCEV *Step = nullptr;
  // Instruction that advances induction variable.
  BinaryOperator *InductionBinOp = nullptr;
  // Instructions used for type-casts of the induction variable,
  // that are redundant when guarded with a runtime SCEV overflow check.
  SmallVector<Instruction *, 2> RedundantCasts;
  // SCEV predicates checking overflow needed for this induction.
  SmallVector<const SCEVPredicate *, 2> NoWrapPredicates;
};
 
/// A struct for saving information about monotonic variables.
/// Monotonic variable can be considered as a "conditional" induction variable:
/// its update happens only on loop iterations for which a certain predicate is
/// satisfied. The step of the monotonic variable must be loop-invariant.
class MonotonicDescriptor {
public:
  MonotonicDescriptor() = default;
 
  /// Returns true if \p PN is a monotonic variable in the loop \p L. If \p PN
  /// is monotonic, the monotonic descriptor \p Desc will contain the data
  /// describing the PHI.
  LLVM_ABI static bool isMonotonicPHI(PHINode *PN, const Loop *L,
                                      MonotonicDescriptor &Desc,
                                      ScalarEvolution &SE);
 
  /// Returns the header PHI described by this descriptor.
  PHINode *getHeaderPHI() const { return HeaderPHI; }
 
  /// Returns the backedge PHI that selects between StepInst and the HeaderPHI.
  PHINode *getBackedgePHI() const { return BackedgePHI; }
 
  /// Returns the instruction that updates the value of the monotonic PHI.
  Instruction *getStepInst() const { return StepInst; }
 
  /// Returns a SCEV expression for the initial value of the monotonic PHI.
  const SCEV *getStartSCEV() const { return StartSCEV; }
 
  /// Returns a SCEV expression for the step of the monotonic PHI. This is
  /// the value the monotonic PHI increments by on loop iterations where the
  /// predicate is satisfied.
  const SCEV *getStepSCEV() const { return StepSCEV; }
 
  /// Returns the SCEV no-wrap flags that apply to StepInst.
  SCEVNoWrapFlags getSCEVNoWrapFlags() const { return NoWrapFlags; }
 
private:
  MonotonicDescriptor(PHINode *HeaderPHI, PHINode *BackedgePHI,
                      Instruction *StepInst, const SCEV *StartSCEV,
                      const SCEV *StepSCEV, SCEVNoWrapFlags NoWrapFlags)
      : HeaderPHI(HeaderPHI), BackedgePHI(BackedgePHI), StepInst(StepInst),
        StartSCEV(StartSCEV), StepSCEV(StepSCEV), NoWrapFlags(NoWrapFlags) {}
 
  /// The header PHI (this is the PHI described by the descriptor).
  PHINode *HeaderPHI = nullptr;
 
  /// The backedge PHI that selects between StepInst and the HeaderPHI.
  PHINode *BackedgePHI = nullptr;
 
  /// The instruction that updates the value of the monotonic PHI.
  Instruction *StepInst = nullptr;
 
  /// SCEV expression representing the start value for the monotonic PHI.
  const SCEV *StartSCEV = nullptr;
 
  /// SCEV expression representing the step value for the monotonic PHI.
  const SCEV *StepSCEV = nullptr;
 
  /// The SCEV no-wrap flags that apply to StepInst.
  SCEVNoWrapFlags NoWrapFlags{};
};
 
} // end namespace llvm
 
#endif // LLVM_ANALYSIS_IVDESCRIPTORS_H