[llvm] r289216 - [SCEVExpander] Remove \brief, reflow comments; NFC
Sanjoy Das via llvm-commits
llvm-commits at lists.llvm.org
Fri Dec 9 06:42:14 PST 2016
Author: sanjoy
Date: Fri Dec 9 08:42:14 2016
New Revision: 289216
URL: http://llvm.org/viewvc/llvm-project?rev=289216&view=rev
Log:
[SCEVExpander] Remove \brief, reflow comments; NFC
Modified:
llvm/trunk/include/llvm/Analysis/ScalarEvolutionExpander.h
Modified: llvm/trunk/include/llvm/Analysis/ScalarEvolutionExpander.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ScalarEvolutionExpander.h?rev=289216&r1=289215&r2=289216&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Analysis/ScalarEvolutionExpander.h (original)
+++ llvm/trunk/include/llvm/Analysis/ScalarEvolutionExpander.h Fri Dec 9 08:42:14 2016
@@ -30,8 +30,8 @@ namespace llvm {
/// all materialized values are safe to speculate.
bool isSafeToExpand(const SCEV *S, ScalarEvolution &SE);
- /// This class uses information about analyze scalars to
- /// rewrite expressions in canonical form.
+ /// This class uses information about analyze scalars to rewrite expressions
+ /// in canonical form.
///
/// Clients should create an instance of this class when rewriting is needed,
/// and destroy it when finished to allow the release of the associated
@@ -54,33 +54,31 @@ namespace llvm {
/// A memoization of the "relevant" loop for a given SCEV.
DenseMap<const SCEV *, const Loop *> RelevantLoops;
- /// \brief Addrecs referring to any of the given loops are expanded
- /// in post-inc mode. For example, expanding {1,+,1}<L> in post-inc mode
- /// returns the add instruction that adds one to the phi for {0,+,1}<L>,
- /// as opposed to a new phi starting at 1. This is only supported in
- /// non-canonical mode.
+ /// Addrecs referring to any of the given loops are expanded in post-inc
+ /// mode. For example, expanding {1,+,1}<L> in post-inc mode returns the add
+ /// instruction that adds one to the phi for {0,+,1}<L>, as opposed to a new
+ /// phi starting at 1. This is only supported in non-canonical mode.
PostIncLoopSet PostIncLoops;
- /// \brief When this is non-null, addrecs expanded in the loop it indicates
- /// should be inserted with increments at IVIncInsertPos.
+ /// When this is non-null, addrecs expanded in the loop it indicates should
+ /// be inserted with increments at IVIncInsertPos.
const Loop *IVIncInsertLoop;
- /// \brief When expanding addrecs in the IVIncInsertLoop loop, insert the IV
+ /// When expanding addrecs in the IVIncInsertLoop loop, insert the IV
/// increment at this position.
Instruction *IVIncInsertPos;
- /// \brief Phis that complete an IV chain. Reuse
+ /// Phis that complete an IV chain. Reuse
DenseSet<AssertingVH<PHINode>> ChainedPhis;
- /// \brief When true, expressions are expanded in "canonical" form. In
- /// particular, addrecs are expanded as arithmetic based on a canonical
- /// induction variable. When false, expression are expanded in a more
- /// literal form.
+ /// When true, expressions are expanded in "canonical" form. In particular,
+ /// addrecs are expanded as arithmetic based on a canonical induction
+ /// variable. When false, expression are expanded in a more literal form.
bool CanonicalMode;
- /// \brief When invoked from LSR, the expander is in "strength reduction"
- /// mode. The only difference is that phi's are only reused if they are
- /// already in "expanded" form.
+ /// When invoked from LSR, the expander is in "strength reduction" mode. The
+ /// only difference is that phi's are only reused if they are already in
+ /// "expanded" form.
bool LSRMode;
typedef IRBuilder<TargetFolder> BuilderType;
@@ -133,7 +131,7 @@ namespace llvm {
friend struct SCEVVisitor<SCEVExpander, Value*>;
public:
- /// \brief Construct a SCEVExpander in "canonical" mode.
+ /// Construct a SCEVExpander in "canonical" mode.
explicit SCEVExpander(ScalarEvolution &se, const DataLayout &DL,
const char *name)
: SE(se), DL(DL), IVName(name), IVIncInsertLoop(nullptr),
@@ -153,9 +151,9 @@ namespace llvm {
void setDebugType(const char* s) { DebugType = s; }
#endif
- /// \brief Erase the contents of the InsertedExpressions map so that users
- /// trying to expand the same expression into multiple BasicBlocks or
- /// different places within the same BasicBlock can do so.
+ /// Erase the contents of the InsertedExpressions map so that users trying
+ /// to expand the same expression into multiple BasicBlocks or different
+ /// places within the same BasicBlock can do so.
void clear() {
InsertedExpressions.clear();
InsertedValues.clear();
@@ -163,8 +161,8 @@ namespace llvm {
ChainedPhis.clear();
}
- /// \brief Return true for expressions that may incur non-trivial cost to
- /// evaluate at runtime.
+ /// Return true for expressions that may incur non-trivial cost to evaluate
+ /// at runtime.
///
/// At is an optional parameter which specifies point in code where user is
/// going to expand this expression. Sometimes this knowledge can lead to a
@@ -175,63 +173,60 @@ namespace llvm {
return isHighCostExpansionHelper(Expr, L, At, Processed);
}
- /// \brief This method returns the canonical induction variable of the
- /// specified type for the specified loop (inserting one if there is none).
- /// A canonical induction variable starts at zero and steps by one on each
+ /// This method returns the canonical induction variable of the specified
+ /// type for the specified loop (inserting one if there is none). A
+ /// canonical induction variable starts at zero and steps by one on each
/// iteration.
PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
- /// \brief Return the induction variable increment's IV operand.
+ /// Return the induction variable increment's IV operand.
Instruction *getIVIncOperand(Instruction *IncV, Instruction *InsertPos,
bool allowScale);
- /// \brief Utility for hoisting an IV increment.
+ /// Utility for hoisting an IV increment.
bool hoistIVInc(Instruction *IncV, Instruction *InsertPos);
- /// \brief replace congruent phis with their most canonical
- /// representative. Return the number of phis eliminated.
+ /// replace congruent phis with their most canonical representative. Return
+ /// the number of phis eliminated.
unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
SmallVectorImpl<WeakVH> &DeadInsts,
const TargetTransformInfo *TTI = nullptr);
- /// \brief Insert code to directly compute the specified SCEV expression
- /// into the program. The inserted code is inserted into the specified
- /// block.
+ /// Insert code to directly compute the specified SCEV expression into the
+ /// program. The inserted code is inserted into the specified block.
Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
- /// \brief Insert code to directly compute the specified SCEV expression
- /// into the program. The inserted code is inserted into the SCEVExpander's
- /// current insertion point. If a type is specified, the result will be
- /// expanded to have that type, with a cast if necessary.
+ /// Insert code to directly compute the specified SCEV expression into the
+ /// program. The inserted code is inserted into the SCEVExpander's current
+ /// insertion point. If a type is specified, the result will be expanded to
+ /// have that type, with a cast if necessary.
Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr);
- /// \brief Generates a code sequence that evaluates this predicate.
- /// The inserted instructions will be at position \p Loc.
- /// The result will be of type i1 and will have a value of 0 when the
- /// predicate is false and 1 otherwise.
+ /// Generates a code sequence that evaluates this predicate. The inserted
+ /// instructions will be at position \p Loc. The result will be of type i1
+ /// and will have a value of 0 when the predicate is false and 1 otherwise.
Value *expandCodeForPredicate(const SCEVPredicate *Pred, Instruction *Loc);
- /// \brief A specialized variant of expandCodeForPredicate, handling the
- /// case when we are expanding code for a SCEVEqualPredicate.
+ /// A specialized variant of expandCodeForPredicate, handling the case when
+ /// we are expanding code for a SCEVEqualPredicate.
Value *expandEqualPredicate(const SCEVEqualPredicate *Pred,
Instruction *Loc);
- /// \brief Generates code that evaluates if the \p AR expression will
- /// overflow.
+ /// Generates code that evaluates if the \p AR expression will overflow.
Value *generateOverflowCheck(const SCEVAddRecExpr *AR, Instruction *Loc,
bool Signed);
- /// \brief A specialized variant of expandCodeForPredicate, handling the
- /// case when we are expanding code for a SCEVWrapPredicate.
+ /// A specialized variant of expandCodeForPredicate, handling the case when
+ /// we are expanding code for a SCEVWrapPredicate.
Value *expandWrapPredicate(const SCEVWrapPredicate *P, Instruction *Loc);
- /// \brief A specialized variant of expandCodeForPredicate, handling the
- /// case when we are expanding code for a SCEVUnionPredicate.
+ /// A specialized variant of expandCodeForPredicate, handling the case when
+ /// we are expanding code for a SCEVUnionPredicate.
Value *expandUnionPredicate(const SCEVUnionPredicate *Pred,
Instruction *Loc);
- /// \brief Set the current IV increment loop and position.
+ /// Set the current IV increment loop and position.
void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
assert(!CanonicalMode &&
"IV increment positions are not supported in CanonicalMode");
@@ -239,7 +234,7 @@ namespace llvm {
IVIncInsertPos = Pos;
}
- /// \brief Enable post-inc expansion for addrecs referring to the given
+ /// Enable post-inc expansion for addrecs referring to the given
/// loops. Post-inc expansion is only supported in non-canonical mode.
void setPostInc(const PostIncLoopSet &L) {
assert(!CanonicalMode &&
@@ -247,7 +242,7 @@ namespace llvm {
PostIncLoops = L;
}
- /// \brief Disable all post-inc expansion.
+ /// Disable all post-inc expansion.
void clearPostInc() {
PostIncLoops.clear();
@@ -256,30 +251,29 @@ namespace llvm {
InsertedPostIncValues.clear();
}
- /// \brief Disable the behavior of expanding expressions in canonical form
- /// rather than in a more literal form. Non-canonical mode is useful for
- /// late optimization passes.
+ /// Disable the behavior of expanding expressions in canonical form rather
+ /// than in a more literal form. Non-canonical mode is useful for late
+ /// optimization passes.
void disableCanonicalMode() { CanonicalMode = false; }
void enableLSRMode() { LSRMode = true; }
- /// \brief Set the current insertion point. This is useful if multiple calls
- /// to expandCodeFor() are going to be made with the same insert point and
- /// the insert point may be moved during one of the expansions (e.g. if the
+ /// Set the current insertion point. This is useful if multiple calls to
+ /// expandCodeFor() are going to be made with the same insert point and the
+ /// insert point may be moved during one of the expansions (e.g. if the
/// insert point is not a block terminator).
void setInsertPoint(Instruction *IP) {
assert(IP);
Builder.SetInsertPoint(IP);
}
- /// \brief Clear the current insertion point. This is useful if the
- /// instruction that had been serving as the insertion point may have been
- /// deleted.
+ /// Clear the current insertion point. This is useful if the instruction
+ /// that had been serving as the insertion point may have been deleted.
void clearInsertPoint() {
Builder.ClearInsertionPoint();
}
- /// \brief Return true if the specified instruction was inserted by the code
+ /// Return true if the specified instruction was inserted by the code
/// rewriter. If so, the client should not modify the instruction.
bool isInsertedInstruction(Instruction *I) const {
return InsertedValues.count(I) || InsertedPostIncValues.count(I);
@@ -291,11 +285,10 @@ namespace llvm {
Value *getExactExistingExpansion(const SCEV *S, const Instruction *At,
Loop *L);
- /// Try to find the ValueOffsetPair for S. The function is mainly
- /// used to check whether S can be expanded cheaply.
- /// If this returns a non-None value, we know we can codegen the
- /// `ValueOffsetPair` into a suitable expansion identical with S
- /// so that S can be expanded cheaply.
+ /// Try to find the ValueOffsetPair for S. The function is mainly used to
+ /// check whether S can be expanded cheaply. If this returns a non-None
+ /// value, we know we can codegen the `ValueOffsetPair` into a suitable
+ /// expansion identical with S so that S can be expanded cheaply.
///
/// L is a hint which tells in which loop to look for the suitable value.
/// On success return value which is equivalent to the expanded S at point
@@ -310,40 +303,39 @@ namespace llvm {
private:
LLVMContext &getContext() const { return SE.getContext(); }
- /// \brief Recursive helper function for isHighCostExpansion.
+ /// Recursive helper function for isHighCostExpansion.
bool isHighCostExpansionHelper(const SCEV *S, Loop *L,
const Instruction *At,
SmallPtrSetImpl<const SCEV *> &Processed);
- /// \brief Insert the specified binary operator, doing a small amount
- /// of work to avoid inserting an obviously redundant operation.
+ /// Insert the specified binary operator, doing a small amount of work to
+ /// avoid inserting an obviously redundant operation.
Value *InsertBinop(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS);
- /// \brief Arrange for there to be a cast of V to Ty at IP, reusing an
- /// existing cast if a suitable one exists, moving an existing cast if a
- /// suitable one exists but isn't in the right place, or or creating a new
- /// one.
+ /// Arrange for there to be a cast of V to Ty at IP, reusing an existing
+ /// cast if a suitable one exists, moving an existing cast if a suitable one
+ /// exists but isn't in the right place, or or creating a new one.
Value *ReuseOrCreateCast(Value *V, Type *Ty,
Instruction::CastOps Op,
BasicBlock::iterator IP);
- /// \brief Insert a cast of V to the specified type, which must be possible
- /// with a noop cast, doing what we can to share the casts.
+ /// Insert a cast of V to the specified type, which must be possible with a
+ /// noop cast, doing what we can to share the casts.
Value *InsertNoopCastOfTo(Value *V, Type *Ty);
- /// \brief Expand a SCEVAddExpr with a pointer type into a GEP
- /// instead of using ptrtoint+arithmetic+inttoptr.
+ /// Expand a SCEVAddExpr with a pointer type into a GEP instead of using
+ /// ptrtoint+arithmetic+inttoptr.
Value *expandAddToGEP(const SCEV *const *op_begin,
const SCEV *const *op_end,
PointerType *PTy, Type *Ty, Value *V);
- /// \brief Find a previous Value in ExprValueMap for expand.
+ /// Find a previous Value in ExprValueMap for expand.
ScalarEvolution::ValueOffsetPair
FindValueInExprValueMap(const SCEV *S, const Instruction *InsertPt);
Value *expand(const SCEV *S);
- /// \brief Determine the most "relevant" loop for the given SCEV.
+ /// Determine the most "relevant" loop for the given SCEV.
const Loop *getRelevantLoop(const SCEV *);
Value *visitConstant(const SCEVConstant *S) {
More information about the llvm-commits
mailing list