replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

do not use the GCD to compute the delinearization strides 

We do not need to compute the GCD anymore after we removed the constant
coefficients from the terms: the terms are now all parametric expressions and
there is no need to recognize constant terms that divide only a subset of the
terms. We only rely on the size of the terms, i.e., the number of operands in
the multiply expressions, to sort the terms and recognize the parametric
dimensions.

llvm-svn: 209693
This commit is contained in:
Sebastian Pop 2014-05-27 22:41:56 +00:00
parent 28e6b97b5d
commit e30bd351cc
1 changed files with 8 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
llvm/lib/Analysis/ScalarEvolution.cpp
View File

@ -7211,82 +7211,31 @@ private:
}; };
} }
// Find the Greatest Common Divisor of A and B.
static const SCEV *
findGCD(ScalarEvolution &SE, const SCEV *A, const SCEV *B) {
if (const SCEVConstant *CA = dyn_cast<SCEVConstant>(A))
if (const SCEVConstant *CB = dyn_cast<SCEVConstant>(B))
return SE.getConstant(gcd(CA, CB));
const SCEV *One = SE.getConstant(A->getType(), 1);
if (isa<SCEVConstant>(A) && isa<SCEVUnknown>(B))
return One;
if (isa<SCEVUnknown>(A) && isa<SCEVConstant>(B))
return One;
const SCEV *Q, *R;
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(A)) {
SmallVector<const SCEV *, 2> Qs;
for (const SCEV *Op : M->operands())
Qs.push_back(findGCD(SE, Op, B));
return SE.getMulExpr(Qs);
}
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(B)) {
SmallVector<const SCEV *, 2> Qs;
for (const SCEV *Op : M->operands())
Qs.push_back(findGCD(SE, A, Op));
return SE.getMulExpr(Qs);
}
SCEVDivision::divide(SE, A, B, &Q, &R);
if (R->isZero())
return B;
SCEVDivision::divide(SE, B, A, &Q, &R);
if (R->isZero())
return A;
return One;
}
// Find the Greatest Common Divisor of all the SCEVs in Terms.
static const SCEV *
findGCD(ScalarEvolution &SE, SmallVectorImpl<const SCEV *> &Terms) {
assert(Terms.size() > 0 && "Terms vector is empty");
const SCEV *GCD = Terms[0];
for (const SCEV *T : Terms)
GCD = findGCD(SE, GCD, T);
return GCD;
}
static bool findArrayDimensionsRec(ScalarEvolution &SE, static bool findArrayDimensionsRec(ScalarEvolution &SE,
SmallVectorImpl<const SCEV *> &Terms, SmallVectorImpl<const SCEV *> &Terms,
SmallVectorImpl<const SCEV *> &Sizes) { SmallVectorImpl<const SCEV *> &Sizes) {
// The GCD of all Terms is the dimension of the innermost dimension. int Last = Terms.size() - 1;
const SCEV *GCD = findGCD(SE, Terms); const SCEV *Step = Terms[Last];
// End of recursion. // End of recursion.
if (Terms.size() == 1) { if (Last == 0) {
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(GCD)) { if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Step)) {
SmallVector<const SCEV *, 2> Qs; SmallVector<const SCEV *, 2> Qs;
for (const SCEV *Op : M->operands()) for (const SCEV *Op : M->operands())
if (!isa<SCEVConstant>(Op)) if (!isa<SCEVConstant>(Op))
Qs.push_back(Op); Qs.push_back(Op);
GCD = SE.getMulExpr(Qs); Step = SE.getMulExpr(Qs);
} }
Sizes.push_back(GCD); Sizes.push_back(Step);
return true; return true;
} }
for (const SCEV *&Term : Terms) { for (const SCEV *&Term : Terms) {
// Normalize the terms before the next call to findArrayDimensionsRec. // Normalize the terms before the next call to findArrayDimensionsRec.
const SCEV *Q, *R; const SCEV *Q, *R;
SCEVDivision::divide(SE, Term, GCD, &Q, &R); SCEVDivision::divide(SE, Term, Step, &Q, &R);
// Bail out when GCD does not evenly divide one of the terms. // Bail out when GCD does not evenly divide one of the terms.
if (!R->isZero()) if (!R->isZero())
@ -7305,7 +7254,7 @@ static bool findArrayDimensionsRec(ScalarEvolution &SE,
if (!findArrayDimensionsRec(SE, Terms, Sizes)) if (!findArrayDimensionsRec(SE, Terms, Sizes))
return false; return false;
Sizes.push_back(GCD); Sizes.push_back(Step);
return true; return true;
} }