replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[SCEV] Don't repeat method/field names in comment in header; NFC. 

llvm-svn: 247918
This commit is contained in:
Sanjoy Das 2015-09-17 19:04:03 +00:00
parent 71d5fe3b11
commit ab39039a2f
1 changed files with 249 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

537
llvm/include/llvm/Analysis/ScalarEvolution.h
View File

@ -53,23 +53,22 @@ namespace llvm {
class SCEV; class SCEV;
template<> struct FoldingSetTrait<SCEV>; template<> struct FoldingSetTrait<SCEV>;
/// SCEV - This class represents an analyzed expression in the program. These /// This class represents an analyzed expression in the program. These are
/// are opaque objects that the client is not allowed to do much with /// opaque objects that the client is not allowed to do much with directly.
/// directly.
/// ///
class SCEV : public FoldingSetNode { class SCEV : public FoldingSetNode {
friend struct FoldingSetTrait<SCEV>; friend struct FoldingSetTrait<SCEV>;
/// FastID - A reference to an Interned FoldingSetNodeID for this node. /// A reference to an Interned FoldingSetNodeID for this node. The
/// The ScalarEvolution's BumpPtrAllocator holds the data. /// ScalarEvolution's BumpPtrAllocator holds the data.
FoldingSetNodeIDRef FastID; FoldingSetNodeIDRef FastID;
// The SCEV baseclass this node corresponds to // The SCEV baseclass this node corresponds to
const unsigned short SCEVType; const unsigned short SCEVType;
protected: protected:
/// SubclassData - This field is initialized to zero and may be used in /// This field is initialized to zero and may be used in subclasses to store
/// subclasses to store miscellaneous information. /// miscellaneous information.
unsigned short SubclassData; unsigned short SubclassData;
private: private:
@ -106,34 +105,31 @@ namespace llvm {
unsigned getSCEVType() const { return SCEVType; } unsigned getSCEVType() const { return SCEVType; }
/// getType - Return the LLVM type of this SCEV expression. /// Return the LLVM type of this SCEV expression.
/// ///
Type *getType() const; Type *getType() const;
/// isZero - Return true if the expression is a constant zero. /// Return true if the expression is a constant zero.
/// ///
bool isZero() const; bool isZero() const;
/// isOne - Return true if the expression is a constant one. /// Return true if the expression is a constant one.
/// ///
bool isOne() const; bool isOne() const;
/// isAllOnesValue - Return true if the expression is a constant /// Return true if the expression is a constant all-ones value.
/// all-ones value.
/// ///
bool isAllOnesValue() const; bool isAllOnesValue() const;
/// isNonConstantNegative - Return true if the specified scev is negated, /// Return true if the specified scev is negated, but not a constant.
/// but not a constant.
bool isNonConstantNegative() const; bool isNonConstantNegative() const;
/// print - Print out the internal representation of this scalar to the /// Print out the internal representation of this scalar to the specified
/// specified stream. This should really only be used for debugging /// stream. This should really only be used for debugging purposes.
/// purposes.
void print(raw_ostream &OS) const; void print(raw_ostream &OS) const;
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
/// dump - This method is used for debugging. /// This method is used for debugging.
/// ///
void dump() const; void dump() const;
#endif #endif
@ -159,11 +155,10 @@ namespace llvm {
return OS; return OS;
} }
/// SCEVCouldNotCompute - An object of this class is returned by queries that /// An object of this class is returned by queries that could not be answered.
/// could not be answered. For example, if you ask for the number of /// For example, if you ask for the number of iterations of a linked-list
/// iterations of a linked-list traversal loop, you will get one of these. /// traversal loop, you will get one of these. None of the standard SCEV
/// None of the standard SCEV operations are valid on this class, it is just a /// operations are valid on this class, it is just a marker.
/// marker.
struct SCEVCouldNotCompute : public SCEV { struct SCEVCouldNotCompute : public SCEV {
SCEVCouldNotCompute(); SCEVCouldNotCompute();
@ -176,16 +171,14 @@ namespace llvm {
/// for services. /// for services.
class ScalarEvolution { class ScalarEvolution {
public: public:
/// LoopDisposition - An enum describing the relationship between a /// An enum describing the relationship between a SCEV and a loop.
/// SCEV and a loop.
enum LoopDisposition { enum LoopDisposition {
LoopVariant, ///< The SCEV is loop-variant (unknown). LoopVariant, ///< The SCEV is loop-variant (unknown).
LoopInvariant, ///< The SCEV is loop-invariant. LoopInvariant, ///< The SCEV is loop-invariant.
LoopComputable ///< The SCEV varies predictably with the loop. LoopComputable ///< The SCEV varies predictably with the loop.
}; };
/// BlockDisposition - An enum describing the relationship between a /// An enum describing the relationship between a SCEV and a basic block.
/// SCEV and a basic block.
enum BlockDisposition { enum BlockDisposition {
DoesNotDominateBlock, ///< The SCEV does not dominate the block. DoesNotDominateBlock, ///< The SCEV does not dominate the block.
DominatesBlock, ///< The SCEV dominates the block. DominatesBlock, ///< The SCEV dominates the block.
@ -208,8 +201,8 @@ namespace llvm {
} }
private: private:
/// SCEVCallbackVH - A CallbackVH to arrange for ScalarEvolution to be /// A CallbackVH to arrange for ScalarEvolution to be notified whenever a
/// notified whenever a Value is deleted. /// Value is deleted.
class SCEVCallbackVH final : public CallbackVH { class SCEVCallbackVH final : public CallbackVH {
ScalarEvolution *SE; ScalarEvolution *SE;
void deleted() override; void deleted() override;
@ -222,35 +215,34 @@ namespace llvm {
friend class SCEVExpander; friend class SCEVExpander;
friend class SCEVUnknown; friend class SCEVUnknown;
/// F - The function we are analyzing. /// The function we are analyzing.
/// ///
Function &F; Function &F;
/// TLI - The target library information for the target we are targeting. /// The target library information for the target we are targeting.
/// ///
TargetLibraryInfo &TLI; TargetLibraryInfo &TLI;
/// The tracker for @llvm.assume intrinsics in this function. /// The tracker for @llvm.assume intrinsics in this function.
AssumptionCache &AC; AssumptionCache &AC;
/// DT - The dominator tree. /// The dominator tree.
/// ///
DominatorTree &DT; DominatorTree &DT;
/// LI - The loop information for the function we are currently analyzing. /// The loop information for the function we are currently analyzing.
/// ///
LoopInfo &LI; LoopInfo &LI;
/// CouldNotCompute - This SCEV is used to represent unknown trip /// This SCEV is used to represent unknown trip counts and things.
/// counts and things.
std::unique_ptr<SCEVCouldNotCompute> CouldNotCompute; std::unique_ptr<SCEVCouldNotCompute> CouldNotCompute;
/// ValueExprMapType - The typedef for ValueExprMap. /// The typedef for ValueExprMap.
/// ///
typedef DenseMap<SCEVCallbackVH, const SCEV *, DenseMapInfo<Value *> > typedef DenseMap<SCEVCallbackVH, const SCEV *, DenseMapInfo<Value *> >
ValueExprMapType; ValueExprMapType;
/// ValueExprMap - This is a cache of the values we have analyzed so far. /// This is a cache of the values we have analyzed so far.
/// ///
ValueExprMapType ValueExprMap; ValueExprMapType ValueExprMap;
@ -261,10 +253,10 @@ namespace llvm {
/// conditions dominating the backedge of a loop. /// conditions dominating the backedge of a loop.
bool WalkingBEDominatingConds; bool WalkingBEDominatingConds;
/// ExitLimit - Information about the number of loop iterations for which a /// Information about the number of loop iterations for which a loop exit's
/// loop exit's branch condition evaluates to the not-taken path. This is a /// branch condition evaluates to the not-taken path. This is a temporary
/// temporary pair of exact and max expressions that are eventually /// pair of exact and max expressions that are eventually summarized in
/// summarized in ExitNotTakenInfo and BackedgeTakenInfo. /// ExitNotTakenInfo and BackedgeTakenInfo.
struct ExitLimit { struct ExitLimit {
const SCEV *Exact; const SCEV *Exact;
const SCEV *Max; const SCEV *Max;
@ -273,16 +265,16 @@ namespace llvm {
ExitLimit(const SCEV *E, const SCEV *M) : Exact(E), Max(M) {} ExitLimit(const SCEV *E, const SCEV *M) : Exact(E), Max(M) {}
/// hasAnyInfo - Test whether this ExitLimit contains any computed /// Test whether this ExitLimit contains any computed information, or
/// information, or whether it's all SCEVCouldNotCompute values. /// whether it's all SCEVCouldNotCompute values.
bool hasAnyInfo() const { bool hasAnyInfo() const {
return !isa<SCEVCouldNotCompute>(Exact) || return !isa<SCEVCouldNotCompute>(Exact) ||
!isa<SCEVCouldNotCompute>(Max); !isa<SCEVCouldNotCompute>(Max);
} }
}; };
/// ExitNotTakenInfo - Information about the number of times a particular /// Information about the number of times a particular loop exit may be
/// loop exit may be reached before exiting the loop. /// reached before exiting the loop.
struct ExitNotTakenInfo { struct ExitNotTakenInfo {
AssertingVH<BasicBlock> ExitingBlock; AssertingVH<BasicBlock> ExitingBlock;
const SCEV *ExactNotTaken; const SCEV *ExactNotTaken;
@ -290,14 +282,14 @@ namespace llvm {
ExitNotTakenInfo() : ExitingBlock(nullptr), ExactNotTaken(nullptr) {} ExitNotTakenInfo() : ExitingBlock(nullptr), ExactNotTaken(nullptr) {}
/// isCompleteList - Return true if all loop exits are computable. /// Return true if all loop exits are computable.
bool isCompleteList() const { bool isCompleteList() const {
return NextExit.getInt() == 0; return NextExit.getInt() == 0;
} }
void setIncomplete() { NextExit.setInt(1); } void setIncomplete() { NextExit.setInt(1); }
/// getNextExit - Return a pointer to the next exit's not-taken info. /// Return a pointer to the next exit's not-taken info.
ExitNotTakenInfo *getNextExit() const { ExitNotTakenInfo *getNextExit() const {
return NextExit.getPointer(); return NextExit.getPointer();
} }
@ -305,16 +297,16 @@ namespace llvm {
void setNextExit(ExitNotTakenInfo *ENT) { NextExit.setPointer(ENT); } void setNextExit(ExitNotTakenInfo *ENT) { NextExit.setPointer(ENT); }
}; };
/// BackedgeTakenInfo - Information about the backedge-taken count /// Information about the backedge-taken count of a loop. This currently
/// of a loop. This currently includes an exact count and a maximum count. /// includes an exact count and a maximum count.
/// ///
class BackedgeTakenInfo { class BackedgeTakenInfo {
/// ExitNotTaken - A list of computable exits and their not-taken counts. /// A list of computable exits and their not-taken counts. Loops almost
/// Loops almost never have more than one computable exit. /// never have more than one computable exit.
ExitNotTakenInfo ExitNotTaken; ExitNotTakenInfo ExitNotTaken;
/// Max - An expression indicating the least maximum backedge-taken /// An expression indicating the least maximum backedge-taken count of the
/// count of the loop that is known, or a SCEVCouldNotCompute. /// loop that is known, or a SCEVCouldNotCompute.
const SCEV *Max; const SCEV *Max;
public: public:
@ -325,80 +317,78 @@ namespace llvm {
SmallVectorImpl< std::pair<BasicBlock *, const SCEV *> > &ExitCounts, SmallVectorImpl< std::pair<BasicBlock *, const SCEV *> > &ExitCounts,
bool Complete, const SCEV *MaxCount); bool Complete, const SCEV *MaxCount);
/// hasAnyInfo - Test whether this BackedgeTakenInfo contains any /// Test whether this BackedgeTakenInfo contains any computed information,
/// computed information, or whether it's all SCEVCouldNotCompute /// or whether it's all SCEVCouldNotCompute values.
/// values.
bool hasAnyInfo() const { bool hasAnyInfo() const {
return ExitNotTaken.ExitingBlock || !isa<SCEVCouldNotCompute>(Max); return ExitNotTaken.ExitingBlock || !isa<SCEVCouldNotCompute>(Max);
} }
/// getExact - Return an expression indicating the exact backedge-taken /// Return an expression indicating the exact backedge-taken count of the
/// count of the loop if it is known, or SCEVCouldNotCompute /// loop if it is known, or SCEVCouldNotCompute otherwise. This is the
/// otherwise. This is the number of times the loop header can be /// number of times the loop header can be guaranteed to execute, minus
/// guaranteed to execute, minus one. /// one.
const SCEV *getExact(ScalarEvolution *SE) const; const SCEV *getExact(ScalarEvolution *SE) const;
/// getExact - Return the number of times this loop exit may fall through /// Return the number of times this loop exit may fall through to the back
/// to the back edge, or SCEVCouldNotCompute. The loop is guaranteed not /// edge, or SCEVCouldNotCompute. The loop is guaranteed not to exit via
/// to exit via this block before this number of iterations, but may exit /// this block before this number of iterations, but may exit via another
/// via another block. /// block.
const SCEV *getExact(BasicBlock *ExitingBlock, ScalarEvolution *SE) const; const SCEV *getExact(BasicBlock *ExitingBlock, ScalarEvolution *SE) const;
/// getMax - Get the max backedge taken count for the loop. /// Get the max backedge taken count for the loop.
const SCEV *getMax(ScalarEvolution *SE) const; const SCEV *getMax(ScalarEvolution *SE) const;
/// Return true if any backedge taken count expressions refer to the given /// Return true if any backedge taken count expressions refer to the given
/// subexpression. /// subexpression.
bool hasOperand(const SCEV *S, ScalarEvolution *SE) const; bool hasOperand(const SCEV *S, ScalarEvolution *SE) const;
/// clear - Invalidate this result and free associated memory. /// Invalidate this result and free associated memory.
void clear(); void clear();
}; };
/// BackedgeTakenCounts - Cache the backedge-taken count of the loops for /// Cache the backedge-taken count of the loops for this function as they
/// this function as they are computed. /// are computed.
DenseMap<const Loop*, BackedgeTakenInfo> BackedgeTakenCounts; DenseMap<const Loop*, BackedgeTakenInfo> BackedgeTakenCounts;
/// ConstantEvolutionLoopExitValue - This map contains entries for all of /// This map contains entries for all of the PHI instructions that we
/// the PHI instructions that we attempt to compute constant evolutions for. /// attempt to compute constant evolutions for. This allows us to avoid
/// This allows us to avoid potentially expensive recomputation of these /// potentially expensive recomputation of these properties. An instruction
/// properties. An instruction maps to null if we are unable to compute its /// maps to null if we are unable to compute its exit value.
/// exit value.
DenseMap<PHINode*, Constant*> ConstantEvolutionLoopExitValue; DenseMap<PHINode*, Constant*> ConstantEvolutionLoopExitValue;
/// ValuesAtScopes - This map contains entries for all the expressions /// This map contains entries for all the expressions that we attempt to
/// that we attempt to compute getSCEVAtScope information for, which can /// compute getSCEVAtScope information for, which can be expensive in
/// be expensive in extreme cases. /// extreme cases.
DenseMap<const SCEV *, DenseMap<const SCEV *,
SmallVector<std::pair<const Loop *, const SCEV *>, 2> > ValuesAtScopes; SmallVector<std::pair<const Loop *, const SCEV *>, 2> > ValuesAtScopes;
/// LoopDispositions - Memoized computeLoopDisposition results. /// Memoized computeLoopDisposition results.
DenseMap<const SCEV *, DenseMap<const SCEV *,
SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>> SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>>
LoopDispositions; LoopDispositions;
/// computeLoopDisposition - Compute a LoopDisposition value. /// Compute a LoopDisposition value.
LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L); LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L);
/// BlockDispositions - Memoized computeBlockDisposition results. /// Memoized computeBlockDisposition results.
DenseMap< DenseMap<
const SCEV *, const SCEV *,
SmallVector<PointerIntPair<const BasicBlock *, 2, BlockDisposition>, 2>> SmallVector<PointerIntPair<const BasicBlock *, 2, BlockDisposition>, 2>>
BlockDispositions; BlockDispositions;
/// computeBlockDisposition - Compute a BlockDisposition value. /// Compute a BlockDisposition value.
BlockDisposition computeBlockDisposition(const SCEV *S, const BasicBlock *BB); BlockDisposition computeBlockDisposition(const SCEV *S, const BasicBlock *BB);
/// UnsignedRanges - Memoized results from getRange /// Memoized results from getRange
DenseMap<const SCEV *, ConstantRange> UnsignedRanges; DenseMap<const SCEV *, ConstantRange> UnsignedRanges;
/// SignedRanges - Memoized results from getRange /// Memoized results from getRange
DenseMap<const SCEV *, ConstantRange> SignedRanges; DenseMap<const SCEV *, ConstantRange> SignedRanges;
/// RangeSignHint - Used to parameterize getRange /// Used to parameterize getRange
enum RangeSignHint { HINT_RANGE_UNSIGNED, HINT_RANGE_SIGNED }; enum RangeSignHint { HINT_RANGE_UNSIGNED, HINT_RANGE_SIGNED };
/// setRange - Set the memoized range for the given SCEV. /// Set the memoized range for the given SCEV.
const ConstantRange &setRange(const SCEV *S, RangeSignHint Hint, const ConstantRange &setRange(const SCEV *S, RangeSignHint Hint,
const ConstantRange &CR) { const ConstantRange &CR) {
DenseMap<const SCEV *, ConstantRange> &Cache = DenseMap<const SCEV *, ConstantRange> &Cache =
@ -411,159 +401,147 @@ namespace llvm {
return Pair.first->second; return Pair.first->second;
} }
/// getRange - Determine the range for a particular SCEV. /// Determine the range for a particular SCEV.
ConstantRange getRange(const SCEV *S, RangeSignHint Hint); ConstantRange getRange(const SCEV *S, RangeSignHint Hint);
/// createSCEV - We know that there is no SCEV for the specified value. /// We know that there is no SCEV for the specified value. Analyze the
/// Analyze the expression. /// expression.
const SCEV *createSCEV(Value *V); const SCEV *createSCEV(Value *V);
/// createNodeForPHI - Provide the special handling we need to analyze PHI /// Provide the special handling we need to analyze PHI SCEVs.
/// SCEVs.
const SCEV *createNodeForPHI(PHINode *PN); const SCEV *createNodeForPHI(PHINode *PN);
/// createNodeForGEP - Provide the special handling we need to analyze GEP /// Provide the special handling we need to analyze GEP SCEVs.
/// SCEVs.
const SCEV *createNodeForGEP(GEPOperator *GEP); const SCEV *createNodeForGEP(GEPOperator *GEP);
/// computeSCEVAtScope - Implementation code for getSCEVAtScope; called /// Implementation code for getSCEVAtScope; called at most once for each
/// at most once for each SCEV+Loop pair. /// SCEV+Loop pair.
/// ///
const SCEV *computeSCEVAtScope(const SCEV *S, const Loop *L); const SCEV *computeSCEVAtScope(const SCEV *S, const Loop *L);
/// ForgetSymbolicValue - This looks up computed SCEV values for all /// This looks up computed SCEV values for all instructions that depend on
/// instructions that depend on the given instruction and removes them from /// the given instruction and removes them from the ValueExprMap map if they
/// the ValueExprMap map if they reference SymName. This is used during PHI /// reference SymName. This is used during PHI resolution.
/// resolution.
void ForgetSymbolicName(Instruction *I, const SCEV *SymName); void ForgetSymbolicName(Instruction *I, const SCEV *SymName);
/// getBackedgeTakenInfo - Return the BackedgeTakenInfo for the given /// Return the BackedgeTakenInfo for the given loop, lazily computing new
/// loop, lazily computing new values if the loop hasn't been analyzed /// values if the loop hasn't been analyzed yet.
/// yet.
const BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L); const BackedgeTakenInfo &getBackedgeTakenInfo(const Loop *L);
/// ComputeBackedgeTakenCount - Compute the number of times the specified /// Compute the number of times the specified loop will iterate.
/// loop will iterate.
BackedgeTakenInfo ComputeBackedgeTakenCount(const Loop *L); BackedgeTakenInfo ComputeBackedgeTakenCount(const Loop *L);
/// ComputeExitLimit - Compute the number of times the backedge of the /// Compute the number of times the backedge of the specified loop will
/// specified loop will execute if it exits via the specified block. /// execute if it exits via the specified block.
ExitLimit ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock); ExitLimit ComputeExitLimit(const Loop *L, BasicBlock *ExitingBlock);
/// ComputeExitLimitFromCond - Compute the number of times the backedge of /// Compute the number of times the backedge of the specified loop will
/// the specified loop will execute if its exit condition were a conditional /// execute if its exit condition were a conditional branch of ExitCond,
/// branch of ExitCond, TBB, and FBB. /// TBB, and FBB.
ExitLimit ComputeExitLimitFromCond(const Loop *L, ExitLimit ComputeExitLimitFromCond(const Loop *L,
Value *ExitCond, Value *ExitCond,
BasicBlock *TBB, BasicBlock *TBB,
BasicBlock *FBB, BasicBlock *FBB,
bool IsSubExpr); bool IsSubExpr);
/// ComputeExitLimitFromICmp - Compute the number of times the backedge of /// Compute the number of times the backedge of the specified loop will
/// the specified loop will execute if its exit condition were a conditional /// execute if its exit condition were a conditional branch of the ICmpInst
/// branch of the ICmpInst ExitCond, TBB, and FBB. /// ExitCond, TBB, and FBB.
ExitLimit ComputeExitLimitFromICmp(const Loop *L, ExitLimit ComputeExitLimitFromICmp(const Loop *L,
ICmpInst *ExitCond, ICmpInst *ExitCond,
BasicBlock *TBB, BasicBlock *TBB,
BasicBlock *FBB, BasicBlock *FBB,
bool IsSubExpr); bool IsSubExpr);
/// ComputeExitLimitFromSingleExitSwitch - Compute the number of times the /// Compute the number of times the backedge of the specified loop will
/// backedge of the specified loop will execute if its exit condition were a /// execute if its exit condition were a switch with a single exiting case
/// switch with a single exiting case to ExitingBB. /// to ExitingBB.
ExitLimit ExitLimit
ComputeExitLimitFromSingleExitSwitch(const Loop *L, SwitchInst *Switch, ComputeExitLimitFromSingleExitSwitch(const Loop *L, SwitchInst *Switch,
BasicBlock *ExitingBB, bool IsSubExpr); BasicBlock *ExitingBB, bool IsSubExpr);
/// ComputeLoadConstantCompareExitLimit - Given an exit condition /// Given an exit condition of 'icmp op load X, cst', try to see if we can
/// of 'icmp op load X, cst', try to see if we can compute the /// compute the backedge-taken count.
/// backedge-taken count.
ExitLimit ComputeLoadConstantCompareExitLimit(LoadInst *LI, ExitLimit ComputeLoadConstantCompareExitLimit(LoadInst *LI,
Constant *RHS, Constant *RHS,
const Loop *L, const Loop *L,
ICmpInst::Predicate p); ICmpInst::Predicate p);
/// ComputeExitCountExhaustively - If the loop is known to execute a /// If the loop is known to execute a constant number of times (the
/// constant number of times (the condition evolves only from constants), /// condition evolves only from constants), try to evaluate a few iterations
/// try to evaluate a few iterations of the loop until we get the exit /// of the loop until we get the exit condition gets a value of ExitWhen
/// condition gets a value of ExitWhen (true or false). If we cannot /// (true or false). If we cannot evaluate the exit count of the loop,
/// evaluate the exit count of the loop, return CouldNotCompute. /// return CouldNotCompute.
const SCEV *ComputeExitCountExhaustively(const Loop *L, const SCEV *ComputeExitCountExhaustively(const Loop *L,
Value *Cond, Value *Cond,
bool ExitWhen); bool ExitWhen);
/// HowFarToZero - Return the number of times an exit condition comparing /// Return the number of times an exit condition comparing the specified
/// the specified value to zero will execute. If not computable, return /// value to zero will execute. If not computable, return CouldNotCompute.
/// CouldNotCompute.
ExitLimit HowFarToZero(const SCEV *V, const Loop *L, bool IsSubExpr); ExitLimit HowFarToZero(const SCEV *V, const Loop *L, bool IsSubExpr);
/// HowFarToNonZero - Return the number of times an exit condition checking /// Return the number of times an exit condition checking the specified
/// the specified value for nonzero will execute. If not computable, return /// value for nonzero will execute. If not computable, return
/// CouldNotCompute. /// CouldNotCompute.
ExitLimit HowFarToNonZero(const SCEV *V, const Loop *L); ExitLimit HowFarToNonZero(const SCEV *V, const Loop *L);
/// HowManyLessThans - Return the number of times an exit condition /// Return the number of times an exit condition containing the specified
/// containing the specified less-than comparison will execute. If not /// less-than comparison will execute. If not computable, return
/// computable, return CouldNotCompute. isSigned specifies whether the /// CouldNotCompute. isSigned specifies whether the less-than is signed.
/// less-than is signed.
ExitLimit HowManyLessThans(const SCEV *LHS, const SCEV *RHS, ExitLimit HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
const Loop *L, bool isSigned, bool IsSubExpr); const Loop *L, bool isSigned, bool IsSubExpr);
ExitLimit HowManyGreaterThans(const SCEV *LHS, const SCEV *RHS, ExitLimit HowManyGreaterThans(const SCEV *LHS, const SCEV *RHS,
const Loop *L, bool isSigned, bool IsSubExpr); const Loop *L, bool isSigned, bool IsSubExpr);
/// getPredecessorWithUniqueSuccessorForBB - Return a predecessor of BB /// Return a predecessor of BB (which may not be an immediate predecessor)
/// (which may not be an immediate predecessor) which has exactly one /// which has exactly one successor from which BB is reachable, or null if
/// successor from which BB is reachable, or null if no such block is /// no such block is found.
/// found.
std::pair<BasicBlock *, BasicBlock *> std::pair<BasicBlock *, BasicBlock *>
getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB); getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB);
/// isImpliedCond - Test whether the condition described by Pred, LHS, and /// Test whether the condition described by Pred, LHS, and RHS is true
/// RHS is true whenever the given FoundCondValue value evaluates to true. /// whenever the given FoundCondValue value evaluates to true.
bool isImpliedCond(ICmpInst::Predicate Pred, bool isImpliedCond(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS, const SCEV *LHS, const SCEV *RHS,
Value *FoundCondValue, Value *FoundCondValue,
bool Inverse); bool Inverse);
/// isImpliedCondOperands - Test whether the condition described by Pred, /// Test whether the condition described by Pred, LHS, and RHS is true
/// LHS, and RHS is true whenever the condition described by Pred, FoundLHS, /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
/// and FoundRHS is true. /// true.
bool isImpliedCondOperands(ICmpInst::Predicate Pred, bool isImpliedCondOperands(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS, const SCEV *LHS, const SCEV *RHS,
const SCEV *FoundLHS, const SCEV *FoundRHS); const SCEV *FoundLHS, const SCEV *FoundRHS);
/// isImpliedCondOperandsHelper - Test whether the condition described by /// Test whether the condition described by Pred, LHS, and RHS is true
/// Pred, LHS, and RHS is true whenever the condition described by Pred, /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
/// FoundLHS, and FoundRHS is true. /// true.
bool isImpliedCondOperandsHelper(ICmpInst::Predicate Pred, bool isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS, const SCEV *LHS, const SCEV *RHS,
const SCEV *FoundLHS, const SCEV *FoundLHS,
const SCEV *FoundRHS); const SCEV *FoundRHS);
/// isImpliedCondOperandsViaRanges - Test whether the condition described by /// Test whether the condition described by Pred, LHS, and RHS is true
/// Pred, LHS, and RHS is true whenever the condition described by Pred, /// whenever the condition described by Pred, FoundLHS, and FoundRHS is
/// FoundLHS, and FoundRHS is true. Utility function used by /// true. Utility function used by isImpliedCondOperands.
/// isImpliedCondOperands.
bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred, bool isImpliedCondOperandsViaRanges(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS, const SCEV *LHS, const SCEV *RHS,
const SCEV *FoundLHS, const SCEV *FoundLHS,
const SCEV *FoundRHS); const SCEV *FoundRHS);
/// getConstantEvolutionLoopExitValue - If we know that the specified Phi is /// If we know that the specified Phi is in the header of its containing
/// in the header of its containing loop, we know the loop executes a /// loop, we know the loop executes a constant number of times, and the PHI
/// constant number of times, and the PHI node is just a recurrence /// node is just a recurrence involving constants, fold it.
/// involving constants, fold it.
Constant *getConstantEvolutionLoopExitValue(PHINode *PN, const APInt& BEs, Constant *getConstantEvolutionLoopExitValue(PHINode *PN, const APInt& BEs,
const Loop *L); const Loop *L);
/// isKnownPredicateWithRanges - Test if the given expression is known to /// Test if the given expression is known to satisfy the condition described
/// satisfy the condition described by Pred and the known constant ranges /// by Pred and the known constant ranges of LHS and RHS.
/// of LHS and RHS.
/// ///
bool isKnownPredicateWithRanges(ICmpInst::Predicate Pred, bool isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS); const SCEV *LHS, const SCEV *RHS);
/// forgetMemoizedResults - Drop memoized information computed for S. /// Drop memoized information computed for S.
void forgetMemoizedResults(const SCEV *S); void forgetMemoizedResults(const SCEV *S);
/// Return an existing SCEV for V if there is one, otherwise return nullptr. /// Return an existing SCEV for V if there is one, otherwise return nullptr.
@ -611,24 +589,23 @@ namespace llvm {
LLVMContext &getContext() const { return F.getContext(); } LLVMContext &getContext() const { return F.getContext(); }
/// isSCEVable - Test if values of the given type are analyzable within /// Test if values of the given type are analyzable within the SCEV
/// the SCEV framework. This primarily includes integer types, and it /// framework. This primarily includes integer types, and it can optionally
/// can optionally include pointer types if the ScalarEvolution class /// include pointer types if the ScalarEvolution class has access to
/// has access to target-specific information. /// target-specific information.
bool isSCEVable(Type *Ty) const; bool isSCEVable(Type *Ty) const;
/// getTypeSizeInBits - Return the size in bits of the specified type, /// Return the size in bits of the specified type, for which isSCEVable must
/// for which isSCEVable must return true. /// return true.
uint64_t getTypeSizeInBits(Type *Ty) const; uint64_t getTypeSizeInBits(Type *Ty) const;
/// getEffectiveSCEVType - Return a type with the same bitwidth as /// Return a type with the same bitwidth as the given type and which
/// the given type and which represents how SCEV will treat the given /// represents how SCEV will treat the given type, for which isSCEVable must
/// type, for which isSCEVable must return true. For pointer types, /// return true. For pointer types, this is the pointer-sized integer type.
/// this is the pointer-sized integer type.
Type *getEffectiveSCEVType(Type *Ty) const; Type *getEffectiveSCEVType(Type *Ty) const;
/// getSCEV - Return a SCEV expression for the full generality of the /// Return a SCEV expression for the full generality of the specified
/// specified expression. /// expression.
const SCEV *getSCEV(Value *V); const SCEV *getSCEV(Value *V);
const SCEV *getConstant(ConstantInt *V); const SCEV *getConstant(ConstantInt *V);
@ -702,82 +679,74 @@ namespace llvm {
const SCEV *getUnknown(Value *V); const SCEV *getUnknown(Value *V);
const SCEV *getCouldNotCompute(); const SCEV *getCouldNotCompute();
/// getSizeOfExpr - Return an expression for sizeof AllocTy that is type /// Return an expression for sizeof AllocTy that is type IntTy
/// IntTy
/// ///
const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy); const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
/// getOffsetOfExpr - Return an expression for offsetof on the given field /// Return an expression for offsetof on the given field with type IntTy
/// with type IntTy
/// ///
const SCEV *getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo); const SCEV *getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo);
/// getNegativeSCEV - Return the SCEV object corresponding to -V. /// Return the SCEV object corresponding to -V.
/// ///
const SCEV *getNegativeSCEV(const SCEV *V, const SCEV *getNegativeSCEV(const SCEV *V,
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap); SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap);
/// getNotSCEV - Return the SCEV object corresponding to ~V. /// Return the SCEV object corresponding to ~V.
/// ///
const SCEV *getNotSCEV(const SCEV *V); const SCEV *getNotSCEV(const SCEV *V);
/// getMinusSCEV - Return LHS-RHS. Minus is represented in SCEV as A+B*-1. /// Return LHS-RHS. Minus is represented in SCEV as A+B*-1.
const SCEV *getMinusSCEV(const SCEV *LHS, const SCEV *RHS, const SCEV *getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap); SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap);
/// getTruncateOrZeroExtend - Return a SCEV corresponding to a conversion /// Return a SCEV corresponding to a conversion of the input value to the
/// of the input value to the specified type. If the type must be /// specified type. If the type must be extended, it is zero extended.
/// extended, it is zero extended.
const SCEV *getTruncateOrZeroExtend(const SCEV *V, Type *Ty); const SCEV *getTruncateOrZeroExtend(const SCEV *V, Type *Ty);
/// getTruncateOrSignExtend - Return a SCEV corresponding to a conversion /// Return a SCEV corresponding to a conversion of the input value to the
/// of the input value to the specified type. If the type must be /// specified type. If the type must be extended, it is sign extended.
/// extended, it is sign extended.
const SCEV *getTruncateOrSignExtend(const SCEV *V, Type *Ty); const SCEV *getTruncateOrSignExtend(const SCEV *V, Type *Ty);
/// getNoopOrZeroExtend - Return a SCEV corresponding to a conversion of /// Return a SCEV corresponding to a conversion of the input value to the
/// the input value to the specified type. If the type must be extended, /// specified type. If the type must be extended, it is zero extended. The
/// it is zero extended. The conversion must not be narrowing. /// conversion must not be narrowing.
const SCEV *getNoopOrZeroExtend(const SCEV *V, Type *Ty); const SCEV *getNoopOrZeroExtend(const SCEV *V, Type *Ty);
/// getNoopOrSignExtend - Return a SCEV corresponding to a conversion of /// Return a SCEV corresponding to a conversion of the input value to the
/// the input value to the specified type. If the type must be extended, /// specified type. If the type must be extended, it is sign extended. The
/// it is sign extended. The conversion must not be narrowing. /// conversion must not be narrowing.
const SCEV *getNoopOrSignExtend(const SCEV *V, Type *Ty); const SCEV *getNoopOrSignExtend(const SCEV *V, Type *Ty);
/// getNoopOrAnyExtend - Return a SCEV corresponding to a conversion of /// Return a SCEV corresponding to a conversion of the input value to the
/// the input value to the specified type. If the type must be extended, /// specified type. If the type must be extended, it is extended with
/// it is extended with unspecified bits. The conversion must not be /// unspecified bits. The conversion must not be narrowing.
/// narrowing.
const SCEV *getNoopOrAnyExtend(const SCEV *V, Type *Ty); const SCEV *getNoopOrAnyExtend(const SCEV *V, Type *Ty);
/// getTruncateOrNoop - Return a SCEV corresponding to a conversion of the /// Return a SCEV corresponding to a conversion of the input value to the
/// input value to the specified type. The conversion must not be /// specified type. The conversion must not be widening.
/// widening.
const SCEV *getTruncateOrNoop(const SCEV *V, Type *Ty); const SCEV *getTruncateOrNoop(const SCEV *V, Type *Ty);
/// getUMaxFromMismatchedTypes - Promote the operands to the wider of /// Promote the operands to the wider of the types using zero-extension, and
/// the types using zero-extension, and then perform a umax operation /// then perform a umax operation with them.
/// with them.
const SCEV *getUMaxFromMismatchedTypes(const SCEV *LHS, const SCEV *getUMaxFromMismatchedTypes(const SCEV *LHS,
const SCEV *RHS); const SCEV *RHS);
/// getUMinFromMismatchedTypes - Promote the operands to the wider of /// Promote the operands to the wider of the types using zero-extension, and
/// the types using zero-extension, and then perform a umin operation /// then perform a umin operation with them.
/// with them.
const SCEV *getUMinFromMismatchedTypes(const SCEV *LHS, const SCEV *getUMinFromMismatchedTypes(const SCEV *LHS,
const SCEV *RHS); const SCEV *RHS);
/// getPointerBase - Transitively follow the chain of pointer-type operands /// Transitively follow the chain of pointer-type operands until reaching a
/// until reaching a SCEV that does not have a single pointer operand. This /// SCEV that does not have a single pointer operand. This returns a
/// returns a SCEVUnknown pointer for well-formed pointer-type expressions, /// SCEVUnknown pointer for well-formed pointer-type expressions, but corner
/// but corner cases do exist. /// cases do exist.
const SCEV *getPointerBase(const SCEV *V); const SCEV *getPointerBase(const SCEV *V);
/// getSCEVAtScope - Return a SCEV expression for the specified value /// Return a SCEV expression for the specified value at the specified scope
/// at the specified scope in the program. The L value specifies a loop /// in the program. The L value specifies a loop nest to evaluate the
/// nest to evaluate the expression at, where null is the top-level or a /// expression at, where null is the top-level or a specified loop is
/// specified loop is immediately inside of the loop. /// immediately inside of the loop.
/// ///
/// This method can be used to compute the exit value for a variable defined /// This method can be used to compute the exit value for a variable defined
/// in a loop by querying what the value will hold in the parent loop. /// in a loop by querying what the value will hold in the parent loop.
@ -786,19 +755,17 @@ namespace llvm {
/// original value V is returned. /// original value V is returned.
const SCEV *getSCEVAtScope(const SCEV *S, const Loop *L); const SCEV *getSCEVAtScope(const SCEV *S, const Loop *L);
/// getSCEVAtScope - This is a convenience function which does /// This is a convenience function which does getSCEVAtScope(getSCEV(V), L).
/// getSCEVAtScope(getSCEV(V), L).
const SCEV *getSCEVAtScope(Value *V, const Loop *L); const SCEV *getSCEVAtScope(Value *V, const Loop *L);
/// isLoopEntryGuardedByCond - Test whether entry to the loop is protected /// Test whether entry to the loop is protected by a conditional between LHS
/// by a conditional between LHS and RHS. This is used to help avoid max /// and RHS. This is used to help avoid max expressions in loop trip
/// expressions in loop trip counts, and to eliminate casts. /// counts, and to eliminate casts.
bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred, bool isLoopEntryGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS); const SCEV *LHS, const SCEV *RHS);
/// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is /// Test whether the backedge of the loop is protected by a conditional
/// protected by a conditional between LHS and RHS. This is used to /// between LHS and RHS. This is used to to eliminate casts.
/// to eliminate casts.
bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred, bool isLoopBackedgeGuardedByCond(const Loop *L, ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS); const SCEV *LHS, const SCEV *RHS);
@ -809,13 +776,13 @@ namespace llvm {
/// the single exiting block passed to it. See that routine for details. /// the single exiting block passed to it. See that routine for details.
unsigned getSmallConstantTripCount(Loop *L); unsigned getSmallConstantTripCount(Loop *L);
/// getSmallConstantTripCount - Returns the maximum trip count of this loop /// Returns the maximum trip count of this loop as a normal unsigned
/// as a normal unsigned value. Returns 0 if the trip count is unknown or /// value. Returns 0 if the trip count is unknown or not constant. This
/// not constant. This "trip count" assumes that control exits via /// "trip count" assumes that control exits via ExitingBlock. More
/// ExitingBlock. More precisely, it is the number of times that control may /// precisely, it is the number of times that control may reach ExitingBlock
/// reach ExitingBlock before taking the branch. For loops with multiple /// before taking the branch. For loops with multiple exits, it may not be
/// exits, it may not be the number times that the loop header executes if /// the number times that the loop header executes if the loop exits
/// the loop exits prematurely via another branch. /// prematurely via another branch.
unsigned getSmallConstantTripCount(Loop *L, BasicBlock *ExitingBlock); unsigned getSmallConstantTripCount(Loop *L, BasicBlock *ExitingBlock);
/// \brief Returns the largest constant divisor of the trip count of the /// \brief Returns the largest constant divisor of the trip count of the
@ -826,25 +793,25 @@ namespace llvm {
/// the single exiting block passed to it. See that routine for details. /// the single exiting block passed to it. See that routine for details.
unsigned getSmallConstantTripMultiple(Loop *L); unsigned getSmallConstantTripMultiple(Loop *L);
/// getSmallConstantTripMultiple - Returns the largest constant divisor of /// Returns the largest constant divisor of the trip count of this loop as a
/// the trip count of this loop as a normal unsigned value, if /// normal unsigned value, if possible. This means that the actual trip
/// possible. This means that the actual trip count is always a multiple of /// count is always a multiple of the returned value (don't forget the trip
/// the returned value (don't forget the trip count could very well be zero /// count could very well be zero as well!). As explained in the comments
/// as well!). As explained in the comments for getSmallConstantTripCount, /// for getSmallConstantTripCount, this assumes that control exits the loop
/// this assumes that control exits the loop via ExitingBlock. /// via ExitingBlock.
unsigned getSmallConstantTripMultiple(Loop *L, BasicBlock *ExitingBlock); unsigned getSmallConstantTripMultiple(Loop *L, BasicBlock *ExitingBlock);
// getExitCount - Get the expression for the number of loop iterations for /// Get the expression for the number of loop iterations for which this loop
// which this loop is guaranteed not to exit via ExitingBlock. Otherwise /// is guaranteed not to exit via ExitingBlock. Otherwise return
// return SCEVCouldNotCompute. /// SCEVCouldNotCompute.
const SCEV *getExitCount(Loop *L, BasicBlock *ExitingBlock); const SCEV *getExitCount(Loop *L, BasicBlock *ExitingBlock);
/// getBackedgeTakenCount - If the specified loop has a predictable /// If the specified loop has a predictable backedge-taken count, return it,
/// backedge-taken count, return it, otherwise return a SCEVCouldNotCompute /// otherwise return a SCEVCouldNotCompute object. The backedge-taken count
/// object. The backedge-taken count is the number of times the loop header /// is the number of times the loop header will be branched to from within
/// will be branched to from within the loop. This is one less than the /// the loop. This is one less than the trip count of the loop, since it
/// trip count of the loop, since it doesn't count the first iteration, /// doesn't count the first iteration, when the header is branched to from
/// when the header is branched to from outside the loop. /// outside the loop.
/// ///
/// Note that it is not valid to call this method on a loop without a /// Note that it is not valid to call this method on a loop without a
/// loop-invariant backedge-taken count (see /// loop-invariant backedge-taken count (see
@ -852,24 +819,23 @@ namespace llvm {
/// ///
const SCEV *getBackedgeTakenCount(const Loop *L); const SCEV *getBackedgeTakenCount(const Loop *L);
/// getMaxBackedgeTakenCount - Similar to getBackedgeTakenCount, except /// Similar to getBackedgeTakenCount, except return the least SCEV value
/// return the least SCEV value that is known never to be less than the /// that is known never to be less than the actual backedge taken count.
/// actual backedge taken count.
const SCEV *getMaxBackedgeTakenCount(const Loop *L); const SCEV *getMaxBackedgeTakenCount(const Loop *L);
/// hasLoopInvariantBackedgeTakenCount - Return true if the specified loop /// Return true if the specified loop has an analyzable loop-invariant
/// has an analyzable loop-invariant backedge-taken count. /// backedge-taken count.
bool hasLoopInvariantBackedgeTakenCount(const Loop *L); bool hasLoopInvariantBackedgeTakenCount(const Loop *L);
/// forgetLoop - This method should be called by the client when it has /// This method should be called by the client when it has changed a loop in
/// changed a loop in a way that may effect ScalarEvolution's ability to /// a way that may effect ScalarEvolution's ability to compute a trip count,
/// compute a trip count, or if the loop is deleted. This call is /// or if the loop is deleted. This call is potentially expensive for large
/// potentially expensive for large loop bodies. /// loop bodies.
void forgetLoop(const Loop *L); void forgetLoop(const Loop *L);
/// forgetValue - This method should be called by the client when it has /// This method should be called by the client when it has changed a value
/// changed a value in a way that may effect its value, or which may /// in a way that may effect its value, or which may disconnect it from a
/// disconnect it from a def-use chain linking it to a loop. /// def-use chain linking it to a loop.
void forgetValue(Value *V); void forgetValue(Value *V);
/// \brief Called when the client has changed the disposition of values in /// \brief Called when the client has changed the disposition of values in
@ -879,50 +845,46 @@ namespace llvm {
/// recompute is simpler. /// recompute is simpler.
void forgetLoopDispositions(const Loop *L) { LoopDispositions.clear(); } void forgetLoopDispositions(const Loop *L) { LoopDispositions.clear(); }
/// GetMinTrailingZeros - Determine the minimum number of zero bits that S /// Determine the minimum number of zero bits that S is guaranteed to end in
/// is guaranteed to end in (at every loop iteration). It is, at the same /// (at every loop iteration). It is, at the same time, the minimum number
/// time, the minimum number of times S is divisible by 2. For example, /// of times S is divisible by 2. For example, given {4,+,8} it returns 2.
/// given {4,+,8} it returns 2. If S is guaranteed to be 0, it returns the /// If S is guaranteed to be 0, it returns the bitwidth of S.
/// bitwidth of S.
uint32_t GetMinTrailingZeros(const SCEV *S); uint32_t GetMinTrailingZeros(const SCEV *S);
/// getUnsignedRange - Determine the unsigned range for a particular SCEV. /// Determine the unsigned range for a particular SCEV.
/// ///
ConstantRange getUnsignedRange(const SCEV *S) { ConstantRange getUnsignedRange(const SCEV *S) {
return getRange(S, HINT_RANGE_UNSIGNED); return getRange(S, HINT_RANGE_UNSIGNED);
} }
/// getSignedRange - Determine the signed range for a particular SCEV. /// Determine the signed range for a particular SCEV.
/// ///
ConstantRange getSignedRange(const SCEV *S) { ConstantRange getSignedRange(const SCEV *S) {
return getRange(S, HINT_RANGE_SIGNED); return getRange(S, HINT_RANGE_SIGNED);
} }
/// isKnownNegative - Test if the given expression is known to be negative. /// Test if the given expression is known to be negative.
/// ///
bool isKnownNegative(const SCEV *S); bool isKnownNegative(const SCEV *S);
/// isKnownPositive - Test if the given expression is known to be positive. /// Test if the given expression is known to be positive.
/// ///
bool isKnownPositive(const SCEV *S); bool isKnownPositive(const SCEV *S);
/// isKnownNonNegative - Test if the given expression is known to be /// Test if the given expression is known to be non-negative.
/// non-negative.
/// ///
bool isKnownNonNegative(const SCEV *S); bool isKnownNonNegative(const SCEV *S);
/// isKnownNonPositive - Test if the given expression is known to be /// Test if the given expression is known to be non-positive.
/// non-positive.
/// ///
bool isKnownNonPositive(const SCEV *S); bool isKnownNonPositive(const SCEV *S);
/// isKnownNonZero - Test if the given expression is known to be /// Test if the given expression is known to be non-zero.
/// non-zero.
/// ///
bool isKnownNonZero(const SCEV *S); bool isKnownNonZero(const SCEV *S);
/// isKnownPredicate - Test if the given expression is known to satisfy /// Test if the given expression is known to satisfy the condition described
/// the condition described by Pred, LHS, and RHS. /// by Pred, LHS, and RHS.
/// ///
bool isKnownPredicate(ICmpInst::Predicate Pred, bool isKnownPredicate(ICmpInst::Predicate Pred,
const SCEV *LHS, const SCEV *RHS); const SCEV *LHS, const SCEV *RHS);
@ -937,44 +899,43 @@ namespace llvm {
const SCEV *&InvariantLHS, const SCEV *&InvariantLHS,
const SCEV *&InvariantRHS); const SCEV *&InvariantRHS);
/// SimplifyICmpOperands - Simplify LHS and RHS in a comparison with /// Simplify LHS and RHS in a comparison with predicate Pred. Return true
/// predicate Pred. Return true iff any changes were made. If the /// iff any changes were made. If the operands are provably equal or
/// operands are provably equal or unequal, LHS and RHS are set to /// unequal, LHS and RHS are set to the same value and Pred is set to either
/// the same value and Pred is set to either ICMP_EQ or ICMP_NE. /// ICMP_EQ or ICMP_NE.
/// ///
bool SimplifyICmpOperands(ICmpInst::Predicate &Pred, bool SimplifyICmpOperands(ICmpInst::Predicate &Pred,
const SCEV *&LHS, const SCEV *&LHS,
const SCEV *&RHS, const SCEV *&RHS,
unsigned Depth = 0); unsigned Depth = 0);
/// getLoopDisposition - Return the "disposition" of the given SCEV with /// Return the "disposition" of the given SCEV with respect to the given
/// respect to the given loop. /// loop.
LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L); LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L);
/// isLoopInvariant - Return true if the value of the given SCEV is /// Return true if the value of the given SCEV is unchanging in the
/// unchanging in the specified loop. /// specified loop.
bool isLoopInvariant(const SCEV *S, const Loop *L); bool isLoopInvariant(const SCEV *S, const Loop *L);
/// hasComputableLoopEvolution - Return true if the given SCEV changes value /// Return true if the given SCEV changes value in a known way in the
/// in a known way in the specified loop. This property being true implies /// specified loop. This property being true implies that the value is
/// that the value is variant in the loop AND that we can emit an expression /// variant in the loop AND that we can emit an expression to compute the
/// to compute the value of the expression at any particular loop iteration. /// value of the expression at any particular loop iteration.
bool hasComputableLoopEvolution(const SCEV *S, const Loop *L); bool hasComputableLoopEvolution(const SCEV *S, const Loop *L);
/// getLoopDisposition - Return the "disposition" of the given SCEV with /// Return the "disposition" of the given SCEV with respect to the given
/// respect to the given block. /// block.
BlockDisposition getBlockDisposition(const SCEV *S, const BasicBlock *BB); BlockDisposition getBlockDisposition(const SCEV *S, const BasicBlock *BB);
/// dominates - Return true if elements that makes up the given SCEV /// Return true if elements that makes up the given SCEV dominate the
/// dominate the specified basic block. /// specified basic block.
bool dominates(const SCEV *S, const BasicBlock *BB); bool dominates(const SCEV *S, const BasicBlock *BB);
/// properlyDominates - Return true if elements that makes up the given SCEV /// Return true if elements that makes up the given SCEV properly dominate
/// properly dominate the specified basic block. /// the specified basic block.
bool properlyDominates(const SCEV *S, const BasicBlock *BB); bool properlyDominates(const SCEV *S, const BasicBlock *BB);
/// hasOperand - Test whether the given SCEV has Op as a direct or /// Test whether the given SCEV has Op as a direct or indirect operand.
/// indirect operand.
bool hasOperand(const SCEV *S, const SCEV *Op) const; bool hasOperand(const SCEV *S, const SCEV *Op) const;
/// Return the size of an element read or written by Inst. /// Return the size of an element read or written by Inst.
@ -1091,9 +1052,9 @@ namespace llvm {
FoldingSet<SCEV> UniqueSCEVs; FoldingSet<SCEV> UniqueSCEVs;
BumpPtrAllocator SCEVAllocator; BumpPtrAllocator SCEVAllocator;
/// FirstUnknown - The head of a linked list of all SCEVUnknown /// The head of a linked list of all SCEVUnknown values that have been
/// values that have been allocated. This is used by releaseMemory /// allocated. This is used by releaseMemory to locate them all and call
/// to locate them all and call their destructors. /// their destructors.
SCEVUnknown *FirstUnknown; SCEVUnknown *FirstUnknown;
}; };