Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-02-09 02:49:11 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Fix a lot of typos. NFC.

Browse Source 
llvm-svn: 304974
This commit is contained in:
Michael Kruse 2017-06-08 12:06:15 +00:00
parent 631109c09c
commit a6d48f59a1
29 changed files with 83 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
polly/include/polly/CodeGen/BlockGenerators.h
View File

@ -180,7 +180,7 @@ protected:
/// MemoryType::PHI (and MemoryType::ExitPHI) objects are used to model PHI
/// nodes. For each PHI nodes we introduce, besides the Array of type
/// MemoryType::Value, a second chunk of memory into which we write at the end
/// of each basic block preceeding the PHI instruction the value passed
/// of each basic block preceding the PHI instruction the value passed
/// through this basic block. At the place where the PHI node is executed, we
/// replace the PHI node with a load from the corresponding MemoryType::PHI
/// memory location. The memory allocations for MemoryType::PHI end with
@ -684,7 +684,7 @@ private:
/// 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
/// scalar value, this value is loaded and shuffled into all elements
/// of the vector.
///
/// %splat_one = load <1 x double>* %p

2
polly/include/polly/CodeGen/IslExprBuilder.h
View File

@ -75,7 +75,7 @@ class ScopArrayInfo;
/// in the wild. Signed computations are needed, as loop bounds may become
/// negative.
///
/// It is possible to track overflows that occured in the generated IR. See the
/// It is possible to track overflows that occurred in the generated IR. See the
/// description of @see OverflowState for more information.
///
/// FIXME: Hardcoding sizes can cause issues:

4
polly/include/polly/CodeGen/IslNodeBuilder.h
View File

@ -112,7 +112,7 @@ public:
/// Get the associated block generator.
///
/// @return A referecne to the associated block generator.
/// @return A reference to the associated block generator.
BlockGenerator &getBlockGenerator() { return BlockGen; }
/// Return the parallel subfunctions that have been created.
@ -182,7 +182,7 @@ protected:
/// Materialize code for @p Id if it was not done before.
///
/// @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 materializeValue(__isl_take isl_id *Id);
/// Materialize parameters of @p Set.

2
polly/include/polly/CodeGen/LoopGenerators.h
View File

@ -172,7 +172,7 @@ public:
/// 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.
/// subfunction and only if the runtime system depends on it.
void createCallCleanupThread();
/// Create a struct for all @p Values and store them in there.

2
polly/include/polly/DependenceInfo.h
View File

@ -131,7 +131,7 @@ struct Dependences {
/// @param S The current SCoP.
/// @param NewSchedules The new schedules
///
/// @return True if the new schedule is valid, false it it reverses
/// @return True if the new schedule is valid, false if it reverses
/// dependences.
bool isValidSchedule(Scop &S, StatementToIslMapTy *NewSchedules) const;

4
polly/include/polly/ScopBuilder.h
View File

@ -125,7 +125,7 @@ class ScopBuilder {
/// @returns True if the access could be built, False otherwise.
bool buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt);
/// Try to build a multi-dimensional parameteric sized MemoryAccess.
/// Try to build a multi-dimensional parametric sized MemoryAccess.
/// from the Load/Store instruction.
///
/// @param Inst The Load/Store instruction that access the memory
@ -196,7 +196,7 @@ class ScopBuilder {
///
/// @param SR A subregion of @p R.
///
/// Some of the statments might be optimized away later when they do not
/// Some of the statements might be optimized away later when they do not
/// access any memory and thus have no effect.
void buildStmts(Region &SR);

8
polly/include/polly/ScopDetection.h
View File

@ -13,7 +13,7 @@
// that only has statically known control flow and can therefore be described
// within the polyhedral model.
//
// Every Scop fullfills these restrictions:
// Every Scop fulfills these restrictions:
//
// * It is a single entry single exit region
//
@ -275,7 +275,7 @@ private:
/// 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.
/// @param BasePointer the base pointer we are interested in.
/// @param Scope The location where @p BasePointer is being used.
/// @param True if consistent (multi-dimensional) array accesses could be
/// derived for this array.
@ -306,8 +306,8 @@ private:
/// 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
/// optimising.
/// in each loop. This can be used as an indicator whether a loop is worth
/// optimizing.
///
/// @param Context The context of scop detection.
/// @param NumLoops The number of loops in the region.

2
polly/include/polly/ScopDetectionDiagnostic.h
View File

@ -145,7 +145,7 @@ public:
typedef std::shared_ptr<RejectReason> RejectReasonPtr;
/// Stores all errors that ocurred during the detection.
/// Stores all errors that occurred during the detection.
class RejectLog {
Region *R;
llvm::SmallVector<RejectReasonPtr, 1> ErrorReports;

32
polly/include/polly/ScopInfo.h
View File

@ -143,7 +143,7 @@ enum class MemoryKind {
/// | use float %V | | use float %V |
/// ----------------- -----------------
///
/// is modeled as if the following memory accesses occured:
/// is modeled as if the following memory accesses occurred:
///
/// __________________________
/// |entry: |
@ -175,7 +175,7 @@ enum class MemoryKind {
///
/// %PHI = phi float [ %Val1, %IncomingBlock1 ], [ %Val2, %IncomingBlock2 ]
///
/// is modeled as if the accesses occured this way:
/// is modeled as if the accesses occurred this way:
///
/// _______________________________
/// |entry: |
@ -651,7 +651,7 @@ private:
/// Get the new access function imported or set by a pass
__isl_give isl_map *getNewAccessRelation() const;
/// Fold the memory access to consider parameteric offsets
/// Fold the memory access to consider parametric offsets
///
/// To recover memory accesses with array size parameters in the subscript
/// expression we post-process the delinearization results.
@ -659,7 +659,7 @@ private:
/// We would normally recover from an access A[exp0(i) * N + exp1(i)] into an
/// array A[][N] the 2D access A[exp0(i)][exp1(i)]. However, another valid
/// delinearization is A[exp0(i) - 1][exp1(i) + N] which - depending on the
/// range of exp1(i) - may be preferrable. Specifically, for cases where we
/// range of exp1(i) - may be preferable. Specifically, for cases where we
/// know exp1(i) is negative, we want to choose the latter expression.
///
/// As we commonly do not have any information about the range of exp1(i),
@ -717,7 +717,7 @@ public:
/// @param AccType Whether read or write access.
/// @param IsAffine Whether the subscripts are affine expressions.
/// @param Kind The kind of memory accessed.
/// @param Subscripts Subscipt expressions
/// @param Subscripts Subscript expressions
/// @param Sizes Dimension lengths of the accessed array.
MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst, AccessType AccType,
Value *BaseAddress, Type *ElemType, bool Affine,
@ -741,7 +741,7 @@ public:
/// 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
/// @param IncomingValue The value when reaching the PHI from the @p
/// IncomingBlock.
void addIncoming(BasicBlock *IncomingBlock, Value *IncomingValue) {
assert(!isRead());
@ -1014,7 +1014,7 @@ public:
return isOriginalPHIKind() || isOriginalExitPHIKind();
}
/// Does this access orginate from one of the two PHI types? Can be
/// Does this access originate from one of the two PHI types? Can be
/// changed to an array access using setNewAccessRelation().
bool isLatestAnyPHIKind() const {
return isLatestPHIKind() || isLatestExitPHIKind();
@ -1154,7 +1154,7 @@ public:
/// @param Stmt The parent statement.
/// @param SourceRel The source location.
/// @param TargetRel The target location.
/// @param Domain The original domain under which copy statement whould
/// @param Domain The original domain under which the copy statement would
/// be executed.
ScopStmt(Scop &parent, __isl_take isl_map *SourceRel,
__isl_take isl_map *TargetRel, __isl_take isl_set *Domain);
@ -1166,7 +1166,7 @@ private:
/// Polyhedral description
//@{
/// The Scop containing this ScopStmt
/// The Scop containing this ScopStmt.
Scop &Parent;
/// The domain under which this statement is not modeled precisely.
@ -1930,7 +1930,7 @@ private:
/// Invariant load hoisting is not guaranteed to hoist all loads that were
/// assumed to be scop invariant during scop detection. This function checks
/// for cases where the hoisting failed, but where it would have been
/// necessary for our scop modeling to be correct. In case of insufficent
/// necessary for our scop modeling to be correct. In case of insufficient
/// hoisting the scop is marked as invalid.
///
/// In the example below Bound[1] is required to be invariant:
@ -2060,7 +2060,7 @@ private:
/// functions and move it to the size of the memory access. We do this as this
/// increases the size of the innermost dimension, consequently widens the
/// valid range the array subscript in this dimension can evaluate to, and
/// as a result increases the likelyhood that our delinearization is
/// as a result increases the likelihood that our delinearization is
/// correct.
///
/// Example:
@ -2076,13 +2076,13 @@ private:
/// S[i,j] -> A[i][2j]
///
/// Constants in outer dimensions can arise when the elements of a parametric
/// multi-dimensional array are not elementar data types, but e.g.,
/// multi-dimensional array are not elementary data types, but e.g.,
/// structures.
void foldSizeConstantsToRight();
/// Fold memory accesses to handle parametric offset.
///
/// As a post-processing step, we 'fold' memory accesses to parameteric
/// As a post-processing step, we 'fold' memory accesses to parametric
/// offsets in the access functions. @see MemoryAccess::foldAccess for
/// details.
void foldAccessRelations();
@ -2203,7 +2203,7 @@ public:
/// @param Stmt The parent statement.
/// @param SourceRel The source location.
/// @param TargetRel The target location.
/// @param Domain The original domain under which copy statement whould
/// @param Domain The original domain under which the copy statement would
/// be executed.
ScopStmt *addScopStmt(__isl_take isl_map *SourceRel,
__isl_take isl_map *TargetRel,
@ -2813,7 +2813,7 @@ public:
private:
/// A map of Region to its Scop object containing
/// Polly IR of static control part
/// Polly IR of static control part.
RegionToScopMapTy RegionToScopMap;
public:
@ -2821,7 +2821,7 @@ public:
LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
AssumptionCache &AC);
/// 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

4
polly/include/polly/Support/GICHelper.h
View File

@ -114,7 +114,7 @@ inline isl::val valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
/// As the input isl_val may be negative, the APInt that this function returns
/// must always be interpreted as signed two's complement value. The bitwidth of
/// the generated APInt is always the minimal bitwidth necessary to model the
/// provided integer when interpreting the bitpattern as signed value.
/// provided integer when interpreting the bit pattern as signed value.
///
/// Some example conversions are:
///
@ -143,7 +143,7 @@ llvm::APInt APIntFromVal(__isl_take isl_val *Val);
/// As the input isl::val may be negative, the APInt that this function returns
/// must always be interpreted as signed two's complement value. The bitwidth of
/// the generated APInt is always the minimal bitwidth necessary to model the
/// provided integer when interpreting the bitpattern as signed value.
/// provided integer when interpreting the bit pattern as signed value.
///
/// Some example conversions are:
///

4
polly/include/polly/Support/SCEVAffinator.h
View File

@ -64,7 +64,7 @@ public:
__isl_give PWACtx getPwAff(const llvm::SCEV *E,
llvm::BasicBlock *BB = nullptr);
/// Take the asumption that @p PWAC is non-negative.
/// Take the assumption that @p PWAC is non-negative.
void takeNonNegativeAssumption(PWACtx &PWAC);
/// Interpret the PWA in @p PWAC as an unsigned value.
@ -110,7 +110,7 @@ private:
/// @param Expr The SCEV expression that might wrap.
/// @param PWAC The isl representation of @p Expr with the invalid domain.
///
/// @returns The isl representation @p PWAC with a posisbly adjusted domain.
/// @returns The isl representation @p PWAC with a possibly adjusted domain.
__isl_give PWACtx checkForWrapping(const llvm::SCEV *Expr, PWACtx PWAC) const;
/// Whether to track the value of this expression precisely, rather than

8
polly/include/polly/Support/ScopHelper.h
View File

@ -72,7 +72,7 @@ using BoxedLoopsSetTy = llvm::SetVector<const llvm::Loop *>;
/// those from llvm/Support/Casting.h. Partial template function specialization
/// is currently not supported in C++ such that those cannot be used directly.
/// (llvm::isa could, but then llvm:cast etc. would not have the expected
/// behaviour)
/// behavior)
class MemAccInst {
private:
llvm::Instruction *I;
@ -331,7 +331,7 @@ void splitEntryBlockForAlloca(llvm::BasicBlock *EntryBlock, llvm::Pass *P);
/// @param E The expression for which code is actually generated.
/// @param Ty The type of the resulting code.
/// @param IP The insertion point for the new code.
/// @param VMap A remaping of values used in @p E.
/// @param VMap A remapping of values used in @p E.
/// @param RTCBB The last block of the RTC. Used to insert loop-invariant
/// instructions in rare cases.
llvm::Value *expandCodeFor(Scop &S, llvm::ScalarEvolution &SE,
@ -342,7 +342,7 @@ llvm::Value *expandCodeFor(Scop &S, llvm::ScalarEvolution &SE,
/// Check if the block is a error block.
///
/// A error block is currently any block that fullfills at least one of
/// A error block is currently any block that fulfills at least one of
/// the following conditions:
///
/// - It is terminated by an unreachable instruction
@ -350,7 +350,7 @@ llvm::Value *expandCodeFor(Scop &S, llvm::ScalarEvolution &SE,
/// dominated by a loop header and that does not dominate the region exit.
/// This is a heuristic to pick only error blocks that are conditionally
/// executed and can be assumed to be not executed at all without the domains
/// beeing available.
/// being available.
///
/// @param BB The block to check.
/// @param R The analyzed region.

4
polly/lib/Analysis/DependenceInfo.cpp
View File

@ -492,7 +492,7 @@ void Dependences::calculateDependences(Scop &S) {
// S0[98 <= i <= 100] is captured in S1[98 <= i <= 100].
// Since we allow free reordering on our reduction dependences, we need to
// remove all instances of a reduction statement that have data dependences
// orignating from them.
// originating from them.
// In the case of the example, we need to remove S0[98 <= i <= 100] from
// our reduction dependences.
//
@ -522,7 +522,7 @@ void Dependences::calculateDependences(Scop &S) {
// void f(int *sum, int A[N], int B[N]) {
// for (int i = 0; i < N; i++) {
// *sum += A[i]; < the store and the load is not tagged as a
// B[i] = *sum; < reductionLike acccess due to the overlap.
// B[i] = *sum; < reduction-like access due to the overlap.
// }
// }

2
polly/lib/Analysis/ScopBuilder.cpp
View File

@ -705,7 +705,7 @@ MemoryAccess *ScopBuilder::addMemoryAccess(
bool isKnownMustAccess = false;
// Accesses in single-basic block statements are always excuted.
// Accesses in single-basic block statements are always executed.
if (Stmt->isBlockStmt())
isKnownMustAccess = true;

8
polly/lib/Analysis/ScopDetection.cpp
View File

@ -13,7 +13,7 @@
// that only has statically known control flow and can therefore be described
// within the polyhedral model.
//
// Every Scop fullfills these restrictions:
// Every Scop fulfills these restrictions:
//
// * It is a single entry single exit region
//
@ -734,11 +734,11 @@ bool ScopDetection::isInvariant(Value &Val, const Region &Reg,
/// 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,
/// Array access expressions as they are generated by GFortran contain smax(0,
/// size) expressions that confuse the 'normal' delinearization algorithm.
/// However, if we extract such expressions before the normal delinearization
/// takes place they can actually help to identify array size expressions in
/// fortran accesses. For the subsequently following delinearization the smax(0,
/// Fortran accesses. For the subsequently following delinearization the smax(0,
/// size) component can be replaced by just 'size'. This is correct as we will
/// always add and verify the assumption that for all subscript expressions
/// 'exp' the inequality 0 <= exp < size holds. Hence, we will also verify
@ -1477,7 +1477,7 @@ bool ScopDetection::isProfitableRegion(DetectionContext &Context) const {
if (NumAffineLoops >= 2)
return true;
// A loop with multiple non-trivial blocks migt be amendable to distribution.
// A loop with multiple non-trivial blocks might be amendable to distribution.
if (NumAffineLoops == 1 && hasPossiblyDistributableLoop(Context))
return true;

10
polly/lib/Analysis/ScopInfo.cpp
View File

@ -930,7 +930,7 @@ static bool isDivisible(const SCEV *Expr, unsigned Size, ScalarEvolution &SE) {
}
// For other n-ary expressions (Add, AddRec, Max,...) all operands need
// to be divisble.
// to be divisible.
if (auto *NAryExpr = dyn_cast<SCEVNAryExpr>(Expr)) {
for (auto *OpExpr : NAryExpr->operands())
if (!isDivisible(OpExpr, Size, SE))
@ -2518,7 +2518,7 @@ static inline Loop *getRegionNodeLoop(RegionNode *RN, LoopInfo &LI) {
// able to model them and to later eliminate the run-time bounds checks.
//
// Specifically, for basic blocks that terminate in an unreachable and
// where the immeditate predecessor is part of a loop, we assume these
// where the immediate predecessor is part of a loop, we assume these
// basic blocks belong to the loop the predecessor belongs to. This
// allows us to model the following code.
//
@ -3739,8 +3739,8 @@ static bool canAlwaysBeHoisted(MemoryAccess *MA, bool StmtInvalidCtxIsEmpty,
if (!NonHoistableCtxIsEmpty)
return false;
// If a dereferencable load is in a statement that is modeled precisely we can
// hoist it.
// If a dereferenceable load is in a statement that is modeled precisely we
// can hoist it.
if (StmtInvalidCtxIsEmpty && MAInvalidCtxIsEmpty)
return true;
@ -4949,7 +4949,7 @@ INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops",
ScopInfo::ScopInfo(const DataLayout &DL, ScopDetection &SD, ScalarEvolution &SE,
LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
AssumptionCache &AC) {
/// Create polyhedral descripton of scops for all the valid regions of a
/// Create polyhedral description of scops for all the valid regions of a
/// function.
for (auto &It : SD) {
Region *R = const_cast<Region *>(It);

8
polly/lib/CodeGen/BlockGenerators.cpp
View File

@ -462,13 +462,13 @@ Value *BlockGenerator::getOrCreateAlloca(const ScopArrayInfo *Array) {
if (Addr) {
// Allow allocas to be (temporarily) redirected once by adding a new
// old-alloca-addr to new-addr mapping to GlobalMap. This funcitionality
// old-alloca-addr to new-addr mapping to GlobalMap. This functionality
// is used for example by the OpenMP code generation where a first use
// of a scalar while still in the host code allocates a normal alloca with
// getOrCreateAlloca. When the values of this scalar are accessed during
// the generation of the parallel subfunction, these values are copied over
// to the parallel subfunction and each request for a scalar alloca slot
// must be forwared to the temporary in-subfunction slot. This mapping is
// must be forwarded to the temporary in-subfunction slot. This mapping is
// removed when the subfunction has been generated and again normal host
// code is generated. Due to the following reasons it is not possible to
// perform the GlobalMap lookup right after creating the alloca below, but
@ -1196,7 +1196,7 @@ void VectorBlockGenerator::copyInstruction(
return;
}
// Falltrough: We generate scalar instructions, if we don't know how to
// Fallthrough: We generate scalar instructions, if we don't know how to
// generate vector code.
}
@ -1447,7 +1447,7 @@ void RegionGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT &LTS,
}
// Add counting PHI nodes to all loops in the region that can be used as
// replacement for SCEVs refering to the old loop.
// replacement for SCEVs referring to the old loop.
for (BasicBlock *BB : SeenBlocks) {
Loop *L = LI.getLoopFor(BB);
if (L == nullptr || L->getHeader() != BB || !R->contains(L))

4
polly/lib/CodeGen/CodeGeneration.cpp
View File

@ -10,7 +10,7 @@
// The CodeGeneration pass takes a Scop created by ScopInfo and translates it
// back to LLVM-IR using the ISL code generator.
//
// The Scop describes the high level memory behaviour of a control flow region.
// The Scop describes the high level memory behavior of a control flow region.
// Transformation passes can update the schedule (execution order) of statements
// in the Scop. ISL is used to generate an abstract syntax tree that reflects
// the updated execution order. This clast is used to create new LLVM-IR that is
@ -253,7 +253,7 @@ public:
CodeGeneration() : ScopPass(ID) {}
/// The datalayout used
/// The data layout used.
const DataLayout *DL;
/// @name The analysis passes we need to generate code.

2
polly/lib/CodeGen/CodegenCleanup.cpp
View File

@ -47,7 +47,7 @@ public:
// TODO: How to make parent passes discoverable?
// TODO: Should be sensitive to compiler options in PassManagerBuilder, to
// which wo do not have access here.
// which we do not have access here.
FPM->add(createScopedNoAliasAAWrapperPass());
FPM->add(createTypeBasedAAWrapperPass());
FPM->add(createAAResultsWrapperPass());

4
polly/lib/CodeGen/IslAst.cpp
View File

@ -21,7 +21,7 @@
//
// Polyhedral AST generation is more than scanning polyhedra
// Tobias Grosser, Sven Verdoolaege, Albert Cohen
// ACM Transations on Programming Languages and Systems (TOPLAS),
// ACM Transactions on Programming Languages and Systems (TOPLAS),
// 37(4), July 2015
// http://www.grosser.es/#pub-polyhedral-AST-generation
//
@ -171,7 +171,7 @@ static isl_printer *cbPrintFor(__isl_take isl_printer *Printer,
/// dependences is broken when we exploit this parallelism. If so,
/// @p IsReductionParallel will be set to true. The reduction dependences we use
/// to check are actually the union of the transitive closure of the initial
/// reduction dependences together with their reveresal. Even though these
/// reduction dependences together with their reversal. Even though these
/// dependences connect all iterations with each other (thus they are cyclic)
/// we can perform the parallelism check as we are only interested in a zero
/// (or non-zero) dependence distance on the dimension in question.

6
polly/lib/CodeGen/IslExprBuilder.cpp
View File

@ -51,7 +51,7 @@ IslExprBuilder::IslExprBuilder(Scop &S, PollyIRBuilder &Builder,
void IslExprBuilder::setTrackOverflow(bool Enable) {
// If potential overflows are tracked always or never we ignore requests
// to change the behaviour.
// to change the behavior.
if (OTMode != OT_REQUEST)
return;
@ -399,7 +399,7 @@ Value *IslExprBuilder::createOpBin(__isl_take isl_ast_expr *Expr) {
}
}
// TODO: Review code and check that this calculation does not yield
// incorrect overflow in some bordercases.
// incorrect overflow in some edge cases.
//
// floord(n,d) ((n < 0) ? (n - d + 1) : n) / d
Value *One = ConstantInt::get(MaxType, 1);
@ -536,7 +536,7 @@ Value *IslExprBuilder::createOpBoolean(__isl_take isl_ast_expr *Expr) {
// 'exp & exp' or 'exp | exp'. This forces the evaluation of both branches,
// but it is, due to the use of i1 types, otherwise equivalent. The reason
// to go for bitwise operations is, that we assume the reduced control flow
// will outweight the overhead introduced by evaluating unneeded expressions.
// will outweigh the overhead introduced by evaluating unneeded expressions.
// The isl code generation currently does not take advantage of the fact that
// the expression after an '||' or '&&' is in some cases not evaluated.
// Evaluating it anyways does not cause any undefined behaviour.

14
polly/lib/CodeGen/IslNodeBuilder.cpp
View File

@ -101,7 +101,7 @@ IslNodeBuilder::getUpperBound(__isl_keep isl_ast_node *For,
Predicate = ICmpInst::ICMP_SLT;
break;
default:
llvm_unreachable("Unexpected comparision type in loop conditon");
llvm_unreachable("Unexpected comparison type in loop condition");
}
Arg0 = isl_ast_expr_get_op_arg(Cond, 0);
@ -588,7 +588,7 @@ void IslNodeBuilder::createForParallel(__isl_take isl_ast_node *For) {
ValueInc = ExprBuilder.create(Inc);
// OpenMP always uses SLE. In case the isl generated AST uses a SLT
// expression, we need to adjust the loop blound by one.
// expression, we need to adjust the loop bound by one.
if (Predicate == CmpInst::ICMP_SLT)
ValueUB = Builder.CreateAdd(
ValueUB, Builder.CreateSExt(Builder.getTrue(), ValueUB->getType()));
@ -832,7 +832,7 @@ void IslNodeBuilder::createSubstitutions(__isl_take isl_ast_expr *Expr,
assert(isl_ast_expr_get_type(Expr) == isl_ast_expr_op &&
"Expression of type 'op' expected");
assert(isl_ast_expr_get_op_type(Expr) == isl_ast_op_call &&
"Opertation of type 'call' expected");
"Operation of type 'call' expected");
for (int i = 0; i < isl_ast_expr_get_op_n_arg(Expr) - 1; ++i) {
isl_ast_expr *SubExpr;
Value *V;
@ -952,9 +952,9 @@ bool IslNodeBuilder::materializeValue(isl_id *Id) {
auto *ParamSCEV = (const SCEV *)isl_id_get_user(Id);
Value *V = nullptr;
// Parameters could refere to invariant loads that need to be
// Parameters could refer to invariant loads that need to be
// preloaded before we can generate code for the parameter. Thus,
// check if any value refered to in ParamSCEV is an invariant load
// check if any value referred to in ParamSCEV is an invariant load
// and if so make sure its equivalence class is preloaded.
SetVector<Value *> Values;
findValues(ParamSCEV, SE, Values);
@ -1093,7 +1093,7 @@ bool IslNodeBuilder::materializeFortranArrayOutermostDimension() {
continue;
isl_pw_aff *ParametricPwAff = Array->getDimensionSizePw(0);
assert(ParametricPwAff && "parameteric pw_aff corresponding "
assert(ParametricPwAff && "parametric pw_aff corresponding "
"to outermost dimension does not "
"exist");
@ -1488,7 +1488,7 @@ Value *IslNodeBuilder::generateSCEV(const SCEV *Expr) {
/// The AST expression we generate to perform the run-time check assumes
/// computations on integer types of infinite size. As we only use 64-bit
/// arithmetic we check for overflows, in case of which we set the result
/// of this run-time check to false to be cosnservatively correct,
/// of this run-time check to false to be conservatively correct,
Value *IslNodeBuilder::createRTC(isl_ast_expr *Condition) {
auto ExprBuilder = getExprBuilder();
ExprBuilder.setTrackOverflow(true);

4
polly/lib/CodeGen/LoopGenerators.cpp
View File

@ -159,7 +159,7 @@ Value *ParallelLoopGenerator::createParallelLoop(
Value *SubFnParam = Builder.CreateBitCast(Struct, Builder.getInt8PtrTy(),
"polly.par.userContext");
// Add one as the upper bound provided by openmp is a < comparison
// Add one as the upper bound provided by OpenMP is a < comparison
// whereas the codegenForSequential function creates a <= comparison.
UB = Builder.CreateAdd(UB, ConstantInt::get(LongType, 1));
@ -357,7 +357,7 @@ Value *ParallelLoopGenerator::createSubFn(Value *Stride, AllocaInst *StructData,
LB = Builder.CreateLoad(LBPtr, "polly.par.LB");
UB = Builder.CreateLoad(UBPtr, "polly.par.UB");
// Subtract one as the upper bound provided by openmp is a < comparison
// Subtract one as the upper bound provided by OpenMP is a < comparison
// whereas the codegenForSequential function creates a <= comparison.
UB = Builder.CreateSub(UB, ConstantInt::get(LongType, 1),
"polly.par.UBAdjusted");

10
polly/lib/CodeGen/PPCGCodeGeneration.cpp
View File

@ -153,7 +153,7 @@ static int computeSizeInBytes(const Type *T) {
/// Generate code for a GPU specific isl AST.
///
/// The GPUNodeBuilder augments the general existing IslNodeBuilder, which
/// generates code for general-prupose AST nodes, with special functionality
/// generates code for general-purpose AST nodes, with special functionality
/// for generating GPU specific user nodes.
///
/// @see GPUNodeBuilder::createUser
@ -434,7 +434,7 @@ private:
/// Finalize the generation of the kernel arguments.
///
/// This function ensures that not-read-only scalars used in a kernel are
/// stored back to the global memory location they ared backed up with before
/// stored back to the global memory location they are backed with before
/// the kernel terminates.
///
/// @params Kernel The kernel to finalize kernel arguments for.
@ -515,7 +515,7 @@ private:
/// @param GridBlockX The size of the first block dimension.
/// @param GridBlockY The size of the second block dimension.
/// @param GridBlockZ The size of the third block dimension.
/// @param Paramters A pointer to an array that contains itself pointers to
/// @param Parameters A pointer to an array that contains itself pointers to
/// the parameter values passed for each kernel argument.
void createCallLaunchKernel(Value *GPUKernel, Value *GridDimX,
Value *GridDimY, Value *BlockDimX,
@ -2046,7 +2046,7 @@ public:
return PPCGScop;
}
/// Collect the array acesses in a statement.
/// Collect the array accesses in a statement.
///
/// @param Stmt The statement for which to collect the accesses.
///
@ -2290,7 +2290,7 @@ public:
/// Create a default-initialized PPCG GPU program.
///
/// @returns A new gpu grogram description.
/// @returns A new gpu program description.
gpu_prog *createPPCGProg(ppcg_scop *PPCGScop) {
if (!PPCGScop)

2
polly/lib/CodeGen/PerfMonitor.cpp
View File

@ -235,7 +235,7 @@ Function *PerfMonitor::insertInitFunction(Function *FinalReporting) {
// constructor lists are just appended, such that the initializer will appear
// multiple times. To avoid initializations being run multiple times (and
// especially to avoid that atExitFn is called more than once), we bail
// out if the intializer is run more than once.
// out if the initializer is run more than once.
Value *HasRunBefore = Builder.CreateLoad(AlreadyInitializedPtr);
Builder.CreateCondBr(HasRunBefore, EarlyReturn, InitBB);
Builder.SetInsertPoint(EarlyReturn);

2
polly/lib/Exchange/JSONExporter.cpp
View File

@ -109,7 +109,7 @@ struct JSONImporter : public ScopPass {
///
/// @param S The scop to update.
/// @param JScop The JScop file describing the new schedule.
/// @param DL The datalayout to assume.
/// @param DL The data layout to assume.
///
/// @returns True if the import succeeded, otherwise False.
bool importAccesses(Scop &S, Json::Value &JScop, const DataLayout &DL);

2
polly/lib/Support/GICHelper.cpp
View File

@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
// Functions for converting between gmp objects and apint.
// Functions for converting between gmp objects and llvm::APInt.
//
//===----------------------------------------------------------------------===//
#include "polly/Support/GICHelper.h"

4
polly/lib/Support/ScopHelper.cpp
View File

@ -195,7 +195,7 @@ static BasicBlock *splitBlock(BasicBlock *Old, Instruction *SplitPt,
}
void polly::splitEntryBlockForAlloca(BasicBlock *EntryBlock, Pass *P) {
// Find first non-alloca instruction. Every basic block has a non-alloc
// Find first non-alloca instruction. Every basic block has a non-alloca
// instruction, as every well formed basic block has a terminator.
BasicBlock::iterator I = EntryBlock->begin();
while (isa<AllocaInst>(I))
@ -483,7 +483,7 @@ bool polly::isIgnoredIntrinsic(const Value *V) {
case llvm::Intrinsic::annotation:
case llvm::Intrinsic::donothing:
case llvm::Intrinsic::assume:
// Some debug info intrisics are supported/ignored.
// Some debug info intrinsics are supported/ignored.
case llvm::Intrinsic::dbg_value:
case llvm::Intrinsic::dbg_declare:
return true;

4
polly/lib/Transform/ScheduleOptimizer.cpp
View File

@ -775,7 +775,7 @@ static bool containsOnlyMatrMultAcc(__isl_keep isl_map *PartialSchedule,
///
/// @param Schedule The schedule of the SCoP statement.
/// @param D The SCoP dependencies.
/// @param Pos The parameter to desribe an acceptable true dependence.
/// @param Pos The parameter to describe an acceptable true dependence.
/// In case it has a negative value, try to determine its
/// acceptable value.
/// @return True in case dependencies correspond to the matrix multiplication
@ -1018,7 +1018,7 @@ getMacroKernelParams(const MicroKernelParamsTy &MicroKernelParams,
// Car can be computed to be zero since it is floor to int.
// On Mac OS, division by 0 does not raise a signal. This causes negative
// tile sizes to be computed. Prevent division by 0 Cac by early returning
// tile sizes to be computed. Prevent division by Cac==0 by early returning
// if this happens.
if (Car == 0)
return {1, 1, 1};