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 synthezised in @p Stmt.
+ /// @brief 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);
/// within this basic block), one for each lane.
/// @param Schedule A map from the statement to a schedule where the
/// innermost dimension is the dimension of the innermost
- /// loop containing the statemenet.
+ /// loop containing the statement.
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
// vector lane, ...
// Each map, contains information about Instructions in the old ScoP, which
// are recalculated in the new SCoP. When copying the basic block, we replace
- // all referenes to the old instructions with their recalculated values.
+ // all references to the old instructions with their recalculated values.
//
// For example, when the code generator produces this AST:
//
std::vector<LoopToScevMapT> &VLTS;
// A map from the statement to a schedule where the innermost dimension is the
- // dimension of the innermost loop containing the statemenet.
+ // dimension of the innermost loop containing the statement.
isl_map *Schedule;
VectorBlockGenerator(BlockGenerator &BlockGen,
/// Generate code for a given SCEV*
///
/// This function generates code for a given SCEV expression. It generated
- /// code is emmitted at the end of the basic block our Builder currently
+ /// code is emitted at the end of the basic block our Builder currently
/// points to and the resulting value is returned.
///
/// @param Expr The expression to code generate.
/// @param All If not set only parameters referred to by the constraints in
/// @p Set will be materialized, otherwise all.
///
- /// @returns False, iff a problem occured and the value was not materialized.
+ /// @returns False, iff a problem occurred and the value was not materialized.
bool materializeParameters(__isl_take isl_set *Set, bool All);
// Extract the upper bound of this loop
// It must not be calculated at each loop iteration and can often even be
// hoisted out further by the loop invariant code motion.
//
- // 2. OpenMP needs a loop invarient upper bound to calculate the number
+ // 2. OpenMP needs a loop invariant upper bound to calculate the number
// of loop iterations.
//
// 3. With the existing code, upper bounds have been easier to implement.
/// map all members of @p IAClass to that preloaded value, potentially casted
/// to the required type.
///
- /// @returns False, iff a problem occured and the load was not preloaded.
+ /// @returns False, iff a problem occurred and the load was not preloaded.
bool preloadInvariantEquivClass(InvariantEquivClassTy &IAClass);
void createForVector(__isl_take isl_ast_node *For, int VectorWidth);
///
/// This function takes a node in an (possibly already optimized) schedule
/// tree and applies a set of additional optimizations on this schedule tree
- /// node and its descendents. The transformations applied include:
+ /// node and its descendants. The transformations applied include:
///
/// - Tiling
/// - Prevectorization
/// @returns True if the access could be built, False otherwise.
bool buildAccessCallInst(MemAccInst Inst, Loop *L);
- /// @brief Build a single-dimensional parameteric sized MemoryAccess
+ /// @brief Build a single-dimensional parametric sized MemoryAccess
/// from the Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
/// @param Affine Whether all subscripts are affine expressions.
/// @param AccessValue Value read or written.
/// @param Subscripts Access subscripts per dimension.
- /// @param Sizes The array diminsion's sizes.
+ /// @param Sizes The array dimension's sizes.
/// @param Kind The kind of memory accessed.
///
/// @return The created MemoryAccess, or nullptr if the access is not within
namespace polly {
-/// @brief Type to hold region delimitors (entry & exit block).
+/// @brief Type to hold region delimiters (entry & exit block).
using BBPair = std::pair<BasicBlock *, BasicBlock *>;
-/// @brief Return the region delimitors (entry & exit block) of @p R.
+/// @brief 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.
///
/// This emits the content of the reject log as optimization remarks.
/// Remember to at least track failures (-polly-detect-track-failures).
-/// @param P The region delimitors (entry & exit) we emit remarks for.
+/// @param P The region delimiters (entry & exit) we emit remarks for.
/// @param Log The error log containing all messages being emitted as remark.
void emitRejectionRemarks(const BBPair &P, const RejectLog &Log);
/// For memory accesses of kind MK_PHI or MK_ExitPHI the access
/// instruction of a load access is the PHI instruction. The access
/// instruction of a PHI-store is the incoming's block's terminator
- /// intruction.
+ /// instruction.
///
/// For memory accesses of kind MK_Value the access instruction of a load
/// access is nullptr because generally there can be multiple instructions in
/// @brief Create the access relation for the underlying memory intrinsic.
void buildMemIntrinsicAccessRelation();
- /// @brief Assemble the access relation from all availbale information.
+ /// @brief Assemble the access relation from all available information.
///
/// In particular, used the information passes in the constructor and the
/// parent ScopStmt set by setStatment().
///
/// After code generation moves some PHIs around during region simplification,
/// we cannot reliably locate the original PHI node and its incoming values
- /// anymore. For this reason we remember these explicitely for all PHI-kind
+ /// anymore. For this reason we remember these explicitly for all PHI-kind
/// accesses.
ArrayRef<std::pair<BasicBlock *, Value *>> getIncoming() const {
assert(isAnyPHIKind());
/// @brief Get the ScopArrayInfo object for the base address.
const ScopArrayInfo *getScopArrayInfo() const;
- /// @brief Return a string representation of the accesse's reduction type.
+ /// @brief 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.
// two subsequent values of 'i' index two values that are stored next to
// each other in memory. By this division we make this characteristic
// obvious again. If the base pointer was accessed with offsets not divisible
- // by the accesses element size, we will have choosen a smaller ArrayElemSize
+ // by the accesses element size, we will have chosen a smaller ArrayElemSize
// that divides the offsets of all accesses to this base pointer.
if (DimsAccess == 1) {
isl_val *V = isl_val_int_from_si(Ctx, ArrayElemSize);
// If there is one scalar extracted, all scalar elements should have
// already been extracted by the code here. So no need to check for the
- // existance of all of them.
+ // existence of all of them.
if (SM.count(Operand))
break;
if (ValueMap.count(MA->getAccessInstruction()))
return true;
- // Check for recurrsion which can be caused by additional constraints, e.g.,
- // non-finitie loop contraints. In such a case we have to bail out and insert
+ // Check for recursion which can be caused by additional constraints, e.g.,
+ // non-finite loop constraints. In such a case we have to bail out and insert
// a "false" runtime check that will cause the original code to be executed.
auto PtrId = std::make_pair(IAClass.IdentifyingPointer, IAClass.AccessType);
if (!PreloadedPtrs.insert(PtrId).second)
return false;
- // The exectution context of the IAClass.
+ // The execution context of the IAClass.
isl_set *&ExecutionCtx = IAClass.ExecutionContext;
// If the base pointer of this class is dependent on another one we have to
//
//===----------------------------------------------------------------------===//
//
-// This pass generates an entirey new schedule tree from the data dependences
+// This pass generates an entirely new schedule tree from the data dependences
// and iteration domains. The new schedule tree is computed in two steps:
//
// 1) The isl scheduling optimizer is run
projects / platform / upstream / llvm.git / commitdiff