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

[SCEV] Introduce ScalarEvolution::getOne and getZero.

Browse Source 
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:
Sanjoy Das 2015-09-23 01:59:04 +00:00
parent cc79e4a6c7
commit c636db0b30
11 changed files with 55 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/Analysis/ScalarEvolution.h
View File

@ -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);

42
lib/Analysis/DependenceAnalysis.cpp
View File

@ -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);

41
lib/Analysis/ScalarEvolution.cpp
View File

@ -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:

2
lib/Target/PowerPC/PPCCTRLoops.cpp
View File

@ -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());

2
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
View File

@ -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.

2
lib/Transforms/Scalar/IndVarSimplify.cpp
View File

@ -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.

4
lib/Transforms/Scalar/LoopIdiomRecognize.cpp
View File

@ -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);

3
lib/Transforms/Scalar/LoopRerollPass.cpp
View File

@ -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

2
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp
View File

@ -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.

3
lib/Transforms/Utils/SimplifyIndVar.cpp
View File

@ -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;

5
lib/Transforms/Vectorize/LoopVectorize.cpp
View File

@ -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();