[polly] r280468 - Drop '@brief' from doxygen comments
Tobias Grosser via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 1 23:33:34 PDT 2016
Author: grosser
Date: Fri Sep 2 01:33:33 2016
New Revision: 280468
URL: http://llvm.org/viewvc/llvm-project?rev=280468&view=rev
Log:
Drop '@brief' from doxygen comments
LLVM's coding guideline suggests to not use @brief for one-sentence doxygen
comments to improve readability. Switch this once and for all to ensure people
do not copy @brief comments from other parts of Polly, when writing new code.
Modified:
polly/trunk/include/polly/Canonicalization.h
polly/trunk/include/polly/CodeGen/BlockGenerators.h
polly/trunk/include/polly/CodeGen/IRBuilder.h
polly/trunk/include/polly/CodeGen/IslAst.h
polly/trunk/include/polly/CodeGen/IslExprBuilder.h
polly/trunk/include/polly/CodeGen/IslNodeBuilder.h
polly/trunk/include/polly/CodeGen/LoopGenerators.h
polly/trunk/include/polly/CodeGen/RuntimeDebugBuilder.h
polly/trunk/include/polly/CodeGen/Utils.h
polly/trunk/include/polly/DependenceInfo.h
polly/trunk/include/polly/PolyhedralInfo.h
polly/trunk/include/polly/ScheduleOptimizer.h
polly/trunk/include/polly/ScopBuilder.h
polly/trunk/include/polly/ScopDetection.h
polly/trunk/include/polly/ScopDetectionDiagnostic.h
polly/trunk/include/polly/ScopInfo.h
polly/trunk/include/polly/ScopPass.h
polly/trunk/include/polly/Support/GICHelper.h
polly/trunk/include/polly/Support/SCEVAffinator.h
polly/trunk/include/polly/Support/SCEVValidator.h
polly/trunk/include/polly/Support/ScopHelper.h
polly/trunk/include/polly/Support/ScopLocation.h
polly/trunk/lib/Analysis/DependenceInfo.cpp
polly/trunk/lib/Analysis/ScopDetection.cpp
polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp
polly/trunk/lib/Analysis/ScopInfo.cpp
polly/trunk/lib/CodeGen/CodeGeneration.cpp
polly/trunk/lib/CodeGen/IRBuilder.cpp
polly/trunk/lib/CodeGen/IslAst.cpp
polly/trunk/lib/CodeGen/IslExprBuilder.cpp
polly/trunk/lib/CodeGen/IslNodeBuilder.cpp
polly/trunk/lib/Exchange/JSONExporter.cpp
polly/trunk/lib/Polly.cpp
polly/trunk/lib/Support/RegisterPasses.cpp
polly/trunk/lib/Support/SCEVAffinator.cpp
polly/trunk/lib/Support/SCEVValidator.cpp
polly/trunk/lib/Transform/CodePreparation.cpp
polly/trunk/lib/Transform/DeadCodeElimination.cpp
polly/trunk/lib/Transform/ScheduleOptimizer.cpp
Modified: polly/trunk/include/polly/Canonicalization.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Canonicalization.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Canonicalization.h (original)
+++ polly/trunk/include/polly/Canonicalization.h Fri Sep 2 01:33:33 2016
@@ -14,7 +14,7 @@
namespace polly {
-/// @brief Schedule a set of canonicalization passes to prepare for Polly
+/// Schedule a set of canonicalization passes to prepare for Polly.
///
/// The set of optimization passes was partially taken/copied from the
/// set of default optimization passes in LLVM. It is used to bring the code
Modified: polly/trunk/include/polly/CodeGen/BlockGenerators.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/BlockGenerators.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/BlockGenerators.h (original)
+++ polly/trunk/include/polly/CodeGen/BlockGenerators.h Fri Sep 2 01:33:33 2016
@@ -38,22 +38,22 @@ class MemoryAccess;
class ScopArrayInfo;
class IslExprBuilder;
-/// @brief Generate a new basic block for a polyhedral statement.
+/// Generate a new basic block for a polyhedral statement.
class BlockGenerator {
public:
typedef llvm::SmallVector<ValueMapT, 8> VectorValueMapT;
- /// @brief Map types to resolve scalar dependences.
+ /// Map types to resolve scalar dependences.
///
///@{
/// @see The ScalarMap and PHIOpMap member.
using ScalarAllocaMapTy = DenseMap<AssertingVH<Value>, AssertingVH<Value>>;
- /// @brief Simple vector of instructions to store escape users.
+ /// Simple vector of instructions to store escape users.
using EscapeUserVectorTy = SmallVector<Instruction *, 4>;
- /// @brief Map type to resolve escaping users for scalar instructions.
+ /// Map type to resolve escaping users for scalar instructions.
///
/// @see The EscapeMap member.
using EscapeUsersAllocaMapTy =
@@ -62,7 +62,7 @@ public:
///@}
- /// @brief Create a generator for basic blocks.
+ /// Create a generator for basic blocks.
///
/// @param Builder The LLVM-IR Builder used to generate the statement. The
/// code is generated at the location, the Builder points
@@ -83,7 +83,7 @@ public:
ScalarAllocaMapTy &PHIOpMap, EscapeUsersAllocaMapTy &EscapeMap,
ValueMapT &GlobalMap, IslExprBuilder *ExprBuilder = nullptr);
- /// @brief Copy the basic block.
+ /// Copy the basic block.
///
/// This copies the entire basic block and updates references to old values
/// with references to new values, as defined by GlobalMap.
@@ -97,7 +97,7 @@ public:
void copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
- /// @brief Return the scalar alloca for @p ScalarBase
+ /// Return the scalar alloca for @p ScalarBase.
///
/// If no alloca was mapped to @p ScalarBase a new one is created.
///
@@ -111,7 +111,7 @@ public:
/// GlobalMap.
Value *getOrCreateScalarAlloca(Value *ScalarBase);
- /// @brief Remove a Value's allocation from the ScalarMap.
+ /// Remove a Value's allocation from the ScalarMap.
///
/// This function allows to remove values from the ScalarMap. This is useful
/// if the corresponding alloca instruction will be deleted (or moved into
@@ -122,7 +122,7 @@ public:
/// @param ScalarBase The value to remove.
void freeScalarAlloc(Value *ScalarBase) { ScalarMap.erase(ScalarBase); }
- /// @brief Return the PHi-node alloca for @p ScalarBase
+ /// Return the PHi-node alloca for @p ScalarBase.
///
/// If no alloca was mapped to @p ScalarBase a new one is created.
///
@@ -132,27 +132,27 @@ public:
/// GlobalMap.
Value *getOrCreatePHIAlloca(Value *ScalarBase);
- /// @brief Return the alloca for @p Access
+ /// Return the alloca for @p Access.
///
/// If no alloca was mapped for @p Access a new one is created.
///
- /// @param Access The memory access for which to generate the alloca
+ /// @param Access The memory access for which to generate the alloca.
///
/// @returns The alloca for @p Access or a replacement value taken from
/// GlobalMap.
Value *getOrCreateAlloca(const MemoryAccess &Access);
- /// @brief Return the alloca for @p Array
+ /// Return the alloca for @p Array.
///
/// If no alloca was mapped for @p Array a new one is created.
///
- /// @param Array The array for which to generate the alloca
+ /// @param Array The array for which to generate the alloca.
///
/// @returns The alloca for @p Array or a replacement value taken from
/// GlobalMap.
Value *getOrCreateAlloca(const ScopArrayInfo *Array);
- /// @brief Finalize the code generation for the SCoP @p S.
+ /// Finalize the code generation for the SCoP @p S.
///
/// This will initialize and finalize the scalar variables we demoted during
/// the code generation.
@@ -161,7 +161,7 @@ public:
/// @see createScalarFinalization(Region &)
void finalizeSCoP(Scop &S);
- /// @brief An empty destructor
+ /// An empty destructor
virtual ~BlockGenerator() {}
BlockGenerator(const BlockGenerator &) = default;
@@ -172,13 +172,13 @@ protected:
ScalarEvolution &SE;
IslExprBuilder *ExprBuilder;
- /// @brief The dominator tree of this function.
+ /// The dominator tree of this function.
DominatorTree &DT;
- /// @brief The entry block of the current function.
+ /// The entry block of the current function.
BasicBlock *EntryBB;
- /// @brief Maps to resolve scalar dependences for PHI operands and scalars.
+ /// Maps to resolve scalar dependences for PHI operands and scalars.
///
/// When translating code that contains scalar dependences as they result from
/// inter-block scalar dependences (including the use of data carrying
@@ -300,25 +300,25 @@ protected:
///
///{
///
- /// @brief Memory locations used for the special PHI node modeling.
+ /// Memory locations used for the special PHI node modeling.
ScalarAllocaMapTy &PHIOpMap;
- /// @brief Memory locations used to model scalar dependences.
+ /// Memory locations used to model scalar dependences.
ScalarAllocaMapTy &ScalarMap;
///}
- /// @brief Map from instructions to their escape users as well as the alloca.
+ /// Map from instructions to their escape users as well as the alloca.
EscapeUsersAllocaMapTy &EscapeMap;
- /// @brief A map from llvm::Values referenced in the old code to a new set of
+ /// A map from llvm::Values referenced in the old code to a new set of
/// llvm::Values, which is used to replace these old values during
/// code generation.
ValueMapT &GlobalMap;
- /// @brief Split @p BB to create a new one we can use to clone @p BB in.
+ /// Split @p BB to create a new one we can use to clone @p BB in.
BasicBlock *splitBB(BasicBlock *BB);
- /// @brief Copy the given basic block.
+ /// Copy the given basic block.
///
/// @param Stmt The statement to code generate.
/// @param BB The basic block to code generate.
@@ -334,7 +334,7 @@ protected:
BasicBlock *copyBB(ScopStmt &Stmt, BasicBlock *BB, ValueMapT &BBMap,
LoopToScevMapT <S, isl_id_to_ast_expr *NewAccesses);
- /// @brief Copy the given basic block.
+ /// Copy the given basic block.
///
/// @param Stmt The statement to code generate.
/// @param BB The basic block to code generate.
@@ -350,7 +350,7 @@ protected:
ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
- /// @brief Return the alloca for @p ScalarBase in @p Map.
+ /// Return the alloca for @p ScalarBase in @p Map.
///
/// If no alloca was mapped to @p ScalarBase in @p Map a new one is created
/// and named after @p ScalarBase with the suffix @p NameExt.
@@ -363,7 +363,7 @@ protected:
Value *getOrCreateAlloca(Value *ScalarBase, ScalarAllocaMapTy &Map,
const char *NameExt);
- /// @brief Generate reload of scalars demoted to memory and needed by @p Stmt.
+ /// Generate reload of scalars demoted to memory and needed by @p Stmt.
///
/// @param Stmt The statement we generate code for.
/// @param LTS A mapping from loops virtual canonical induction
@@ -374,7 +374,7 @@ protected:
ValueMapT &BBMap,
__isl_keep isl_id_to_ast_expr *NewAccesses);
- /// @brief Generate the scalar stores for the given statement.
+ /// Generate the scalar stores for the given statement.
///
/// After the statement @p Stmt was copied all inner-SCoP scalar dependences
/// starting in @p Stmt (hence all scalar write accesses in @p Stmt) need to
@@ -391,13 +391,13 @@ protected:
ValueMapT &BBMap,
__isl_keep isl_id_to_ast_expr *NewAccesses);
- /// @brief Handle users of @p Inst outside the SCoP.
+ /// Handle users of @p Inst outside the SCoP.
///
/// @param S The current SCoP.
/// @param Inst The current instruction we check.
void handleOutsideUsers(const Scop &S, Instruction *Inst);
- /// @brief Find scalar statements that have outside users.
+ /// Find scalar statements that have outside users.
///
/// We register these scalar values to later update subsequent scalar uses of
/// these values to either use the newly computed value from within the scop
@@ -407,12 +407,12 @@ protected:
/// @param S The scop for which to find the outside users.
void findOutsideUsers(Scop &S);
- /// @brief Initialize the memory of demoted scalars.
+ /// Initialize the memory of demoted scalars.
///
/// @param S The scop for which to generate the scalar initializers.
void createScalarInitialization(Scop &S);
- /// @brief Create exit PHI node merges for PHI nodes with more than two edges
+ /// Create exit PHI node merges for PHI nodes with more than two edges
/// from inside the scop.
///
/// For scops which have a PHI node in the exit block that has more than two
@@ -428,14 +428,14 @@ protected:
/// @param S The scop for which to generate the exiting PHI nodes.
void createExitPHINodeMerges(Scop &S);
- /// @brief Promote the values of demoted scalars after the SCoP.
+ /// Promote the values of demoted scalars after the SCoP.
///
/// If a scalar value was used outside the SCoP we need to promote the value
/// stored in the memory cell allocated for that scalar and combine it with
/// the original value in the non-optimized SCoP.
void createScalarFinalization(Scop &S);
- /// @brief Try to synthesize a new value
+ /// Try to synthesize a new value
///
/// Given an old value, we try to synthesize it in a new context from its
/// original SCEV expression. We start from the original SCEV expression,
@@ -459,7 +459,7 @@ protected:
Value *trySynthesizeNewValue(ScopStmt &Stmt, Value *Old, ValueMapT &BBMap,
LoopToScevMapT <S, Loop *L) const;
- /// @brief Get the new version of a value.
+ /// Get the new version of a value.
///
/// Given an old value, we first check if a new version of this value is
/// available in the BBMap or GlobalMap. In case it is not and the value can
@@ -489,10 +489,10 @@ protected:
void copyInstScalar(ScopStmt &Stmt, Instruction *Inst, ValueMapT &BBMap,
LoopToScevMapT <S);
- /// @brief Get the innermost loop that surrounds the statement @p Stmt.
+ /// Get the innermost loop that surrounds the statement @p Stmt.
Loop *getLoopForStmt(const ScopStmt &Stmt) const;
- /// @brief Generate the operand address
+ /// Generate the operand address
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
@@ -500,7 +500,7 @@ protected:
ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
- /// @brief Generate the operand address.
+ /// Generate the operand address.
///
/// @param Stmt The statement to generate code for.
/// @param L The innermost loop that surrounds the statement.
@@ -520,7 +520,7 @@ protected:
isl_id_to_ast_expr *NewAccesses,
__isl_take isl_id *Id, Type *ExpectedType);
- /// @brief Generate the pointer value that is accesses by @p Access.
+ /// Generate the pointer value that is accesses by @p Access.
///
/// For write accesses, generate the target address. For read accesses,
/// generate the source address.
@@ -556,14 +556,14 @@ protected:
LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
- /// @brief Copy a single PHI instruction.
+ /// Copy a single PHI instruction.
///
/// The implementation in the BlockGenerator is trivial, however it allows
/// subclasses to handle PHIs different.
virtual void copyPHIInstruction(ScopStmt &, PHINode *, ValueMapT &,
LoopToScevMapT &) {}
- /// @brief Copy a single Instruction.
+ /// Copy a single Instruction.
///
/// This copies a single Instruction and updates references to old values
/// with references to new values, as defined by GlobalMap and BBMap.
@@ -585,18 +585,18 @@ protected:
void copyInstruction(ScopStmt &Stmt, Instruction *Inst, ValueMapT &BBMap,
LoopToScevMapT <S, isl_id_to_ast_expr *NewAccesses);
- /// @brief Helper to determine if @p Inst can be synthesized in @p Stmt.
+ /// Helper to determine if @p Inst can be synthesized in @p Stmt.
///
/// @returns false, iff @p Inst can be synthesized in @p Stmt.
bool canSyntheziseInStmt(ScopStmt &Stmt, Instruction *Inst);
- /// @brief Remove dead instructions generated for BB
+ /// Remove dead instructions generated for BB
///
/// @param BB The basic block code for which code has been generated.
/// @param BBMap A local map from old to new instructions.
void removeDeadInstructions(BasicBlock *BB, ValueMapT &BBMap);
- /// @brief Invalidate the scalar evolution expressions for a scop.
+ /// Invalidate the scalar evolution expressions for a scop.
///
/// This function invalidates the scalar evolution results for all
/// instructions that are part of a given scop. This is necessary to ensure
@@ -609,12 +609,12 @@ protected:
void invalidateScalarEvolution(Scop &S);
};
-/// @brief Generate a new vector basic block for a polyhedral statement.
+/// Generate a new vector basic block for a polyhedral statement.
///
/// The only public function exposed is generate().
class VectorBlockGenerator : BlockGenerator {
public:
- /// @brief Generate a new vector basic block for a ScoPStmt.
+ /// Generate a new vector basic block for a ScoPStmt.
///
/// This code generation is similar to the normal, scalar code generation,
/// except that each instruction is code generated for several vector lanes
@@ -676,7 +676,7 @@ private:
Type *getVectorPtrTy(const Value *V, int Width);
- /// @brief Load a vector from a set of adjacent scalars
+ /// Load a vector from a set of adjacent scalars
///
/// In case a set of scalars is known to be next to each other in memory,
/// create a vector load that loads those scalars
@@ -699,7 +699,7 @@ private:
__isl_keep isl_id_to_ast_expr *NewAccesses,
bool NegativeStride);
- /// @brief Load a vector initialized from a single scalar in memory
+ /// Load a vector initialized from a single scalar in memory
///
/// In case all elements of a vector are initialized to the same
/// scalar value, this value is loaded and shuffeled into all elements
@@ -716,7 +716,7 @@ private:
ValueMapT &BBMap,
__isl_keep isl_id_to_ast_expr *NewAccesses);
- /// @brief Load a vector from scalars distributed in memory
+ /// Load a vector from scalars distributed in memory
///
/// In case some scalars a distributed randomly in memory. Create a vector
/// by loading each scalar and by inserting one after the other into the
@@ -766,14 +766,14 @@ private:
bool hasVectorOperands(const Instruction *Inst, ValueMapT &VectorMap);
- /// @brief Generate vector loads for scalars.
+ /// Generate vector loads for scalars.
///
/// @param Stmt The scop statement for which to generate the loads.
/// @param VectorBlockMap A map that will be updated to relate the original
/// values with the newly generated vector loads.
void generateScalarVectorLoads(ScopStmt &Stmt, ValueMapT &VectorBlockMap);
- /// @brief Verify absence of scalar stores.
+ /// Verify absence of scalar stores.
///
/// @param Stmt The scop statement to check for scalar stores.
void verifyNoScalarStores(ScopStmt &Stmt);
@@ -791,17 +791,17 @@ private:
void copyStmt(ScopStmt &Stmt, __isl_keep isl_id_to_ast_expr *NewAccesses);
};
-/// @brief Generator for new versions of polyhedral region statements.
+/// Generator for new versions of polyhedral region statements.
class RegionGenerator : public BlockGenerator {
public:
- /// @brief Create a generator for regions.
+ /// Create a generator for regions.
///
/// @param BlockGen A generator for basic blocks.
RegionGenerator(BlockGenerator &BlockGen) : BlockGenerator(BlockGen) {}
virtual ~RegionGenerator() {}
- /// @brief Copy the region statement @p Stmt.
+ /// Copy the region statement @p Stmt.
///
/// This copies the entire region represented by @p Stmt and updates
/// references to old values with references to new values, as defined by
@@ -813,22 +813,22 @@ public:
__isl_keep isl_id_to_ast_expr *IdToAstExp);
private:
- /// @brief A map from old to new blocks in the region.
+ /// A map from old to new blocks in the region.
DenseMap<BasicBlock *, BasicBlock *> BlockMap;
- /// @brief The "BBMaps" for the whole region (one for each block).
+ /// The "BBMaps" for the whole region (one for each block).
DenseMap<BasicBlock *, ValueMapT> RegionMaps;
- /// @brief Mapping to remember PHI nodes that still need incoming values.
+ /// Mapping to remember PHI nodes that still need incoming values.
using PHINodePairTy = std::pair<const PHINode *, PHINode *>;
DenseMap<BasicBlock *, SmallVector<PHINodePairTy, 4>> IncompletePHINodeMap;
- /// @brief Repair the dominance tree after we created a copy block for @p BB.
+ /// Repair the dominance tree after we created a copy block for @p BB.
///
/// @returns The immediate dominator in the DT for @p BBCopy if in the region.
BasicBlock *repairDominance(BasicBlock *BB, BasicBlock *BBCopy);
- /// @brief Add the new operand from the copy of @p IncomingBB to @p PHICopy.
+ /// Add the new operand from the copy of @p IncomingBB to @p PHICopy.
///
/// @param Stmt The statement to code generate.
/// @param PHI The original PHI we copy.
@@ -839,8 +839,8 @@ private:
void addOperandToPHI(ScopStmt &Stmt, const PHINode *PHI, PHINode *PHICopy,
BasicBlock *IncomingBB, LoopToScevMapT <S);
- /// @brief Create a PHI that combines the incoming values from all incoming
- /// blocks that are in the subregion.
+ /// Create a PHI that combines the incoming values from all incoming blocks
+ /// that are in the subregion.
///
/// PHIs in the subregion's exit block can have incoming edges from within and
/// outside the subregion. This function combines the incoming values from
@@ -872,7 +872,7 @@ private:
/// @see buildExitPHI
Value *getExitScalar(MemoryAccess *MA, LoopToScevMapT <S, ValueMapT &BBMap);
- /// @brief Generate the scalar stores for the given statement.
+ /// Generate the scalar stores for the given statement.
///
/// After the statement @p Stmt was copied all inner-SCoP scalar dependences
/// starting in @p Stmt (hence all scalar write accesses in @p Stmt) need to
@@ -889,7 +889,7 @@ private:
generateScalarStores(ScopStmt &Stmt, LoopToScevMapT <S, ValueMapT &BBMAp,
__isl_keep isl_id_to_ast_expr *NewAccesses) override;
- /// @brief Copy a single PHI instruction.
+ /// Copy a single PHI instruction.
///
/// This copies a single PHI instruction and updates references to old values
/// with references to new values, as defined by GlobalMap and BBMap.
Modified: polly/trunk/include/polly/CodeGen/IRBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/IRBuilder.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/IRBuilder.h (original)
+++ polly/trunk/include/polly/CodeGen/IRBuilder.h Fri Sep 2 01:33:33 2016
@@ -26,7 +26,7 @@ class ScalarEvolution;
namespace polly {
class Scop;
-/// @brief Helper class to annotate newly generated SCoPs with metadata.
+/// Helper class to annotate newly generated SCoPs with metadata.
///
/// The annotations are twofold:
/// 1) Loops are stored in a stack-like structure in the order they are
@@ -44,23 +44,23 @@ class ScopAnnotator {
public:
ScopAnnotator();
- /// @brief Build all alias scopes for the given SCoP.
+ /// Build all alias scopes for the given SCoP.
void buildAliasScopes(Scop &S);
- /// @brief Add a new loop @p L which is parallel if @p IsParallel is true.
+ /// Add a new loop @p L which is parallel if @p IsParallel is true.
void pushLoop(llvm::Loop *L, bool IsParallel);
- /// @brief Remove the last added loop.
+ /// Remove the last added loop.
void popLoop(bool isParallel);
- /// @brief Annotate the new instruction @p I for all parallel loops.
+ /// Annotate the new instruction @p I for all parallel loops.
void annotate(llvm::Instruction *I);
- /// @brief Annotate the loop latch @p B wrt. @p L.
+ /// Annotate the loop latch @p B wrt. @p L.
void annotateLoopLatch(llvm::BranchInst *B, llvm::Loop *L,
bool IsParallel) const;
- /// @brief Add alternative alias based pointers
+ /// Add alternative alias based pointers
///
/// When annotating instructions with alias scope metadata, the right metadata
/// is identified through the base pointer of the memory access. In some cases
@@ -77,26 +77,26 @@ public:
AlternativeAliasBases.insert(NewMap.begin(), NewMap.end());
}
- /// @brief Delete the set of alternative alias bases
+ /// Delete the set of alternative alias bases
void resetAlternativeAliasBases() { AlternativeAliasBases.clear(); }
private:
- /// @brief The ScalarEvolution analysis we use to find base pointers.
+ /// The ScalarEvolution analysis we use to find base pointers.
llvm::ScalarEvolution *SE;
- /// @brief All loops currently under construction.
+ /// All loops currently under construction.
llvm::SmallVector<llvm::Loop *, 8> ActiveLoops;
- /// @brief Metadata pointing to parallel loops currently under construction.
+ /// Metadata pointing to parallel loops currently under construction.
llvm::SmallVector<llvm::MDNode *, 8> ParallelLoops;
- /// @brief The alias scope domain for the current SCoP.
+ /// The alias scope domain for the current SCoP.
llvm::MDNode *AliasScopeDomain;
- /// @brief A map from base pointers to its alias scope.
+ /// A map from base pointers to its alias scope.
llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::MDNode *> AliasScopeMap;
- /// @brief A map from base pointers to an alias scope list of other pointers.
+ /// A map from base pointers to an alias scope list of other pointers.
llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::MDNode *>
OtherAliasScopeListMap;
@@ -104,7 +104,7 @@ private:
AlternativeAliasBases;
};
-/// @brief Add Polly specifics when running IRBuilder.
+/// Add Polly specifics when running IRBuilder.
///
/// This is used to add additional items such as e.g. the llvm.loop.parallel
/// metadata.
@@ -132,7 +132,7 @@ private:
// matches for certain names.
typedef llvm::IRBuilder<llvm::ConstantFolder, IRInserter> PollyIRBuilder;
-/// @brief Return an IR builder pointed before the @p BB terminator.
+/// Return an IR builder pointed before the @p BB terminator.
static inline PollyIRBuilder createPollyIRBuilder(llvm::BasicBlock *BB,
ScopAnnotator &LA) {
PollyIRBuilder Builder(BB->getContext(), llvm::ConstantFolder(),
Modified: polly/trunk/include/polly/CodeGen/IslAst.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/IslAst.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/IslAst.h (original)
+++ polly/trunk/include/polly/CodeGen/IslAst.h Fri Sep 2 01:33:33 2016
@@ -53,10 +53,10 @@ public:
__isl_give isl_ast_node *getAst();
- /// @brief Get the run-time conditions for the Scop.
+ /// Get the run-time conditions for the Scop.
__isl_give isl_ast_expr *getRunCondition();
- /// @brief Build run-time condition for scop.
+ /// Build run-time condition for scop.
///
/// @param S The scop to build the condition for.
/// @param Build The isl_build object to use to build the condition.
@@ -79,36 +79,36 @@ class IslAstInfo : public ScopPass {
public:
using MemoryAccessSet = SmallPtrSet<MemoryAccess *, 4>;
- /// @brief Payload information used to annotate an AST node.
+ /// Payload information used to annotate an AST node.
struct IslAstUserPayload {
- /// @brief Construct and initialize the payload.
+ /// Construct and initialize the payload.
IslAstUserPayload()
: IsInnermost(false), IsInnermostParallel(false),
IsOutermostParallel(false), IsReductionParallel(false),
MinimalDependenceDistance(nullptr), Build(nullptr) {}
- /// @brief Cleanup all isl structs on destruction.
+ /// Cleanup all isl structs on destruction.
~IslAstUserPayload();
- /// @brief Flag to mark innermost loops.
+ /// Flag to mark innermost loops.
bool IsInnermost;
- /// @brief Flag to mark innermost parallel loops.
+ /// Flag to mark innermost parallel loops.
bool IsInnermostParallel;
- /// @brief Flag to mark outermost parallel loops.
+ /// Flag to mark outermost parallel loops.
bool IsOutermostParallel;
- /// @brief Flag to mark parallel loops which break reductions.
+ /// Flag to mark parallel loops which break reductions.
bool IsReductionParallel;
- /// @brief The minimal dependence distance for non parallel loops.
+ /// The minimal dependence distance for non parallel loops.
isl_pw_aff *MinimalDependenceDistance;
- /// @brief The build environment at the time this node was constructed.
+ /// The build environment at the time this node was constructed.
isl_ast_build *Build;
- /// @brief Set of accesses which break reduction dependences.
+ /// Set of accesses which break reduction dependences.
MemoryAccessSet BrokenReductions;
};
@@ -120,22 +120,22 @@ public:
static char ID;
IslAstInfo() : ScopPass(ID), S(nullptr), Ast(nullptr) {}
- /// @brief Build the AST for the given SCoP @p S.
+ /// Build the AST for the given SCoP @p S.
bool runOnScop(Scop &S) override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
- /// @brief Release the internal memory.
+ /// Release the internal memory.
void releaseMemory() override;
- /// @brief Print a source code representation of the program.
+ /// Print a source code representation of the program.
void printScop(llvm::raw_ostream &OS, Scop &S) const override;
- /// @brief Return a copy of the AST root node.
+ /// Return a copy of the AST root node.
__isl_give isl_ast_node *getAst() const;
- /// @brief Get the run condition.
+ /// Get the run condition.
///
/// Only if the run condition evaluates at run-time to a non-zero value, the
/// assumptions that have been taken hold. If the run condition evaluates to
@@ -147,38 +147,38 @@ public:
///
///{
- /// @brief Get the complete payload attached to @p Node.
+ /// Get the complete payload attached to @p Node.
static IslAstUserPayload *getNodePayload(__isl_keep isl_ast_node *Node);
- /// @brief Is this loop an innermost loop?
+ /// Is this loop an innermost loop?
static bool isInnermost(__isl_keep isl_ast_node *Node);
- /// @brief Is this loop a parallel loop?
+ /// Is this loop a parallel loop?
static bool isParallel(__isl_keep isl_ast_node *Node);
- /// @brief Is this loop an outermost parallel loop?
+ /// Is this loop an outermost parallel loop?
static bool isOutermostParallel(__isl_keep isl_ast_node *Node);
- /// @brief Is this loop an innermost parallel loop?
+ /// Is this loop an innermost parallel loop?
static bool isInnermostParallel(__isl_keep isl_ast_node *Node);
- /// @brief Is this loop a reduction parallel loop?
+ /// Is this loop a reduction parallel loop?
static bool isReductionParallel(__isl_keep isl_ast_node *Node);
- /// @brief Will the loop be run as thread parallel?
+ /// Will the loop be run as thread parallel?
static bool isExecutedInParallel(__isl_keep isl_ast_node *Node);
- /// @brief Get the nodes schedule or a nullptr if not available.
+ /// Get the nodes schedule or a nullptr if not available.
static __isl_give isl_union_map *getSchedule(__isl_keep isl_ast_node *Node);
- /// @brief Get minimal dependence distance or nullptr if not available.
+ /// Get minimal dependence distance or nullptr if not available.
static __isl_give isl_pw_aff *
getMinimalDependenceDistance(__isl_keep isl_ast_node *Node);
- /// @brief Get the nodes broken reductions or a nullptr if not available.
+ /// Get the nodes broken reductions or a nullptr if not available.
static MemoryAccessSet *getBrokenReductions(__isl_keep isl_ast_node *Node);
- /// @brief Get the nodes build context or a nullptr if not available.
+ /// Get the nodes build context or a nullptr if not available.
static __isl_give isl_ast_build *getBuild(__isl_keep isl_ast_node *Node);
///}
Modified: polly/trunk/include/polly/CodeGen/IslExprBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/IslExprBuilder.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/IslExprBuilder.h (original)
+++ polly/trunk/include/polly/CodeGen/IslExprBuilder.h Fri Sep 2 01:33:33 2016
@@ -41,7 +41,7 @@ public:
namespace polly {
class ScopArrayInfo;
-/// @brief LLVM-IR generator for isl_ast_expr[essions]
+/// LLVM-IR generator for isl_ast_expr[essions]
///
/// This generator generates LLVM-IR that performs the computation described by
/// an isl_ast_expr[ession].
@@ -90,12 +90,12 @@ class ScopArrayInfo;
///
class IslExprBuilder {
public:
- /// @brief A map from isl_ids to llvm::Values.
+ /// A map from isl_ids to llvm::Values.
typedef llvm::MapVector<isl_id *, llvm::AssertingVH<llvm::Value>> IDToValueTy;
typedef llvm::MapVector<isl_id *, const ScopArrayInfo *> IDToScopArrayInfoTy;
- /// @brief A map from isl_ids to ScopArrayInfo objects.
+ /// A map from isl_ids to ScopArrayInfo objects.
///
/// This map is used to obtain ScopArrayInfo objects for isl_ids which do not
/// carry a ScopArrayInfo object in their user pointer. This is useful if the
@@ -107,12 +107,12 @@ public:
/// code generation.
IDToScopArrayInfoTy *IDToSAI = nullptr;
- /// @brief Set the isl_id to ScopArrayInfo map.
+ /// Set the isl_id to ScopArrayInfo map.
///
/// @param NewIDToSAI The new isl_id to ScopArrayInfo map to use.
void setIDToSAI(IDToScopArrayInfoTy *NewIDToSAI) { IDToSAI = NewIDToSAI; }
- /// @brief Construct an IslExprBuilder.
+ /// Construct an IslExprBuilder.
///
/// @param Builder The IRBuilder used to construct the isl_ast_expr[ession].
/// The insert location of this IRBuilder defines WHERE the
@@ -127,14 +127,14 @@ public:
llvm::ScalarEvolution &SE, llvm::DominatorTree &DT,
llvm::LoopInfo &LI);
- /// @brief Create LLVM-IR for an isl_ast_expr[ession].
+ /// Create LLVM-IR for an isl_ast_expr[ession].
///
/// @param Expr The ast expression for which we generate LLVM-IR.
///
/// @return The llvm::Value* containing the result of the computation.
llvm::Value *create(__isl_take isl_ast_expr *Expr);
- /// @brief Return the largest of two types.
+ /// Return the largest of two types.
///
/// @param T1 The first type.
/// @param T2 The second type.
@@ -142,7 +142,7 @@ public:
/// @return The largest of the two types.
llvm::Type *getWidestType(llvm::Type *T1, llvm::Type *T2);
- /// @brief Return the type with which this expression should be computed.
+ /// Return the type with which this expression should be computed.
///
/// The type needs to be large enough to hold all possible input and all
/// possible output values.
@@ -151,7 +151,7 @@ public:
/// @return The type with which the expression should be computed.
llvm::IntegerType *getType(__isl_keep isl_ast_expr *Expr);
- /// @brief Change if runtime overflows are tracked or not.
+ /// Change if runtime overflows are tracked or not.
///
/// @param Enable Flag to enable/disable the tracking.
///
@@ -159,7 +159,7 @@ public:
/// allowed if the last tracked expression dominates the current insert point.
void setTrackOverflow(bool Enable);
- /// @brief Return the current overflow status or nullptr if it is not tracked.
+ /// Return the current overflow status or nullptr if it is not tracked.
///
/// @return A nullptr if tracking is disabled or otherwise an i1 that has the
/// value of "0" if and only if no overflow happened since tracking
@@ -169,7 +169,7 @@ public:
private:
Scop &S;
- /// @brief Flag that will be set if an overflow occurred at runtime.
+ /// Flag that will be set if an overflow occurred at runtime.
///
/// Note that this flag is by default a nullptr and if it is a nullptr
/// we will not record overflows but simply perform the computations.
@@ -205,7 +205,7 @@ private:
llvm::Value *createOpAddressOf(__isl_take isl_ast_expr *Expr);
llvm::Value *createAccessAddress(__isl_take isl_ast_expr *Expr);
- /// @brief Create a binary operation @p Opc and track overflows if requested.
+ /// Create a binary operation @p Opc and track overflows if requested.
///
/// @param OpC The binary operation that should be performed [Add/Sub/Mul].
/// @param LHS The left operand.
@@ -217,7 +217,7 @@ private:
llvm::Value *LHS, llvm::Value *RHS,
const llvm::Twine &Name);
- /// @brief Create an addition and track overflows if requested.
+ /// Create an addition and track overflows if requested.
///
/// @param LHS The left operand.
/// @param RHS The right operand.
@@ -227,7 +227,7 @@ private:
llvm::Value *createAdd(llvm::Value *LHS, llvm::Value *RHS,
const llvm::Twine &Name = "");
- /// @brief Create a subtraction and track overflows if requested.
+ /// Create a subtraction and track overflows if requested.
///
/// @param LHS The left operand.
/// @param RHS The right operand.
@@ -237,7 +237,7 @@ private:
llvm::Value *createSub(llvm::Value *LHS, llvm::Value *RHS,
const llvm::Twine &Name = "");
- /// @brief Create a multiplication and track overflows if requested.
+ /// Create a multiplication and track overflows if requested.
///
/// @param LHS The left operand.
/// @param RHS The right operand.
Modified: polly/trunk/include/polly/CodeGen/IslNodeBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/IslNodeBuilder.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/IslNodeBuilder.h (original)
+++ polly/trunk/include/polly/CodeGen/IslNodeBuilder.h Fri Sep 2 01:33:33 2016
@@ -67,7 +67,7 @@ public:
void addParameters(__isl_take isl_set *Context);
- /// @brief Generate code that evaluates @p Condition at run-time.
+ /// Generate code that evaluates @p Condition at run-time.
///
/// This function is typically called to generate the LLVM-IR for the
/// run-time condition of the scop, that verifies that all the optimistic
@@ -82,25 +82,25 @@ public:
void create(__isl_take isl_ast_node *Node);
- /// @brief Allocate memory for all new arrays created by Polly.
+ /// Allocate memory for all new arrays created by Polly.
void allocateNewArrays();
- /// @brief Preload all memory loads that are invariant.
+ /// Preload all memory loads that are invariant.
bool preloadInvariantLoads();
- /// @brief Finalize code generation.
+ /// Finalize code generation.
///
/// @see BlockGenerator::finalizeSCoP(Scop &S)
virtual void finalize() { BlockGen.finalizeSCoP(S); }
IslExprBuilder &getExprBuilder() { return ExprBuilder; }
- /// @brief Get the associated block generator.
+ /// Get the associated block generator.
///
/// @return A referecne to the associated block generator.
BlockGenerator &getBlockGenerator() { return BlockGen; }
- /// @brief Return the parallel subfunctions that have been created.
+ /// Return the parallel subfunctions that have been created.
const ArrayRef<Function *> getParallelSubfunctions() const {
return ParallelSubfunctions;
}
@@ -112,25 +112,25 @@ protected:
IslExprBuilder ExprBuilder;
- /// @brief Maps used by the block and region generator to demote scalars.
+ /// Maps used by the block and region generator to demote scalars.
///
///@{
- /// @brief See BlockGenerator::ScalarMap.
+ /// See BlockGenerator::ScalarMap.
BlockGenerator::ScalarAllocaMapTy ScalarMap;
- /// @brief See BlockGenerator::PhiOpMap.
+ /// See BlockGenerator::PhiOpMap.
BlockGenerator::ScalarAllocaMapTy PHIOpMap;
- /// @brief See BlockGenerator::EscapeMap.
+ /// See BlockGenerator::EscapeMap.
BlockGenerator::EscapeUsersAllocaMapTy EscapeMap;
///@}
- /// @brief The generator used to copy a basic block.
+ /// The generator used to copy a basic block.
BlockGenerator BlockGen;
- /// @brief The generator used to copy a non-affine region.
+ /// The generator used to copy a non-affine region.
RegionGenerator RegionGen;
Pass *const P;
@@ -139,7 +139,7 @@ protected:
ScalarEvolution &SE;
DominatorTree &DT;
- /// @brief The current iteration of out-of-scop loops
+ /// The current iteration of out-of-scop loops
///
/// This map provides for a given loop a llvm::Value that contains the current
/// loop iteration.
@@ -150,7 +150,7 @@ protected:
// ivs.
IslExprBuilder::IDToValueTy IDToValue;
- /// @brief A collection of all parallel subfunctions that have been created.
+ /// A collection of all parallel subfunctions that have been created.
SmallVector<Function *, 8> ParallelSubfunctions;
/// Generate code for a given SCEV*
@@ -168,12 +168,12 @@ protected:
/// llvm::Values to new llvm::Values.
ValueMapT ValueMap;
- /// @brief Materialize code for @p Id if it was not done before.
+ /// Materialize code for @p Id if it was not done before.
///
/// @returns False, iff a problem occured and the value was not materialized.
bool materializeValue(__isl_take isl_id *Id);
- /// @brief Materialize parameters of @p Set.
+ /// Materialize parameters of @p Set.
///
/// @param All If not set only parameters referred to by the constraints in
/// @p Set will be materialized, otherwise all.
@@ -248,7 +248,7 @@ protected:
/// @param NewValues A map that maps certain llvm::Values to new llvm::Values.
void updateValues(ValueMapT &NewValues);
- /// @brief Generate code for a marker now.
+ /// Generate code for a marker now.
///
/// For mark nodes with an unknown name, we just forward the code generation
/// to its child. This is currently the only behavior implemented, as there is
@@ -258,18 +258,18 @@ protected:
virtual void createMark(__isl_take isl_ast_node *Marker);
virtual void createFor(__isl_take isl_ast_node *For);
- /// @brief Set to remember materialized invariant loads.
+ /// Set to remember materialized invariant loads.
///
/// An invariant load is identified by its pointer (the SCEV) and its type.
SmallSet<std::pair<const SCEV *, Type *>, 16> PreloadedPtrs;
- /// @brief Preload the memory access at @p AccessRange with @p Build.
+ /// Preload the memory access at @p AccessRange with @p Build.
///
/// @returns The preloaded value casted to type @p Ty
Value *preloadUnconditionally(__isl_take isl_set *AccessRange,
isl_ast_build *Build, Instruction *AccInst);
- /// @brief Preload the memory load access @p MA.
+ /// Preload the memory load access @p MA.
///
/// If @p MA is not always executed it will be conditionally loaded and
/// merged with undef from the same type. Hence, if @p MA is executed only
@@ -282,7 +282,7 @@ protected:
Value *preloadInvariantLoad(const MemoryAccess &MA,
__isl_take isl_set *Domain);
- /// @brief Preload the invariant access equivalence class @p IAClass
+ /// Preload the invariant access equivalence class @p IAClass
///
/// This function will preload the representing load from @p IAClass and
/// map all members of @p IAClass to that preloaded value, potentially casted
@@ -299,7 +299,7 @@ protected:
/// @param For The FOR isl_ast_node for which code is generated.
void createForParallel(__isl_take isl_ast_node *For);
- /// @brief Create new access functions for modified memory accesses.
+ /// Create new access functions for modified memory accesses.
///
/// In case the access function of one of the memory references in the Stmt
/// has been modified, we generate a new isl_ast_expr that reflects the
@@ -363,7 +363,7 @@ protected:
virtual void createUser(__isl_take isl_ast_node *User);
virtual void createBlock(__isl_take isl_ast_node *Block);
- /// @brief Get the schedule for a given AST node.
+ /// Get the schedule for a given AST node.
///
/// This information is used to reason about parallelism of loops or the
/// locality of memory accesses under a given schedule.
Modified: polly/trunk/include/polly/CodeGen/LoopGenerators.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/LoopGenerators.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/LoopGenerators.h (original)
+++ polly/trunk/include/polly/CodeGen/LoopGenerators.h Fri Sep 2 01:33:33 2016
@@ -29,7 +29,7 @@ class BasicBlock;
namespace polly {
using namespace llvm;
-/// @brief Create a scalar do/for-style loop.
+/// Create a scalar do/for-style loop.
///
/// @param LowerBound The starting value of the induction variable.
/// @param UpperBound The upper bound of the induction variable.
@@ -56,7 +56,7 @@ Value *createLoop(Value *LowerBound, Val
ScopAnnotator *Annotator = NULL, bool Parallel = false,
bool UseGuard = true);
-/// @brief The ParallelLoopGenerator allows to create parallelized loops
+/// The ParallelLoopGenerator allows to create parallelized loops
///
/// To parallelize a loop, we perform the following steps:
/// o Generate a subfunction which will hold the loop body.
@@ -98,7 +98,7 @@ Value *createLoop(Value *LowerBound, Val
/// }
class ParallelLoopGenerator {
public:
- /// @brief Create a parallel loop generator for the current function.
+ /// Create a parallel loop generator for the current function.
ParallelLoopGenerator(PollyIRBuilder &Builder, Pass *P, LoopInfo &LI,
DominatorTree &DT, const DataLayout &DL)
: Builder(Builder), P(P), LI(LI), DT(DT), DL(DL),
@@ -106,7 +106,7 @@ public:
Type::getIntNTy(Builder.getContext(), DL.getPointerSizeInBits())),
M(Builder.GetInsertBlock()->getParent()->getParent()) {}
- /// @brief Create a parallel loop.
+ /// Create a parallel loop.
///
/// This function is the main function to automatically generate a parallel
/// loop with all its components.
@@ -128,25 +128,25 @@ public:
BasicBlock::iterator *LoopBody);
private:
- /// @brief The IR builder we use to create instructions.
+ /// The IR builder we use to create instructions.
PollyIRBuilder &Builder;
- /// @brief A pass pointer to update analysis information.
+ /// A pass pointer to update analysis information.
Pass *P;
- /// @brief The loop info of the current function we need to update.
+ /// The loop info of the current function we need to update.
LoopInfo &LI;
- /// @brief The dominance tree of the current function we need to update.
+ /// The dominance tree of the current function we need to update.
DominatorTree &DT;
- /// @brief The target layout to get the right size for types.
+ /// The target layout to get the right size for types.
const DataLayout &DL;
- /// @brief The type of a "long" on this hardware used for backend calls.
+ /// The type of a "long" on this hardware used for backend calls.
Type *LongType;
- /// @brief The current module
+ /// The current module
Module *M;
public:
@@ -154,7 +154,7 @@ public:
/// specific OpenMP parallel loop, but generate individual parts of it
/// (e.g., the subfunction definition).
- /// @brief Create a runtime library call to spawn the worker threads.
+ /// Create a runtime library call to spawn the worker threads.
///
/// @param SubFn The subfunction which holds the loop body.
/// @param SubFnParam The parameter for the subfunction (basically the struct
@@ -165,10 +165,10 @@ public:
void createCallSpawnThreads(Value *SubFn, Value *SubFnParam, Value *LB,
Value *UB, Value *Stride);
- /// @brief Create a runtime library call to join the worker threads.
+ /// Create a runtime library call to join the worker threads.
void createCallJoinThreads();
- /// @brief Create a runtime library call to get the next work item.
+ /// Create a runtime library call to get the next work item.
///
/// @param LBPtr A pointer value to store the work item begin in.
/// @param UBPtr A pointer value to store the work item end in.
@@ -176,20 +176,20 @@ public:
/// @returns A true value if the work item is not empty.
Value *createCallGetWorkItem(Value *LBPtr, Value *UBPtr);
- /// @brief Create a runtime library call to allow cleanup of the thread.
+ /// Create a runtime library call to allow cleanup of the thread.
///
/// @note This function is called right before the thread will exit the
/// subfunction and only if the runtime system depends depends on it.
void createCallCleanupThread();
- /// @brief Create a struct for all @p Values and store them in there.
+ /// Create a struct for all @p Values and store them in there.
///
/// @param Values The values which should be stored in the struct.
///
/// @return The created struct.
AllocaInst *storeValuesIntoStruct(SetVector<Value *> &Values);
- /// @brief Extract all values from the @p Struct and construct the mapping.
+ /// Extract all values from the @p Struct and construct the mapping.
///
/// @param Values The values which were stored in the struct.
/// @param Struct The struct holding all the values in @p Values.
@@ -198,10 +198,10 @@ public:
void extractValuesFromStruct(SetVector<Value *> Values, Type *Ty,
Value *Struct, ValueMapT &VMap);
- /// @brief Create the definition of the parallel subfunction.
+ /// Create the definition of the parallel subfunction.
Function *createSubFnDefinition();
- /// @brief Create the parallel subfunction.
+ /// Create the parallel subfunction.
///
/// @param Stride The induction variable increment.
/// @param Struct A struct holding all values in @p Values.
Modified: polly/trunk/include/polly/CodeGen/RuntimeDebugBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/RuntimeDebugBuilder.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/RuntimeDebugBuilder.h (original)
+++ polly/trunk/include/polly/CodeGen/RuntimeDebugBuilder.h Fri Sep 2 01:33:33 2016
@@ -24,13 +24,13 @@ class Function;
namespace polly {
-/// @brief Insert function calls that print certain LLVM values at run time.
+/// Insert function calls that print certain LLVM values at run time.
///
/// This class inserts libc function calls to print certain LLVM values at
/// run time.
struct RuntimeDebugBuilder {
- /// @brief Print a set of LLVM-IR Values or StringRefs via printf
+ /// Print a set of LLVM-IR Values or StringRefs via printf
///
/// This function emits a call to printf that will print the given arguments.
/// It is useful for debugging CPU programs. All arguments given in this list
@@ -46,7 +46,7 @@ struct RuntimeDebugBuilder {
createPrinter(Builder, /* CPU */ false, Vector, args...);
}
- /// @brief Print a set of LLVM-IR Values or StringRefs on an NVIDIA GPU.
+ /// Print a set of LLVM-IR Values or StringRefs on an NVIDIA GPU.
///
/// This function emits a call to vprintf that will print the given
/// arguments from within a kernel thread. It is useful for debugging
@@ -64,7 +64,7 @@ struct RuntimeDebugBuilder {
}
private:
- /// @brief Handle Values.
+ /// Handle Values.
template <typename... Args>
static void createPrinter(PollyIRBuilder &Builder, bool UseGPU,
std::vector<llvm::Value *> &Values,
@@ -73,7 +73,7 @@ private:
createPrinter(Builder, UseGPU, Values, args...);
}
- /// @brief Handle StringRefs.
+ /// Handle StringRefs.
template <typename... Args>
static void createPrinter(PollyIRBuilder &Builder, bool UseGPU,
std::vector<llvm::Value *> &Values,
@@ -82,7 +82,7 @@ private:
createPrinter(Builder, UseGPU, Values, args...);
}
- /// @brief Handle ArrayRefs.
+ /// Handle ArrayRefs.
template <typename... Args>
static void createPrinter(PollyIRBuilder &Builder, bool UseGPU,
std::vector<llvm::Value *> &Values,
@@ -97,25 +97,25 @@ private:
createPrinter(Builder, UseGPU, Values, args...);
}
- /// @brief Print a list of Values.
+ /// Print a list of Values.
static void createPrinter(PollyIRBuilder &Builder, bool UseGPU,
llvm::ArrayRef<llvm::Value *> Values);
- /// @brief Print a list of Values on a GPU.
+ /// Print a list of Values on a GPU.
static void createGPUPrinterT(PollyIRBuilder &Builder,
llvm::ArrayRef<llvm::Value *> Values);
- /// @brief Print a list of Values on a CPU.
+ /// Print a list of Values on a CPU.
static void createCPUPrinterT(PollyIRBuilder &Builder,
llvm::ArrayRef<llvm::Value *> Values);
- /// @brief Get a reference to the 'printf' function.
+ /// Get a reference to the 'printf' function.
///
/// If the current module does not yet contain a reference to printf, we
/// insert a reference to it. Otherwise the existing reference is returned.
static llvm::Function *getPrintF(PollyIRBuilder &Builder);
- /// @brief Call printf
+ /// Call printf
///
/// @param Builder The builder used to insert the code.
/// @param Format The format string.
@@ -123,21 +123,21 @@ private:
static void createPrintF(PollyIRBuilder &Builder, std::string Format,
llvm::ArrayRef<llvm::Value *> Values);
- /// @brief Get (and possibly insert) a vprintf declaration into the module.
+ /// Get (and possibly insert) a vprintf declaration into the module.
static llvm::Function *getVPrintF(PollyIRBuilder &Builder);
- /// @brief Call fflush
+ /// Call fflush
///
/// @parma Builder The builder used to insert the code.
static void createFlush(PollyIRBuilder &Builder);
- /// @brief Get (and possibly insert) a NVIDIA address space cast call.
+ /// Get (and possibly insert) a NVIDIA address space cast call.
static llvm::Function *getAddressSpaceCast(PollyIRBuilder &Builder,
unsigned Src, unsigned Dst,
unsigned SrcBits = 8,
unsigned DstBits = 8);
- /// @brief Get identifiers that describe the currently executed GPU thread.
+ /// Get identifiers that describe the currently executed GPU thread.
///
/// The result will be a vector that if passed to the GPU printer will result
/// into a string (initialized to values corresponding to the printing
Modified: polly/trunk/include/polly/CodeGen/Utils.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/Utils.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/Utils.h (original)
+++ polly/trunk/include/polly/CodeGen/Utils.h Fri Sep 2 01:33:33 2016
@@ -23,7 +23,7 @@ namespace polly {
class Scop;
-/// @brief Execute a Scop conditionally wrt @p RTC.
+/// Execute a Scop conditionally wrt @p RTC.
///
/// In the CFG the optimized code of the Scop is generated next to the
/// original code. Both the new and the original version of the code remain
Modified: polly/trunk/include/polly/DependenceInfo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/DependenceInfo.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/DependenceInfo.h (original)
+++ polly/trunk/include/polly/DependenceInfo.h Fri Sep 2 01:33:33 2016
@@ -41,7 +41,7 @@ class Scop;
class ScopStmt;
class MemoryAccess;
-/// @brief The accumulated dependence information for a SCoP.
+/// The accumulated dependence information for a SCoP.
///
/// The Dependences struct holds all dependence information we collect and
/// compute for one SCoP. It also offers an interface that allows users to
@@ -58,13 +58,13 @@ struct Dependences {
NumAnalysisLevels
};
- /// @brief Map type for reduction dependences.
+ /// Map type for reduction dependences.
using ReductionDependencesMapTy = DenseMap<MemoryAccess *, isl_map *>;
- /// @brief Map type to associate statements with schedules.
+ /// Map type to associate statements with schedules.
using StatementToIslMapTy = DenseMap<ScopStmt *, isl_map *>;
- /// @brief The type of the dependences.
+ /// The type of the dependences.
///
/// Reduction dependences are separated from RAW/WAW/WAR dependences because
/// we can ignore them during the scheduling. That's because the order
@@ -92,27 +92,27 @@ struct Dependences {
TYPE_TC_RED = 1 << 4,
};
- /// @brief Get the dependences of type @p Kinds.
+ /// Get the dependences of type @p Kinds.
///
/// @param Kinds This integer defines the different kinds of dependences
/// that will be returned. To return more than one kind, the
/// different kinds are 'ored' together.
__isl_give isl_union_map *getDependences(int Kinds) const;
- /// @brief Report if valid dependences are available.
+ /// Report if valid dependences are available.
bool hasValidDependences() const;
- /// @brief Return the reduction dependences caused by @p MA.
+ /// Return the reduction dependences caused by @p MA.
///
/// @return The reduction dependences caused by @p MA or nullptr if none.
__isl_give isl_map *getReductionDependences(MemoryAccess *MA) const;
- /// @brief Return all reduction dependences.
+ /// Return all reduction dependences.
const ReductionDependencesMapTy &getReductionDependences() const {
return ReductionDependences;
}
- /// @brief Check if a partial schedule is parallel wrt to @p Deps.
+ /// Check if a partial schedule is parallel wrt to @p Deps.
///
/// @param Schedule The subset of the schedule space that we want to
/// check.
@@ -126,7 +126,7 @@ struct Dependences {
__isl_take isl_union_map *Deps,
__isl_give isl_pw_aff **MinDistancePtr = nullptr) const;
- /// @brief Check if a new schedule is valid.
+ /// Check if a new schedule is valid.
///
/// @param S The current SCoP.
/// @param NewSchedules The new schedules
@@ -135,64 +135,64 @@ struct Dependences {
/// dependences.
bool isValidSchedule(Scop &S, StatementToIslMapTy *NewSchedules) const;
- /// @brief Print the stored dependence information.
+ /// Print the stored dependence information.
void print(llvm::raw_ostream &OS) const;
- /// @brief Dump the dependence information stored to the dbgs stream.
+ /// Dump the dependence information stored to the dbgs stream.
void dump() const;
- /// @brief Return the granularity of this dependence analysis.
+ /// Return the granularity of this dependence analysis.
AnalyisLevel getDependenceLevel() { return Level; }
- /// @brief Allow the DependenceInfo access to private members and methods.
+ /// Allow the DependenceInfo access to private members and methods.
///
/// To restrict access to the internal state, only the DependenceInfo class
/// is able to call or modify a Dependences struct.
friend class DependenceInfo;
friend class DependenceInfoWrapperPass;
- /// @brief Destructor that will free internal objects.
+ /// Destructor that will free internal objects.
~Dependences() { releaseMemory(); }
private:
- /// @brief Create an empty dependences struct.
+ /// Create an empty dependences struct.
explicit Dependences(const std::shared_ptr<isl_ctx> &IslCtx,
AnalyisLevel Level)
: RAW(nullptr), WAR(nullptr), WAW(nullptr), RED(nullptr), TC_RED(nullptr),
IslCtx(IslCtx), Level(Level) {}
- /// @brief Calculate and add at the privatization dependences.
+ /// Calculate and add at the privatization dependences.
void addPrivatizationDependences();
- /// @brief Calculate the dependences for a certain SCoP @p S.
+ /// Calculate the dependences for a certain SCoP @p S.
void calculateDependences(Scop &S);
- /// @brief Set the reduction dependences for @p MA to @p Deps.
+ /// Set the reduction dependences for @p MA to @p Deps.
void setReductionDependences(MemoryAccess *MA, __isl_take isl_map *Deps);
- /// @brief Free the objects associated with this Dependences struct.
+ /// Free the objects associated with this Dependences struct.
///
/// The Dependences struct will again be "empty" afterwards.
void releaseMemory();
- /// @brief The different basic kinds of dependences we calculate.
+ /// The different basic kinds of dependences we calculate.
isl_union_map *RAW;
isl_union_map *WAR;
isl_union_map *WAW;
- /// @brief The special reduction dependences.
+ /// The special reduction dependences.
isl_union_map *RED;
- /// @brief The (reverse) transitive closure of reduction dependences.
+ /// The (reverse) transitive closure of reduction dependences.
isl_union_map *TC_RED;
- /// @brief Mapping from memory accesses to their reduction dependences.
+ /// Mapping from memory accesses to their reduction dependences.
ReductionDependencesMapTy ReductionDependences;
- /// @brief Isl context from the SCoP.
+ /// Isl context from the SCoP.
std::shared_ptr<isl_ctx> IslCtx;
- /// @brief Granularity of this dependence analysis
+ /// Granularity of this dependence analysis.
const AnalyisLevel Level;
};
@@ -200,10 +200,10 @@ class DependenceInfo : public ScopPass {
public:
static char ID;
- /// @brief Construct a new DependenceInfo pass.
+ /// Construct a new DependenceInfo pass.
DependenceInfo() : ScopPass(ID) {}
- /// @brief Return the dependence information for the current SCoP.
+ /// Return the dependence information for the current SCoP.
///
/// @param Level The granularity of dependence analysis result.
///
@@ -211,40 +211,40 @@ public:
///
const Dependences &getDependences(Dependences::AnalyisLevel Level);
- /// @brief Recompute dependences from schedule and memory accesses.
+ /// Recompute dependences from schedule and memory accesses.
const Dependences &recomputeDependences(Dependences::AnalyisLevel Level);
- /// @brief Compute the dependence information for the SCoP @p S.
+ /// Compute the dependence information for the SCoP @p S.
bool runOnScop(Scop &S) override;
- /// @brief Print the dependences for the given SCoP to @p OS.
+ /// Print the dependences for the given SCoP to @p OS.
void printScop(raw_ostream &OS, Scop &) const override;
- /// @brief Release the internal memory.
+ /// Release the internal memory.
void releaseMemory() override {
for (auto &d : D)
d.reset();
}
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
private:
Scop *S;
- /// @brief Dependences struct for the current SCoP.
+ /// Dependences struct for the current SCoP.
std::unique_ptr<Dependences> D[Dependences::NumAnalysisLevels];
};
-/// @brief Construct a new DependenceInfoWrapper pass.
+/// Construct a new DependenceInfoWrapper pass.
class DependenceInfoWrapperPass : public FunctionPass {
public:
static char ID;
- /// @brief Construct a new DependenceInfoWrapper pass.
+ /// Construct a new DependenceInfoWrapper pass.
DependenceInfoWrapperPass() : FunctionPass(ID) {}
- /// @brief Return the dependence information for the given SCoP.
+ /// Return the dependence information for the given SCoP.
///
/// @param S SCoP object.
/// @param Level The granularity of dependence analysis result.
@@ -253,26 +253,26 @@ public:
///
const Dependences &getDependences(Scop *S, Dependences::AnalyisLevel Level);
- /// @brief Recompute dependences from schedule and memory accesses.
+ /// Recompute dependences from schedule and memory accesses.
const Dependences &recomputeDependences(Scop *S,
Dependences::AnalyisLevel Level);
- /// @brief Compute the dependence information on-the-fly for the function.
+ /// Compute the dependence information on-the-fly for the function.
bool runOnFunction(Function &F) override;
- /// @brief Print the dependences for the current function to @p OS.
+ /// Print the dependences for the current function to @p OS.
void print(raw_ostream &OS, const Module *M = nullptr) const override;
- /// @brief Release the internal memory.
+ /// Release the internal memory.
void releaseMemory() override { ScopToDepsMap.clear(); }
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
private:
using ScopToDepsMapTy = DenseMap<Scop *, std::unique_ptr<Dependences>>;
- /// @brief Scop to Dependence map for the current function.
+ /// Scop to Dependence map for the current function.
ScopToDepsMapTy ScopToDepsMap;
};
Modified: polly/trunk/include/polly/PolyhedralInfo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/PolyhedralInfo.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/PolyhedralInfo.h (original)
+++ polly/trunk/include/polly/PolyhedralInfo.h Fri Sep 2 01:33:33 2016
@@ -34,18 +34,18 @@ class PolyhedralInfo : public llvm::Func
public:
static char ID; // Pass identification, replacement for typeid
- /// @brief Construct a new PolyhedralInfo pass.
+ /// Construct a new PolyhedralInfo pass.
PolyhedralInfo() : FunctionPass(ID) {}
~PolyhedralInfo() {}
- /// @brief Check if a given loop is parallel.
+ /// Check if a given loop is parallel.
///
/// @param L The loop.
///
/// @return Returns true, if loop is parallel false otherwise.
bool isParallel(llvm::Loop *L) const;
- /// @brief Return the SCoP containing the @p L loop.
+ /// Return the SCoP containing the @p L loop.
///
/// @param L The loop.
///
@@ -53,7 +53,7 @@ public:
/// Returns null if the loop is not contained in any SCoP.
const Scop *getScopContainingLoop(llvm::Loop *L) const;
- /// @brief Computes the partial schedule for the given @p L loop.
+ /// Computes the partial schedule for the given @p L loop.
///
/// @param S The SCoP containing the given loop
/// @param L The loop.
@@ -62,21 +62,21 @@ public:
__isl_give isl_union_map *getScheduleForLoop(const Scop *S,
llvm::Loop *L) const;
- /// @brief Get the SCoP and dependence analysis information for @p F.
+ /// Get the SCoP and dependence analysis information for @p F.
bool runOnFunction(llvm::Function &F) override;
- /// @brief Release the internal memory.
+ /// Release the internal memory.
void releaseMemory() override {}
- /// @brief Print to @p OS if each dimension of a loop nest is parallel or not.
+ /// Print to @p OS if each dimension of a loop nest is parallel or not.
void print(llvm::raw_ostream &OS,
const llvm::Module *M = nullptr) const override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(llvm::AnalysisUsage &AU) const override;
private:
- /// @brief Check if a given loop is parallel or vectorizable.
+ /// Check if a given loop is parallel or vectorizable.
///
/// @param L The loop.
/// @param MinDepDistPtr If not nullptr, the minimal dependence distance will
Modified: polly/trunk/include/polly/ScheduleOptimizer.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScheduleOptimizer.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScheduleOptimizer.h (original)
+++ polly/trunk/include/polly/ScheduleOptimizer.h Fri Sep 2 01:33:33 2016
@@ -20,7 +20,7 @@ struct isl_schedule;
struct isl_schedule_node;
struct isl_union_map;
-/// @brief Parameters of the micro kernel.
+/// Parameters of the micro kernel.
///
/// Parameters, which determine sizes of rank-1 (i.e., outer product) update
/// used in the optimized matrix multiplication.
@@ -30,7 +30,7 @@ struct MicroKernelParamsTy {
int Nr;
};
-/// @brief Parameters of the macro kernel.
+/// Parameters of the macro kernel.
///
/// Parameters, which determine sizes of blocks of partitioned matrices
/// used in the optimized matrix multiplication.
@@ -48,7 +48,7 @@ class Scop;
class ScheduleTreeOptimizer {
public:
- /// @brief Apply schedule tree transformations.
+ /// Apply schedule tree transformations.
///
/// This function takes an (possibly already optimized) schedule tree and
/// applies a set of additional optimizations on the schedule tree. The
@@ -65,7 +65,7 @@ public:
optimizeSchedule(__isl_take isl_schedule *Schedule,
const llvm::TargetTransformInfo *TTI = nullptr);
- /// @brief Apply schedule tree transformations.
+ /// Apply schedule tree transformations.
///
/// This function takes a node in an (possibly already optimized) schedule
/// tree and applies a set of additional optimizations on this schedule tree
@@ -81,7 +81,7 @@ public:
optimizeScheduleNode(__isl_take isl_schedule_node *Node,
const llvm::TargetTransformInfo *TTI = nullptr);
- /// @brief Decide if the @p NewSchedule is profitable for @p S.
+ /// Decide if the @p NewSchedule is profitable for @p S.
///
/// @param S The SCoP we optimize.
/// @param NewSchedule The new schedule we computed.
@@ -90,7 +90,7 @@ public:
static bool isProfitableSchedule(polly::Scop &S,
__isl_keep isl_union_map *NewSchedule);
- /// @brief Isolate a set of partial tile prefixes.
+ /// Isolate a set of partial tile prefixes.
///
/// This set should ensure that it contains only partial tile prefixes that
/// have exactly VectorWidth iterations.
@@ -102,7 +102,7 @@ public:
isolateFullPartialTiles(__isl_take isl_schedule_node *Node, int VectorWidth);
private:
- /// @brief Tile a schedule node.
+ /// Tile a schedule node.
///
/// @param Node The node to tile.
/// @param Identifier An name that identifies this kind of tiling and
@@ -116,7 +116,7 @@ private:
tileNode(__isl_take isl_schedule_node *Node, const char *Identifier,
llvm::ArrayRef<int> TileSizes, int DefaultTileSize);
- /// @brief Tile a schedule node and unroll point loops.
+ /// Tile a schedule node and unroll point loops.
///
/// @param Node The node to register tile.
/// @param TileSizes A vector of tile sizes that should be used for
@@ -126,7 +126,7 @@ private:
applyRegisterTiling(__isl_take isl_schedule_node *Node,
llvm::ArrayRef<int> TileSizes, int DefaultTileSize);
- /// @brief Apply the BLIS matmul optimization pattern.
+ /// Apply the BLIS matmul optimization pattern.
///
/// Apply the BLIS matmul optimization pattern. BLIS implements gemm as three
/// nested loops around a macro-kernel, plus two packing routines.
@@ -158,7 +158,7 @@ private:
optimizeMatMulPattern(__isl_take isl_schedule_node *Node,
const llvm::TargetTransformInfo *TTI);
- /// @brief Check if this node is a band node we want to tile.
+ /// Check if this node is a band node we want to tile.
///
/// We look for innermost band nodes where individual dimensions are marked as
/// permutable.
@@ -166,7 +166,7 @@ private:
/// @param Node The node to check.
static bool isTileableBandNode(__isl_keep isl_schedule_node *Node);
- /// @brief Pre-vectorizes one scheduling dimension of a schedule band.
+ /// Pre-vectorizes one scheduling dimension of a schedule band.
///
/// prevectSchedBand splits out the dimension DimToVectorize, tiles it and
/// sinks the resulting point loop.
@@ -201,7 +201,7 @@ private:
prevectSchedBand(__isl_take isl_schedule_node *Node, unsigned DimToVectorize,
int VectorWidth);
- /// @brief Apply additional optimizations on the bands in the schedule tree.
+ /// Apply additional optimizations on the bands in the schedule tree.
///
/// We are looking for an innermost band node and apply the following
/// transformations:
@@ -219,7 +219,7 @@ private:
/// (currently unused).
static isl_schedule_node *optimizeBand(isl_schedule_node *Node, void *User);
- /// @brief Apply additional optimizations on the bands in the schedule tree.
+ /// Apply additional optimizations on the bands in the schedule tree.
///
/// We apply the following
/// transformations:
@@ -235,7 +235,7 @@ private:
static isl_schedule_node *standardBandOpts(__isl_take isl_schedule_node *Node,
void *User);
- /// @brief Check if this node contains a partial schedule that could
+ /// Check if this node contains a partial schedule that could
/// probably be optimized with analytical modeling.
///
/// isMatrMultPattern tries to determine whether the following conditions
@@ -255,7 +255,7 @@ private:
/// @param Node The node to check.
static bool isMatrMultPattern(__isl_keep isl_schedule_node *Node);
- /// @brief Create the BLIS macro-kernel.
+ /// Create the BLIS macro-kernel.
///
/// We create the BLIS macro-kernel by applying a combination of tiling
/// of dimensions of the band node and interchanging of two innermost
@@ -269,7 +269,7 @@ private:
createMacroKernel(__isl_take isl_schedule_node *Node,
MacroKernelParamsTy MacroKernelParams);
- /// @brief Create the BLIS macro-kernel.
+ /// Create the BLIS macro-kernel.
///
/// We create the BLIS macro-kernel by applying a combination of tiling
/// of dimensions of the band node and interchanging of two innermost
Modified: polly/trunk/include/polly/ScopBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopBuilder.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopBuilder.h (original)
+++ polly/trunk/include/polly/ScopBuilder.h Fri Sep 2 01:33:33 2016
@@ -21,34 +21,34 @@
namespace polly {
-/// @brief Build the Polly IR (Scop and ScopStmt) on a Region.
+/// Build the Polly IR (Scop and ScopStmt) on a Region.
class ScopBuilder {
//===-------------------------------------------------------------------===//
ScopBuilder(const ScopBuilder &) = delete;
const ScopBuilder &operator=(const ScopBuilder &) = delete;
- /// @brief The AliasAnalysis to build AliasSetTracker.
+ /// The AliasAnalysis to build AliasSetTracker.
AliasAnalysis &AA;
- /// @brief Target data for element size computing.
+ /// Target data for element size computing.
const DataLayout &DL;
- /// @brief DominatorTree to reason about guaranteed execution.
+ /// DominatorTree to reason about guaranteed execution.
DominatorTree &DT;
- /// @brief LoopInfo for information about loops
+ /// LoopInfo for information about loops.
LoopInfo &LI;
- /// @biref Valid Regions for Scop
+ /// Valid Regions for Scop
ScopDetection &SD;
- /// @brief The ScalarEvolution to help building Scop.
+ /// The ScalarEvolution to help building Scop.
ScalarEvolution &SE;
- /// @brief Set of instructions that might read any memory location.
+ /// Set of instructions that might read any memory location.
SmallVector<Instruction *, 16> GlobalReads;
- /// @brief Set of all accessed array base pointers.
+ /// Set of all accessed array base pointers.
SmallSetVector<Value *, 16> ArrayBasePointers;
// The Scop
@@ -57,8 +57,8 @@ class ScopBuilder {
// Build the SCoP for Region @p R.
void buildScop(Region &R, AssumptionCache &AC);
- /// @brief Try to build a multi-dimensional fixed sized MemoryAccess from
- /// the Load/Store instruction.
+ /// Try to build a multi-dimensional fixed sized MemoryAccess from the
+ /// Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
/// @param L The parent loop of the instruction
@@ -66,7 +66,7 @@ class ScopBuilder {
/// @returns True if the access could be built, False otherwise.
bool buildAccessMultiDimFixed(MemAccInst Inst, Loop *L);
- /// @brief Try to build a multi-dimensional parameteric sized MemoryAccess
+ /// Try to build a multi-dimensional parameteric sized MemoryAccess.
/// from the Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
@@ -75,7 +75,7 @@ class ScopBuilder {
/// @returns True if the access could be built, False otherwise.
bool buildAccessMultiDimParam(MemAccInst Inst, Loop *L);
- /// @brief Try to build a MemoryAccess for a memory intrinsic.
+ /// Try to build a MemoryAccess for a memory intrinsic.
///
/// @param Inst The instruction that access the memory
/// @param L The parent loop of the instruction
@@ -83,7 +83,7 @@ class ScopBuilder {
/// @returns True if the access could be built, False otherwise.
bool buildAccessMemIntrinsic(MemAccInst Inst, Loop *L);
- /// @brief Try to build a MemoryAccess for a call instruction.
+ /// Try to build a MemoryAccess for a call instruction.
///
/// @param Inst The call instruction that access the memory
/// @param L The parent loop of the instruction
@@ -91,33 +91,35 @@ class ScopBuilder {
/// @returns True if the access could be built, False otherwise.
bool buildAccessCallInst(MemAccInst Inst, Loop *L);
- /// @brief Build a single-dimensional parametric sized MemoryAccess
+ /// Build a single-dimensional parametric sized MemoryAccess
/// from the Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
/// @param L The parent loop of the instruction
void buildAccessSingleDim(MemAccInst Inst, Loop *L);
- /// @brief Build an instance of MemoryAccess from the Load/Store instruction.
+ /// Build an instance of MemoryAccess from the Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
/// @param L The parent loop of the instruction
void buildMemoryAccess(MemAccInst Inst, Loop *L);
- /// @brief Analyze and extract the cross-BB scalar dependences (or,
- /// dataflow dependencies) of an instruction.
+ /// Analyze and extract the cross-BB scalar dependences (or, dataflow
+ /// dependencies) of an instruction.
///
/// @param Inst The instruction to be analyzed.
void buildScalarDependences(Instruction *Inst);
- /// @brief Search for uses of the llvm::Value defined by @p Inst that are not
- /// within the SCoP. If there is such use, add a SCALAR WRITE such that
- /// it is available after the SCoP as escaping value.
+ /// Build the escaping dependences for @p Inst.
+ ///
+ /// Search for uses of the llvm::Value defined by @p Inst that are not
+ /// within the SCoP. If there is such use, add a SCALAR WRITE such that
+ /// it is available after the SCoP as escaping value.
///
/// @param Inst The instruction to be analyzed.
void buildEscapingDependences(Instruction *Inst);
- /// @brief Create MemoryAccesses for the given PHI node in the given region.
+ /// Create MemoryAccesses for the given PHI node in the given region.
///
/// @param PHI The PHI node to be handled
/// @param NonAffineSubRegion The non affine sub-region @p PHI is in.
@@ -125,13 +127,13 @@ class ScopBuilder {
void buildPHIAccesses(PHINode *PHI, Region *NonAffineSubRegion,
bool IsExitBlock = false);
- /// @brief Build the access functions for the subregion @p SR.
+ /// Build the access functions for the subregion @p SR.
///
/// @param SR A subregion of @p R.
/// @param InsnToMemAcc The Instruction to MemoryAccess mapping.
void buildAccessFunctions(Region &SR);
- /// @brief Create ScopStmt for all BBs and non-affine subregions of @p SR.
+ /// Create ScopStmt for all BBs and non-affine subregions of @p SR.
///
/// @param SR A subregion of @p R.
///
@@ -139,7 +141,7 @@ class ScopBuilder {
/// access any memory and thus have no effect.
void buildStmts(Region &SR);
- /// @brief Build the access functions for the basic block @p BB
+ /// Build the access functions for the basic block @p BB.
///
/// @param BB A basic block in @p R.
/// @param NonAffineSubRegion The non affine sub-region @p BB is in.
@@ -148,7 +150,7 @@ class ScopBuilder {
Region *NonAffineSubRegion = nullptr,
bool IsExitBlock = false);
- /// @brief Create a new MemoryAccess object and add it to #AccFuncMap.
+ /// Create a new MemoryAccess object and add it to #AccFuncMap.
///
/// @param BB The block where the access takes place.
/// @param Inst The instruction doing the access. It is not necessarily
@@ -172,7 +174,7 @@ class ScopBuilder {
ArrayRef<const SCEV *> Sizes,
ScopArrayInfo::MemoryKind Kind);
- /// @brief Create a MemoryAccess that represents either a LoadInst or
+ /// Create a MemoryAccess that represents either a LoadInst or
/// StoreInst.
///
/// @param MemAccInst The LoadInst or StoreInst.
@@ -190,7 +192,7 @@ class ScopBuilder {
ArrayRef<const SCEV *> Subscripts,
ArrayRef<const SCEV *> Sizes, Value *AccessValue);
- /// @brief Create a MemoryAccess for writing an llvm::Instruction.
+ /// Create a MemoryAccess for writing an llvm::Instruction.
///
/// The access will be created at the position of @p Inst.
///
@@ -200,8 +202,8 @@ class ScopBuilder {
/// @see ScopArrayInfo::MemoryKind
void ensureValueWrite(Instruction *Inst);
- /// @brief Ensure an llvm::Value is available in the BB's statement, creating
- /// a MemoryAccess for reloading it if necessary.
+ /// Ensure an llvm::Value is available in the BB's statement, creating a
+ /// MemoryAccess for reloading it if necessary.
///
/// @param V The value expected to be loaded.
/// @param UserBB Where to reload the value.
@@ -210,7 +212,7 @@ class ScopBuilder {
/// @see ScopArrayInfo::MemoryKind
void ensureValueRead(Value *V, BasicBlock *UserBB);
- /// @brief Create a write MemoryAccess for the incoming block of a phi node.
+ /// Create a write MemoryAccess for the incoming block of a phi node.
///
/// Each of the incoming blocks write their incoming value to be picked in the
/// phi's block.
@@ -226,7 +228,7 @@ class ScopBuilder {
void ensurePHIWrite(PHINode *PHI, BasicBlock *IncomingBlock,
Value *IncomingValue, bool IsExitBlock);
- /// @brief Create a MemoryAccess for reading the value of a phi.
+ /// Create a MemoryAccess for reading the value of a phi.
///
/// The modeling assumes that all incoming blocks write their incoming value
/// to the same location. Thus, this access will read the incoming block's
@@ -245,8 +247,8 @@ public:
ScopDetection &SD, ScalarEvolution &SE);
~ScopBuilder() {}
- /// @brief Try to build the Polly IR of static control part on the current
- /// SESE-Region.
+ /// Try to build the Polly IR of static control part on the current
+ /// SESE-Region.
///
/// @return Give up the ownership of the scop object or static control part
/// for the region
Modified: polly/trunk/include/polly/ScopDetection.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopDetection.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopDetection.h (original)
+++ polly/trunk/include/polly/ScopDetection.h Fri Sep 2 01:33:33 2016
@@ -112,11 +112,11 @@ extern bool PollyUseRuntimeAliasChecks;
extern bool PollyProcessUnprofitable;
extern bool PollyInvariantLoadHoisting;
-/// @brief A function attribute which will cause Polly to skip the function
+/// A function attribute which will cause Polly to skip the function
extern llvm::StringRef PollySkipFnAttr;
//===----------------------------------------------------------------------===//
-/// @brief Pass to detect the maximal static control parts (Scops) of a
+/// Pass to detect the maximal static control parts (Scops) of a
/// function.
class ScopDetection : public FunctionPass {
public:
@@ -125,56 +125,56 @@ public:
// Remember the valid regions
RegionSet ValidRegions;
- /// @brief Context variables for SCoP detection.
+ /// Context variables for SCoP detection.
struct DetectionContext {
Region &CurRegion; // The region to check.
AliasSetTracker AST; // The AliasSetTracker to hold the alias information.
bool Verifying; // If we are in the verification phase?
- /// @brief Container to remember rejection reasons for this region.
+ /// Container to remember rejection reasons for this region.
RejectLog Log;
- /// @brief Map a base pointer to all access functions accessing it.
+ /// Map a base pointer to all access functions accessing it.
///
/// This map is indexed by the base pointer. Each element of the map
/// is a list of memory accesses that reference this base pointer.
BaseToAFs Accesses;
- /// @brief The set of base pointers with non-affine accesses.
+ /// The set of base pointers with non-affine accesses.
///
/// This set contains all base pointers and the locations where they are
/// used for memory accesses that can not be detected as affine accesses.
SetVector<std::pair<const SCEVUnknown *, Loop *>> NonAffineAccesses;
BaseToElSize ElementSize;
- /// @brief The region has at least one load instruction.
+ /// The region has at least one load instruction.
bool hasLoads;
- /// @brief The region has at least one store instruction.
+ /// The region has at least one store instruction.
bool hasStores;
- /// @brief Flag to indicate the region has at least one unknown access.
+ /// Flag to indicate the region has at least one unknown access.
bool HasUnknownAccess;
- /// @brief The set of non-affine subregions in the region we analyze.
+ /// The set of non-affine subregions in the region we analyze.
RegionSet NonAffineSubRegionSet;
- /// @brief The set of loops contained in non-affine regions.
+ /// The set of loops contained in non-affine regions.
BoxedLoopsSetTy BoxedLoopsSet;
- /// @brief Loads that need to be invariant during execution.
+ /// Loads that need to be invariant during execution.
InvariantLoadsSetTy RequiredILS;
- /// @brief Map to memory access description for the corresponding LLVM
+ /// Map to memory access description for the corresponding LLVM
/// instructions.
MapInsnToMemAcc InsnToMemAcc;
- /// @brief Initialize a DetectionContext from scratch.
+ /// Initialize a DetectionContext from scratch.
DetectionContext(Region &R, AliasAnalysis &AA, bool Verify)
: CurRegion(R), AST(AA), Verifying(Verify), Log(&R), hasLoads(false),
hasStores(false), HasUnknownAccess(false) {}
- /// @brief Initialize a DetectionContext with the data from @p DC.
+ /// Initialize a DetectionContext with the data from @p DC.
DetectionContext(const DetectionContext &&DC)
: CurRegion(DC.CurRegion), AST(DC.AST.getAliasAnalysis()),
Verifying(DC.Verifying), Log(std::move(DC.Log)),
@@ -194,7 +194,7 @@ private:
ScopDetection(const ScopDetection &) = delete;
const ScopDetection &operator=(const ScopDetection &) = delete;
- /// @brief Analysis passes used.
+ /// Analysis passes used.
//@{
const DominatorTree *DT;
ScalarEvolution *SE;
@@ -203,19 +203,19 @@ private:
AliasAnalysis *AA;
//@}
- /// @brief Map to remember detection contexts for all regions.
+ /// Map to remember detection contexts for all regions.
using DetectionContextMapTy = DenseMap<BBPair, DetectionContext>;
mutable DetectionContextMapTy DetectionContextMap;
- /// @brief Remove cached results for @p R.
+ /// Remove cached results for @p R.
void removeCachedResults(const Region &R);
- /// @brief Remove cached results for the children of @p R recursively.
+ /// Remove cached results for the children of @p R recursively.
///
/// @returns The number of regions erased regions.
unsigned removeCachedResultsRecursively(const Region &R);
- /// @brief Add the region @p AR as over approximated sub-region in @p Context.
+ /// Add the region @p AR as over approximated sub-region in @p Context.
///
/// @param AR The non-affine subregion.
/// @param Context The current detection context.
@@ -223,7 +223,7 @@ private:
/// @returns True if the subregion can be over approximated, false otherwise.
bool addOverApproximatedRegion(Region *AR, DetectionContext &Context) const;
- /// @brief Find for a given base pointer terms that hint towards dimension
+ /// Find for a given base pointer terms that hint towards dimension
/// sizes of a multi-dimensional array.
///
/// @param Context The current detection context.
@@ -233,7 +233,7 @@ private:
getDelinearizationTerms(DetectionContext &Context,
const SCEVUnknown *BasePointer) const;
- /// @brief Check if the dimension size of a delinearized array is valid.
+ /// Check if the dimension size of a delinearized array is valid.
///
/// @param Context The current detection context.
/// @param Sizes The sizes of the different array dimensions.
@@ -245,7 +245,7 @@ private:
SmallVectorImpl<const SCEV *> &Sizes,
const SCEVUnknown *BasePointer, Loop *Scope) const;
- /// @brief Derive access functions for a given base pointer.
+ /// Derive access functions for a given base pointer.
///
/// @param Context The current detection context.
/// @param Sizes The sizes of the different array dimensions.
@@ -259,7 +259,7 @@ private:
const SCEVUnknown *BasePointer,
std::shared_ptr<ArrayShape> Shape) const;
- /// @brief Check if all accesses to a given BasePointer are affine.
+ /// Check if all accesses to a given BasePointer are affine.
///
/// @param Context The current detection context.
/// @param basepointer the base pointer we are interested in.
@@ -283,14 +283,14 @@ private:
/// @param The region tree to scan for scops.
void findScops(Region &R);
- /// @brief Check if all basic block in the region are valid.
+ /// Check if all basic block in the region are valid.
///
/// @param Context The context of scop detection.
///
/// @return True if all blocks in R are valid, false otherwise.
bool allBlocksValid(DetectionContext &Context) const;
- /// @brief Check if a region has sufficient compute instructions
+ /// Check if a region has sufficient compute instructions.
///
/// This function checks if a region has a non-trivial number of instructions
/// in each loop. This can be used as an indicator if a loop is worth
@@ -304,7 +304,7 @@ private:
bool hasSufficientCompute(DetectionContext &Context,
int NumAffineLoops) const;
- /// @brief Check if the unique affine loop might be amendable to distribution.
+ /// Check if the unique affine loop might be amendable to distribution.
///
/// This function checks if the number of non-trivial blocks in the unique
/// affine loop in Context.CurRegion is at least two, thus if the loop might
@@ -315,7 +315,7 @@ private:
/// @return True only if the affine loop might be amendable to distributable.
bool hasPossiblyDistributableLoop(DetectionContext &Context) const;
- /// @brief Check if a region is profitable to optimize.
+ /// Check if a region is profitable to optimize.
///
/// Regions that are unlikely to expose interesting optimization opportunities
/// are called 'unprofitable' and may be skipped during scop detection.
@@ -325,14 +325,14 @@ private:
/// @return True if region is profitable to optimize, false otherwise.
bool isProfitableRegion(DetectionContext &Context) const;
- /// @brief Check if a region is a Scop.
+ /// Check if a region is a Scop.
///
/// @param Context The context of scop detection.
///
/// @return True if R is a Scop, false otherwise.
bool isValidRegion(DetectionContext &Context) const;
- /// @brief Check if an intrinsic call can be part of a Scop.
+ /// Check if an intrinsic call can be part of a Scop.
///
/// @param II The intrinsic call instruction to check.
/// @param Context The current detection context.
@@ -340,7 +340,7 @@ private:
/// @return True if the call instruction is valid, false otherwise.
bool isValidIntrinsicInst(IntrinsicInst &II, DetectionContext &Context) const;
- /// @brief Check if a call instruction can be part of a Scop.
+ /// Check if a call instruction can be part of a Scop.
///
/// @param CI The call instruction to check.
/// @param Context The current detection context.
@@ -348,7 +348,7 @@ private:
/// @return True if the call instruction is valid, false otherwise.
bool isValidCallInst(CallInst &CI, DetectionContext &Context) const;
- /// @brief Check if the given loads could be invariant and can be hoisted.
+ /// Check if the given loads could be invariant and can be hoisted.
///
/// If true is returned the loads are added to the required invariant loads
/// contained in the @p Context.
@@ -360,7 +360,7 @@ private:
bool onlyValidRequiredInvariantLoads(InvariantLoadsSetTy &RequiredILS,
DetectionContext &Context) const;
- /// @brief Check if a value is invariant in the region Reg.
+ /// Check if a value is invariant in the region Reg.
///
/// @param Val Value to check for invariance.
/// @param Reg The region to consider for the invariance of Val.
@@ -369,7 +369,7 @@ private:
/// identified by Reg.
bool isInvariant(const Value &Val, const Region &Reg) const;
- /// @brief Check if the memory access caused by @p Inst is valid.
+ /// Check if the memory access caused by @p Inst is valid.
///
/// @param Inst The access instruction.
/// @param AF The access function.
@@ -378,7 +378,7 @@ private:
bool isValidAccess(Instruction *Inst, const SCEV *AF, const SCEVUnknown *BP,
DetectionContext &Context) const;
- /// @brief Check if a memory access can be part of a Scop.
+ /// Check if a memory access can be part of a Scop.
///
/// @param Inst The instruction accessing the memory.
/// @param Context The context of scop detection.
@@ -386,8 +386,8 @@ private:
/// @return True if the memory access is valid, false otherwise.
bool isValidMemoryAccess(MemAccInst Inst, DetectionContext &Context) const;
- /// @brief Check if an instruction has any non trivial scalar dependencies
- /// as part of a Scop.
+ /// Check if an instruction has any non trivial scalar dependencies as part of
+ /// a Scop.
///
/// @param Inst The instruction to check.
/// @param RefRegion The region in respect to which we check the access
@@ -396,7 +396,7 @@ private:
/// @return True if the instruction has scalar dependences, false otherwise.
bool hasScalarDependency(Instruction &Inst, Region &RefRegion) const;
- /// @brief Check if an instruction can be part of a Scop.
+ /// Check if an instruction can be part of a Scop.
///
/// @param Inst The instruction to check.
/// @param Context The context of scop detection.
@@ -404,7 +404,7 @@ private:
/// @return True if the instruction is valid, false otherwise.
bool isValidInstruction(Instruction &Inst, DetectionContext &Context) const;
- /// @brief Check if the switch @p SI with condition @p Condition is valid.
+ /// Check if the switch @p SI with condition @p Condition is valid.
///
/// @param BB The block to check.
/// @param SI The switch to check.
@@ -416,7 +416,7 @@ private:
bool isValidSwitch(BasicBlock &BB, SwitchInst *SI, Value *Condition,
bool IsLoopBranch, DetectionContext &Context) const;
- /// @brief Check if the branch @p BI with condition @p Condition is valid.
+ /// Check if the branch @p BI with condition @p Condition is valid.
///
/// @param BB The block to check.
/// @param BI The branch to check.
@@ -428,7 +428,7 @@ private:
bool isValidBranch(BasicBlock &BB, BranchInst *BI, Value *Condition,
bool IsLoopBranch, DetectionContext &Context) const;
- /// @brief Check if the SCEV @p S is affine in the current @p Context.
+ /// Check if the SCEV @p S is affine in the current @p Context.
///
/// This will also use a heuristic to decide if we want to require loads to be
/// invariant to make the expression affine or if we want to treat is as
@@ -439,7 +439,7 @@ private:
/// @param Context The context of scop detection.
bool isAffine(const SCEV *S, Loop *Scope, DetectionContext &Context) const;
- /// @brief Check if the control flow in a basic block is valid.
+ /// Check if the control flow in a basic block is valid.
///
/// This function checks if a certain basic block is terminated by a
/// Terminator instruction we can handle or, if this is not the case,
@@ -456,7 +456,7 @@ private:
bool isValidCFG(BasicBlock &BB, bool IsLoopBranch, bool AllowUnreachable,
DetectionContext &Context) const;
- /// @brief Is a loop valid with respect to a given region.
+ /// Is a loop valid with respect to a given region.
///
/// @param L The loop to check.
/// @param Context The context of scop detection.
@@ -464,17 +464,17 @@ private:
/// @return True if the loop is valid in the region.
bool isValidLoop(Loop *L, DetectionContext &Context) const;
- /// @brief Count the number of beneficial loops in @p R.
+ /// Count the number of beneficial loops in @p R.
///
/// @param R The region to check
int countBeneficialLoops(Region *R) const;
- /// @brief Check if the function @p F is marked as invalid.
+ /// Check if the function @p F is marked as invalid.
///
/// @note An OpenMP subfunction will be marked as invalid.
bool isValidFunction(llvm::Function &F);
- /// @brief Can ISL compute the trip count of a loop.
+ /// Can ISL compute the trip count of a loop.
///
/// @param L The loop to check.
/// @param Context The context of scop detection.
@@ -482,10 +482,10 @@ private:
/// @return True if ISL can compute the trip count of the loop.
bool canUseISLTripCount(Loop *L, DetectionContext &Context) const;
- /// @brief Print the locations of all detected scops.
+ /// Print the locations of all detected scops.
void printLocations(llvm::Function &F);
- /// @brief Check if a region is reducible or not.
+ /// Check if a region is reducible or not.
///
/// @param Region The region to check.
/// @param DbgLoc Parameter to save the location of instruction that
@@ -494,7 +494,7 @@ private:
/// @return True if R is reducible, false otherwise.
bool isReducibleRegion(Region &R, DebugLoc &DbgLoc) const;
- /// @brief Track diagnostics for invalid scops.
+ /// Track diagnostics for invalid scops.
///
/// @param Context The context of scop detection.
/// @param Assert Throw an assert in verify mode or not.
@@ -507,15 +507,15 @@ public:
static char ID;
explicit ScopDetection();
- /// @brief Get the RegionInfo stored in this pass.
+ /// Get the RegionInfo stored in this pass.
///
/// This was added to give the DOT printer easy access to this information.
RegionInfo *getRI() const { return RI; }
- /// @brief Get the LoopInfo stored in this pass.
+ /// Get the LoopInfo stored in this pass.
LoopInfo *getLI() const { return LI; }
- /// @brief Is the region is the maximum region of a Scop?
+ /// Is the region is the maximum region of a Scop?
///
/// @param R The Region to test if it is maximum.
/// @param Verify Rerun the scop detection to verify SCoP was not invalidated
@@ -524,16 +524,16 @@ public:
/// @return Return true if R is the maximum Region in a Scop, false otherwise.
bool isMaxRegionInScop(const Region &R, bool Verify = true) const;
- /// @brief Return the detection context for @p R, nullptr if @p R was invalid.
+ /// Return the detection context for @p R, nullptr if @p R was invalid.
DetectionContext *getDetectionContext(const Region *R) const;
- /// @brief Return the set of rejection causes for @p R.
+ /// Return the set of rejection causes for @p R.
const RejectLog *lookupRejectionLog(const Region *R) const;
- /// @brief Return true if @p SubR is a non-affine subregion in @p ScopR.
+ /// Return true if @p SubR is a non-affine subregion in @p ScopR.
bool isNonAffineSubRegion(const Region *SubR, const Region *ScopR) const;
- /// @brief Get a message why a region is invalid
+ /// Get a message why a region is invalid
///
/// @param R The region for which we get the error message
///
@@ -555,23 +555,22 @@ public:
const_iterator end() const { return ValidRegions.end(); }
//@}
- /// @brief Emit rejection remarks for all rejected regions.
+ /// Emit rejection remarks for all rejected regions.
///
/// @param F The function to emit remarks for.
void emitMissedRemarks(const Function &F);
- /// @brief Mark the function as invalid so we will not extract any scop from
+ /// Mark the function as invalid so we will not extract any scop from
/// the function.
///
/// @param F The function to mark as invalid.
static void markFunctionAsInvalid(Function *F);
- /// @brief Verify if all valid Regions in this Function are still valid
+ /// Verify if all valid Regions in this Function are still valid
/// after some transformations.
void verifyAnalysis() const;
- /// @brief Verify if R is still a valid part of Scop after some
- /// transformations.
+ /// Verify if R is still a valid part of Scop after some transformations.
///
/// @param R The Region to verify.
void verifyRegion(const Region &R) const;
Modified: polly/trunk/include/polly/ScopDetectionDiagnostic.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopDetectionDiagnostic.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopDetectionDiagnostic.h (original)
+++ polly/trunk/include/polly/ScopDetectionDiagnostic.h Fri Sep 2 01:33:33 2016
@@ -43,17 +43,17 @@ class Region;
namespace polly {
-/// @brief Type to hold region delimiters (entry & exit block).
+/// Type to hold region delimiters (entry & exit block).
using BBPair = std::pair<BasicBlock *, BasicBlock *>;
-/// @brief Return the region delimiters (entry & exit block) of @p R.
+/// Return the region delimiters (entry & exit block) of @p R.
BBPair getBBPairForRegion(const Region *R);
-/// @brief Set the begin and end source location for the region limited by @p P.
+/// Set the begin and end source location for the region limited by @p P.
void getDebugLocations(const BBPair &P, DebugLoc &Begin, DebugLoc &End);
class RejectLog;
-/// @brief Emit optimization remarks about the rejected regions to the user.
+/// Emit optimization remarks about the rejected regions to the user.
///
/// This emits the content of the reject log as optimization remarks.
/// Remember to at least track failures (-polly-detect-track-failures).
@@ -102,7 +102,7 @@ enum RejectReasonKind {
};
//===----------------------------------------------------------------------===//
-/// @brief Base class of all reject reasons found during Scop detection.
+/// Base class of all reject reasons found during Scop detection.
///
/// Subclasses of RejectReason should provide means to capture enough
/// diagnostic information to help clients figure out what and where something
@@ -122,12 +122,12 @@ public:
virtual ~RejectReason() {}
- /// @brief Generate a reasonable diagnostic message describing this error.
+ /// Generate a reasonable diagnostic message describing this error.
///
/// @return A debug message representing this error.
virtual std::string getMessage() const = 0;
- /// @brief Generate a message for the end-user describing this error.
+ /// Generate a message for the end-user describing this error.
///
/// The message provided has to be suitable for the end-user. So it should
/// not reference any LLVM internal data structures or terminology.
@@ -137,7 +137,7 @@ public:
/// @return A short message representing this error.
virtual std::string getEndUserMessage() const { return "Unspecified error."; }
- /// @brief Get the source location of this error.
+ /// Get the source location of this error.
///
/// @return The debug location for this error.
virtual const llvm::DebugLoc &getDebugLoc() const;
@@ -145,7 +145,7 @@ public:
typedef std::shared_ptr<RejectReason> RejectReasonPtr;
-/// @brief Stores all errors that ocurred during the detection.
+/// Stores all errors that ocurred during the detection.
class RejectLog {
Region *R;
llvm::SmallVector<RejectReasonPtr, 1> ErrorReports;
@@ -159,7 +159,7 @@ public:
iterator end() const { return ErrorReports.end(); }
size_t size() const { return ErrorReports.size(); }
- /// @brief Returns true, if we store at least one error.
+ /// Returns true, if we store at least one error.
///
/// @return true, if we store at least one error.
bool hasErrors() const { return size() > 0; }
@@ -171,7 +171,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Base class for CFG related reject reasons.
+/// Base class for CFG related reject reasons.
///
/// Scop candidates that violate structural restrictions can be grouped under
/// this reject reason class.
@@ -187,7 +187,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures bad terminator within a Scop candidate.
+/// Captures bad terminator within a Scop candidate.
class ReportInvalidTerminator : public ReportCFG {
BasicBlock *BB;
@@ -208,7 +208,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures irreducible regions in CFG.
+/// Captures irreducible regions in CFG.
class ReportIrreducibleRegion : public ReportCFG {
Region *R;
DebugLoc DbgLoc;
@@ -231,7 +231,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Base class for non-affine reject reasons.
+/// Base class for non-affine reject reasons.
///
/// Scop candidates that violate restrictions to affinity are reported under
/// this class.
@@ -258,7 +258,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures a condition that is based on an 'undef' value.
+/// Captures a condition that is based on an 'undef' value.
class ReportUndefCond : public ReportAffFunc {
//===--------------------------------------------------------------------===//
@@ -281,7 +281,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures an invalid condition
+/// Captures an invalid condition
///
/// Conditions have to be either constants or icmp instructions.
class ReportInvalidCond : public ReportAffFunc {
@@ -306,7 +306,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures an undefined operand.
+/// Captures an undefined operand.
class ReportUndefOperand : public ReportAffFunc {
//===--------------------------------------------------------------------===//
@@ -329,14 +329,14 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures a non-affine branch.
+/// Captures a non-affine branch.
class ReportNonAffBranch : public ReportAffFunc {
//===--------------------------------------------------------------------===//
// The BasicBlock we found the non-affine branch in.
BasicBlock *BB;
- /// @brief LHS & RHS of the failed condition.
+ /// LHS & RHS of the failed condition.
//@{
const SCEV *LHS;
const SCEV *RHS;
@@ -362,7 +362,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures a missing base pointer.
+/// Captures a missing base pointer.
class ReportNoBasePtr : public ReportAffFunc {
//===--------------------------------------------------------------------===//
public:
@@ -381,7 +381,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures an undefined base pointer.
+/// Captures an undefined base pointer.
class ReportUndefBasePtr : public ReportAffFunc {
//===--------------------------------------------------------------------===//
public:
@@ -400,7 +400,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures a base pointer that is not invariant in the region.
+/// Captures a base pointer that is not invariant in the region.
class ReportVariantBasePtr : public ReportAffFunc {
//===--------------------------------------------------------------------===//
@@ -424,7 +424,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures a non-affine access function.
+/// Captures a non-affine access function.
class ReportNonAffineAccess : public ReportAffFunc {
//===--------------------------------------------------------------------===//
@@ -455,7 +455,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Report array accesses with differing element size.
+/// Report array accesses with differing element size.
class ReportDifferentArrayElementSize : public ReportAffFunc {
//===--------------------------------------------------------------------===//
@@ -479,7 +479,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with non affine loop bounds.
+/// Captures errors with non affine loop bounds.
class ReportLoopBound : public RejectReason {
//===--------------------------------------------------------------------===//
@@ -511,11 +511,11 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors when loop overlap with nonaffine subregion.
+/// Captures errors when loop overlap with nonaffine subregion.
class ReportLoopOverlapWithNonAffineSubRegion : public RejectReason {
//===--------------------------------------------------------------------===//
- /// @brief If L and R are set then L and R overlap.
+ /// If L and R are set then L and R overlap.
/// The loop contains stmt overlapping nonaffine subregion.
Loop *L;
@@ -542,7 +542,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with non-side-effect-known function calls.
+/// Captures errors with non-side-effect-known function calls.
class ReportFuncCall : public RejectReason {
//===--------------------------------------------------------------------===//
@@ -566,14 +566,14 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with aliasing.
+/// Captures errors with aliasing.
class ReportAlias : public RejectReason {
//===--------------------------------------------------------------------===//
public:
typedef std::vector<const llvm::Value *> PointerSnapshotTy;
private:
- /// @brief Format an invalid alias set.
+ /// Format an invalid alias set.
///
// @param Prefix A prefix string to put before the list of aliasing pointers.
// @param Suffix A suffix string to put after the list of aliasing pointers.
@@ -604,7 +604,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Base class for otherwise ungrouped reject reasons.
+/// Base class for otherwise ungrouped reject reasons.
class ReportOther : public RejectReason {
//===--------------------------------------------------------------------===//
public:
@@ -622,7 +622,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with bad IntToPtr instructions.
+/// Captures errors with bad IntToPtr instructions.
class ReportIntToPtr : public ReportOther {
//===--------------------------------------------------------------------===//
@@ -645,7 +645,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with alloca instructions.
+/// Captures errors with alloca instructions.
class ReportAlloca : public ReportOther {
//===--------------------------------------------------------------------===//
Instruction *Inst;
@@ -666,7 +666,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with unknown instructions.
+/// Captures errors with unknown instructions.
class ReportUnknownInst : public ReportOther {
//===--------------------------------------------------------------------===//
Instruction *Inst;
@@ -687,7 +687,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with regions containing the function entry block.
+/// Captures errors with regions containing the function entry block.
class ReportEntry : public ReportOther {
//===--------------------------------------------------------------------===//
BasicBlock *BB;
@@ -708,7 +708,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Report regions that seem not profitable to be optimized.
+/// Report regions that seem not profitable to be optimized.
class ReportUnprofitable : public ReportOther {
//===--------------------------------------------------------------------===//
Region *R;
@@ -730,7 +730,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief Captures errors with non-simple memory accesses.
+/// Captures errors with non-simple memory accesses.
class ReportNonSimpleMemoryAccess : public ReportOther {
//===--------------------------------------------------------------------===//
Modified: polly/trunk/include/polly/ScopInfo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopInfo.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopInfo.h (original)
+++ polly/trunk/include/polly/ScopInfo.h Fri Sep 2 01:33:33 2016
@@ -66,7 +66,7 @@ class ScopBuilder;
//===---------------------------------------------------------------------===//
-/// @brief Enumeration of assumptions Polly can take.
+/// Enumeration of assumptions Polly can take.
enum AssumptionKind {
ALIASING,
INBOUNDS,
@@ -80,7 +80,7 @@ enum AssumptionKind {
DELINEARIZATION,
};
-/// @brief Enum to distinguish between assumptions and restrictions.
+/// Enum to distinguish between assumptions and restrictions.
enum AssumptionSign { AS_ASSUMPTION, AS_RESTRICTION };
/// Maps from a loop to the affine function expressing its backedge taken count.
@@ -93,14 +93,14 @@ typedef std::map<const Loop *, const SCE
typedef std::vector<std::unique_ptr<MemoryAccess>> AccFuncVector;
-/// @brief A class to store information about arrays in the SCoP.
+/// A class to store information about arrays in the SCoP.
///
/// Objects are accessible via the ScoP, MemoryAccess or the id associated with
/// the MemoryAccess access function.
///
class ScopArrayInfo {
public:
- /// @brief The kind of a ScopArrayInfo memory object.
+ /// The kind of a ScopArrayInfo memory object.
///
/// We distinguish between arrays and various scalar memory objects. We use
/// the term ``array'' to describe memory objects that consist of a set of
@@ -221,7 +221,7 @@ public:
MK_ExitPHI
};
- /// @brief Construct a ScopArrayInfo object.
+ /// Construct a ScopArrayInfo object.
///
/// @param BasePtr The array base pointer.
/// @param ElementType The type of the elements stored in the array.
@@ -235,7 +235,7 @@ public:
ArrayRef<const SCEV *> DimensionSizes, enum MemoryKind Kind,
const DataLayout &DL, Scop *S, const char *BaseName = nullptr);
- /// @brief Update the element type of the ScopArrayInfo object.
+ /// Update the element type of the ScopArrayInfo object.
///
/// Memory accesses referencing this ScopArrayInfo object may use
/// different element sizes. This function ensures the canonical element type
@@ -245,7 +245,7 @@ public:
/// @param NewElementType An element type that is used to access this array.
void updateElementType(Type *NewElementType);
- /// @brief Update the sizes of the ScopArrayInfo object.
+ /// Update the sizes of the ScopArrayInfo object.
///
/// A ScopArrayInfo object may be created without all outer dimensions being
/// available. This function is called when new memory accesses are added for
@@ -257,31 +257,31 @@ public:
/// defined in SAI.
bool updateSizes(ArrayRef<const SCEV *> Sizes);
- /// @brief Destructor to free the isl id of the base pointer.
+ /// Destructor to free the isl id of the base pointer.
~ScopArrayInfo();
- /// @brief Set the base pointer to @p BP.
+ /// Set the base pointer to @p BP.
void setBasePtr(Value *BP) { BasePtr = BP; }
- /// @brief Return the base pointer.
+ /// Return the base pointer.
Value *getBasePtr() const { return BasePtr; }
- /// @brief For indirect accesses return the origin SAI of the BP, else null.
+ /// For indirect accesses return the origin SAI of the BP, else null.
const ScopArrayInfo *getBasePtrOriginSAI() const { return BasePtrOriginSAI; }
- /// @brief The set of derived indirect SAIs for this origin SAI.
+ /// The set of derived indirect SAIs for this origin SAI.
const SmallPtrSetImpl<ScopArrayInfo *> &getDerivedSAIs() const {
return DerivedSAIs;
}
- /// @brief Return the number of dimensions.
+ /// Return the number of dimensions.
unsigned getNumberOfDimensions() const {
if (Kind == MK_PHI || Kind == MK_ExitPHI || Kind == MK_Value)
return 0;
return DimensionSizes.size() + 1;
}
- /// @brief Return the size of dimension @p dim as SCEV*.
+ /// Return the size of dimension @p dim as SCEV*.
//
// Scalars do not have array dimensions and the first dimension of
// a (possibly multi-dimensional) array also does not carry any size
@@ -292,7 +292,7 @@ public:
return DimensionSizes[Dim - 1];
}
- /// @brief Return the size of dimension @p dim as isl_pw_aff.
+ /// Return the size of dimension @p dim as isl_pw_aff.
//
// Scalars do not have array dimensions and the first dimension of
// a (possibly multi-dimensional) array also does not carry any size
@@ -303,27 +303,27 @@ public:
return isl_pw_aff_copy(DimensionSizesPw[Dim - 1]);
}
- /// @brief Get the canonical element type of this array.
+ /// Get the canonical element type of this array.
///
/// @returns The canonical element type of this array.
Type *getElementType() const { return ElementType; }
- /// @brief Get element size in bytes.
+ /// Get element size in bytes.
int getElemSizeInBytes() const;
- /// @brief Get the name of this memory reference.
+ /// Get the name of this memory reference.
std::string getName() const;
- /// @brief Return the isl id for the base pointer.
+ /// Return the isl id for the base pointer.
__isl_give isl_id *getBasePtrId() const;
- /// @brief Return what kind of memory this represents.
+ /// Return what kind of memory this represents.
enum MemoryKind getKind() const { return Kind; }
- /// @brief Is this array info modeling an llvm::Value?
+ /// Is this array info modeling an llvm::Value?
bool isValueKind() const { return Kind == MK_Value; }
- /// @brief Is this array info modeling special PHI node memory?
+ /// Is this array info modeling special PHI node memory?
///
/// During code generation of PHI nodes, there is a need for two kinds of
/// virtual storage. The normal one as it is used for all scalar dependences,
@@ -335,28 +335,28 @@ public:
/// normal scalar array modeling.
bool isPHIKind() const { return Kind == MK_PHI; }
- /// @brief Is this array info modeling an MK_ExitPHI?
+ /// Is this array info modeling an MK_ExitPHI?
bool isExitPHIKind() const { return Kind == MK_ExitPHI; }
- /// @brief Is this array info modeling an array?
+ /// Is this array info modeling an array?
bool isArrayKind() const { return Kind == MK_Array; }
- /// @brief Dump a readable representation to stderr.
+ /// Dump a readable representation to stderr.
void dump() const;
- /// @brief Print a readable representation to @p OS.
+ /// Print a readable representation to @p OS.
///
/// @param SizeAsPwAff Print the size as isl_pw_aff
void print(raw_ostream &OS, bool SizeAsPwAff = false) const;
- /// @brief Access the ScopArrayInfo associated with an access function.
+ /// Access the ScopArrayInfo associated with an access function.
static const ScopArrayInfo *
getFromAccessFunction(__isl_keep isl_pw_multi_aff *PMA);
- /// @brief Access the ScopArrayInfo associated with an isl Id.
+ /// Access the ScopArrayInfo associated with an isl Id.
static const ScopArrayInfo *getFromId(__isl_take isl_id *Id);
- /// @brief Get the space of this array access.
+ /// Get the space of this array access.
__isl_give isl_space *getSpace() const;
private:
@@ -364,16 +364,16 @@ private:
DerivedSAIs.insert(DerivedSAI);
}
- /// @brief For indirect accesses this is the SAI of the BP origin.
+ /// For indirect accesses this is the SAI of the BP origin.
const ScopArrayInfo *BasePtrOriginSAI;
- /// @brief For origin SAIs the set of derived indirect SAIs.
+ /// For origin SAIs the set of derived indirect SAIs.
SmallPtrSet<ScopArrayInfo *, 2> DerivedSAIs;
- /// @brief The base pointer.
+ /// The base pointer.
AssertingVH<Value> BasePtr;
- /// @brief The canonical element type of this array.
+ /// The canonical element type of this array.
///
/// The canonical element type describes the minimal accessible element in
/// this array. Not all elements accessed, need to be of the very same type,
@@ -382,34 +382,34 @@ private:
/// type.
Type *ElementType;
- /// @brief The isl id for the base pointer.
+ /// The isl id for the base pointer.
isl_id *Id;
- /// @brief The sizes of each dimension as SCEV*.
+ /// The sizes of each dimension as SCEV*.
SmallVector<const SCEV *, 4> DimensionSizes;
- /// @brief The sizes of each dimension as isl_pw_aff.
+ /// The sizes of each dimension as isl_pw_aff.
SmallVector<isl_pw_aff *, 4> DimensionSizesPw;
- /// @brief The type of this scop array info object.
+ /// The type of this scop array info object.
///
/// We distinguish between SCALAR, PHI and ARRAY objects.
enum MemoryKind Kind;
- /// @brief The data layout of the module.
+ /// The data layout of the module.
const DataLayout &DL;
- /// @brief The scop this SAI object belongs to.
+ /// The scop this SAI object belongs to.
Scop &S;
};
-/// @brief Represent memory accesses in statements.
+/// Represent memory accesses in statements.
class MemoryAccess {
friend class Scop;
friend class ScopStmt;
public:
- /// @brief The access type of a memory access
+ /// The access type of a memory access
///
/// There are three kind of access types:
///
@@ -435,7 +435,7 @@ public:
MAY_WRITE = 0x3,
};
- /// @brief Reduction access type
+ /// Reduction access type
///
/// Commutative and associative binary operations suitable for reductions
enum ReductionType {
@@ -451,21 +451,21 @@ private:
MemoryAccess(const MemoryAccess &) = delete;
const MemoryAccess &operator=(const MemoryAccess &) = delete;
- /// @brief A unique identifier for this memory access.
+ /// A unique identifier for this memory access.
///
/// The identifier is unique between all memory accesses belonging to the same
/// scop statement.
isl_id *Id;
- /// @brief What is modeled by this MemoryAccess.
+ /// What is modeled by this MemoryAccess.
/// @see ScopArrayInfo::MemoryKind
ScopArrayInfo::MemoryKind Kind;
- /// @brief Whether it a reading or writing access, and if writing, whether it
+ /// Whether it a reading or writing access, and if writing, whether it
/// is conditional (MAY_WRITE).
enum AccessType AccType;
- /// @brief Reduction type for reduction like accesses, RT_NONE otherwise
+ /// Reduction type for reduction like accesses, RT_NONE otherwise
///
/// An access is reduction like if it is part of a load-store chain in which
/// both access the same memory location (use the same LLVM-IR value
@@ -491,10 +491,10 @@ private:
/// could allow us to handle the above example.
ReductionType RedType = RT_NONE;
- /// @brief Parent ScopStmt of this access.
+ /// Parent ScopStmt of this access.
ScopStmt *Statement;
- /// @brief The domain under which this access is not modeled precisely.
+ /// The domain under which this access is not modeled precisely.
///
/// The invalid domain for an access describes all parameter combinations
/// under which the statement looks to be executed but is in fact not because
@@ -505,7 +505,7 @@ private:
// TODO: It might be possible to move them to ScopArrayInfo.
// @{
- /// @brief The base address (e.g., A for A[i+j]).
+ /// The base address (e.g., A for A[i+j]).
///
/// The #BaseAddr of a memory access of kind MK_Array is the base pointer
/// of the memory access.
@@ -515,20 +515,20 @@ private:
/// defining the value.
AssertingVH<Value> BaseAddr;
- /// @brief An unique name of the accessed array.
+ /// An unique name of the accessed array.
std::string BaseName;
- /// @brief Type a single array element wrt. this access.
+ /// Type a single array element wrt. this access.
Type *ElementType;
- /// @brief Size of each dimension of the accessed array.
+ /// Size of each dimension of the accessed array.
SmallVector<const SCEV *, 4> Sizes;
// @}
// Properties describing the accessed element.
// @{
- /// @brief The access instruction of this memory access.
+ /// The access instruction of this memory access.
///
/// For memory accesses of kind MK_Array the access instruction is the
/// Load or Store instruction performing the access.
@@ -544,10 +544,10 @@ private:
/// write access is the instruction that defines the llvm::Value.
Instruction *AccessInstruction;
- /// @brief Incoming block and value of a PHINode.
+ /// Incoming block and value of a PHINode.
SmallVector<std::pair<BasicBlock *, Value *>, 4> Incoming;
- /// @brief The value associated with this memory access.
+ /// The value associated with this memory access.
///
/// - For array memory accesses (MK_Array) it is the loaded result or the
/// stored value. If the access instruction is a memory intrinsic it
@@ -558,13 +558,13 @@ private:
///
AssertingVH<Value> AccessValue;
- /// @brief Are all the subscripts affine expression?
+ /// Are all the subscripts affine expression?
bool IsAffine;
- /// @brief Subscript expression for each dimension.
+ /// Subscript expression for each dimension.
SmallVector<const SCEV *, 4> Subscripts;
- /// @brief Relation from statement instances to the accessed array elements.
+ /// Relation from statement instances to the accessed array elements.
///
/// In the common case this relation is a function that maps a set of loop
/// indices to the memory address from which a value is loaded/stored:
@@ -592,7 +592,7 @@ private:
/// => { S[i] -> A[i]; S[i] -> A[o] : 4i <= o <= 4i + 3 }
isl_map *AccessRelation;
- /// @brief Updated access relation read from JSCOP file.
+ /// Updated access relation read from JSCOP file.
isl_map *NewAccessRelation;
// @}
@@ -602,21 +602,21 @@ private:
void assumeNoOutOfBound();
- /// @brief Compute bounds on an over approximated access relation.
+ /// Compute bounds on an over approximated access relation.
///
/// @param ElementSize The size of one element accessed.
void computeBoundsOnAccessRelation(unsigned ElementSize);
- /// @brief Get the original access function as read from IR.
+ /// Get the original access function as read from IR.
__isl_give isl_map *getOriginalAccessRelation() const;
- /// @brief Return the space in which the access relation lives in.
+ /// Return the space in which the access relation lives in.
__isl_give isl_space *getOriginalAccessRelationSpace() const;
- /// @brief Get the new access function imported or set by a pass
+ /// Get the new access function imported or set by a pass
__isl_give isl_map *getNewAccessRelation() const;
- /// @brief Fold the memory access to consider parameteric offsets
+ /// Fold the memory access to consider parameteric offsets
///
/// To recover memory accesses with array size parameters in the subscript
/// expression we post-process the delinearization results.
@@ -647,10 +647,10 @@ private:
__isl_give isl_map *foldAccess(__isl_take isl_map *AccessRelation,
ScopStmt *Statement);
- /// @brief Create the access relation for the underlying memory intrinsic.
+ /// Create the access relation for the underlying memory intrinsic.
void buildMemIntrinsicAccessRelation();
- /// @brief Assemble the access relation from all available information.
+ /// Assemble the access relation from all available information.
///
/// In particular, used the information passes in the constructor and the
/// parent ScopStmt set by setStatment().
@@ -658,8 +658,8 @@ private:
/// @param SAI Info object for the accessed array.
void buildAccessRelation(const ScopArrayInfo *SAI);
- /// @brief Carry index overflows of dimensions with constant size to the next
- /// higher dimension.
+ /// Carry index overflows of dimensions with constant size to the next higher
+ /// dimension.
///
/// For dimensions that have constant size, modulo the index by the size and
/// add up the carry (floored division) to the next higher dimension. This is
@@ -674,7 +674,7 @@ private:
void wrapConstantDimensions();
public:
- /// @brief Create a new MemoryAccess.
+ /// Create a new MemoryAccess.
///
/// @param Stmt The parent statement.
/// @param AccessInst The instruction doing the access.
@@ -693,7 +693,7 @@ public:
StringRef BaseName);
~MemoryAccess();
- /// @brief Add a new incoming block/value pairs for this PHI/ExitPHI access.
+ /// Add a new incoming block/value pairs for this PHI/ExitPHI access.
///
/// @param IncomingBlock The PHI's incoming block.
/// @param IncomingValue The value when reacing the PHI from the @p
@@ -704,7 +704,7 @@ public:
Incoming.emplace_back(std::make_pair(IncomingBlock, IncomingValue));
}
- /// @brief Return the list of possible PHI/ExitPHI values.
+ /// Return the list of possible PHI/ExitPHI values.
///
/// After code generation moves some PHIs around during region simplification,
/// we cannot reliably locate the original PHI node and its incoming values
@@ -715,28 +715,28 @@ public:
return Incoming;
}
- /// @brief Get the type of a memory access.
+ /// Get the type of a memory access.
enum AccessType getType() { return AccType; }
- /// @brief Is this a reduction like access?
+ /// Is this a reduction like access?
bool isReductionLike() const { return RedType != RT_NONE; }
- /// @brief Is this a read memory access?
+ /// Is this a read memory access?
bool isRead() const { return AccType == MemoryAccess::READ; }
- /// @brief Is this a must-write memory access?
+ /// Is this a must-write memory access?
bool isMustWrite() const { return AccType == MemoryAccess::MUST_WRITE; }
- /// @brief Is this a may-write memory access?
+ /// Is this a may-write memory access?
bool isMayWrite() const { return AccType == MemoryAccess::MAY_WRITE; }
- /// @brief Is this a write memory access?
+ /// Is this a write memory access?
bool isWrite() const { return isMustWrite() || isMayWrite(); }
- /// @brief Check if a new access relation was imported or set by a pass.
+ /// Check if a new access relation was imported or set by a pass.
bool hasNewAccessRelation() const { return NewAccessRelation; }
- /// @brief Return the newest access relation of this access.
+ /// Return the newest access relation of this access.
///
/// There are two possibilities:
/// 1) The original access relation read from the LLVM-IR.
@@ -751,12 +751,12 @@ public:
: getOriginalAccessRelation();
}
- /// @brief Old name of getLatestAccessRelation().
+ /// Old name of getLatestAccessRelation().
__isl_give isl_map *getAccessRelation() const {
return getLatestAccessRelation();
}
- /// @brief Get an isl map describing the memory address accessed.
+ /// Get an isl map describing the memory address accessed.
///
/// In most cases the memory address accessed is well described by the access
/// relation obtained with getAccessRelation. However, in case of arrays
@@ -771,17 +771,17 @@ public:
/// @returns The address function for this memory access.
__isl_give isl_map *getAddressFunction() const;
- /// @brief Return the access relation after the schedule was applied.
+ /// Return the access relation after the schedule was applied.
__isl_give isl_pw_multi_aff *
applyScheduleToAccessRelation(__isl_take isl_union_map *Schedule) const;
- /// @brief Get an isl string representing the access function read from IR.
+ /// Get an isl string representing the access function read from IR.
std::string getOriginalAccessRelationStr() const;
- /// @brief Get an isl string representing a new access function, if available.
+ /// Get an isl string representing a new access function, if available.
std::string getNewAccessRelationStr() const;
- /// @brief Get the base address of this access (e.g. A for A[i+j]) when
+ /// Get the base address of this access (e.g. A for A[i+j]) when
/// detected.
Value *getOriginalBaseAddr() const {
assert(!getOriginalScopArrayInfo() /* may noy yet be initialized */ ||
@@ -789,71 +789,71 @@ public:
return BaseAddr;
}
- /// @brief Get the base address of this access (e.g. A for A[i+j]) after a
+ /// Get the base address of this access (e.g. A for A[i+j]) after a
/// potential change by setNewAccessRelation().
Value *getLatestBaseAddr() const {
return getLatestScopArrayInfo()->getBasePtr();
}
- /// @brief Old name for getOriginalBaseAddr().
+ /// Old name for getOriginalBaseAddr().
Value *getBaseAddr() const { return getOriginalBaseAddr(); }
- /// @brief Get the detection-time base array isl_id for this access.
+ /// Get the detection-time base array isl_id for this access.
__isl_give isl_id *getOriginalArrayId() const;
- /// @brief Get the base array isl_id for this access, modifiable through
+ /// Get the base array isl_id for this access, modifiable through
/// setNewAccessRelation().
__isl_give isl_id *getLatestArrayId() const;
- /// @brief Old name of getOriginalArrayId().
+ /// Old name of getOriginalArrayId().
__isl_give isl_id *getArrayId() const { return getOriginalArrayId(); }
- /// @brief Get the detection-time ScopArrayInfo object for the base address.
+ /// Get the detection-time ScopArrayInfo object for the base address.
const ScopArrayInfo *getOriginalScopArrayInfo() const;
- /// @brief Get the ScopArrayInfo object for the base address, or the one set
+ /// Get the ScopArrayInfo object for the base address, or the one set
/// by setNewAccessRelation().
const ScopArrayInfo *getLatestScopArrayInfo() const;
- /// @brief Legacy name of getOriginalScopArrayInfo().
+ /// Legacy name of getOriginalScopArrayInfo().
const ScopArrayInfo *getScopArrayInfo() const {
return getOriginalScopArrayInfo();
}
- /// @brief Return a string representation of the access's reduction type.
+ /// Return a string representation of the access's reduction type.
const std::string getReductionOperatorStr() const;
- /// @brief Return a string representation of the reduction type @p RT.
+ /// Return a string representation of the reduction type @p RT.
static const std::string getReductionOperatorStr(ReductionType RT);
const std::string &getBaseName() const { return BaseName; }
- /// @brief Return the element type of the accessed array wrt. this access.
+ /// Return the element type of the accessed array wrt. this access.
Type *getElementType() const { return ElementType; }
- /// @brief Return the access value of this memory access.
+ /// Return the access value of this memory access.
Value *getAccessValue() const { return AccessValue; }
- /// @brief Return the access instruction of this memory access.
+ /// Return the access instruction of this memory access.
Instruction *getAccessInstruction() const { return AccessInstruction; }
- /// @brief Return the number of access function subscript.
+ /// Return the number of access function subscript.
unsigned getNumSubscripts() const { return Subscripts.size(); }
- /// @brief Return the access function subscript in the dimension @p Dim.
+ /// Return the access function subscript in the dimension @p Dim.
const SCEV *getSubscript(unsigned Dim) const { return Subscripts[Dim]; }
- /// @brief Compute the isl representation for the SCEV @p E wrt. this access.
+ /// Compute the isl representation for the SCEV @p E wrt. this access.
///
/// Note that this function will also adjust the invalid context accordingly.
__isl_give isl_pw_aff *getPwAff(const SCEV *E);
- /// @brief Get the invalid domain for this access.
+ /// Get the invalid domain for this access.
__isl_give isl_set *getInvalidDomain() const {
return isl_set_copy(InvalidDomain);
}
- /// @brief Get the invalid context for this access.
+ /// Get the invalid context for this access.
__isl_give isl_set *getInvalidContext() const {
return isl_set_params(getInvalidDomain());
}
@@ -880,33 +880,33 @@ public:
/// statement.
bool isStrideZero(__isl_take const isl_map *Schedule) const;
- /// @brief Return the kind when this access was first detected.
+ /// Return the kind when this access was first detected.
ScopArrayInfo::MemoryKind getOriginalKind() const {
assert(!getOriginalScopArrayInfo() /* not yet initialized */ ||
getOriginalScopArrayInfo()->getKind() == Kind);
return Kind;
}
- /// @brief Return the kind considering a potential setNewAccessRelation.
+ /// Return the kind considering a potential setNewAccessRelation.
ScopArrayInfo::MemoryKind getLatestKind() const {
return getLatestScopArrayInfo()->getKind();
}
- /// @brief Whether this is an access of an explicit load or store in the IR.
+ /// Whether this is an access of an explicit load or store in the IR.
bool isOriginalArrayKind() const {
return getOriginalKind() == ScopArrayInfo::MK_Array;
}
- /// @brief Whether storage memory is either an custom .s2a/.phiops alloca
+ /// Whether storage memory is either an custom .s2a/.phiops alloca
/// (false) or an existing pointer into an array (true).
bool isLatestArrayKind() const {
return getLatestKind() == ScopArrayInfo::MK_Array;
}
- /// @brief Old name of isOriginalArrayKind.
+ /// Old name of isOriginalArrayKind.
bool isArrayKind() const { return isOriginalArrayKind(); }
- /// @brief Whether this access is an array to a scalar memory object, without
+ /// Whether this access is an array to a scalar memory object, without
/// considering changes by setNewAccessRelation.
///
/// Scalar accesses are accesses to MK_Value, MK_PHI or MK_ExitPHI.
@@ -914,88 +914,88 @@ public:
return getOriginalKind() != ScopArrayInfo::MK_Array;
}
- /// @brief Whether this access is an array to a scalar memory object, also
+ /// Whether this access is an array to a scalar memory object, also
/// considering changes by setNewAccessRelation.
bool isLatestScalarKind() const {
return getLatestKind() != ScopArrayInfo::MK_Array;
}
- /// @brief Old name of isOriginalScalarKind.
+ /// Old name of isOriginalScalarKind.
bool isScalarKind() const { return isOriginalScalarKind(); }
- /// @brief Was this MemoryAccess detected as a scalar dependences?
+ /// Was this MemoryAccess detected as a scalar dependences?
bool isOriginalValueKind() const {
return getOriginalKind() == ScopArrayInfo::MK_Value;
}
- /// @brief Is this MemoryAccess currently modeling scalar dependences?
+ /// Is this MemoryAccess currently modeling scalar dependences?
bool isLatestValueKind() const {
return getLatestKind() == ScopArrayInfo::MK_Value;
}
- /// @brief Old name of isOriginalValueKind().
+ /// Old name of isOriginalValueKind().
bool isValueKind() const { return isOriginalValueKind(); }
- /// @brief Was this MemoryAccess detected as a special PHI node access?
+ /// Was this MemoryAccess detected as a special PHI node access?
bool isOriginalPHIKind() const {
return getOriginalKind() == ScopArrayInfo::MK_PHI;
}
- /// @brief Is this MemoryAccess modeling special PHI node accesses, also
+ /// Is this MemoryAccess modeling special PHI node accesses, also
/// considering a potential change by setNewAccessRelation?
bool isLatestPHIKind() const {
return getLatestKind() == ScopArrayInfo::MK_PHI;
}
- /// @brief Old name of isOriginalPHIKind.
+ /// Old name of isOriginalPHIKind.
bool isPHIKind() const { return isOriginalPHIKind(); }
- /// @brief Was this MemoryAccess detected as the accesses of a PHI node in the
+ /// Was this MemoryAccess detected as the accesses of a PHI node in the
/// SCoP's exit block?
bool isOriginalExitPHIKind() const {
return getOriginalKind() == ScopArrayInfo::MK_ExitPHI;
}
- /// @brief Is this MemoryAccess modeling the accesses of a PHI node in the
+ /// Is this MemoryAccess modeling the accesses of a PHI node in the
/// SCoP's exit block? Can be changed to an array access using
/// setNewAccessRelation().
bool isLatestExitPHIKind() const {
return getLatestKind() == ScopArrayInfo::MK_ExitPHI;
}
- /// @brief Old name of isOriginalExitPHIKind().
+ /// Old name of isOriginalExitPHIKind().
bool isExitPHIKind() const { return isOriginalExitPHIKind(); }
- /// @brief Was this access detected as one of the two PHI types?
+ /// Was this access detected as one of the two PHI types?
bool isOriginalAnyPHIKind() const {
return isOriginalPHIKind() || isOriginalExitPHIKind();
}
- /// @brief Does this access orginate from one of the two PHI types? Can be
+ /// Does this access orginate from one of the two PHI types? Can be
/// changed to an array access using setNewAccessRelation().
bool isLatestAnyPHIKind() const {
return isLatestPHIKind() || isLatestExitPHIKind();
}
- /// @brief Old name of isOriginalAnyPHIKind().
+ /// Old name of isOriginalAnyPHIKind().
bool isAnyPHIKind() const { return isOriginalAnyPHIKind(); }
- /// @brief Get the statement that contains this memory access.
+ /// Get the statement that contains this memory access.
ScopStmt *getStatement() const { return Statement; }
- /// @brief Get the reduction type of this access
+ /// Get the reduction type of this access
ReductionType getReductionType() const { return RedType; }
- /// @brief Set the updated access relation read from JSCOP file.
+ /// Set the updated access relation read from JSCOP file.
void setNewAccessRelation(__isl_take isl_map *NewAccessRelation);
- /// @brief Mark this a reduction like access
+ /// Mark this a reduction like access
void markAsReductionLike(ReductionType RT) { RedType = RT; }
- /// @brief Align the parameters in the access relation to the scop context
+ /// Align the parameters in the access relation to the scop context
void realignParams();
- /// @brief Update the dimensionality of the memory access.
+ /// Update the dimensionality of the memory access.
///
/// During scop construction some memory accesses may not be constructed with
/// their full dimensionality, but outer dimensions may have been omitted if
@@ -1005,40 +1005,40 @@ public:
/// access.
void updateDimensionality();
- /// @brief Get identifier for the memory access.
+ /// Get identifier for the memory access.
///
/// This identifier is unique for all accesses that belong to the same scop
/// statement.
__isl_give isl_id *getId() const;
- /// @brief Print the MemoryAccess.
+ /// Print the MemoryAccess.
///
/// @param OS The output stream the MemoryAccess is printed to.
void print(raw_ostream &OS) const;
- /// @brief Print the MemoryAccess to stderr.
+ /// Print the MemoryAccess to stderr.
void dump() const;
};
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
MemoryAccess::ReductionType RT);
-/// @brief Ordered list type to hold accesses.
+/// Ordered list type to hold accesses.
using MemoryAccessList = std::forward_list<MemoryAccess *>;
-/// @brief Helper structure for invariant memory accesses.
+/// Helper structure for invariant memory accesses.
struct InvariantAccess {
- /// @brief The memory access that is (partially) invariant.
+ /// The memory access that is (partially) invariant.
MemoryAccess *MA;
- /// @brief The context under which the access is not invariant.
+ /// The context under which the access is not invariant.
isl_set *NonHoistableCtx;
};
-/// @brief Ordered container type to hold invariant accesses.
+/// Ordered container type to hold invariant accesses.
using InvariantAccessesTy = SmallVector<InvariantAccess, 8>;
-/// @brief Type for equivalent invariant accesses and their domain context.
+/// Type for equivalent invariant accesses and their domain context.
struct InvariantEquivClassTy {
/// The pointer that identifies this equivalence class
@@ -1064,10 +1064,10 @@ struct InvariantEquivClassTy {
Type *AccessType;
};
-/// @brief Type for invariant accesses equivalence classes.
+/// Type for invariant accesses equivalence classes.
using InvariantEquivClassesTy = SmallVector<InvariantEquivClassTy, 8>;
-/// @brief Statement of the Scop
+/// Statement of the Scop
///
/// A Scop statement represents an instruction in the Scop.
///
@@ -1095,7 +1095,7 @@ private:
/// The Scop containing this ScopStmt
Scop &Parent;
- /// @brief The domain under which this statement is not modeled precisely.
+ /// The domain under which this statement is not modeled precisely.
///
/// The invalid domain for a statement describes all parameter combinations
/// under which the statement looks to be executed but is in fact not because
@@ -1129,18 +1129,18 @@ private:
typedef SmallVector<MemoryAccess *, 8> MemoryAccessVec;
MemoryAccessVec MemAccs;
- /// @brief Mapping from instructions to (scalar) memory accesses.
+ /// Mapping from instructions to (scalar) memory accesses.
DenseMap<const Instruction *, MemoryAccessList> InstructionToAccess;
- /// @brief The set of values defined elsewhere required in this ScopStmt and
+ /// The set of values defined elsewhere required in this ScopStmt and
/// their MK_Value READ MemoryAccesses.
DenseMap<Value *, MemoryAccess *> ValueReads;
- /// @brief The set of values defined in this ScopStmt that are required
+ /// The set of values defined in this ScopStmt that are required
/// elsewhere, mapped to their MK_Value WRITE MemoryAccesses.
DenseMap<Instruction *, MemoryAccess *> ValueWrites;
- /// @brief Map from PHI nodes to its incoming value when coming from this
+ /// Map from PHI nodes to its incoming value when coming from this
/// statement.
///
/// Non-affine subregions can have multiple exiting blocks that are incoming
@@ -1151,22 +1151,23 @@ private:
//@}
- /// @brief A SCoP statement represents either a basic block (affine/precise
- /// case) or a whole region (non-affine case). Only one of the
- /// following two members will therefore be set and indicate which
- /// kind of statement this is.
+ /// A SCoP statement represents either a basic block (affine/precise case) or
+ /// a whole region (non-affine case).
+ ///
+ /// Only one of the following two members will therefore be set and indicate
+ /// which kind of statement this is.
///
///{
- /// @brief The BasicBlock represented by this statement (in the affine case).
+ /// The BasicBlock represented by this statement (in the affine case).
BasicBlock *BB;
- /// @brief The region represented by this statement (in the non-affine case).
+ /// The region represented by this statement (in the non-affine case).
Region *R;
///}
- /// @brief The isl AST build for the new generated AST.
+ /// The isl AST build for the new generated AST.
isl_ast_build *Build;
SmallVector<Loop *, 4> NestLoops;
@@ -1177,22 +1178,22 @@ private:
//@{
void buildDomain();
- /// @brief Fill NestLoops with loops surrounding this statement.
+ /// Fill NestLoops with loops surrounding this statement.
void collectSurroundingLoops();
- /// @brief Build the access relation of all memory accesses.
+ /// Build the access relation of all memory accesses.
void buildAccessRelations();
- /// @brief Detect and mark reductions in the ScopStmt
+ /// Detect and mark reductions in the ScopStmt
void checkForReductions();
- /// @brief Collect loads which might form a reduction chain with @p StoreMA
+ /// Collect loads which might form a reduction chain with @p StoreMA
void
collectCandiateReductionLoads(MemoryAccess *StoreMA,
llvm::SmallVectorImpl<MemoryAccess *> &Loads);
//@}
- /// @brief Derive assumptions about parameter values from GetElementPtrInst
+ /// Derive assumptions about parameter values from GetElementPtrInst
///
/// In case a GEP instruction references into a fixed size array e.g., an
/// access A[i][j] into an array A[100x100], LLVM-IR does not guarantee that
@@ -1221,82 +1222,82 @@ private:
/// or non-optimal run-time checks.
void deriveAssumptionsFromGEP(GetElementPtrInst *Inst, LoopInfo &LI);
- /// @brief Derive assumptions about parameter values.
+ /// Derive assumptions about parameter values.
void deriveAssumptions(LoopInfo &LI);
public:
~ScopStmt();
- /// @brief Get an isl_ctx pointer.
+ /// Get an isl_ctx pointer.
isl_ctx *getIslCtx() const;
- /// @brief Get the iteration domain of this ScopStmt.
+ /// Get the iteration domain of this ScopStmt.
///
/// @return The iteration domain of this ScopStmt.
__isl_give isl_set *getDomain() const;
- /// @brief Get the space of the iteration domain
+ /// Get the space of the iteration domain
///
/// @return The space of the iteration domain
__isl_give isl_space *getDomainSpace() const;
- /// @brief Get the id of the iteration domain space
+ /// Get the id of the iteration domain space
///
/// @return The id of the iteration domain space
__isl_give isl_id *getDomainId() const;
- /// @brief Get an isl string representing this domain.
+ /// Get an isl string representing this domain.
std::string getDomainStr() const;
- /// @brief Get the schedule function of this ScopStmt.
+ /// Get the schedule function of this ScopStmt.
///
/// @return The schedule function of this ScopStmt.
__isl_give isl_map *getSchedule() const;
- /// @brief Get an isl string representing this schedule.
+ /// Get an isl string representing this schedule.
std::string getScheduleStr() const;
- /// @brief Get the invalid domain for this statement.
+ /// Get the invalid domain for this statement.
__isl_give isl_set *getInvalidDomain() const {
return isl_set_copy(InvalidDomain);
}
- /// @brief Get the invalid context for this statement.
+ /// Get the invalid context for this statement.
__isl_give isl_set *getInvalidContext() const {
return isl_set_params(getInvalidDomain());
}
- /// @brief Set the invalid context for this statement to @p ID.
+ /// Set the invalid context for this statement to @p ID.
void setInvalidDomain(__isl_take isl_set *ID);
- /// @brief Get the BasicBlock represented by this ScopStmt (if any).
+ /// Get the BasicBlock represented by this ScopStmt (if any).
///
/// @return The BasicBlock represented by this ScopStmt, or null if the
/// statement represents a region.
BasicBlock *getBasicBlock() const { return BB; }
- /// @brief Return true if this statement represents a single basic block.
+ /// Return true if this statement represents a single basic block.
bool isBlockStmt() const { return BB != nullptr; }
- /// @brief Get the region represented by this ScopStmt (if any).
+ /// Get the region represented by this ScopStmt (if any).
///
/// @return The region represented by this ScopStmt, or null if the statement
/// represents a basic block.
Region *getRegion() const { return R; }
- /// @brief Return true if this statement represents a whole region.
+ /// Return true if this statement represents a whole region.
bool isRegionStmt() const { return R != nullptr; }
- /// @brief Return a BasicBlock from this statement.
+ /// Return a BasicBlock from this statement.
///
/// For block statements, it returns the BasicBlock itself. For subregion
/// statements, return its entry block.
BasicBlock *getEntryBlock() const;
- /// @brief Return true if this statement does not contain any accesses.
+ /// Return true if this statement does not contain any accesses.
bool isEmpty() const { return MemAccs.empty(); }
- /// @brief Return the only array access for @p Inst, if existing.
+ /// Return the only array access for @p Inst, if existing.
///
/// @param Inst The instruction for which to look up the access.
/// @returns The unique array memory access related to Inst or nullptr if
@@ -1320,7 +1321,7 @@ public:
return ArrayAccess;
}
- /// @brief Return the only array access for @p Inst.
+ /// Return the only array access for @p Inst.
///
/// @param Inst The instruction for which to look up the access.
/// @returns The unique array memory access related to Inst.
@@ -1331,7 +1332,7 @@ public:
return *ArrayAccess;
}
- /// @brief Return the MemoryAccess that writes the value of an instruction
+ /// Return the MemoryAccess that writes the value of an instruction
/// defined in this statement, or nullptr if not existing, respectively
/// not yet added.
MemoryAccess *lookupValueWriteOf(Instruction *Inst) const {
@@ -1340,13 +1341,13 @@ public:
return ValueWrites.lookup(Inst);
}
- /// @brief Return the MemoryAccess that reloads a value, or nullptr if not
+ /// Return the MemoryAccess that reloads a value, or nullptr if not
/// existing, respectively not yet added.
MemoryAccess *lookupValueReadOf(Value *Inst) const {
return ValueReads.lookup(Inst);
}
- /// @brief Return the PHI write MemoryAccess for the incoming values from any
+ /// Return the PHI write MemoryAccess for the incoming values from any
/// basic block in this ScopStmt, or nullptr if not existing,
/// respectively not yet added.
MemoryAccess *lookupPHIWriteOf(PHINode *PHI) const {
@@ -1354,10 +1355,10 @@ public:
return PHIWrites.lookup(PHI);
}
- /// @brief Add @p Access to this statement's list of accesses.
+ /// Add @p Access to this statement's list of accesses.
void addAccess(MemoryAccess *Access);
- /// @brief Remove a MemoryAccess from this statement.
+ /// Remove a MemoryAccess from this statement.
///
/// Note that scalar accesses that are caused by MA will
/// be eliminated too.
@@ -1379,18 +1380,18 @@ public:
const char *getBaseName() const;
- /// @brief Set the isl AST build.
+ /// Set the isl AST build.
void setAstBuild(__isl_keep isl_ast_build *B) { Build = B; }
- /// @brief Get the isl AST build.
+ /// Get the isl AST build.
__isl_keep isl_ast_build *getAstBuild() const { return Build; }
- /// @brief Restrict the domain of the statement.
+ /// Restrict the domain of the statement.
///
/// @param NewDomain The new statement domain.
void restrictDomain(__isl_take isl_set *NewDomain);
- /// @brief Compute the isl representation for the SCEV @p E in this stmt.
+ /// Compute the isl representation for the SCEV @p E in this stmt.
///
/// @param E The SCEV that should be translated.
/// @param NonNegative Flag to indicate the @p E has to be non-negative.
@@ -1398,31 +1399,31 @@ public:
/// Note that this function will also adjust the invalid context accordingly.
__isl_give isl_pw_aff *getPwAff(const SCEV *E, bool NonNegative = false);
- /// @brief Get the loop for a dimension.
+ /// Get the loop for a dimension.
///
/// @param Dimension The dimension of the induction variable
/// @return The loop at a certain dimension.
Loop *getLoopForDimension(unsigned Dimension) const;
- /// @brief Align the parameters in the statement to the scop context
+ /// Align the parameters in the statement to the scop context
void realignParams();
- /// @brief Print the ScopStmt.
+ /// Print the ScopStmt.
///
/// @param OS The output stream the ScopStmt is printed to.
void print(raw_ostream &OS) const;
- /// @brief Print the ScopStmt to stderr.
+ /// Print the ScopStmt to stderr.
void dump() const;
};
-/// @brief Print ScopStmt S to raw_ostream O.
+/// Print ScopStmt S to raw_ostream O.
static inline raw_ostream &operator<<(raw_ostream &O, const ScopStmt &S) {
S.print(O);
return O;
}
-/// @brief Static Control Part
+/// Static Control Part
///
/// A Scop is the polyhedral representation of a control flow region detected
/// by the Scop detection. It is generated by translating the LLVM-IR and
@@ -1441,17 +1442,17 @@ static inline raw_ostream &operator<<(ra
/// can take and relations between different parameters.
class Scop {
public:
- /// @brief Type to represent a pair of minimal/maximal access to an array.
+ /// Type to represent a pair of minimal/maximal access to an array.
using MinMaxAccessTy = std::pair<isl_pw_multi_aff *, isl_pw_multi_aff *>;
- /// @brief Vector of minimal/maximal accesses to different arrays.
+ /// Vector of minimal/maximal accesses to different arrays.
using MinMaxVectorTy = SmallVector<MinMaxAccessTy, 4>;
- /// @brief Pair of minimal/maximal access vectors representing
+ /// Pair of minimal/maximal access vectors representing
/// read write and read only accesses
using MinMaxVectorPairTy = std::pair<MinMaxVectorTy, MinMaxVectorTy>;
- /// @brief Vector of pair of minimal/maximal access vectors representing
+ /// Vector of pair of minimal/maximal access vectors representing
/// non read only and read only accesses for each alias group.
using MinMaxVectorPairVectorTy = SmallVector<MinMaxVectorPairTy, 4>;
@@ -1472,10 +1473,10 @@ private:
/// Flag to indicate that the scheduler actually optimized the SCoP.
bool IsOptimized;
- /// @brief True if the underlying region has a single exiting block.
+ /// True if the underlying region has a single exiting block.
bool HasSingleExitEdge;
- /// @brief Flag to remember if the SCoP contained an error block or not.
+ /// Flag to remember if the SCoP contained an error block or not.
bool HasErrorBlock;
/// Max loop depth.
@@ -1485,13 +1486,13 @@ private:
/// The statements in this Scop.
StmtSet Stmts;
- /// @brief Parameters of this Scop
+ /// Parameters of this Scop
ParameterSetTy Parameters;
- /// @brief Mapping from parameters to their ids.
+ /// Mapping from parameters to their ids.
DenseMap<const SCEV *, isl_id *> ParameterIds;
- /// @brief The context of the SCoP created during SCoP detection.
+ /// The context of the SCoP created during SCoP detection.
ScopDetection::DetectionContext &DC;
/// Isl context.
@@ -1503,16 +1504,16 @@ private:
/// delete the last object that creates isl objects with the context.
std::shared_ptr<isl_ctx> IslCtx;
- /// @brief A map from basic blocks to SCoP statements.
+ /// A map from basic blocks to SCoP statements.
DenseMap<BasicBlock *, ScopStmt *> StmtMap;
- /// @brief A map from basic blocks to their domains.
+ /// A map from basic blocks to their domains.
DenseMap<BasicBlock *, isl_set *> DomainMap;
/// Constraints on parameters.
isl_set *Context;
- /// @brief The affinator used to translate SCEVs to isl expressions.
+ /// The affinator used to translate SCEVs to isl expressions.
SCEVAffinator Affinator;
typedef std::map<std::pair<AssertingVH<const Value>, int>,
@@ -1523,22 +1524,22 @@ private:
typedef SetVector<ScopArrayInfo *> ArrayInfoSetTy;
- /// @brief A map to remember ScopArrayInfo objects for all base pointers.
+ /// A map to remember ScopArrayInfo objects for all base pointers.
///
/// As PHI nodes may have two array info objects associated, we add a flag
/// that distinguishes between the PHI node specific ArrayInfo object
/// and the normal one.
ArrayInfoMapTy ScopArrayInfoMap;
- /// @brief A map to remember ScopArrayInfo objects for all names of memory
+ /// A map to remember ScopArrayInfo objects for all names of memory
/// references.
ArrayNameMapTy ScopArrayNameMap;
- /// @brief A set to remember ScopArrayInfo objects.
+ /// A set to remember ScopArrayInfo objects.
/// @see Scop::ScopArrayInfoMap
ArrayInfoSetTy ScopArrayInfoSet;
- /// @brief The assumptions under which this scop was built.
+ /// The assumptions under which this scop was built.
///
/// When constructing a scop sometimes the exact representation of a statement
/// or condition would be very complex, but there is a common case which is a
@@ -1547,7 +1548,7 @@ private:
/// this scop and that need to be code generated as a run-time test.
isl_set *AssumedContext;
- /// @brief The restrictions under which this SCoP was built.
+ /// The restrictions under which this SCoP was built.
///
/// The invalid context is similar to the assumed context as it contains
/// constraints over the parameters. However, while we need the constraints
@@ -1555,26 +1556,26 @@ private:
/// need to be "false". Otherwise they behave the same.
isl_set *InvalidContext;
- /// @brief Helper struct to remember assumptions.
+ /// Helper struct to remember assumptions.
struct Assumption {
- /// @brief The kind of the assumption (e.g., WRAPPING).
+ /// The kind of the assumption (e.g., WRAPPING).
AssumptionKind Kind;
- /// @brief Flag to distinguish assumptions and restrictions.
+ /// Flag to distinguish assumptions and restrictions.
AssumptionSign Sign;
- /// @brief The valid/invalid context if this is an assumption/restriction.
+ /// The valid/invalid context if this is an assumption/restriction.
isl_set *Set;
- /// @brief The location that caused this assumption.
+ /// The location that caused this assumption.
DebugLoc Loc;
- /// @brief An optional block whose domain can simplify the assumption.
+ /// An optional block whose domain can simplify the assumption.
BasicBlock *BB;
};
- /// @brief Collection to hold taken assumptions.
+ /// Collection to hold taken assumptions.
///
/// There are two reasons why we want to record assumptions first before we
/// add them to the assumed/invalid context:
@@ -1586,7 +1587,7 @@ private:
/// only be simplified later on.
SmallVector<Assumption, 8> RecordedAssumptions;
- /// @brief The schedule of the SCoP
+ /// The schedule of the SCoP
///
/// The schedule of the SCoP describes the execution order of the statements
/// in the scop by assigning each statement instance a possibly
@@ -1622,7 +1623,7 @@ private:
/// in a schedule tree is given in the isl manual.
isl_schedule *Schedule;
- /// @brief The set of minimal/maximal accesses for each alias group.
+ /// The set of minimal/maximal accesses for each alias group.
///
/// When building runtime alias checks we look at all memory instructions and
/// build so called alias groups. Each group contains a set of accesses to
@@ -1637,29 +1638,29 @@ private:
/// group to ensure the SCoP is executed in an alias free environment.
MinMaxVectorPairVectorTy MinMaxAliasGroups;
- /// @brief Mapping from invariant loads to the representing invariant load of
+ /// Mapping from invariant loads to the representing invariant load of
/// their equivalence class.
ValueToValueMap InvEquivClassVMap;
- /// @brief List of invariant accesses.
+ /// List of invariant accesses.
InvariantEquivClassesTy InvariantEquivClasses;
- /// @brief Scop constructor; invoked from ScopBuilder::buildScop.
+ /// Scop constructor; invoked from ScopBuilder::buildScop.
Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
ScopDetection::DetectionContext &DC);
- /// @brief Add the access function to all MemoryAccess objects of the Scop
+ /// Add the access function to all MemoryAccess objects of the Scop
/// created in this pass.
void addAccessFunction(MemoryAccess *Access) {
AccessFunctions.emplace_back(Access);
}
//@}
- /// @brief Initialize this ScopBuilder.
+ /// Initialize this ScopBuilder.
void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
LoopInfo &LI);
- /// @brief Propagate domains that are known due to graph properties.
+ /// Propagate domains that are known due to graph properties.
///
/// As a CFG is mostly structured we use the graph properties to propagate
/// domains without the need to compute all path conditions. In particular, if
@@ -1685,7 +1686,7 @@ private:
BasicBlock *BB, Loop *BBLoop,
SmallPtrSetImpl<BasicBlock *> &FinishedExitBlocks, LoopInfo &LI);
- /// @brief Compute the union of predecessor domains for @p BB.
+ /// Compute the union of predecessor domains for @p BB.
///
/// To compute the union of all domains of predecessors of @p BB this
/// function applies similar reasoning on the CFG structure as described for
@@ -1701,7 +1702,7 @@ private:
getPredecessorDomainConstraints(BasicBlock *BB, __isl_keep isl_set *Domain,
DominatorTree &DT, LoopInfo &LI);
- /// @brief Add loop carried constraints to the header block of the loop @p L.
+ /// Add loop carried constraints to the header block of the loop @p L.
///
/// @param L The loop to process.
/// @param LI The LoopInfo for the current function.
@@ -1709,7 +1710,7 @@ private:
/// @returns True if there was no problem and false otherwise.
bool addLoopBoundsToHeaderDomain(Loop *L, LoopInfo &LI);
- /// @brief Compute the branching constraints for each basic block in @p R.
+ /// Compute the branching constraints for each basic block in @p R.
///
/// @param R The region we currently build branching conditions for.
/// @param DT The DominatorTree for the current function.
@@ -1719,7 +1720,7 @@ private:
bool buildDomainsWithBranchConstraints(Region *R, DominatorTree &DT,
LoopInfo &LI);
- /// @brief Propagate the domain constraints through the region @p R.
+ /// Propagate the domain constraints through the region @p R.
///
/// @param R The region we currently build branching conditions for.
/// @param DT The DominatorTree for the current function.
@@ -1728,7 +1729,7 @@ private:
/// @returns True if there was no problem and false otherwise.
bool propagateDomainConstraints(Region *R, DominatorTree &DT, LoopInfo &LI);
- /// @brief Propagate invalid domains of statements through @p R.
+ /// Propagate invalid domains of statements through @p R.
///
/// This method will propagate invalid statement domains through @p R and at
/// the same time add error block domains to them. Additionally, the domains
@@ -1742,7 +1743,7 @@ private:
/// @returns True if there was no problem and false otherwise.
bool propagateInvalidStmtDomains(Region *R, DominatorTree &DT, LoopInfo &LI);
- /// @brief Compute the domain for each basic block in @p R.
+ /// Compute the domain for each basic block in @p R.
///
/// @param R The region we currently traverse.
/// @param DT The DominatorTree for the current function.
@@ -1751,20 +1752,20 @@ private:
/// @returns True if there was no problem and false otherwise.
bool buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI);
- /// @brief Add parameter constraints to @p C that imply a non-empty domain.
+ /// Add parameter constraints to @p C that imply a non-empty domain.
__isl_give isl_set *addNonEmptyDomainConstraints(__isl_take isl_set *C) const;
- /// @brief Simplify the SCoP representation
+ /// Simplify the SCoP representation
void simplifySCoP(bool AfterHoisting);
- /// @brief Return the access for the base ptr of @p MA if any.
+ /// Return the access for the base ptr of @p MA if any.
MemoryAccess *lookupBasePtrAccess(MemoryAccess *MA);
- /// @brief Check if the base ptr of @p MA is in the SCoP but not hoistable.
+ /// Check if the base ptr of @p MA is in the SCoP but not hoistable.
bool hasNonHoistableBasePtrInScop(MemoryAccess *MA,
__isl_keep isl_union_map *Writes);
- /// @brief Create equivalence classes for required invariant accesses.
+ /// Create equivalence classes for required invariant accesses.
///
/// These classes will consolidate multiple required invariant loads from the
/// same address in order to keep the number of dimensions in the SCoP
@@ -1778,7 +1779,7 @@ private:
/// invariant location.
void buildInvariantEquivalenceClasses();
- /// @brief Return the context under which the access cannot be hoisted.
+ /// Return the context under which the access cannot be hoisted.
///
/// @param Access The access to check.
/// @param Writes The set of all memory writes in the scop.
@@ -1788,7 +1789,7 @@ private:
__isl_give isl_set *getNonHoistableCtx(MemoryAccess *Access,
__isl_keep isl_union_map *Writes);
- /// @brief Verify that all required invariant loads have been hoisted.
+ /// Verify that all required invariant loads have been hoisted.
///
/// Invariant load hoisting is not guaranteed to hoist all loads that were
/// assumed to be scop invariant during scop detection. This function checks
@@ -1804,7 +1805,7 @@ private:
///
void verifyInvariantLoads();
- /// @brief Hoist invariant memory loads and check for required ones.
+ /// Hoist invariant memory loads and check for required ones.
///
/// We first identify "common" invariant loads, thus loads that are invariant
/// and can be hoisted. Then we check if all required invariant loads have
@@ -1824,28 +1825,28 @@ private:
///
void hoistInvariantLoads();
- /// @brief Add invariant loads listed in @p InvMAs with the domain of @p Stmt.
+ /// Add invariant loads listed in @p InvMAs with the domain of @p Stmt.
void addInvariantLoads(ScopStmt &Stmt, InvariantAccessesTy &InvMAs);
- /// @brief Create an id for @p Param and store it in the ParameterIds map.
+ /// Create an id for @p Param and store it in the ParameterIds map.
void createParameterId(const SCEV *Param);
- /// @brief Build the Context of the Scop.
+ /// Build the Context of the Scop.
void buildContext();
- /// @brief Add user provided parameter constraints to context (source code).
+ /// Add user provided parameter constraints to context (source code).
void addUserAssumptions(AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI);
- /// @brief Add user provided parameter constraints to context (command line).
+ /// Add user provided parameter constraints to context (command line).
void addUserContext();
- /// @brief Add the bounds of the parameters to the context.
+ /// Add the bounds of the parameters to the context.
void addParameterBounds();
- /// @brief Simplify the assumed and invalid context.
+ /// Simplify the assumed and invalid context.
void simplifyContexts();
- /// @brief Get the representing SCEV for @p S if applicable, otherwise @p S.
+ /// Get the representing SCEV for @p S if applicable, otherwise @p S.
///
/// Invariant loads of the same location are put in an equivalence class and
/// only one of them is chosen as a representing element that will be
@@ -1858,7 +1859,7 @@ private:
/// @return The representing SCEV for invariant loads or @p S if none.
const SCEV *getRepresentingInvariantLoadSCEV(const SCEV *S);
- /// @brief Create a new SCoP statement for either @p BB or @p R.
+ /// Create a new SCoP statement for either @p BB or @p R.
///
/// Either @p BB or @p R should be non-null. A new statement for the non-null
/// argument will be created and added to the statement vector and map.
@@ -1876,12 +1877,12 @@ private:
/// the dimensionality of the underlying ScopArrayInfo object.
void updateAccessDimensionality();
- /// @brief Construct the schedule of this SCoP.
+ /// Construct the schedule of this SCoP.
///
/// @param LI The LoopInfo for the current function.
void buildSchedule(LoopInfo &LI);
- /// @brief A loop stack element to keep track of per-loop information during
+ /// A loop stack element to keep track of per-loop information during
/// schedule construction.
typedef struct LoopStackElement {
// The loop for which we keep information.
@@ -1899,7 +1900,7 @@ private:
: L(L), Schedule(S), NumBlocksProcessed(NumBlocksProcessed) {}
} LoopStackElementTy;
- /// @brief The loop stack used for schedule construction.
+ /// The loop stack used for schedule construction.
///
/// The loop stack keeps track of schedule information for a set of nested
/// loops as well as an (optional) 'nullptr' loop that models the outermost
@@ -1908,7 +1909,7 @@ private:
/// position n + 1.
typedef SmallVector<LoopStackElementTy, 4> LoopStackTy;
- /// @brief Construct schedule information for a given Region and add the
+ /// Construct schedule information for a given Region and add the
/// derived information to @p LoopStack.
///
/// Given a Region we derive schedule information for all RegionNodes
@@ -1921,7 +1922,7 @@ private:
/// @param LI The LoopInfo for the current function.
void buildSchedule(Region *R, LoopStackTy &LoopStack, LoopInfo &LI);
- /// @brief Build Schedule for the region node @p RN and add the derived
+ /// Build Schedule for the region node @p RN and add the derived
/// information to @p LoopStack.
///
/// In case @p RN is a BasicBlock or a non-affine Region, we construct the
@@ -1937,7 +1938,7 @@ private:
/// @param LI The LoopInfo for the current function.
void buildSchedule(RegionNode *RN, LoopStackTy &LoopStack, LoopInfo &LI);
- /// @brief Collect all memory access relations of a given type.
+ /// Collect all memory access relations of a given type.
///
/// @param Predicate A predicate function that returns true if an access is
/// of a given type.
@@ -1962,15 +1963,15 @@ public:
ScalarEvolution *getSE() const;
- /// @brief Get the count of parameters used in this Scop.
+ /// Get the count of parameters used in this Scop.
///
/// @return The count of parameters used in this Scop.
size_t getNumParams() const { return Parameters.size(); }
- /// @brief Take a list of parameters and add the new ones to the scop.
+ /// Take a list of parameters and add the new ones to the scop.
void addParams(const ParameterSetTy &NewParameters);
- /// @brief Return whether this scop is empty, i.e. contains no statements that
+ /// Return whether this scop is empty, i.e. contains no statements that
/// could be executed.
bool isEmpty() const { return Stmts.empty(); }
@@ -1999,89 +2000,89 @@ public:
return const_array_range(array_begin(), array_end());
}
- /// @brief Return the isl_id that represents a certain parameter.
+ /// Return the isl_id that represents a certain parameter.
///
/// @param Parameter A SCEV that was recognized as a Parameter.
///
/// @return The corresponding isl_id or NULL otherwise.
__isl_give isl_id *getIdForParam(const SCEV *Parameter);
- /// @brief Get the maximum region of this static control part.
+ /// Get the maximum region of this static control part.
///
/// @return The maximum region of this static control part.
inline const Region &getRegion() const { return R; }
inline Region &getRegion() { return R; }
- /// @brief Return the function this SCoP is in.
+ /// Return the function this SCoP is in.
Function &getFunction() const { return *R.getEntry()->getParent(); }
- /// @brief Check if @p L is contained in the SCoP.
+ /// Check if @p L is contained in the SCoP.
bool contains(const Loop *L) const { return R.contains(L); }
- /// @brief Check if @p BB is contained in the SCoP.
+ /// Check if @p BB is contained in the SCoP.
bool contains(const BasicBlock *BB) const { return R.contains(BB); }
- /// @brief Check if @p I is contained in the SCoP.
+ /// Check if @p I is contained in the SCoP.
bool contains(const Instruction *I) const { return R.contains(I); }
- /// @brief Return the unique exit block of the SCoP.
+ /// Return the unique exit block of the SCoP.
BasicBlock *getExit() const { return R.getExit(); }
- /// @brief Return the unique exiting block of the SCoP if any.
+ /// Return the unique exiting block of the SCoP if any.
BasicBlock *getExitingBlock() const { return R.getExitingBlock(); }
- /// @brief Return the unique entry block of the SCoP.
+ /// Return the unique entry block of the SCoP.
BasicBlock *getEntry() const { return R.getEntry(); }
- /// @brief Return the unique entering block of the SCoP if any.
+ /// Return the unique entering block of the SCoP if any.
BasicBlock *getEnteringBlock() const { return R.getEnteringBlock(); }
- /// @brief Return true if @p BB is the exit block of the SCoP.
+ /// Return true if @p BB is the exit block of the SCoP.
bool isExit(BasicBlock *BB) const { return getExit() == BB; }
- /// @brief Return a range of all basic blocks in the SCoP.
+ /// Return a range of all basic blocks in the SCoP.
Region::block_range blocks() const { return R.blocks(); }
- /// @brief Return true if and only if @p BB dominates the SCoP.
+ /// Return true if and only if @p BB dominates the SCoP.
bool isDominatedBy(const DominatorTree &DT, BasicBlock *BB) const;
- /// @brief Get the maximum depth of the loop.
+ /// Get the maximum depth of the loop.
///
/// @return The maximum depth of the loop.
inline unsigned getMaxLoopDepth() const { return MaxLoopDepth; }
- /// @brief Return the invariant equivalence class for @p Val if any.
+ /// Return the invariant equivalence class for @p Val if any.
InvariantEquivClassTy *lookupInvariantEquivClass(Value *Val);
- /// @brief Return the set of invariant accesses.
+ /// Return the set of invariant accesses.
InvariantEquivClassesTy &getInvariantAccesses() {
return InvariantEquivClasses;
}
- /// @brief Check if the scop has any invariant access.
+ /// Check if the scop has any invariant access.
bool hasInvariantAccesses() { return !InvariantEquivClasses.empty(); }
- /// @brief Mark the SCoP as optimized by the scheduler.
+ /// Mark the SCoP as optimized by the scheduler.
void markAsOptimized() { IsOptimized = true; }
- /// @brief Check if the SCoP has been optimized by the scheduler.
+ /// Check if the SCoP has been optimized by the scheduler.
bool isOptimized() const { return IsOptimized; }
- /// @brief Get the name of this Scop.
+ /// Get the name of this Scop.
std::string getNameStr() const;
- /// @brief Get the constraint on parameter of this Scop.
+ /// Get the constraint on parameter of this Scop.
///
/// @return The constraint on parameter of this Scop.
__isl_give isl_set *getContext() const;
__isl_give isl_space *getParamSpace() const;
- /// @brief Get the assumed context for this Scop.
+ /// Get the assumed context for this Scop.
///
/// @return The assumed context of this Scop.
__isl_give isl_set *getAssumedContext() const;
- /// @brief Return true if the optimized SCoP can be executed.
+ /// Return true if the optimized SCoP can be executed.
///
/// In addition to the runtime check context this will also utilize the domain
/// constraints to decide it the optimized version can actually be executed.
@@ -2089,7 +2090,7 @@ public:
/// @returns True if the optimized SCoP can be executed.
bool hasFeasibleRuntimeContext() const;
- /// @brief Check if the assumption in @p Set is trivial or not.
+ /// Check if the assumption in @p Set is trivial or not.
///
/// @param Set The relations between parameters that are assumed to hold.
/// @param Sign Enum to indicate if the assumptions in @p Set are positive
@@ -2098,7 +2099,7 @@ public:
/// @returns True if the assumption @p Set is not trivial.
bool isEffectiveAssumption(__isl_keep isl_set *Set, AssumptionSign Sign);
- /// @brief Track and report an assumption.
+ /// Track and report an assumption.
///
/// Use 'clang -Rpass-analysis=polly-scops' or 'opt
/// -pass-remarks-analysis=polly-scops' to output the assumptions.
@@ -2113,7 +2114,7 @@ public:
bool trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
DebugLoc Loc, AssumptionSign Sign);
- /// @brief Add assumptions to assumed context.
+ /// Add assumptions to assumed context.
///
/// The assumptions added will be assumed to hold during the execution of the
/// scop. However, as they are generally not statically provable, at code
@@ -2132,7 +2133,7 @@ public:
void addAssumption(AssumptionKind Kind, __isl_take isl_set *Set, DebugLoc Loc,
AssumptionSign Sign);
- /// @brief Record an assumption for later addition to the assumed context.
+ /// Record an assumption for later addition to the assumed context.
///
/// This function will add the assumption to the RecordedAssumptions. This
/// collection will be added (@see addAssumption) to the assumed context once
@@ -2151,10 +2152,10 @@ public:
DebugLoc Loc, AssumptionSign Sign,
BasicBlock *BB = nullptr);
- /// @brief Add all recorded assumptions to the assumed context.
+ /// Add all recorded assumptions to the assumed context.
void addRecordedAssumptions();
- /// @brief Mark the scop as invalid.
+ /// Mark the scop as invalid.
///
/// This method adds an assumption to the scop that is always invalid. As a
/// result, the scop will not be optimized later on. This function is commonly
@@ -2165,58 +2166,58 @@ public:
/// @param Loc The location in the source that triggered .
void invalidate(AssumptionKind Kind, DebugLoc Loc);
- /// @brief Get the invalid context for this Scop.
+ /// Get the invalid context for this Scop.
///
/// @return The invalid context of this Scop.
__isl_give isl_set *getInvalidContext() const;
- /// @brief Return true if and only if the InvalidContext is trivial (=empty).
+ /// Return true if and only if the InvalidContext is trivial (=empty).
bool hasTrivialInvalidContext() const {
return isl_set_is_empty(InvalidContext);
}
- /// @brief Build the alias checks for this SCoP.
+ /// Build the alias checks for this SCoP.
bool buildAliasChecks(AliasAnalysis &AA);
- /// @brief Build all alias groups for this SCoP.
+ /// Build all alias groups for this SCoP.
///
/// @returns True if __no__ error occurred, false otherwise.
bool buildAliasGroups(AliasAnalysis &AA);
- /// @brief Return all alias groups for this SCoP.
+ /// Return all alias groups for this SCoP.
const MinMaxVectorPairVectorTy &getAliasGroups() const {
return MinMaxAliasGroups;
}
- /// @brief Get an isl string representing the context.
+ /// Get an isl string representing the context.
std::string getContextStr() const;
- /// @brief Get an isl string representing the assumed context.
+ /// Get an isl string representing the assumed context.
std::string getAssumedContextStr() const;
- /// @brief Get an isl string representing the invalid context.
+ /// Get an isl string representing the invalid context.
std::string getInvalidContextStr() const;
- /// @brief Return the ScopStmt for the given @p BB or nullptr if there is
+ /// Return the ScopStmt for the given @p BB or nullptr if there is
/// none.
ScopStmt *getStmtFor(BasicBlock *BB) const;
- /// @brief Return the ScopStmt that represents the Region @p R, or nullptr if
+ /// Return the ScopStmt that represents the Region @p R, or nullptr if
/// it is not represented by any statement in this Scop.
ScopStmt *getStmtFor(Region *R) const;
- /// @brief Return the ScopStmt that represents @p RN; can return nullptr if
+ /// Return the ScopStmt that represents @p RN; can return nullptr if
/// the RegionNode is not within the SCoP or has been removed due to
/// simplifications.
ScopStmt *getStmtFor(RegionNode *RN) const;
- /// @brief Return the ScopStmt an instruction belongs to, or nullptr if it
+ /// Return the ScopStmt an instruction belongs to, or nullptr if it
/// does not belong to any statement in this Scop.
ScopStmt *getStmtFor(Instruction *Inst) const {
return getStmtFor(Inst->getParent());
}
- /// @brief Return the number of statements in the SCoP.
+ /// Return the number of statements in the SCoP.
size_t getSize() const { return Stmts.size(); }
/// @name Statements Iterators
@@ -2240,30 +2241,30 @@ public:
const_reverse_iterator rend() const { return Stmts.rend(); }
//@}
- /// @brief Return the set of required invariant loads.
+ /// Return the set of required invariant loads.
const InvariantLoadsSetTy &getRequiredInvariantLoads() const {
return DC.RequiredILS;
}
- /// @brief Add @p LI to the set of required invariant loads.
+ /// Add @p LI to the set of required invariant loads.
void addRequiredInvariantLoad(LoadInst *LI) { DC.RequiredILS.insert(LI); }
- /// @brief Return true if and only if @p LI is a required invariant load.
+ /// Return true if and only if @p LI is a required invariant load.
bool isRequiredInvariantLoad(LoadInst *LI) const {
return getRequiredInvariantLoads().count(LI);
}
- /// @brief Return the set of boxed (thus overapproximated) loops.
+ /// Return the set of boxed (thus overapproximated) loops.
const BoxedLoopsSetTy &getBoxedLoops() const { return DC.BoxedLoopsSet; }
- /// @brief Return true if and only if @p R is a non-affine subregion.
+ /// Return true if and only if @p R is a non-affine subregion.
bool isNonAffineSubRegion(const Region *R) {
return DC.NonAffineSubRegionSet.count(R);
}
const MapInsnToMemAcc &getInsnToMemAccMap() const { return DC.InsnToMemAcc; }
- /// @brief Return the (possibly new) ScopArrayInfo object for @p Access.
+ /// Return the (possibly new) ScopArrayInfo object for @p Access.
///
/// @param ElementType The type of the elements stored in this array.
/// @param Kind The kind of the array info object.
@@ -2274,7 +2275,7 @@ public:
ScopArrayInfo::MemoryKind Kind,
const char *BaseName = nullptr);
- /// @brief Create an array and return the corresponding ScopArrayInfo object.
+ /// Create an array and return the corresponding ScopArrayInfo object.
///
/// @param ElementType The type of the elements stored in this array.
/// @param BaseName The name of this memory reference.
@@ -2283,14 +2284,14 @@ public:
const std::string &BaseName,
const std::vector<unsigned> &Sizes);
- /// @brief Return the cached ScopArrayInfo object for @p BasePtr.
+ /// Return the cached ScopArrayInfo object for @p BasePtr.
///
/// @param BasePtr The base pointer the object has been stored for.
/// @param Kind The kind of array info object.
const ScopArrayInfo *getScopArrayInfo(Value *BasePtr,
ScopArrayInfo::MemoryKind Kind);
- /// @brief Invalidate ScopArrayInfo object for base address.
+ /// Invalidate ScopArrayInfo object for base address.
///
/// @param BasePtr The base pointer of the ScopArrayInfo object to invalidate.
/// @param Kind The Kind of the ScopArrayInfo object.
@@ -2304,35 +2305,35 @@ public:
void setContext(__isl_take isl_set *NewContext);
- /// @brief Align the parameters in the statement to the scop context
+ /// Align the parameters in the statement to the scop context
void realignParams();
- /// @brief Return true if this SCoP can be profitably optimized.
+ /// Return true if this SCoP can be profitably optimized.
bool isProfitable() const;
- /// @brief Return true if the SCoP contained at least one error block.
+ /// Return true if the SCoP contained at least one error block.
bool hasErrorBlock() const { return HasErrorBlock; }
- /// @brief Return true if the underlying region has a single exiting block.
+ /// Return true if the underlying region has a single exiting block.
bool hasSingleExitEdge() const { return HasSingleExitEdge; }
- /// @brief Print the static control part.
+ /// Print the static control part.
///
/// @param OS The output stream the static control part is printed to.
void print(raw_ostream &OS) const;
- /// @brief Print the ScopStmt to stderr.
+ /// Print the ScopStmt to stderr.
void dump() const;
- /// @brief Get the isl context of this static control part.
+ /// Get the isl context of this static control part.
///
/// @return The isl context of this static control part.
isl_ctx *getIslCtx() const;
- /// @brief Directly return the shared_ptr of the context.
+ /// Directly return the shared_ptr of the context.
const std::shared_ptr<isl_ctx> &getSharedIslCtx() const { return IslCtx; }
- /// @brief Compute the isl representation for the SCEV @p E
+ /// Compute the isl representation for the SCEV @p E
///
/// @param E The SCEV that should be translated.
/// @param BB An (optional) basic block in which the isl_pw_aff is computed.
@@ -2347,62 +2348,62 @@ public:
__isl_give PWACtx getPwAff(const SCEV *E, BasicBlock *BB = nullptr,
bool NonNegative = false);
- /// @brief Compute the isl representation for the SCEV @p E
+ /// Compute the isl representation for the SCEV @p E
///
/// This function is like @see Scop::getPwAff() but strips away the invalid
/// domain part associated with the piecewise affine function.
__isl_give isl_pw_aff *getPwAffOnly(const SCEV *E, BasicBlock *BB = nullptr);
- /// @brief Return the domain of @p Stmt.
+ /// Return the domain of @p Stmt.
///
/// @param Stmt The statement for which the conditions should be returned.
__isl_give isl_set *getDomainConditions(const ScopStmt *Stmt) const;
- /// @brief Return the domain of @p BB.
+ /// Return the domain of @p BB.
///
/// @param BB The block for which the conditions should be returned.
__isl_give isl_set *getDomainConditions(BasicBlock *BB) const;
- /// @brief Get a union set containing the iteration domains of all statements.
+ /// Get a union set containing the iteration domains of all statements.
__isl_give isl_union_set *getDomains() const;
- /// @brief Get a union map of all may-writes performed in the SCoP.
+ /// Get a union map of all may-writes performed in the SCoP.
__isl_give isl_union_map *getMayWrites();
- /// @brief Get a union map of all must-writes performed in the SCoP.
+ /// Get a union map of all must-writes performed in the SCoP.
__isl_give isl_union_map *getMustWrites();
- /// @brief Get a union map of all writes performed in the SCoP.
+ /// Get a union map of all writes performed in the SCoP.
__isl_give isl_union_map *getWrites();
- /// @brief Get a union map of all reads performed in the SCoP.
+ /// Get a union map of all reads performed in the SCoP.
__isl_give isl_union_map *getReads();
- /// @brief Get a union map of all memory accesses performed in the SCoP.
+ /// Get a union map of all memory accesses performed in the SCoP.
__isl_give isl_union_map *getAccesses();
- /// @brief Get the schedule of all the statements in the SCoP.
+ /// Get the schedule of all the statements in the SCoP.
__isl_give isl_union_map *getSchedule() const;
- /// @brief Get a schedule tree describing the schedule of all statements.
+ /// Get a schedule tree describing the schedule of all statements.
__isl_give isl_schedule *getScheduleTree() const;
- /// @brief Update the current schedule
+ /// Update the current schedule
///
- /// @brief NewSchedule The new schedule (given as a flat union-map).
+ /// NewSchedule The new schedule (given as a flat union-map).
void setSchedule(__isl_take isl_union_map *NewSchedule);
- /// @brief Update the current schedule
+ /// Update the current schedule
///
- /// @brief NewSchedule The new schedule (given as schedule tree).
+ /// NewSchedule The new schedule (given as schedule tree).
void setScheduleTree(__isl_take isl_schedule *NewSchedule);
- /// @brief Intersects the domains of all statements in the SCoP.
+ /// Intersects the domains of all statements in the SCoP.
///
/// @return true if a change was made
bool restrictDomains(__isl_take isl_union_set *Domain);
- /// @brief Get the depth of a loop relative to the outermost loop in the Scop.
+ /// Get the depth of a loop relative to the outermost loop in the Scop.
///
/// This will return
/// 0 if @p L is an outermost loop in the SCoP
@@ -2410,21 +2411,21 @@ public:
/// -1 if @p L is nullptr or there is no outermost loop in the SCoP
int getRelativeLoopDepth(const Loop *L) const;
- /// @brief Find the ScopArrayInfo associated with an isl Id
+ /// Find the ScopArrayInfo associated with an isl Id
/// that has name @p Name.
ScopArrayInfo *getArrayInfoByName(const std::string BaseName);
};
-/// @brief Print Scop scop to raw_ostream O.
+/// Print Scop scop to raw_ostream O.
static inline raw_ostream &operator<<(raw_ostream &O, const Scop &scop) {
scop.print(O);
return O;
}
-/// @brief The legacy pass manager's analysis pass to compute scop information
+/// The legacy pass manager's analysis pass to compute scop information
/// for a region.
class ScopInfoRegionPass : public RegionPass {
- /// @brief The Scop pointer which is used to construct a Scop.
+ /// The Scop pointer which is used to construct a Scop.
std::unique_ptr<Scop> S;
public:
@@ -2433,7 +2434,7 @@ public:
ScopInfoRegionPass() : RegionPass(ID) {}
~ScopInfoRegionPass() {}
- /// @brief Build Scop object, the Polly IR of static control
+ /// Build Scop object, the Polly IR of static control
/// part for the current SESE-Region.
///
/// @return If the current region is a valid for a static control part,
@@ -2442,7 +2443,7 @@ public:
Scop *getScop() { return S.get(); }
const Scop *getScop() const { return S.get(); }
- /// @brief Calculate the polyhedral scop information for a given Region.
+ /// Calculate the polyhedral scop information for a given Region.
bool runOnRegion(Region *R, RGPassManager &RGM) override;
void releaseMemory() override { S.reset(); }
@@ -2453,7 +2454,7 @@ public:
};
//===----------------------------------------------------------------------===//
-/// @brief The legacy pass manager's analysis pass to compute scop information
+/// The legacy pass manager's analysis pass to compute scop information
/// for the whole function.
///
/// This pass will maintain a map of the maximal region within a scop to its
@@ -2468,7 +2469,7 @@ public:
using const_iterator = RegionToScopMapTy::const_iterator;
private:
- /// @brief A map of Region to its Scop object containing
+ /// A map of Region to its Scop object containing
/// Polly IR of static control part
RegionToScopMapTy RegionToScopMap;
@@ -2478,7 +2479,7 @@ public:
ScopInfoWrapperPass() : FunctionPass(ID) {}
~ScopInfoWrapperPass() {}
- /// @brief Get the Scop object for the given Region
+ /// Get the Scop object for the given Region
///
/// @return If the given region is the maximal region within a scop, return
/// the scop object. If the given region is a subregion, return a
@@ -2496,7 +2497,7 @@ public:
const_iterator begin() const { return RegionToScopMap.begin(); }
const_iterator end() const { return RegionToScopMap.end(); }
- /// @brief Calculate all the polyhedral scops for a given function.
+ /// Calculate all the polyhedral scops for a given function.
bool runOnFunction(Function &F) override;
void releaseMemory() override { RegionToScopMap.clear(); }
Modified: polly/trunk/include/polly/ScopPass.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopPass.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopPass.h (original)
+++ polly/trunk/include/polly/ScopPass.h Fri Sep 2 01:33:33 2016
@@ -39,7 +39,7 @@ protected:
///
virtual bool runOnScop(Scop &S) = 0;
- /// @brief Print method for SCoPs.
+ /// Print method for SCoPs.
virtual void printScop(raw_ostream &OS, Scop &S) const {}
/// getAnalysisUsage - Subclasses that override getAnalysisUsage
Modified: polly/trunk/include/polly/Support/GICHelper.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Support/GICHelper.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Support/GICHelper.h (original)
+++ polly/trunk/include/polly/Support/GICHelper.h Fri Sep 2 01:33:33 2016
@@ -38,7 +38,7 @@ class Value;
namespace polly {
-/// @brief Translate an llvm::APInt to an isl_val.
+/// Translate an llvm::APInt to an isl_val.
///
/// Translate the bitsequence without sign information as provided by APInt into
/// a signed isl_val type. Depending on the value of @p IsSigned @p Int is
@@ -70,7 +70,7 @@ namespace polly {
__isl_give isl_val *isl_valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
bool IsSigned);
-/// @brief Translate isl_val to llvm::APInt.
+/// Translate isl_val to llvm::APInt.
///
/// This function can only be called on isl_val values which are integers.
/// Calling this function with a non-integral rational, NaN or infinity value
@@ -99,7 +99,7 @@ __isl_give isl_val *isl_valFromAPInt(isl
/// @return The APInt value corresponding to @p Val.
llvm::APInt APIntFromVal(__isl_take isl_val *Val);
-/// @brief Get c++ string from Isl objects.
+/// Get c++ string from Isl objects.
//@{
std::string stringFromIslObj(__isl_keep isl_map *map);
std::string stringFromIslObj(__isl_keep isl_union_map *umap);
@@ -168,7 +168,7 @@ inline llvm::raw_ostream &operator<<(llv
return OS;
}
-/// @brief Return @p Prefix + @p Val->getName() + @p Suffix but Isl compatible.
+/// Return @p Prefix + @p Val->getName() + @p Suffix but Isl compatible.
std::string getIslCompatibleName(const std::string &Prefix,
const llvm::Value *Val,
const std::string &Suffix);
Modified: polly/trunk/include/polly/Support/SCEVAffinator.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Support/SCEVAffinator.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Support/SCEVAffinator.h (original)
+++ polly/trunk/include/polly/Support/SCEVAffinator.h Fri Sep 2 01:33:33 2016
@@ -43,7 +43,7 @@ namespace polly {
class Scop;
class ScopStmt;
-/// @brief The result type of the SCEVAffinator.
+/// The result type of the SCEVAffinator.
///
/// The first element of the pair is the isl representation of the SCEV, the
/// second is the domain under which it is __invalid__.
@@ -55,7 +55,7 @@ public:
SCEVAffinator(Scop *S, llvm::LoopInfo &LI);
~SCEVAffinator();
- /// @brief Translate a SCEV to an isl_pw_aff.
+ /// Translate a SCEV to an isl_pw_aff.
///
/// @param E he expression that is translated.
/// @param BB The block in which @p E is executed.
@@ -64,20 +64,20 @@ public:
__isl_give PWACtx getPwAff(const llvm::SCEV *E,
llvm::BasicBlock *BB = nullptr);
- /// @brief Take the asumption that @p PWAC is non-negative.
+ /// Take the asumption that @p PWAC is non-negative.
void takeNonNegativeAssumption(PWACtx &PWAC);
- /// @brief Interpret the PWA in @p PWAC as an unsigned value.
+ /// Interpret the PWA in @p PWAC as an unsigned value.
void interpretAsUnsigned(__isl_keep PWACtx &PWAC, unsigned Width);
- /// @brief Check an <nsw> AddRec for the loop @p L is cached.
+ /// Check an <nsw> AddRec for the loop @p L is cached.
bool hasNSWAddRecForLoop(llvm::Loop *L) const;
private:
- /// @brief Key to identify cached expressions.
+ /// Key to identify cached expressions.
using CacheKey = std::pair<const llvm::SCEV *, llvm::BasicBlock *>;
- /// @brief Map to remembered cached expressions.
+ /// Map to remembered cached expressions.
llvm::DenseMap<CacheKey, PWACtx> CachedExpressions;
Scop *S;
@@ -87,16 +87,16 @@ private:
llvm::LoopInfo &LI;
llvm::BasicBlock *BB;
- /// @brief Target data for element size computing.
+ /// Target data for element size computing.
const llvm::DataLayout &TD;
- /// @brief Return the loop for the current block if any.
+ /// Return the loop for the current block if any.
llvm::Loop *getScope();
- /// @brief Return a PWACtx for @p PWA that is always valid.
+ /// Return a PWACtx for @p PWA that is always valid.
__isl_give PWACtx getPWACtxFromPWA(__isl_take isl_pw_aff *PWA);
- /// @brief Compute the non-wrapping version of @p PWA for type @p ExprType.
+ /// Compute the non-wrapping version of @p PWA for type @p ExprType.
///
/// @param PWA The piece-wise affine function that might wrap.
/// @param Type The type of the SCEV that was translated to @p PWA.
@@ -105,7 +105,7 @@ private:
__isl_give isl_pw_aff *addModuloSemantic(__isl_take isl_pw_aff *PWA,
llvm::Type *ExprType) const;
- /// @brief If @p Expr might cause an integer wrap record an assumption.
+ /// If @p Expr might cause an integer wrap record an assumption.
///
/// @param Expr The SCEV expression that might wrap.
/// @param PWAC The isl representation of @p Expr with the invalid domain.
Modified: polly/trunk/include/polly/Support/SCEVValidator.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Support/SCEVValidator.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Support/SCEVValidator.h (original)
+++ polly/trunk/include/polly/Support/SCEVValidator.h Fri Sep 2 01:33:33 2016
@@ -26,14 +26,14 @@ class LoadInst;
} // namespace llvm
namespace polly {
-/// @brief Find the loops referenced from a SCEV expression.
+/// Find the loops referenced from a SCEV expression.
///
/// @param Expr The SCEV expression to scan for loops.
/// @param Loops A vector into which the found loops are inserted.
void findLoops(const llvm::SCEV *Expr,
llvm::SetVector<const llvm::Loop *> &Loops);
-/// @brief Find the values referenced by SCEVUnknowns in a given SCEV
+/// Find the values referenced by SCEVUnknowns in a given SCEV
/// expression.
///
/// @param Expr The SCEV expression to scan for SCEVUnknowns.
@@ -56,7 +56,7 @@ bool isAffineExpr(const llvm::Region *R,
const llvm::SCEV *Expression, llvm::ScalarEvolution &SE,
InvariantLoadsSetTy *ILS = nullptr);
-/// @brief Check if @p V describes an affine constraint in @p R.
+/// Check if @p V describes an affine constraint in @p R.
bool isAffineConstraint(llvm::Value *V, const llvm::Region *R,
llvm::Loop *Scope, llvm::ScalarEvolution &SE,
ParameterSetTy &Params, bool OrExpr = false);
@@ -65,7 +65,7 @@ ParameterSetTy getParamsInAffineExpr(con
const llvm::SCEV *Expression,
llvm::ScalarEvolution &SE);
-/// @brief Extract the constant factors from the multiplication @p M.
+/// Extract the constant factors from the multiplication @p M.
///
/// @param M A potential SCEV multiplication.
/// @param SE The ScalarEvolution analysis to create new SCEVs.
Modified: polly/trunk/include/polly/Support/ScopHelper.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Support/ScopHelper.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Support/ScopHelper.h (original)
+++ polly/trunk/include/polly/Support/ScopHelper.h Fri Sep 2 01:33:33 2016
@@ -37,20 +37,20 @@ class GetElementPtrInst;
namespace polly {
class Scop;
-/// @brief Type to remap values.
+/// Type to remap values.
using ValueMapT = llvm::DenseMap<llvm::AssertingVH<llvm::Value>,
llvm::AssertingVH<llvm::Value>>;
-/// @brief Type for a set of invariant loads.
+/// Type for a set of invariant loads.
using InvariantLoadsSetTy = llvm::SetVector<llvm::AssertingVH<llvm::LoadInst>>;
-/// @brief Set type for parameters.
+/// Set type for parameters.
using ParameterSetTy = llvm::SetVector<const llvm::SCEV *>;
-/// @brief Set of loops (used to remember loops in non-affine subregions).
+/// Set of loops (used to remember loops in non-affine subregions).
using BoxedLoopsSetTy = llvm::SetVector<const llvm::Loop *>;
-/// @brief Utility proxy to wrap the common members of LoadInst and StoreInst.
+/// Utility proxy to wrap the common members of LoadInst and StoreInst.
///
/// This works like the LLVM utility class CallSite, ie. it forwards all calls
/// to either a LoadInst, StoreInst, MemIntrinsic or MemTransferInst.
@@ -281,7 +281,7 @@ private:
} // namespace polly
namespace llvm {
-/// @brief Specialize simplify_type for MemAccInst to enable dyn_cast and cast
+/// Specialize simplify_type for MemAccInst to enable dyn_cast and cast
/// from a MemAccInst object.
template <> struct simplify_type<polly::MemAccInst> {
typedef Instruction *SimpleType;
@@ -293,7 +293,7 @@ template <> struct simplify_type<polly::
namespace polly {
-/// @brief Check if the PHINode has any incoming Invoke edge.
+/// Check if the PHINode has any incoming Invoke edge.
///
/// @param PN The PHINode to check.
///
@@ -302,7 +302,7 @@ namespace polly {
/// otherwise, return false.
bool hasInvokeEdge(const llvm::PHINode *PN);
-/// @brief Simplify the region to have a single unconditional entry edge and a
+/// Simplify the region to have a single unconditional entry edge and a
/// single exit edge.
///
/// Although this function allows DT and RI to be null, regions only work
@@ -316,7 +316,7 @@ bool hasInvokeEdge(const llvm::PHINode *
void simplifyRegion(llvm::Region *R, llvm::DominatorTree *DT,
llvm::LoopInfo *LI, llvm::RegionInfo *RI);
-/// @brief Split the entry block of a function to store the newly inserted
+/// Split the entry block of a function to store the newly inserted
/// allocations outside of all Scops.
///
/// @param EntryBlock The entry block of the current function.
@@ -324,7 +324,7 @@ void simplifyRegion(llvm::Region *R, llv
///
void splitEntryBlockForAlloca(llvm::BasicBlock *EntryBlock, llvm::Pass *P);
-/// @brief Wrapper for SCEVExpander extended to all Polly features.
+/// Wrapper for SCEVExpander extended to all Polly features.
///
/// This wrapper will internally call the SCEVExpander but also makes sure that
/// all additional features not represented in SCEV (e.g., SDiv/SRem are not
@@ -346,7 +346,7 @@ llvm::Value *expandCodeFor(Scop &S, llvm
const llvm::SCEV *E, llvm::Type *Ty,
llvm::Instruction *IP, ValueMapT *VMap = nullptr);
-/// @brief Check if the block is a error block.
+/// Check if the block is a error block.
///
/// A error block is currently any block that fullfills at least one of
/// the following conditions:
@@ -367,7 +367,7 @@ llvm::Value *expandCodeFor(Scop &S, llvm
bool isErrorBlock(llvm::BasicBlock &BB, const llvm::Region &R,
llvm::LoopInfo &LI, const llvm::DominatorTree &DT);
-/// @brief Return the condition for the terminator @p TI.
+/// Return the condition for the terminator @p TI.
///
/// For unconditional branches the "i1 true" condition will be returned.
///
@@ -376,7 +376,7 @@ bool isErrorBlock(llvm::BasicBlock &BB,
/// @return The condition of @p TI and nullptr if none could be extracted.
llvm::Value *getConditionFromTerminator(llvm::TerminatorInst *TI);
-/// @brief Check if @p LInst can be hoisted in @p R.
+/// Check if @p LInst can be hoisted in @p R.
///
/// @param LInst The load to check.
/// @param R The analyzed region.
@@ -387,11 +387,11 @@ llvm::Value *getConditionFromTerminator(
bool isHoistableLoad(llvm::LoadInst *LInst, llvm::Region &R, llvm::LoopInfo &LI,
llvm::ScalarEvolution &SE);
-/// @brief Return true iff @p V is an intrinsic that we ignore during code
+/// Return true iff @p V is an intrinsic that we ignore during code
/// generation.
bool isIgnoredIntrinsic(const llvm::Value *V);
-/// @brief Check whether a value an be synthesized by the code generator.
+/// Check whether a value an be synthesized by the code generator.
///
/// Some value will be recalculated only from information that is code generated
/// from the polyhedral representation. For such instructions we do not need to
@@ -409,7 +409,7 @@ bool canSynthesize(const llvm::Value *V,
const llvm::LoopInfo *LI, llvm::ScalarEvolution *SE,
llvm::Loop *Scope);
-/// @brief Return the block in which a value is used.
+/// Return the block in which a value is used.
///
/// For normal instructions, this is the instruction's parent block. For PHI
/// nodes, this is the incoming block of that use, because this is where the
@@ -418,7 +418,7 @@ bool canSynthesize(const llvm::Value *V,
/// case this function returns nullptr.
llvm::BasicBlock *getUseBlock(llvm::Use &U);
-/// @brief Derive the individual index expressions from a GEP instruction.
+/// Derive the individual index expressions from a GEP instruction.
///
/// This function optimistically assumes the GEP references into a fixed size
/// array. If this is actually true, this function returns a list of array
Modified: polly/trunk/include/polly/Support/ScopLocation.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/Support/ScopLocation.h?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/include/polly/Support/ScopLocation.h (original)
+++ polly/trunk/include/polly/Support/ScopLocation.h Fri Sep 2 01:33:33 2016
@@ -22,7 +22,7 @@ class Region;
namespace polly {
-/// @brief Get the location of a region from the debug info.
+/// Get the location of a region from the debug info.
///
/// @param R The region to get debug info for.
/// @param LineBegin The first line in the region.
Modified: polly/trunk/lib/Analysis/DependenceInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/DependenceInfo.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/DependenceInfo.cpp (original)
+++ polly/trunk/lib/Analysis/DependenceInfo.cpp Fri Sep 2 01:33:33 2016
@@ -87,7 +87,7 @@ static cl::opt<Dependences::AnalyisLevel
//===----------------------------------------------------------------------===//
-/// @brief Tag the @p Relation domain with @p TagId
+/// Tag the @p Relation domain with @p TagId
static __isl_give isl_map *tag(__isl_take isl_map *Relation,
__isl_take isl_id *TagId) {
isl_space *Space = isl_map_get_space(Relation);
@@ -98,7 +98,7 @@ static __isl_give isl_map *tag(__isl_tak
return Relation;
}
-/// @brief Tag the @p Relation domain with either MA->getArrayId() or
+/// Tag the @p Relation domain with either MA->getArrayId() or
/// MA->getId() based on @p TagLevel
static __isl_give isl_map *tag(__isl_take isl_map *Relation, MemoryAccess *MA,
Dependences::AnalyisLevel TagLevel) {
@@ -112,7 +112,7 @@ static __isl_give isl_map *tag(__isl_tak
return Relation;
}
-/// @brief Collect information about the SCoP @p S.
+/// Collect information about the SCoP @p S.
static void collectInfo(Scop &S, isl_union_map **Read, isl_union_map **Write,
isl_union_map **MayWrite,
isl_union_map **AccessSchedule,
@@ -185,7 +185,7 @@ static void collectInfo(Scop &S, isl_uni
*MayWrite = isl_union_map_coalesce(*MayWrite);
}
-/// @brief Fix all dimension of @p Zero to 0 and add it to @p user
+/// Fix all dimension of @p Zero to 0 and add it to @p user
static isl_stat fixSetToZero(__isl_take isl_set *Zero, void *user) {
isl_union_set **User = (isl_union_set **)user;
for (unsigned i = 0; i < isl_set_dim(Zero, isl_dim_set); i++)
@@ -194,7 +194,7 @@ static isl_stat fixSetToZero(__isl_take
return isl_stat_ok;
}
-/// @brief Compute the privatization dependences for a given dependency @p Map
+/// Compute the privatization dependences for a given dependency @p Map
///
/// Privatization dependences are widened original dependences which originate
/// or end in a reduction access. To compute them we apply the transitive close
@@ -780,7 +780,7 @@ bool DependenceInfo::runOnScop(Scop &Sco
return false;
}
-/// @brief Print the dependences for the given SCoP to @p OS.
+/// Print the dependences for the given SCoP to @p OS.
void polly::DependenceInfo::printScop(raw_ostream &OS, Scop &S) const {
if (auto d = D[OptAnalysisLevel].get()) {
Modified: polly/trunk/lib/Analysis/ScopDetection.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopDetection.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/ScopDetection.cpp (original)
+++ polly/trunk/lib/Analysis/ScopDetection.cpp Fri Sep 2 01:33:33 2016
@@ -178,7 +178,7 @@ static cl::opt<bool, true> XPollyInvaria
cl::location(PollyInvariantLoadHoisting), cl::Hidden, cl::ZeroOrMore,
cl::init(false), cl::cat(PollyCategory));
-/// @brief The minimal trip count under which loops are considered unprofitable.
+/// The minimal trip count under which loops are considered unprofitable.
static const unsigned MIN_LOOP_TRIP_COUNT = 8;
bool polly::PollyTrackFailures = false;
@@ -621,7 +621,7 @@ bool ScopDetection::isInvariant(const Va
return true;
}
-/// @brief Remove smax of smax(0, size) expressions from a SCEV expression and
+/// Remove smax of smax(0, size) expressions from a SCEV expression and
/// register the '...' components.
///
/// Array access expressions as they are generated by gfortran contain smax(0,
@@ -1096,7 +1096,7 @@ bool ScopDetection::isValidLoop(Loop *L,
return invalid<ReportLoopBound>(Context, /*Assert=*/true, L, LoopCount);
}
-/// @brief Return the number of loops in @p L (incl. @p L) that have a trip
+/// Return the number of loops in @p L (incl. @p L) that have a trip
/// count that is not known to be less than MIN_LOOP_TRIP_COUNT.
static int countBeneficialSubLoops(Loop *L, ScalarEvolution &SE) {
auto *TripCount = SE.getBackedgeTakenCount(L);
@@ -1435,7 +1435,7 @@ void ScopDetection::emitMissedRemarks(co
}
bool ScopDetection::isReducibleRegion(Region &R, DebugLoc &DbgLoc) const {
- /// @brief Enum for coloring BBs in Region.
+ /// Enum for coloring BBs in Region.
///
/// WHITE - Unvisited BB in DFS walk.
/// GREY - BBs which are currently on the DFS stack for processing.
Modified: polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp (original)
+++ polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp Fri Sep 2 01:33:33 2016
@@ -51,7 +51,7 @@ BADSCOP_STAT(Alias, "Found base address
BADSCOP_STAT(Other, "Others");
namespace polly {
-/// @brief Small string conversion via raw_string_stream.
+/// Small string conversion via raw_string_stream.
template <typename T> std::string operator+(Twine LHS, const T &RHS) {
std::string Buf;
raw_string_ostream fmt(Buf);
@@ -63,7 +63,7 @@ template <typename T> std::string operat
} // namespace polly
namespace llvm {
-// @brief Lexicographic order on (line, col) of our debug locations.
+// Lexicographic order on (line, col) of our debug locations.
static bool operator<(const llvm::DebugLoc &LHS, const llvm::DebugLoc &RHS) {
return LHS.getLine() < RHS.getLine() ||
(LHS.getLine() == RHS.getLine() && LHS.getCol() < RHS.getCol());
Modified: polly/trunk/lib/Analysis/ScopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopInfo.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/ScopInfo.cpp (original)
+++ polly/trunk/lib/Analysis/ScopInfo.cpp Fri Sep 2 01:33:33 2016
@@ -461,7 +461,7 @@ MemoryAccess::getReductionOperatorStr(Me
return "";
}
-/// @brief Return the reduction type for a given binary operator
+/// Return the reduction type for a given binary operator.
static MemoryAccess::ReductionType getReductionType(const BinaryOperator *BinOp,
const Instruction *Load) {
if (!BinOp)
@@ -747,7 +747,7 @@ __isl_give isl_map *MemoryAccess::foldAc
return AccessRelation;
}
-/// @brief Check if @p Expr is divisible by @p Size.
+/// Check if @p Expr is divisible by @p Size.
static bool isDivisible(const SCEV *Expr, unsigned Size, ScalarEvolution &SE) {
assert(Size != 0);
if (Size == 1)
@@ -1114,7 +1114,7 @@ void ScopStmt::realignParams() {
Domain = isl_set_gist_params(Domain, Ctx);
}
-/// @brief Add @p BSet to the set @p User if @p BSet is bounded.
+/// Add @p BSet to the set @p User if @p BSet is bounded.
static isl_stat collectBoundedParts(__isl_take isl_basic_set *BSet,
void *User) {
isl_set **BoundedParts = static_cast<isl_set **>(User);
@@ -1125,7 +1125,7 @@ static isl_stat collectBoundedParts(__is
return isl_stat_ok;
}
-/// @brief Return the bounded parts of @p S.
+/// Return the bounded parts of @p S.
static __isl_give isl_set *collectBoundedParts(__isl_take isl_set *S) {
isl_set *BoundedParts = isl_set_empty(isl_set_get_space(S));
isl_set_foreach_basic_set(S, collectBoundedParts, &BoundedParts);
@@ -1133,7 +1133,7 @@ static __isl_give isl_set *collectBounde
return BoundedParts;
}
-/// @brief Compute the (un)bounded parts of @p S wrt. to dimension @p Dim.
+/// Compute the (un)bounded parts of @p S wrt. to dimension @p Dim.
///
/// @returns A separation of @p S into first an unbounded then a bounded subset,
/// both with regards to the dimension @p Dim.
@@ -1176,7 +1176,7 @@ partitionSetParts(__isl_take isl_set *S,
return std::make_pair(UnboundedParts, BoundedParts);
}
-/// @brief Set the dimension Ids from @p From in @p To.
+/// Set the dimension Ids from @p From in @p To.
static __isl_give isl_set *setDimensionIds(__isl_keep isl_set *From,
__isl_take isl_set *To) {
for (unsigned u = 0, e = isl_set_n_dim(From); u < e; u++) {
@@ -1186,7 +1186,7 @@ static __isl_give isl_set *setDimensionI
return To;
}
-/// @brief Create the conditions under which @p L @p Pred @p R is true.
+/// Create the conditions under which @p L @p Pred @p R is true.
static __isl_give isl_set *buildConditionSet(ICmpInst::Predicate Pred,
__isl_take isl_pw_aff *L,
__isl_take isl_pw_aff *R) {
@@ -1216,7 +1216,7 @@ static __isl_give isl_set *buildConditio
}
}
-/// @brief Create the conditions under which @p L @p Pred @p R is true.
+/// Create the conditions under which @p L @p Pred @p R is true.
///
/// Helper function that will make sure the dimensions of the result have the
/// same isl_id's as the @p Domain.
@@ -1228,7 +1228,7 @@ static __isl_give isl_set *buildConditio
return setDimensionIds(Domain, ConsequenceCondSet);
}
-/// @brief Build the conditions sets for the switch @p SI in the @p Domain.
+/// Build the conditions sets for the switch @p SI in the @p Domain.
///
/// This will fill @p ConditionSets with the conditions under which control
/// will be moved from @p SI to its successors. Hence, @p ConditionSets will
@@ -1272,8 +1272,8 @@ buildConditionSets(ScopStmt &Stmt, Switc
return true;
}
-/// @brief Build the conditions sets for the branch condition @p Condition in
-/// the @p Domain.
+/// Build the conditions sets for the branch condition @p Condition in
+/// the @p Domain.
///
/// This will fill @p ConditionSets with the conditions under which control
/// will be moved from @p TI to its successors. Hence, @p ConditionSets will
@@ -1364,7 +1364,7 @@ buildConditionSets(ScopStmt &Stmt, Value
return true;
}
-/// @brief Build the conditions sets for the terminator @p TI in the @p Domain.
+/// Build the conditions sets for the terminator @p TI in the @p Domain.
///
/// This will fill @p ConditionSets with the conditions under which control
/// will be moved from @p TI to its successors. Hence, @p ConditionSets will
@@ -1505,7 +1505,7 @@ void ScopStmt::init(LoopInfo &LI) {
checkForReductions();
}
-/// @brief Collect loads which might form a reduction chain with @p StoreMA
+/// Collect loads which might form a reduction chain with @p StoreMA.
///
/// Check if the stored value for @p StoreMA is a binary operator with one or
/// two loads as operands. If the binary operand is commutative & associative,
@@ -1559,7 +1559,7 @@ void ScopStmt::collectCandiateReductionL
Loads.push_back(&getArrayAccessFor(PossibleLoad1));
}
-/// @brief Check for reductions in this ScopStmt
+/// Check for reductions in this ScopStmt.
///
/// Iterate over all store memory accesses and check for valid binary reduction
/// like chains. For all candidates we check if they have the same base address
@@ -1725,7 +1725,7 @@ void Scop::setContext(__isl_take isl_set
Context = NewContext;
}
-/// @brief Remap parameter values but keep AddRecs valid wrt. invariant loads.
+/// Remap parameter values but keep AddRecs valid wrt. invariant loads.
struct SCEVSensitiveParameterRewriter
: public SCEVVisitor<SCEVSensitiveParameterRewriter, const SCEV *> {
ValueToValueMap &VMap;
@@ -2099,7 +2099,7 @@ void Scop::simplifyContexts() {
InvalidContext = isl_set_align_params(InvalidContext, getParamSpace());
}
-/// @brief Add the minimal/maximal access in @p Set to @p User.
+/// Add the minimal/maximal access in @p Set to @p User.
static isl_stat buildMinMaxAccess(__isl_take isl_set *Set, void *User) {
Scop::MinMaxVectorTy *MinMaxAccesses = (Scop::MinMaxVectorTy *)User;
isl_pw_multi_aff *MinPMA, *MaxPMA;
@@ -2172,7 +2172,7 @@ static __isl_give isl_set *getAccessDoma
return isl_set_reset_tuple_id(Domain);
}
-/// @brief Wrapper function to calculate minimal/maximal accesses to each array.
+/// Wrapper function to calculate minimal/maximal accesses to each array.
static bool calculateMinMaxAccess(__isl_take isl_union_map *Accesses,
__isl_take isl_union_set *Domains,
Scop::MinMaxVectorTy &MinMaxAccesses) {
@@ -2187,17 +2187,17 @@ static bool calculateMinMaxAccess(__isl_
return Valid;
}
-/// @brief Helper to treat non-affine regions and basic blocks the same.
+/// Helper to treat non-affine regions and basic blocks the same.
///
///{
-/// @brief Return the block that is the representing block for @p RN.
+/// Return the block that is the representing block for @p RN.
static inline BasicBlock *getRegionNodeBasicBlock(RegionNode *RN) {
return RN->isSubRegion() ? RN->getNodeAs<Region>()->getEntry()
: RN->getNodeAs<BasicBlock>();
}
-/// @brief Return the @p idx'th block that is executed after @p RN.
+/// Return the @p idx'th block that is executed after @p RN.
static inline BasicBlock *
getRegionNodeSuccessor(RegionNode *RN, TerminatorInst *TI, unsigned idx) {
if (RN->isSubRegion()) {
@@ -2207,7 +2207,7 @@ getRegionNodeSuccessor(RegionNode *RN, T
return TI->getSuccessor(idx);
}
-/// @brief Return the smallest loop surrounding @p RN.
+/// Return the smallest loop surrounding @p RN.
static inline Loop *getRegionNodeLoop(RegionNode *RN, LoopInfo &LI) {
if (!RN->isSubRegion())
return LI.getLoopFor(RN->getNodeAs<BasicBlock>());
@@ -2321,7 +2321,7 @@ static Loop *getFirstNonBoxedLoopFor(Bas
return L;
}
-/// @brief Adjust the dimensions of @p Dom that was constructed for @p OldL
+/// Adjust the dimensions of @p Dom that was constructed for @p OldL
/// to be compatible to domains constructed for loop @p NewL.
///
/// This function assumes @p NewL and @p OldL are equal or there is a CFG
@@ -2735,10 +2735,13 @@ bool Scop::propagateDomainConstraints(Re
return true;
}
-/// @brief Create a map from SetSpace -> SetSpace where the dimensions @p Dim
-/// is incremented by one and all other dimensions are equal, e.g.,
+/// Create a map to map from a given iteration to a subsequent iteration.
+///
+/// This map maps from SetSpace -> SetSpace where the dimensions @p Dim
+/// is incremented by one and all other dimensions are equal, e.g.,
/// [i0, i1, i2, i3] -> [i0, i1, i2 + 1, i3]
-/// if @p Dim is 2 and @p SetSpace has 4 dimensions.
+///
+/// if @p Dim is 2 and @p SetSpace has 4 dimensions.
static __isl_give isl_map *
createNextIterationMap(__isl_take isl_space *SetSpace, unsigned Dim) {
auto *MapSpace = isl_space_map_from_set(SetSpace);
@@ -3076,7 +3079,7 @@ bool Scop::buildAliasGroups(AliasAnalysi
return true;
}
-/// @brief Get the smallest loop that contains @p S but is not in @p S.
+/// Get the smallest loop that contains @p S but is not in @p S.
static Loop *getLoopSurroundingScop(Scop &S, LoopInfo &LI) {
// Start with the smallest loop containing the entry and expand that
// loop until it contains all blocks in the region. If there is a loop
@@ -3285,7 +3288,7 @@ InvariantEquivClassTy *Scop::lookupInvar
return nullptr;
}
-/// @brief Check if @p MA can always be hoisted without execution context.
+/// Check if @p MA can always be hoisted without execution context.
static bool canAlwaysBeHoisted(MemoryAccess *MA, bool StmtInvalidCtxIsEmpty,
bool MAInvalidCtxIsEmpty,
bool NonHoistableCtxIsEmpty) {
@@ -4038,8 +4041,8 @@ struct MapToDimensionDataTy {
isl_union_pw_multi_aff *Res;
};
-// @brief Create a function that maps the elements of 'Set' to its N-th
-// dimension and add it to User->Res.
+// Create a function that maps the elements of 'Set' to its N-th dimension and
+// add it to User->Res.
//
// @param Set The input set.
// @param User->N The dimension to map to.
@@ -4065,8 +4068,8 @@ static isl_stat mapToDimension_AddSet(__
return isl_stat_ok;
}
-// @brief Create an isl_multi_union_aff that defines an identity mapping
-// from the elements of USet to their N-th dimension.
+// Create an isl_multi_union_aff that defines an identity mapping from the
+// elements of USet to their N-th dimension.
//
// # Example:
//
Modified: polly/trunk/lib/CodeGen/CodeGeneration.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/CodeGeneration.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/CodeGeneration.cpp (original)
+++ polly/trunk/lib/CodeGen/CodeGeneration.cpp Fri Sep 2 01:33:33 2016
@@ -53,7 +53,7 @@ public:
CodeGeneration() : ScopPass(ID) {}
- /// @brief The datalayout used
+ /// The datalayout used
const DataLayout *DL;
/// @name The analysis passes we need to generate code.
@@ -96,7 +96,7 @@ public:
}
}
- /// @brief Mark a basic block unreachable.
+ /// Mark a basic block unreachable.
///
/// Marks the basic block @p Block unreachable by equipping it with an
/// UnreachableInst.
@@ -107,7 +107,7 @@ public:
OrigTerminator->eraseFromParent();
}
- /// @brief Generate LLVM-IR for the SCoP @p S.
+ /// Generate LLVM-IR for the SCoP @p S.
bool runOnScop(Scop &S) override {
AI = &getAnalysis<IslAstInfo>();
@@ -198,7 +198,7 @@ public:
return true;
}
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<DominatorTreeWrapperPass>();
AU.addRequired<IslAstInfo>();
Modified: polly/trunk/lib/CodeGen/IRBuilder.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/IRBuilder.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/IRBuilder.cpp (original)
+++ polly/trunk/lib/CodeGen/IRBuilder.cpp Fri Sep 2 01:33:33 2016
@@ -21,7 +21,7 @@
using namespace llvm;
using namespace polly;
-/// @brief Get a self referencing id metadata node.
+/// Get a self referencing id metadata node.
///
/// The MDNode looks like this (if arg0/arg1 are not null):
///
Modified: polly/trunk/lib/CodeGen/IslAst.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/IslAst.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/IslAst.cpp (original)
+++ polly/trunk/lib/CodeGen/IslAst.cpp Fri Sep 2 01:33:33 2016
@@ -72,24 +72,24 @@ static cl::opt<bool> DetectParallel("pol
cl::cat(PollyCategory));
namespace polly {
-/// @brief Temporary information used when building the ast.
+/// Temporary information used when building the ast.
struct AstBuildUserInfo {
- /// @brief Construct and initialize the helper struct for AST creation.
+ /// Construct and initialize the helper struct for AST creation.
AstBuildUserInfo()
: Deps(nullptr), InParallelFor(false), LastForNodeId(nullptr) {}
- /// @brief The dependence information used for the parallelism check.
+ /// The dependence information used for the parallelism check.
const Dependences *Deps;
- /// @brief Flag to indicate that we are inside a parallel for node.
+ /// Flag to indicate that we are inside a parallel for node.
bool InParallelFor;
- /// @brief The last iterator id created for the current SCoP.
+ /// The last iterator id created for the current SCoP.
isl_id *LastForNodeId;
};
} // namespace polly
-/// @brief Free an IslAstUserPayload object pointed to by @p Ptr
+/// Free an IslAstUserPayload object pointed to by @p Ptr.
static void freeIslAstUserPayload(void *Ptr) {
delete ((IslAstInfo::IslAstUserPayload *)Ptr);
}
@@ -99,7 +99,7 @@ IslAstInfo::IslAstUserPayload::~IslAstUs
isl_pw_aff_free(MinimalDependenceDistance);
}
-/// @brief Print a string @p str in a single line using @p Printer.
+/// Print a string @p str in a single line using @p Printer.
static isl_printer *printLine(__isl_take isl_printer *Printer,
const std::string &str,
__isl_keep isl_pw_aff *PWA = nullptr) {
@@ -110,7 +110,7 @@ static isl_printer *printLine(__isl_take
return isl_printer_end_line(Printer);
}
-/// @brief Return all broken reductions as a string of clauses (OpenMP style).
+/// Return all broken reductions as a string of clauses (OpenMP style).
static const std::string getBrokenReductionsStr(__isl_keep isl_ast_node *Node) {
IslAstInfo::MemoryAccessSet *BrokenReductions;
std::string str;
@@ -138,7 +138,7 @@ static const std::string getBrokenReduct
return str;
}
-/// @brief Callback executed for each for node in the ast in order to print it.
+/// Callback executed for each for node in the ast in order to print it.
static isl_printer *cbPrintFor(__isl_take isl_printer *Printer,
__isl_take isl_ast_print_options *Options,
__isl_keep isl_ast_node *Node, void *) {
@@ -165,7 +165,7 @@ static isl_printer *cbPrintFor(__isl_tak
return isl_ast_node_for_print(Node, Printer, Options);
}
-/// @brief Check if the current scheduling dimension is parallel
+/// Check if the current scheduling dimension is parallel.
///
/// In case the dimension is parallel we also check if any reduction
/// dependences is broken when we exploit this parallelism. If so,
@@ -371,7 +371,7 @@ IslAst::buildRunCondition(Scop *S, __isl
return RunCondition;
}
-/// @brief Simple cost analysis for a given SCoP
+/// Simple cost analysis for a given SCoP.
///
/// TODO: Improve this analysis and extract it to make it usable in other
/// places too.
Modified: polly/trunk/lib/CodeGen/IslExprBuilder.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/IslExprBuilder.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/IslExprBuilder.cpp (original)
+++ polly/trunk/lib/CodeGen/IslExprBuilder.cpp Fri Sep 2 01:33:33 2016
@@ -20,7 +20,7 @@
using namespace llvm;
using namespace polly;
-/// @brief Different overflow tracking modes.
+/// Different overflow tracking modes.
enum OverflowTrackingChoice {
OT_NEVER, ///< Never tack potential overflows.
OT_REQUEST, ///< Track potential overflows if requested.
Modified: polly/trunk/lib/CodeGen/IslNodeBuilder.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/IslNodeBuilder.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/IslNodeBuilder.cpp (original)
+++ polly/trunk/lib/CodeGen/IslNodeBuilder.cpp Fri Sep 2 01:33:33 2016
@@ -106,8 +106,8 @@ IslNodeBuilder::getUpperBound(__isl_keep
return UB;
}
-/// @brief Return true if a return value of Predicate is true for the value
-/// represented by passed isl_ast_expr_int.
+/// Return true if a return value of Predicate is true for the value represented
+/// by passed isl_ast_expr_int.
static bool checkIslAstExprInt(__isl_take isl_ast_expr *Expr,
isl_bool (*Predicate)(__isl_keep isl_val *)) {
if (isl_ast_expr_get_type(Expr) != isl_ast_expr_int) {
@@ -128,7 +128,7 @@ int IslNodeBuilder::getNumberOfIteration
assert(isl_ast_node_get_type(For) == isl_ast_node_for);
auto Body = isl_ast_node_for_get_body(For);
- // First, check if we can actually handle this code
+ // First, check if we can actually handle this code.
switch (isl_ast_node_get_type(Body)) {
case isl_ast_node_user:
break;
@@ -177,7 +177,7 @@ int IslNodeBuilder::getNumberOfIteration
return NumberIterations + 1;
}
-/// @brief Extract the values and SCEVs needed to generate code for a block.
+/// Extract the values and SCEVs needed to generate code for a block.
static int findReferencesInBlock(struct SubtreeReferences &References,
const ScopStmt *Stmt, const BasicBlock *BB) {
for (const Instruction &Inst : *BB)
@@ -487,7 +487,7 @@ void IslNodeBuilder::createForSequential
isl_id_free(IteratorID);
}
-/// @brief Remove the BBs contained in a (sub)function from the dominator tree.
+/// Remove the BBs contained in a (sub)function from the dominator tree.
///
/// This function removes the basic blocks that are part of a subfunction from
/// the dominator tree. Specifically, when generating code it may happen that at
@@ -904,7 +904,7 @@ bool IslNodeBuilder::materializeParamete
return true;
}
-/// @brief Add the number of dimensions in @p BS to @p U.
+/// Add the number of dimensions in @p BS to @p U.
static isl_stat countTotalDims(isl_basic_set *BS, void *U) {
unsigned *NumTotalDim = static_cast<unsigned *>(U);
*NumTotalDim += isl_basic_set_total_dim(BS);
Modified: polly/trunk/lib/Exchange/JSONExporter.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Exchange/JSONExporter.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Exchange/JSONExporter.cpp (original)
+++ polly/trunk/lib/Exchange/JSONExporter.cpp Fri Sep 2 01:33:33 2016
@@ -62,13 +62,13 @@ struct JSONExporter : public ScopPass {
std::string getFileName(Scop &S) const;
Json::Value getJSON(Scop &S) const;
- /// @brief Export the SCoP @p S to a JSON file.
+ /// Export the SCoP @p S to a JSON file.
bool runOnScop(Scop &S) override;
- /// @brief Print the SCoP @p S as it is exported.
+ /// Print the SCoP @p S as it is exported.
void printScop(raw_ostream &OS, Scop &S) const override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
@@ -116,13 +116,13 @@ struct JSONImporter : public ScopPass {
std::string getFileName(Scop &S) const;
- /// @brief Import new access functions for SCoP @p S from a JSON file.
+ /// Import new access functions for SCoP @p S from a JSON file.
bool runOnScop(Scop &S) override;
- /// @brief Print the SCoP @p S and the imported access functions.
+ /// Print the SCoP @p S and the imported access functions.
void printScop(raw_ostream &OS, Scop &S) const override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
};
} // namespace
@@ -469,7 +469,7 @@ bool JSONImporter::importAccesses(Scop &
return true;
}
-/// @brief Check whether @p SAI and @p Array represent the same array.
+/// Check whether @p SAI and @p Array represent the same array.
bool areArraysEqual(ScopArrayInfo *SAI, Json::Value Array) {
std::string Buffer;
llvm::raw_string_ostream RawStringOstream(Buffer);
@@ -494,7 +494,7 @@ bool areArraysEqual(ScopArrayInfo *SAI,
return true;
}
-/// @brief Get the accepted primitive type from its textual representation
+/// Get the accepted primitive type from its textual representation
/// @p TypeTextRepresentation.
///
/// @param TypeTextRepresentation The textual representation of the type.
Modified: polly/trunk/lib/Polly.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Polly.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Polly.cpp (original)
+++ polly/trunk/lib/Polly.cpp Fri Sep 2 01:33:33 2016
@@ -14,7 +14,7 @@
namespace {
-/// @brief Initialize Polly passes when library is loaded.
+/// Initialize Polly passes when library is loaded.
///
/// We use the constructor of a statically declared object to initialize the
/// different Polly passes right after the Polly library is loaded. This ensures
Modified: polly/trunk/lib/Support/RegisterPasses.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Support/RegisterPasses.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Support/RegisterPasses.cpp (original)
+++ polly/trunk/lib/Support/RegisterPasses.cpp Fri Sep 2 01:33:33 2016
@@ -181,7 +181,7 @@ void initializePollyPasses(PassRegistry
initializeCodegenCleanupPass(Registry);
}
-/// @brief Register Polly passes such that they form a polyhedral optimizer.
+/// Register Polly passes such that they form a polyhedral optimizer.
///
/// The individual Polly passes are registered in the pass manager such that
/// they form a full polyhedral optimizer. The flow of the optimizer starts with
@@ -328,7 +328,7 @@ registerPollyScalarOptimizerLatePasses(c
PM.add(createCodegenCleanupPass());
}
-/// @brief Register Polly to be available as an optimizer
+/// Register Polly to be available as an optimizer
///
///
/// We can currently run Polly at three different points int the pass manager.
Modified: polly/trunk/lib/Support/SCEVAffinator.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Support/SCEVAffinator.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Support/SCEVAffinator.cpp (original)
+++ polly/trunk/lib/Support/SCEVAffinator.cpp Fri Sep 2 01:33:33 2016
@@ -42,17 +42,17 @@ static unsigned const MaxZextSmallBitWid
// The maximal number of bits for which a truncate is modeled precisely.
static unsigned const MaxTruncateSmallBitWidth = 31;
-/// @brief Return true if a zero-extend from @p Width bits is precisely modeled.
+/// Return true if a zero-extend from @p Width bits is precisely modeled.
static bool isPreciseZeroExtend(unsigned Width) {
return Width <= MaxZextSmallBitWidth;
}
-/// @brief Return true if a truncate from @p Width bits is precisely modeled.
+/// Return true if a truncate from @p Width bits is precisely modeled.
static bool isPreciseTruncate(unsigned Width) {
return Width <= MaxTruncateSmallBitWidth;
}
-/// @brief Add the number of basic sets in @p Domain to @p User
+/// Add the number of basic sets in @p Domain to @p User
static isl_stat addNumBasicSets(isl_set *Domain, isl_aff *Aff, void *User) {
auto *NumBasicSets = static_cast<unsigned *>(User);
*NumBasicSets += isl_set_n_basic_set(Domain);
@@ -61,18 +61,18 @@ static isl_stat addNumBasicSets(isl_set
return isl_stat_ok;
}
-/// @brief Helper to free a PWACtx object.
+/// Helper to free a PWACtx object.
static void freePWACtx(__isl_take PWACtx &PWAC) {
isl_pw_aff_free(PWAC.first);
isl_set_free(PWAC.second);
}
-/// @brief Helper to copy a PWACtx object.
+/// Helper to copy a PWACtx object.
static __isl_give PWACtx copyPWACtx(const __isl_keep PWACtx &PWAC) {
return std::make_pair(isl_pw_aff_copy(PWAC.first), isl_set_copy(PWAC.second));
}
-/// @brief Determine if @p PWAC is too complex to continue.
+/// Determine if @p PWAC is too complex to continue.
///
/// Note that @p PWAC will be "free" (deallocated) if this function returns
/// true, but not if this function returns false.
@@ -85,7 +85,7 @@ static bool isTooComplex(PWACtx &PWAC) {
return true;
}
-/// @brief Return the flag describing the possible wrapping of @p Expr.
+/// Return the flag describing the possible wrapping of @p Expr.
static SCEV::NoWrapFlags getNoWrapFlags(const SCEV *Expr) {
if (auto *NAry = dyn_cast<SCEVNAryExpr>(Expr))
return NAry->getNoWrapFlags();
@@ -98,7 +98,7 @@ static void combine(__isl_keep PWACtx &P
PWAC0.second = isl_set_union(PWAC0.second, PWAC1.second);
}
-/// @brief Set the possible wrapping of @p Expr to @p Flags.
+/// Set the possible wrapping of @p Expr to @p Flags.
static const SCEV *setNoWrapFlags(ScalarEvolution &SE, const SCEV *Expr,
SCEV::NoWrapFlags Flags) {
auto *NAry = dyn_cast<SCEVNAryExpr>(Expr);
Modified: polly/trunk/lib/Support/SCEVValidator.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Support/SCEVValidator.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Support/SCEVValidator.cpp (original)
+++ polly/trunk/lib/Support/SCEVValidator.cpp Fri Sep 2 01:33:33 2016
@@ -12,7 +12,7 @@ using namespace polly;
#define DEBUG_TYPE "polly-scev-validator"
namespace SCEVType {
-/// @brief The type of a SCEV
+/// The type of a SCEV
///
/// To check for the validity of a SCEV we assign to each SCEV a type. The
/// possible types are INT, PARAM, IV and INVALID. The order of the types is
@@ -34,58 +34,58 @@ enum TYPE {
};
} // namespace SCEVType
-/// @brief The result the validator returns for a SCEV expression.
+/// The result the validator returns for a SCEV expression.
class ValidatorResult {
- /// @brief The type of the expression
+ /// The type of the expression
SCEVType::TYPE Type;
- /// @brief The set of Parameters in the expression.
+ /// The set of Parameters in the expression.
ParameterSetTy Parameters;
public:
- /// @brief The copy constructor
+ /// The copy constructor
ValidatorResult(const ValidatorResult &Source) {
Type = Source.Type;
Parameters = Source.Parameters;
}
- /// @brief Construct a result with a certain type and no parameters.
+ /// Construct a result with a certain type and no parameters.
ValidatorResult(SCEVType::TYPE Type) : Type(Type) {
assert(Type != SCEVType::PARAM && "Did you forget to pass the parameter");
}
- /// @brief Construct a result with a certain type and a single parameter.
+ /// Construct a result with a certain type and a single parameter.
ValidatorResult(SCEVType::TYPE Type, const SCEV *Expr) : Type(Type) {
Parameters.insert(Expr);
}
- /// @brief Get the type of the ValidatorResult.
+ /// Get the type of the ValidatorResult.
SCEVType::TYPE getType() { return Type; }
- /// @brief Is the analyzed SCEV constant during the execution of the SCoP.
+ /// Is the analyzed SCEV constant during the execution of the SCoP.
bool isConstant() { return Type == SCEVType::INT || Type == SCEVType::PARAM; }
- /// @brief Is the analyzed SCEV valid.
+ /// Is the analyzed SCEV valid.
bool isValid() { return Type != SCEVType::INVALID; }
- /// @brief Is the analyzed SCEV of Type IV.
+ /// Is the analyzed SCEV of Type IV.
bool isIV() { return Type == SCEVType::IV; }
- /// @brief Is the analyzed SCEV of Type INT.
+ /// Is the analyzed SCEV of Type INT.
bool isINT() { return Type == SCEVType::INT; }
- /// @brief Is the analyzed SCEV of Type PARAM.
+ /// Is the analyzed SCEV of Type PARAM.
bool isPARAM() { return Type == SCEVType::PARAM; }
- /// @brief Get the parameters of this validator result.
+ /// Get the parameters of this validator result.
const ParameterSetTy &getParameters() { return Parameters; }
- /// @brief Add the parameters of Source to this result.
+ /// Add the parameters of Source to this result.
void addParamsFrom(const ValidatorResult &Source) {
Parameters.insert(Source.Parameters.begin(), Source.Parameters.end());
}
- /// @brief Merge a result.
+ /// Merge a result.
///
/// This means to merge the parameters and to set the Type to the most
/// specific Type that matches both.
@@ -387,7 +387,7 @@ public:
}
};
-/// @brief Check whether a SCEV refers to an SSA name defined inside a region.
+/// Check whether a SCEV refers to an SSA name defined inside a region.
class SCEVInRegionDependences {
const Region *R;
Loop *Scope;
Modified: polly/trunk/lib/Transform/CodePreparation.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/CodePreparation.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Transform/CodePreparation.cpp (original)
+++ polly/trunk/lib/Transform/CodePreparation.cpp Fri Sep 2 01:33:33 2016
@@ -30,7 +30,7 @@ using namespace polly;
namespace {
-/// @brief Prepare the IR for the scop detection.
+/// Prepare the IR for the scop detection.
///
class CodePreparation : public FunctionPass {
CodePreparation(const CodePreparation &) = delete;
Modified: polly/trunk/lib/Transform/DeadCodeElimination.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/DeadCodeElimination.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Transform/DeadCodeElimination.cpp (original)
+++ polly/trunk/lib/Transform/DeadCodeElimination.cpp Fri Sep 2 01:33:33 2016
@@ -59,14 +59,14 @@ public:
static char ID;
explicit DeadCodeElim() : ScopPass(ID) {}
- /// @brief Remove dead iterations from the schedule of @p S.
+ /// Remove dead iterations from the schedule of @p S.
bool runOnScop(Scop &S) override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
private:
- /// @brief Return the set of live iterations.
+ /// Return the set of live iterations.
///
/// The set of live iterations are all iterations that write to memory and for
/// which we can not prove that there will be a later write that _must_
Modified: polly/trunk/lib/Transform/ScheduleOptimizer.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Transform/ScheduleOptimizer.cpp?rev=280468&r1=280467&r2=280468&view=diff
==============================================================================
--- polly/trunk/lib/Transform/ScheduleOptimizer.cpp (original)
+++ polly/trunk/lib/Transform/ScheduleOptimizer.cpp Fri Sep 2 01:33:33 2016
@@ -204,8 +204,8 @@ static cl::opt<bool> OptimizedScops(
"transformations is applied on the schedule tree"),
cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
-/// @brief Create an isl_union_set, which describes the isolate option based
-/// on IsoalteDomain.
+/// Create an isl_union_set, which describes the isolate option based on
+/// IsoalteDomain.
///
/// @param IsolateDomain An isl_set whose last dimension is the only one that
/// should belong to the current band node.
@@ -220,8 +220,8 @@ getIsolateOptions(__isl_take isl_set *Is
return isl_union_set_from_set(isl_set_set_tuple_id(IsolateOption, Id));
}
-/// @brief Create an isl_union_set, which describes the atomic option for the
-/// dimension of the current node.
+/// Create an isl_union_set, which describes the atomic option for the dimension
+/// of the current node.
///
/// It may help to reduce the size of generated code.
///
@@ -233,8 +233,7 @@ static __isl_give isl_union_set *getAtom
return isl_union_set_from_set(isl_set_set_tuple_id(AtomicOption, Id));
}
-/// @brief Make the last dimension of Set to take values
-/// from 0 to VectorWidth - 1.
+/// Make the last dimension of Set to take values from 0 to VectorWidth - 1.
///
/// @param Set A set, which should be modified.
/// @param VectorWidth A parameter, which determines the constraint.
@@ -256,7 +255,7 @@ static __isl_give isl_set *addExtentCons
return isl_set_add_constraint(Set, ExtConstr);
}
-/// @brief Build the desired set of partial tile prefixes.
+/// Build the desired set of partial tile prefixes.
///
/// We build a set of partial tile prefixes, which are prefixes of the vector
/// loop that have exactly VectorWidth iterations.
@@ -438,8 +437,8 @@ ScheduleTreeOptimizer::standardBandOpts(
return Node;
}
-/// @brief Check whether output dimensions of the map rely on the specified
-/// input dimension.
+/// Check whether output dimensions of the map rely on the specified input
+/// dimension.
///
/// @param IslMap The isl map to be considered.
/// @param DimNum The number of an input dimension to be checked.
@@ -460,8 +459,8 @@ static bool isInputDimUsed(__isl_take is
return res;
}
-/// @brief Check if the SCoP statement could probably be optimized with
-/// analytical modeling.
+/// Check if the SCoP statement could probably be optimized with analytical
+/// modeling.
///
/// containsMatrMult tries to determine whether the following conditions
/// are true:
@@ -498,7 +497,7 @@ static bool containsMatrMult(__isl_keep
return !isInputDimUsed((*MemA)->getAccessRelation(), DimNum - 1);
}
-/// @brief Circular shift of output dimensions of the integer map.
+/// Circular shift of output dimensions of the integer map.
///
/// @param IslMap The isl map to be modified.
static __isl_give isl_map *circularShiftOutputDims(__isl_take isl_map *IslMap) {
@@ -511,7 +510,7 @@ static __isl_give isl_map *circularShift
return isl_map_set_tuple_id(IslMap, isl_dim_in, InputDimsId);
}
-/// @brief Permute two dimensions of the band node.
+/// Permute two dimensions of the band node.
///
/// Permute FirstDim and SecondDim dimensions of the Node.
///
@@ -625,8 +624,7 @@ getMacroKernelParams(const MicroKernelPa
return {Mc, Nc, Kc};
}
-/// @brief Identify a memory access through the shape of its memory access
-/// relation.
+/// Identify a memory access through the shape of its memory access relation.
///
/// Identify the unique memory access in @p Stmt, that has an access relation
/// equal to @p ExpectedAccessRelation.
@@ -662,7 +660,7 @@ identifyAccessByAccessRelation(ScopStmt
return IdentifiedAccess;
}
-/// @brief Create an access relation that is specific to the matrix
+/// Create an access relation that is specific to the matrix
/// multiplication pattern.
///
/// Create an access relation of the following form:
@@ -685,8 +683,8 @@ getMatMulPatternOriginalAccessRelation(S
return AccessRel;
}
-/// @brief Identify the memory access that corresponds to the access
-/// to the second operand of the matrix multiplication.
+/// Identify the memory access that corresponds to the access to the second
+/// operand of the matrix multiplication.
///
/// Identify the memory access that corresponds to the access
/// to the matrix B of the matrix multiplication C = A x B.
@@ -700,8 +698,8 @@ MemoryAccess *identifyAccessA(ScopStmt *
return identifyAccessByAccessRelation(Stmt, OriginalRel);
}
-/// @brief Identify the memory access that corresponds to the access
-/// to the first operand of the matrix multiplication.
+/// Identify the memory access that corresponds to the access to the first
+/// operand of the matrix multiplication.
///
/// Identify the memory access that corresponds to the access
/// to the matrix A of the matrix multiplication C = A x B.
@@ -715,7 +713,7 @@ MemoryAccess *identifyAccessB(ScopStmt *
return identifyAccessByAccessRelation(Stmt, OriginalRel);
}
-/// @brief Create an access relation that is specific to
+/// Create an access relation that is specific to
/// the matrix multiplication pattern.
///
/// Create an access relation of the following form:
@@ -761,7 +759,7 @@ __isl_give isl_map *getMatMulAccRel(__is
return isl_map_apply_range(MapOldIndVar, AccessRel);
}
-/// @brief Apply the packing transformation.
+/// Apply the packing transformation.
///
/// The packing transformation can be described as a data-layout
/// transformation that requires to introduce a new array, copy data
@@ -804,8 +802,8 @@ static void optimizeDataLayoutMatrMulPat
MemAccessB->setNewAccessRelation(AccRel);
}
-/// @brief Get a relation mapping induction variables produced by schedule
-/// transformations to the original ones.
+/// Get a relation mapping induction variables produced by schedule
+/// transformations to the original ones.
///
/// @param Node The schedule node produced as the result of creation
/// of the BLIS kernels.
@@ -928,16 +926,16 @@ public:
~IslScheduleOptimizer() { isl_schedule_free(LastSchedule); }
- /// @brief Optimize the schedule of the SCoP @p S.
+ /// Optimize the schedule of the SCoP @p S.
bool runOnScop(Scop &S) override;
- /// @brief Print the new schedule for the SCoP @p S.
+ /// Print the new schedule for the SCoP @p S.
void printScop(raw_ostream &OS, Scop &S) const override;
- /// @brief Register all analyses and transformation required.
+ /// Register all analyses and transformation required.
void getAnalysisUsage(AnalysisUsage &AU) const override;
- /// @brief Release the internal memory.
+ /// Release the internal memory.
void releaseMemory() override {
isl_schedule_free(LastSchedule);
LastSchedule = nullptr;
More information about the llvm-commits
mailing list