From: Sanjoy Das Date: Fri, 9 Dec 2016 14:42:14 +0000 (+0000) Subject: [SCEVExpander] Remove \brief, reflow comments; NFC X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=004de6fe69ecda7659396510e28dc448cb51e377;p=platform%2Fupstream%2Fllvm.git [SCEVExpander] Remove \brief, reflow comments; NFC llvm-svn: 289216 --- diff --git a/llvm/include/llvm/Analysis/ScalarEvolutionExpander.h b/llvm/include/llvm/Analysis/ScalarEvolutionExpander.h index 19c1177..517592a 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolutionExpander.h +++ b/llvm/include/llvm/Analysis/ScalarEvolutionExpander.h @@ -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 RelevantLoops; - /// \brief Addrecs referring to any of the given loops are expanded - /// in post-inc mode. For example, expanding {1,+,1} in post-inc mode - /// returns the add instruction that adds one to the phi for {0,+,1}, - /// 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} in post-inc mode returns the add + /// instruction that adds one to the phi for {0,+,1}, 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> 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 BuilderType; @@ -133,7 +131,7 @@ namespace llvm { friend struct SCEVVisitor; 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 &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 &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) {