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