RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 19:12:56 +02:00
Code Issues Projects Releases Wiki Activity

Clarify SCEV comments.

Browse Source 
We handle for(i=n; i>0; i -= s) by canonicalizing within SCEV to for(i=-n; i<0; i += s).

llvm-svn: 193147
This commit is contained in:
Andrew Trick 2013-10-22 05:09:40 +00:00
parent 8b2b2a7210
commit a454a863ad
1 changed files with 11 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
lib/Analysis/ScalarEvolution.cpp
View File

@ -6394,11 +6394,14 @@ ScalarEvolution::HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
// With unit stride, the iteration never steps past the limit value.
} else if (isKnownPositive(Step)) {
// Test whether a positive iteration can step past the limit value and
// past the maximum value for its type in a single step. The NSW/NUW flags
// can imply that stepping past RHS would immediately result in undefined
// behavior. No self-wrap is not useful here because the loop counter may
// signed or unsigned wrap but continue iterating and terminate with
// defined behavior without ever self-wrapping.
// past the maximum value for its type in a single step. Constant negative
// stride should be rare because LHS > RHS comparisons are canonicalized
// to -LHS < -RHS.
//
// NSW/NUW flags imply that stepping past RHS would immediately result in
// undefined behavior. No self-wrap is not useful here because the loop
// counter may signed or unsigned wrap but continue iterating and
// terminate with defined behavior without ever self-wrapping.
const SCEV *One = getConstant(Step->getType(), 1);
if (isSigned) {
if (!AddRec->getNoWrapFlags(SCEV::FlagNSW)) {
@ -6413,10 +6416,10 @@ ScalarEvolution::HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
.ult(getUnsignedRange(RHS).getUnsignedMax()))
return getCouldNotCompute();
}
} else
// TODO: Handle negative strides here and below.
} else {
// Cannot handle variable stride.
return getCouldNotCompute();
}
// We know the LHS is of the form {n,+,s} and the RHS is some loop-invariant
// m. So, we count the number of iterations in which {n,+,s} < m is true.
// Note that we cannot simply return max(m-n,0)/s because it's not safe to