mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 11:02:59 +02:00
[SCEV] Introduce ScalarEvolution::getOne and getZero.
Summary: It is fairly common to call SE->getConstant(Ty, 0) or SE->getConstant(Ty, 1); this change makes such uses a little bit briefer. I've refactored the call sites I could find easily to use getZero / getOne. Reviewers: hfinkel, majnemer, reames Subscribers: sanjoy, llvm-commits Differential Revision: http://reviews.llvm.org/D12947 llvm-svn: 248362
This commit is contained in:
parent
cc79e4a6c7
commit
c636db0b30
@ -679,6 +679,12 @@ namespace llvm {
|
|||||||
const SCEV *getUnknown(Value *V);
|
const SCEV *getUnknown(Value *V);
|
||||||
const SCEV *getCouldNotCompute();
|
const SCEV *getCouldNotCompute();
|
||||||
|
|
||||||
|
/// \brief Return a SCEV for the constant 0 of a specific type.
|
||||||
|
const SCEV *getZero(Type *Ty) { return getConstant(Ty, 0); }
|
||||||
|
|
||||||
|
/// \brief Return a SCEV for the constant 1 of a specific type.
|
||||||
|
const SCEV *getOne(Type *Ty) { return getConstant(Ty, 1); }
|
||||||
|
|
||||||
/// Return an expression for sizeof AllocTy that is type IntTy
|
/// Return an expression for sizeof AllocTy that is type IntTy
|
||||||
///
|
///
|
||||||
const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
|
const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
|
||||||
|
@ -372,7 +372,7 @@ void DependenceAnalysis::Constraint::setLine(const SCEV *AA,
|
|||||||
void DependenceAnalysis::Constraint::setDistance(const SCEV *D,
|
void DependenceAnalysis::Constraint::setDistance(const SCEV *D,
|
||||||
const Loop *CurLoop) {
|
const Loop *CurLoop) {
|
||||||
Kind = Distance;
|
Kind = Distance;
|
||||||
A = SE->getConstant(D->getType(), 1);
|
A = SE->getOne(D->getType());
|
||||||
B = SE->getNegativeSCEV(A);
|
B = SE->getNegativeSCEV(A);
|
||||||
C = SE->getNegativeSCEV(D);
|
C = SE->getNegativeSCEV(D);
|
||||||
AssociatedLoop = CurLoop;
|
AssociatedLoop = CurLoop;
|
||||||
@ -1257,11 +1257,9 @@ bool DependenceAnalysis::weakCrossingSIVtest(const SCEV *Coeff,
|
|||||||
assert(SE->isKnownPositive(ConstCoeff) && "ConstCoeff should be positive");
|
assert(SE->isKnownPositive(ConstCoeff) && "ConstCoeff should be positive");
|
||||||
|
|
||||||
// compute SplitIter for use by DependenceAnalysis::getSplitIteration()
|
// compute SplitIter for use by DependenceAnalysis::getSplitIteration()
|
||||||
SplitIter =
|
SplitIter = SE->getUDivExpr(
|
||||||
SE->getUDivExpr(SE->getSMaxExpr(SE->getConstant(Delta->getType(), 0),
|
SE->getSMaxExpr(SE->getZero(Delta->getType()), Delta),
|
||||||
Delta),
|
SE->getMulExpr(SE->getConstant(Delta->getType(), 2), ConstCoeff));
|
||||||
SE->getMulExpr(SE->getConstant(Delta->getType(), 2),
|
|
||||||
ConstCoeff));
|
|
||||||
DEBUG(dbgs() << "\t Split iter = " << *SplitIter << "\n");
|
DEBUG(dbgs() << "\t Split iter = " << *SplitIter << "\n");
|
||||||
|
|
||||||
const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
|
const SCEVConstant *ConstDelta = dyn_cast<SCEVConstant>(Delta);
|
||||||
@ -1303,7 +1301,7 @@ bool DependenceAnalysis::weakCrossingSIVtest(const SCEV *Coeff,
|
|||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
Result.DV[Level].Splitable = false;
|
Result.DV[Level].Splitable = false;
|
||||||
Result.DV[Level].Distance = SE->getConstant(Delta->getType(), 0);
|
Result.DV[Level].Distance = SE->getZero(Delta->getType());
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1666,8 +1664,8 @@ bool DependenceAnalysis::weakZeroSrcSIVtest(const SCEV *DstCoeff,
|
|||||||
Level--;
|
Level--;
|
||||||
Result.Consistent = false;
|
Result.Consistent = false;
|
||||||
const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
|
const SCEV *Delta = SE->getMinusSCEV(SrcConst, DstConst);
|
||||||
NewConstraint.setLine(SE->getConstant(Delta->getType(), 0),
|
NewConstraint.setLine(SE->getZero(Delta->getType()), DstCoeff, Delta,
|
||||||
DstCoeff, Delta, CurLoop);
|
CurLoop);
|
||||||
DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
|
DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
|
||||||
if (isKnownPredicate(CmpInst::ICMP_EQ, SrcConst, DstConst)) {
|
if (isKnownPredicate(CmpInst::ICMP_EQ, SrcConst, DstConst)) {
|
||||||
if (Level < CommonLevels) {
|
if (Level < CommonLevels) {
|
||||||
@ -1776,8 +1774,8 @@ bool DependenceAnalysis::weakZeroDstSIVtest(const SCEV *SrcCoeff,
|
|||||||
Level--;
|
Level--;
|
||||||
Result.Consistent = false;
|
Result.Consistent = false;
|
||||||
const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
|
const SCEV *Delta = SE->getMinusSCEV(DstConst, SrcConst);
|
||||||
NewConstraint.setLine(SrcCoeff, SE->getConstant(Delta->getType(), 0),
|
NewConstraint.setLine(SrcCoeff, SE->getZero(Delta->getType()), Delta,
|
||||||
Delta, CurLoop);
|
CurLoop);
|
||||||
DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
|
DEBUG(dbgs() << "\t Delta = " << *Delta << "\n");
|
||||||
if (isKnownPredicate(CmpInst::ICMP_EQ, DstConst, SrcConst)) {
|
if (isKnownPredicate(CmpInst::ICMP_EQ, DstConst, SrcConst)) {
|
||||||
if (Level < CommonLevels) {
|
if (Level < CommonLevels) {
|
||||||
@ -2729,10 +2727,10 @@ void DependenceAnalysis::findBoundsALL(CoefficientInfo *A,
|
|||||||
// If the difference is 0, we won't need to know the number of iterations.
|
// If the difference is 0, we won't need to know the number of iterations.
|
||||||
if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].NegPart, B[K].PosPart))
|
if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].NegPart, B[K].PosPart))
|
||||||
Bound[K].Lower[Dependence::DVEntry::ALL] =
|
Bound[K].Lower[Dependence::DVEntry::ALL] =
|
||||||
SE->getConstant(A[K].Coeff->getType(), 0);
|
SE->getZero(A[K].Coeff->getType());
|
||||||
if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].PosPart, B[K].NegPart))
|
if (isKnownPredicate(CmpInst::ICMP_EQ, A[K].PosPart, B[K].NegPart))
|
||||||
Bound[K].Upper[Dependence::DVEntry::ALL] =
|
Bound[K].Upper[Dependence::DVEntry::ALL] =
|
||||||
SE->getConstant(A[K].Coeff->getType(), 0);
|
SE->getZero(A[K].Coeff->getType());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2801,9 +2799,8 @@ void DependenceAnalysis::findBoundsLT(CoefficientInfo *A,
|
|||||||
Bound[K].Lower[Dependence::DVEntry::LT] = nullptr; // Default value = -infinity.
|
Bound[K].Lower[Dependence::DVEntry::LT] = nullptr; // Default value = -infinity.
|
||||||
Bound[K].Upper[Dependence::DVEntry::LT] = nullptr; // Default value = +infinity.
|
Bound[K].Upper[Dependence::DVEntry::LT] = nullptr; // Default value = +infinity.
|
||||||
if (Bound[K].Iterations) {
|
if (Bound[K].Iterations) {
|
||||||
const SCEV *Iter_1 =
|
const SCEV *Iter_1 = SE->getMinusSCEV(
|
||||||
SE->getMinusSCEV(Bound[K].Iterations,
|
Bound[K].Iterations, SE->getOne(Bound[K].Iterations->getType()));
|
||||||
SE->getConstant(Bound[K].Iterations->getType(), 1));
|
|
||||||
const SCEV *NegPart =
|
const SCEV *NegPart =
|
||||||
getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
|
getNegativePart(SE->getMinusSCEV(A[K].NegPart, B[K].Coeff));
|
||||||
Bound[K].Lower[Dependence::DVEntry::LT] =
|
Bound[K].Lower[Dependence::DVEntry::LT] =
|
||||||
@ -2848,9 +2845,8 @@ void DependenceAnalysis::findBoundsGT(CoefficientInfo *A,
|
|||||||
Bound[K].Lower[Dependence::DVEntry::GT] = nullptr; // Default value = -infinity.
|
Bound[K].Lower[Dependence::DVEntry::GT] = nullptr; // Default value = -infinity.
|
||||||
Bound[K].Upper[Dependence::DVEntry::GT] = nullptr; // Default value = +infinity.
|
Bound[K].Upper[Dependence::DVEntry::GT] = nullptr; // Default value = +infinity.
|
||||||
if (Bound[K].Iterations) {
|
if (Bound[K].Iterations) {
|
||||||
const SCEV *Iter_1 =
|
const SCEV *Iter_1 = SE->getMinusSCEV(
|
||||||
SE->getMinusSCEV(Bound[K].Iterations,
|
Bound[K].Iterations, SE->getOne(Bound[K].Iterations->getType()));
|
||||||
SE->getConstant(Bound[K].Iterations->getType(), 1));
|
|
||||||
const SCEV *NegPart =
|
const SCEV *NegPart =
|
||||||
getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
|
getNegativePart(SE->getMinusSCEV(A[K].Coeff, B[K].PosPart));
|
||||||
Bound[K].Lower[Dependence::DVEntry::GT] =
|
Bound[K].Lower[Dependence::DVEntry::GT] =
|
||||||
@ -2875,13 +2871,13 @@ void DependenceAnalysis::findBoundsGT(CoefficientInfo *A,
|
|||||||
|
|
||||||
// X^+ = max(X, 0)
|
// X^+ = max(X, 0)
|
||||||
const SCEV *DependenceAnalysis::getPositivePart(const SCEV *X) const {
|
const SCEV *DependenceAnalysis::getPositivePart(const SCEV *X) const {
|
||||||
return SE->getSMaxExpr(X, SE->getConstant(X->getType(), 0));
|
return SE->getSMaxExpr(X, SE->getZero(X->getType()));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// X^- = min(X, 0)
|
// X^- = min(X, 0)
|
||||||
const SCEV *DependenceAnalysis::getNegativePart(const SCEV *X) const {
|
const SCEV *DependenceAnalysis::getNegativePart(const SCEV *X) const {
|
||||||
return SE->getSMinExpr(X, SE->getConstant(X->getType(), 0));
|
return SE->getSMinExpr(X, SE->getZero(X->getType()));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@ -2892,7 +2888,7 @@ DependenceAnalysis::CoefficientInfo *
|
|||||||
DependenceAnalysis::collectCoeffInfo(const SCEV *Subscript,
|
DependenceAnalysis::collectCoeffInfo(const SCEV *Subscript,
|
||||||
bool SrcFlag,
|
bool SrcFlag,
|
||||||
const SCEV *&Constant) const {
|
const SCEV *&Constant) const {
|
||||||
const SCEV *Zero = SE->getConstant(Subscript->getType(), 0);
|
const SCEV *Zero = SE->getZero(Subscript->getType());
|
||||||
CoefficientInfo *CI = new CoefficientInfo[MaxLevels + 1];
|
CoefficientInfo *CI = new CoefficientInfo[MaxLevels + 1];
|
||||||
for (unsigned K = 1; K <= MaxLevels; ++K) {
|
for (unsigned K = 1; K <= MaxLevels; ++K) {
|
||||||
CI[K].Coeff = Zero;
|
CI[K].Coeff = Zero;
|
||||||
@ -2976,7 +2972,7 @@ const SCEV *DependenceAnalysis::findCoefficient(const SCEV *Expr,
|
|||||||
const Loop *TargetLoop) const {
|
const Loop *TargetLoop) const {
|
||||||
const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
|
const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Expr);
|
||||||
if (!AddRec)
|
if (!AddRec)
|
||||||
return SE->getConstant(Expr->getType(), 0);
|
return SE->getZero(Expr->getType());
|
||||||
if (AddRec->getLoop() == TargetLoop)
|
if (AddRec->getLoop() == TargetLoop)
|
||||||
return AddRec->getStepRecurrence(*SE);
|
return AddRec->getStepRecurrence(*SE);
|
||||||
return findCoefficient(AddRec->getStart(), TargetLoop);
|
return findCoefficient(AddRec->getStart(), TargetLoop);
|
||||||
|
@ -898,8 +898,8 @@ private:
|
|||||||
SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
|
SCEVDivision(ScalarEvolution &S, const SCEV *Numerator,
|
||||||
const SCEV *Denominator)
|
const SCEV *Denominator)
|
||||||
: SE(S), Denominator(Denominator) {
|
: SE(S), Denominator(Denominator) {
|
||||||
Zero = SE.getConstant(Denominator->getType(), 0);
|
Zero = SE.getZero(Denominator->getType());
|
||||||
One = SE.getConstant(Denominator->getType(), 1);
|
One = SE.getOne(Denominator->getType());
|
||||||
|
|
||||||
// We generally do not know how to divide Expr by Denominator. We
|
// We generally do not know how to divide Expr by Denominator. We
|
||||||
// initialize the division to a "cannot divide" state to simplify the rest
|
// initialize the division to a "cannot divide" state to simplify the rest
|
||||||
@ -1743,8 +1743,8 @@ const SCEV *ScalarEvolution::getSignExtendExpr(const SCEV *Op,
|
|||||||
if (C1.isStrictlyPositive() && C2.isStrictlyPositive() && C2.ugt(C1) &&
|
if (C1.isStrictlyPositive() && C2.isStrictlyPositive() && C2.ugt(C1) &&
|
||||||
C2.isPowerOf2()) {
|
C2.isPowerOf2()) {
|
||||||
Start = getSignExtendExpr(Start, Ty);
|
Start = getSignExtendExpr(Start, Ty);
|
||||||
const SCEV *NewAR = getAddRecExpr(getConstant(AR->getType(), 0), Step,
|
const SCEV *NewAR = getAddRecExpr(getZero(AR->getType()), Step, L,
|
||||||
L, AR->getNoWrapFlags());
|
AR->getNoWrapFlags());
|
||||||
return getAddExpr(Start, getSignExtendExpr(NewAR, Ty));
|
return getAddExpr(Start, getSignExtendExpr(NewAR, Ty));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -2120,7 +2120,7 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
|
|||||||
Ops.push_back(getMulExpr(getConstant(I->first),
|
Ops.push_back(getMulExpr(getConstant(I->first),
|
||||||
getAddExpr(I->second)));
|
getAddExpr(I->second)));
|
||||||
if (Ops.empty())
|
if (Ops.empty())
|
||||||
return getConstant(Ty, 0);
|
return getZero(Ty);
|
||||||
if (Ops.size() == 1)
|
if (Ops.size() == 1)
|
||||||
return Ops[0];
|
return Ops[0];
|
||||||
return getAddExpr(Ops);
|
return getAddExpr(Ops);
|
||||||
@ -2148,7 +2148,7 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
|
|||||||
MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
|
MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
|
||||||
InnerMul = getMulExpr(MulOps);
|
InnerMul = getMulExpr(MulOps);
|
||||||
}
|
}
|
||||||
const SCEV *One = getConstant(Ty, 1);
|
const SCEV *One = getOne(Ty);
|
||||||
const SCEV *AddOne = getAddExpr(One, InnerMul);
|
const SCEV *AddOne = getAddExpr(One, InnerMul);
|
||||||
const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
|
const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
|
||||||
if (Ops.size() == 2) return OuterMul;
|
if (Ops.size() == 2) return OuterMul;
|
||||||
@ -2540,7 +2540,7 @@ const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
|
|||||||
SmallVector<const SCEV*, 7> AddRecOps;
|
SmallVector<const SCEV*, 7> AddRecOps;
|
||||||
for (int x = 0, xe = AddRec->getNumOperands() +
|
for (int x = 0, xe = AddRec->getNumOperands() +
|
||||||
OtherAddRec->getNumOperands() - 1; x != xe && !Overflow; ++x) {
|
OtherAddRec->getNumOperands() - 1; x != xe && !Overflow; ++x) {
|
||||||
const SCEV *Term = getConstant(Ty, 0);
|
const SCEV *Term = getZero(Ty);
|
||||||
for (int y = x, ye = 2*x+1; y != ye && !Overflow; ++y) {
|
for (int y = x, ye = 2*x+1; y != ye && !Overflow; ++y) {
|
||||||
uint64_t Coeff1 = Choose(x, 2*x - y, Overflow);
|
uint64_t Coeff1 = Choose(x, 2*x - y, Overflow);
|
||||||
for (int z = std::max(y-x, y-(int)AddRec->getNumOperands()+1),
|
for (int z = std::max(y-x, y-(int)AddRec->getNumOperands()+1),
|
||||||
@ -2920,7 +2920,7 @@ ScalarEvolution::getGEPExpr(Type *PointeeType, const SCEV *BaseExpr,
|
|||||||
// adds.
|
// adds.
|
||||||
SCEV::NoWrapFlags Wrap = InBounds ? SCEV::FlagNSW : SCEV::FlagAnyWrap;
|
SCEV::NoWrapFlags Wrap = InBounds ? SCEV::FlagNSW : SCEV::FlagAnyWrap;
|
||||||
|
|
||||||
const SCEV *TotalOffset = getConstant(IntPtrTy, 0);
|
const SCEV *TotalOffset = getZero(IntPtrTy);
|
||||||
// The address space is unimportant. The first thing we do on CurTy is getting
|
// The address space is unimportant. The first thing we do on CurTy is getting
|
||||||
// its element type.
|
// its element type.
|
||||||
Type *CurTy = PointerType::getUnqual(PointeeType);
|
Type *CurTy = PointerType::getUnqual(PointeeType);
|
||||||
@ -3349,7 +3349,7 @@ const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
|
|||||||
SCEV::NoWrapFlags Flags) {
|
SCEV::NoWrapFlags Flags) {
|
||||||
// Fast path: X - X --> 0.
|
// Fast path: X - X --> 0.
|
||||||
if (LHS == RHS)
|
if (LHS == RHS)
|
||||||
return getConstant(LHS->getType(), 0);
|
return getZero(LHS->getType());
|
||||||
|
|
||||||
// We represent LHS - RHS as LHS + (-1)*RHS. This transformation
|
// We represent LHS - RHS as LHS + (-1)*RHS. This transformation
|
||||||
// makes it so that we cannot make much use of NUW.
|
// makes it so that we cannot make much use of NUW.
|
||||||
@ -4177,7 +4177,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
|
|||||||
else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
|
else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
|
||||||
return getConstant(CI);
|
return getConstant(CI);
|
||||||
else if (isa<ConstantPointerNull>(V))
|
else if (isa<ConstantPointerNull>(V))
|
||||||
return getConstant(V->getType(), 0);
|
return getZero(V->getType());
|
||||||
else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
|
else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
|
||||||
return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
|
return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
|
||||||
else
|
else
|
||||||
@ -4529,7 +4529,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
|
|||||||
if (getTypeSizeInBits(LHS->getType()) <=
|
if (getTypeSizeInBits(LHS->getType()) <=
|
||||||
getTypeSizeInBits(U->getType()) &&
|
getTypeSizeInBits(U->getType()) &&
|
||||||
isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
|
isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
|
||||||
const SCEV *One = getConstant(U->getType(), 1);
|
const SCEV *One = getOne(U->getType());
|
||||||
const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
|
const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
|
||||||
const SCEV *LA = getSCEV(U->getOperand(1));
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
||||||
const SCEV *RA = getSCEV(U->getOperand(2));
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
||||||
@ -4544,7 +4544,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
|
|||||||
if (getTypeSizeInBits(LHS->getType()) <=
|
if (getTypeSizeInBits(LHS->getType()) <=
|
||||||
getTypeSizeInBits(U->getType()) &&
|
getTypeSizeInBits(U->getType()) &&
|
||||||
isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
|
isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
|
||||||
const SCEV *One = getConstant(U->getType(), 1);
|
const SCEV *One = getOne(U->getType());
|
||||||
const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
|
const SCEV *LS = getNoopOrZeroExtend(getSCEV(LHS), U->getType());
|
||||||
const SCEV *LA = getSCEV(U->getOperand(1));
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
||||||
const SCEV *RA = getSCEV(U->getOperand(2));
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
||||||
@ -4641,8 +4641,7 @@ ScalarEvolution::getSmallConstantTripMultiple(Loop *L,
|
|||||||
return 1;
|
return 1;
|
||||||
|
|
||||||
// Get the trip count from the BE count by adding 1.
|
// Get the trip count from the BE count by adding 1.
|
||||||
const SCEV *TCMul = getAddExpr(ExitCount,
|
const SCEV *TCMul = getAddExpr(ExitCount, getOne(ExitCount->getType()));
|
||||||
getConstant(ExitCount->getType(), 1));
|
|
||||||
// FIXME: SCEV distributes multiplication as V1*C1 + V2*C1. We could attempt
|
// FIXME: SCEV distributes multiplication as V1*C1 + V2*C1. We could attempt
|
||||||
// to factor simple cases.
|
// to factor simple cases.
|
||||||
if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(TCMul))
|
if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(TCMul))
|
||||||
@ -5197,7 +5196,7 @@ ScalarEvolution::ComputeExitLimitFromCond(const Loop *L,
|
|||||||
return getCouldNotCompute();
|
return getCouldNotCompute();
|
||||||
else
|
else
|
||||||
// The backedge is never taken.
|
// The backedge is never taken.
|
||||||
return getConstant(CI->getType(), 0);
|
return getZero(CI->getType());
|
||||||
}
|
}
|
||||||
|
|
||||||
// If it's not an integer or pointer comparison then compute it the hard way.
|
// If it's not an integer or pointer comparison then compute it the hard way.
|
||||||
@ -6372,7 +6371,7 @@ ScalarEvolution::HowFarToNonZero(const SCEV *V, const Loop *L) {
|
|||||||
// already. If so, the backedge will execute zero times.
|
// already. If so, the backedge will execute zero times.
|
||||||
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
|
||||||
if (!C->getValue()->isNullValue())
|
if (!C->getValue()->isNullValue())
|
||||||
return getConstant(C->getType(), 0);
|
return getZero(C->getType());
|
||||||
return getCouldNotCompute(); // Otherwise it will loop infinitely.
|
return getCouldNotCompute(); // Otherwise it will loop infinitely.
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -7510,7 +7509,7 @@ bool ScalarEvolution::doesIVOverflowOnLT(const SCEV *RHS, const SCEV *Stride,
|
|||||||
if (NoWrap) return false;
|
if (NoWrap) return false;
|
||||||
|
|
||||||
unsigned BitWidth = getTypeSizeInBits(RHS->getType());
|
unsigned BitWidth = getTypeSizeInBits(RHS->getType());
|
||||||
const SCEV *One = getConstant(Stride->getType(), 1);
|
const SCEV *One = getOne(Stride->getType());
|
||||||
|
|
||||||
if (IsSigned) {
|
if (IsSigned) {
|
||||||
APInt MaxRHS = getSignedRange(RHS).getSignedMax();
|
APInt MaxRHS = getSignedRange(RHS).getSignedMax();
|
||||||
@ -7539,7 +7538,7 @@ bool ScalarEvolution::doesIVOverflowOnGT(const SCEV *RHS, const SCEV *Stride,
|
|||||||
if (NoWrap) return false;
|
if (NoWrap) return false;
|
||||||
|
|
||||||
unsigned BitWidth = getTypeSizeInBits(RHS->getType());
|
unsigned BitWidth = getTypeSizeInBits(RHS->getType());
|
||||||
const SCEV *One = getConstant(Stride->getType(), 1);
|
const SCEV *One = getOne(Stride->getType());
|
||||||
|
|
||||||
if (IsSigned) {
|
if (IsSigned) {
|
||||||
APInt MinRHS = getSignedRange(RHS).getSignedMin();
|
APInt MinRHS = getSignedRange(RHS).getSignedMin();
|
||||||
@ -7564,7 +7563,7 @@ bool ScalarEvolution::doesIVOverflowOnGT(const SCEV *RHS, const SCEV *Stride,
|
|||||||
// stride and presence of the equality in the comparison.
|
// stride and presence of the equality in the comparison.
|
||||||
const SCEV *ScalarEvolution::computeBECount(const SCEV *Delta, const SCEV *Step,
|
const SCEV *ScalarEvolution::computeBECount(const SCEV *Delta, const SCEV *Step,
|
||||||
bool Equality) {
|
bool Equality) {
|
||||||
const SCEV *One = getConstant(Step->getType(), 1);
|
const SCEV *One = getOne(Step->getType());
|
||||||
Delta = Equality ? getAddExpr(Delta, Step)
|
Delta = Equality ? getAddExpr(Delta, Step)
|
||||||
: getAddExpr(Delta, getMinusSCEV(Step, One));
|
: getAddExpr(Delta, getMinusSCEV(Step, One));
|
||||||
return getUDivExpr(Delta, Step);
|
return getUDivExpr(Delta, Step);
|
||||||
@ -7753,7 +7752,7 @@ const SCEV *SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
|
|||||||
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
|
||||||
if (!SC->getValue()->isZero()) {
|
if (!SC->getValue()->isZero()) {
|
||||||
SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
|
SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
|
||||||
Operands[0] = SE.getConstant(SC->getType(), 0);
|
Operands[0] = SE.getZero(SC->getType());
|
||||||
const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
|
const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
|
||||||
getNoWrapFlags(FlagNW));
|
getNoWrapFlags(FlagNW));
|
||||||
if (const SCEVAddRecExpr *ShiftedAddRec =
|
if (const SCEVAddRecExpr *ShiftedAddRec =
|
||||||
@ -7778,7 +7777,7 @@ const SCEV *SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
|
|||||||
// iteration exits.
|
// iteration exits.
|
||||||
unsigned BitWidth = SE.getTypeSizeInBits(getType());
|
unsigned BitWidth = SE.getTypeSizeInBits(getType());
|
||||||
if (!Range.contains(APInt(BitWidth, 0)))
|
if (!Range.contains(APInt(BitWidth, 0)))
|
||||||
return SE.getConstant(getType(), 0);
|
return SE.getZero(getType());
|
||||||
|
|
||||||
if (isAffine()) {
|
if (isAffine()) {
|
||||||
// If this is an affine expression then we have this situation:
|
// If this is an affine expression then we have this situation:
|
||||||
|
@ -546,7 +546,7 @@ bool PPCCTRLoops::convertToCTRLoop(Loop *L) {
|
|||||||
if (!ExitCount->getType()->isPointerTy() &&
|
if (!ExitCount->getType()->isPointerTy() &&
|
||||||
ExitCount->getType() != CountType)
|
ExitCount->getType() != CountType)
|
||||||
ExitCount = SE->getZeroExtendExpr(ExitCount, CountType);
|
ExitCount = SE->getZeroExtendExpr(ExitCount, CountType);
|
||||||
ExitCount = SE->getAddExpr(ExitCount, SE->getConstant(CountType, 1));
|
ExitCount = SE->getAddExpr(ExitCount, SE->getOne(CountType));
|
||||||
Value *ECValue =
|
Value *ECValue =
|
||||||
SCEVE.expandCodeFor(ExitCount, CountType, Preheader->getTerminator());
|
SCEVE.expandCodeFor(ExitCount, CountType, Preheader->getTerminator());
|
||||||
|
|
||||||
|
@ -270,7 +270,7 @@ bool AlignmentFromAssumptions::extractAlignmentInfo(CallInst *I,
|
|||||||
OffSCEV = nullptr;
|
OffSCEV = nullptr;
|
||||||
if (PtrToIntInst *PToI = dyn_cast<PtrToIntInst>(AndLHS)) {
|
if (PtrToIntInst *PToI = dyn_cast<PtrToIntInst>(AndLHS)) {
|
||||||
AAPtr = PToI->getPointerOperand();
|
AAPtr = PToI->getPointerOperand();
|
||||||
OffSCEV = SE->getConstant(Int64Ty, 0);
|
OffSCEV = SE->getZero(Int64Ty);
|
||||||
} else if (const SCEVAddExpr* AndLHSAddSCEV =
|
} else if (const SCEVAddExpr* AndLHSAddSCEV =
|
||||||
dyn_cast<SCEVAddExpr>(AndLHSSCEV)) {
|
dyn_cast<SCEVAddExpr>(AndLHSSCEV)) {
|
||||||
// Try to find the ptrtoint; subtract it and the rest is the offset.
|
// Try to find the ptrtoint; subtract it and the rest is the offset.
|
||||||
|
@ -1796,7 +1796,7 @@ LinearFunctionTestReplace(Loop *L,
|
|||||||
// This addition may overflow, which is valid as long as the comparison is
|
// This addition may overflow, which is valid as long as the comparison is
|
||||||
// truncated to BackedgeTakenCount->getType().
|
// truncated to BackedgeTakenCount->getType().
|
||||||
IVCount = SE->getAddExpr(BackedgeTakenCount,
|
IVCount = SE->getAddExpr(BackedgeTakenCount,
|
||||||
SE->getConstant(BackedgeTakenCount->getType(), 1));
|
SE->getOne(BackedgeTakenCount->getType()));
|
||||||
// The BackedgeTaken expression contains the number of times that the
|
// The BackedgeTaken expression contains the number of times that the
|
||||||
// backedge branches to the loop header. This is one less than the
|
// backedge branches to the loop header. This is one less than the
|
||||||
// number of times the loop executes, so use the incremented indvar.
|
// number of times the loop executes, so use the incremented indvar.
|
||||||
|
@ -531,7 +531,7 @@ bool LoopIdiomRecognize::processLoopStridedStore(
|
|||||||
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr);
|
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr);
|
||||||
|
|
||||||
const SCEV *NumBytesS =
|
const SCEV *NumBytesS =
|
||||||
SE->getAddExpr(BECount, SE->getConstant(IntPtr, 1), SCEV::FlagNUW);
|
SE->getAddExpr(BECount, SE->getOne(IntPtr), SCEV::FlagNUW);
|
||||||
if (StoreSize != 1) {
|
if (StoreSize != 1) {
|
||||||
NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtr, StoreSize),
|
NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtr, StoreSize),
|
||||||
SCEV::FlagNUW);
|
SCEV::FlagNUW);
|
||||||
@ -635,7 +635,7 @@ bool LoopIdiomRecognize::processLoopStoreOfLoopLoad(
|
|||||||
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtrTy);
|
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtrTy);
|
||||||
|
|
||||||
const SCEV *NumBytesS =
|
const SCEV *NumBytesS =
|
||||||
SE->getAddExpr(BECount, SE->getConstant(IntPtrTy, 1), SCEV::FlagNUW);
|
SE->getAddExpr(BECount, SE->getOne(IntPtrTy), SCEV::FlagNUW);
|
||||||
if (StoreSize != 1)
|
if (StoreSize != 1)
|
||||||
NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtrTy, StoreSize),
|
NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtrTy, StoreSize),
|
||||||
SCEV::FlagNUW);
|
SCEV::FlagNUW);
|
||||||
|
@ -1487,8 +1487,7 @@ bool LoopReroll::runOnLoop(Loop *L, LPPassManager &LPM) {
|
|||||||
return Changed;
|
return Changed;
|
||||||
|
|
||||||
const SCEV *LIBETC = SE->getBackedgeTakenCount(L);
|
const SCEV *LIBETC = SE->getBackedgeTakenCount(L);
|
||||||
const SCEV *IterCount =
|
const SCEV *IterCount = SE->getAddExpr(LIBETC, SE->getOne(LIBETC->getType()));
|
||||||
SE->getAddExpr(LIBETC, SE->getConstant(LIBETC->getType(), 1));
|
|
||||||
DEBUG(dbgs() << "LRR: iteration count = " << *IterCount << "\n");
|
DEBUG(dbgs() << "LRR: iteration count = " << *IterCount << "\n");
|
||||||
|
|
||||||
// First, we need to find the induction variable with respect to which we can
|
// First, we need to find the induction variable with respect to which we can
|
||||||
|
@ -524,7 +524,7 @@ void StraightLineStrengthReduce::allocateCandidatesAndFindBasisForGEP(
|
|||||||
continue;
|
continue;
|
||||||
|
|
||||||
const SCEV *OrigIndexExpr = IndexExprs[I - 1];
|
const SCEV *OrigIndexExpr = IndexExprs[I - 1];
|
||||||
IndexExprs[I - 1] = SE->getConstant(OrigIndexExpr->getType(), 0);
|
IndexExprs[I - 1] = SE->getZero(OrigIndexExpr->getType());
|
||||||
|
|
||||||
// The base of this candidate is GEP's base plus the offsets of all
|
// The base of this candidate is GEP's base plus the offsets of all
|
||||||
// indices except this current one.
|
// indices except this current one.
|
||||||
|
@ -253,8 +253,7 @@ void SimplifyIndvar::eliminateIVRemainder(BinaryOperator *Rem,
|
|||||||
Rem->replaceAllUsesWith(Rem->getOperand(0));
|
Rem->replaceAllUsesWith(Rem->getOperand(0));
|
||||||
else {
|
else {
|
||||||
// (i+1) % n --> (i+1)==n?0:(i+1) if i is in [0,n).
|
// (i+1) % n --> (i+1)==n?0:(i+1) if i is in [0,n).
|
||||||
const SCEV *LessOne =
|
const SCEV *LessOne = SE->getMinusSCEV(S, SE->getOne(S->getType()));
|
||||||
SE->getMinusSCEV(S, SE->getConstant(S->getType(), 1));
|
|
||||||
if (IsSigned && !SE->isKnownNonNegative(LessOne))
|
if (IsSigned && !SE->isKnownNonNegative(LessOne))
|
||||||
return;
|
return;
|
||||||
|
|
||||||
|
@ -2625,9 +2625,8 @@ Value *InnerLoopVectorizer::getOrCreateTripCount(Loop *L) {
|
|||||||
BackedgeTakenCount = SE->getNoopOrZeroExtend(BackedgeTakenCount, IdxTy);
|
BackedgeTakenCount = SE->getNoopOrZeroExtend(BackedgeTakenCount, IdxTy);
|
||||||
|
|
||||||
// Get the total trip count from the count by adding 1.
|
// Get the total trip count from the count by adding 1.
|
||||||
const SCEV *ExitCount =
|
const SCEV *ExitCount = SE->getAddExpr(
|
||||||
SE->getAddExpr(BackedgeTakenCount,
|
BackedgeTakenCount, SE->getOne(BackedgeTakenCount->getType()));
|
||||||
SE->getConstant(BackedgeTakenCount->getType(), 1));
|
|
||||||
|
|
||||||
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
|
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user