[llvm] [SCEV] Consolidate NoWrapFlags (NFC) (PR #214743)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 7 07:46:22 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Ramkumar Ramachandra (artagnon)
<details>
<summary>Changes</summary>
Eliminate IncrementWrapFlags, which is a poor copy of SCEV::NoWrapFlags where we eliminate NSSW = NSW, and add NUSW to the new structure, as it has different semantics. This initial patch has been kept simple, but has a clear rationale: all flags in the new SCEV::NoWrapFlags can be used in SCEVWrapPredicates. The next step is to eliminate the unclear SCEVWrapPredicates::getImpliedFlags and PSE::hasNoOverflow, both of whom have the sole LoopAccessAnalysis user.
---
Patch is 52.60 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/214743.diff
16 Files Affected:
- (modified) llvm/include/llvm/Analysis/ScalarEvolution.h (+33-63)
- (modified) llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h (+1-1)
- (modified) llvm/lib/Analysis/LoopAccessAnalysis.cpp (+3-4)
- (modified) llvm/lib/Analysis/ScalarEvolution.cpp (+78-90)
- (modified) llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp (+10-11)
- (modified) llvm/lib/Transforms/Utils/SimplifyIndVar.cpp (+2-4)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll (+1-1)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll (+12-12)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll (+4-4)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/wrapping-pointer-versioning.ll (+3-3)
- (modified) llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll (+3-3)
- (modified) llvm/test/Analysis/ScalarEvolution/ne-overflow.ll (+9-9)
- (modified) llvm/test/Analysis/ScalarEvolution/pr117133.ll (+3-3)
- (modified) llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll (+14-2)
- (modified) llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll (+3-3)
- (modified) llvm/unittests/Analysis/ScalarEvolutionTest.cpp (+4-6)
``````````diff
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 0d7f9ae298e2a..aa76f2d2d3ee7 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -108,14 +108,33 @@ LLVM_ABI extern bool VerifySCEV;
/// at runtime. A SCEV being defined does not require the existence of any
/// instruction within the defined scope.
enum class SCEVNoWrapFlags {
- FlagAnyWrap = 0, // No guarantee.
- FlagNW = (1 << 0), // No self-wrap.
- FlagNUW = (1 << 1), // No unsigned wrap.
- FlagNSW = (1 << 2), // No signed wrap.
- NoWrapMask = (1 << 3) - 1,
+ FlagAnyWrap = 0, // No guarantee.
+ FlagNW = (1 << 0), // No self-wrap.
+ FlagNUW = (1 << 1), // No unsigned wrap.
+ FlagNSW = (1 << 2), // No signed wrap.
+ FlagNUSW = (1 << 3), // No unsigned signed wrap.
+ NoWrapMask = (1 << 4) - 1,
LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/NoWrapMask)
};
+/// Convenient NoWrapFlags manipulation.
+[[nodiscard]] inline SCEVNoWrapFlags maskFlags(SCEVNoWrapFlags Flags,
+ SCEVNoWrapFlags Mask) {
+ return Flags & Mask;
+}
+[[nodiscard]] inline SCEVNoWrapFlags setFlags(SCEVNoWrapFlags Flags,
+ SCEVNoWrapFlags OnFlags) {
+ return Flags | OnFlags;
+}
+[[nodiscard]] inline SCEVNoWrapFlags clearFlags(SCEVNoWrapFlags Flags,
+ SCEVNoWrapFlags OffFlags) {
+ return Flags & ~OffFlags;
+}
+[[nodiscard]] inline bool hasFlags(SCEVNoWrapFlags Flags,
+ SCEVNoWrapFlags TestFlags) {
+ return TestFlags == maskFlags(Flags, TestFlags);
+}
+
class SCEV;
template <typename SCEVPtrT = const SCEV *>
@@ -278,6 +297,7 @@ class SCEV : public FoldingSetNode {
static constexpr auto FlagNW = SCEVNoWrapFlags::FlagNW;
static constexpr auto FlagNUW = SCEVNoWrapFlags::FlagNUW;
static constexpr auto FlagNSW = SCEVNoWrapFlags::FlagNSW;
+ static constexpr auto FlagNUSW = SCEVNoWrapFlags::FlagNUSW;
static constexpr auto NoWrapMask = SCEVNoWrapFlags::NoWrapMask;
explicit SCEV(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
@@ -510,50 +530,21 @@ class LLVM_ABI SCEVWrapPredicate final : public SCEVPredicate {
IncrementNoWrapMask = (1 << 2) - 1
};
- /// Convenient IncrementWrapFlags manipulation methods.
- [[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
- clearFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
- SCEVWrapPredicate::IncrementWrapFlags OffFlags) {
- assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
- assert((OffFlags & IncrementNoWrapMask) == OffFlags &&
- "Invalid flags value!");
- return (SCEVWrapPredicate::IncrementWrapFlags)(Flags & ~OffFlags);
- }
-
- [[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
- maskFlags(SCEVWrapPredicate::IncrementWrapFlags Flags, int Mask) {
- assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
- assert((Mask & IncrementNoWrapMask) == Mask && "Invalid mask value!");
-
- return (SCEVWrapPredicate::IncrementWrapFlags)(Flags & Mask);
- }
-
- [[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
- setFlags(SCEVWrapPredicate::IncrementWrapFlags Flags,
- SCEVWrapPredicate::IncrementWrapFlags OnFlags) {
- assert((Flags & IncrementNoWrapMask) == Flags && "Invalid flags value!");
- assert((OnFlags & IncrementNoWrapMask) == OnFlags &&
- "Invalid flags value!");
-
- return (SCEVWrapPredicate::IncrementWrapFlags)(Flags | OnFlags);
- }
-
/// Returns the set of SCEVWrapPredicate no wrap flags implied by a
/// SCEVAddRecExpr.
- [[nodiscard]] static SCEVWrapPredicate::IncrementWrapFlags
- getImpliedFlags(const SCEVAddRecExpr *AR, ScalarEvolution &SE);
+ [[nodiscard]] static SCEVNoWrapFlags getImpliedFlags(const SCEVAddRecExpr *AR,
+ ScalarEvolution &SE);
private:
const SCEVAddRecExpr *AR;
- IncrementWrapFlags Flags;
+ SCEVNoWrapFlags Flags;
public:
explicit SCEVWrapPredicate(const FoldingSetNodeIDRef ID,
- const SCEVAddRecExpr *AR,
- IncrementWrapFlags Flags);
+ const SCEVAddRecExpr *AR, SCEVNoWrapFlags Flags);
/// Returns the set assumed no overflow flags.
- IncrementWrapFlags getFlags() const { return Flags; }
+ SCEVNoWrapFlags getFlags() const { return Flags; }
/// Implementation of the SCEVPredicate interface
const SCEVAddRecExpr *getExpr() const;
@@ -636,25 +627,6 @@ class ScalarEvolution {
ProperlyDominatesBlock ///< The SCEV properly dominates the block.
};
- /// Convenient NoWrapFlags manipulation. TODO: Replace with & operator of
- /// enum class.
- [[nodiscard]] static SCEV::NoWrapFlags maskFlags(SCEV::NoWrapFlags Flags,
- SCEV::NoWrapFlags Mask) {
- return Flags & Mask;
- }
- [[nodiscard]] static SCEV::NoWrapFlags setFlags(SCEV::NoWrapFlags Flags,
- SCEV::NoWrapFlags OnFlags) {
- return Flags | OnFlags;
- }
- [[nodiscard]] static SCEV::NoWrapFlags
- clearFlags(SCEV::NoWrapFlags Flags, SCEV::NoWrapFlags OffFlags) {
- return Flags & ~OffFlags;
- }
- [[nodiscard]] static bool hasFlags(SCEV::NoWrapFlags Flags,
- SCEV::NoWrapFlags TestFlags) {
- return TestFlags == maskFlags(Flags, TestFlags);
- };
-
LLVM_ABI ScalarEvolution(Function &F, TargetLibraryInfo &TLI,
AssumptionCache &AC, DominatorTree &DT,
LoopInfo &LI);
@@ -1520,9 +1492,8 @@ class ScalarEvolution {
const SCEV *LHS,
const SCEV *RHS);
- LLVM_ABI const SCEVPredicate *
- getWrapPredicate(const SCEVAddRecExpr *AR,
- SCEVWrapPredicate::IncrementWrapFlags AddedFlags);
+ LLVM_ABI const SCEVPredicate *getWrapPredicate(const SCEVAddRecExpr *AR,
+ SCEVNoWrapFlags AddedFlags);
/// Re-writes the SCEV according to the Predicates in \p A.
LLVM_ABI const SCEV *rewriteUsingPredicate(const SCEV *S, const Loop *L,
@@ -2674,8 +2645,7 @@ class PredicatedScalarEvolution {
SmallVectorImpl<const SCEVPredicate *> *WrapPredsAdded = nullptr);
/// Returns true if we've statically proved that V doesn't wrap.
- LLVM_ABI bool hasNoOverflow(Value *V,
- SCEVWrapPredicate::IncrementWrapFlags Flags);
+ LLVM_ABI bool hasNoOverflow(Value *V, SCEVNoWrapFlags Flags);
/// Returns the ScalarEvolution analysis used.
ScalarEvolution *getSE() const { return &SE; }
diff --git a/llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h b/llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h
index ebee63963c701..67de6d4bb3911 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -371,7 +371,7 @@ class SCEVAddRecExpr : public SCEVNAryExpr {
/// to make it easier to propagate flags.
void setNoWrapFlags(NoWrapFlags Flags) {
if (any(Flags & (FlagNUW | FlagNSW)))
- Flags = ScalarEvolution::setFlags(Flags, FlagNW);
+ Flags = setFlags(Flags, FlagNW);
SubclassData |= static_cast<unsigned short>(Flags);
}
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index e248b22de7d43..31ca9e28c0ff6 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -1041,7 +1041,7 @@ isNoWrap(PredicatedScalarEvolution &PSE, const SCEVAddRecExpr *AR, Value *Ptr,
if (any(AR->getNoWrapFlags(SCEV::NoWrapMask)))
return true;
- if (Ptr && PSE.hasNoOverflow(Ptr, SCEVWrapPredicate::IncrementNUSW))
+ if (Ptr && PSE.hasNoOverflow(Ptr, SCEV::FlagNUSW))
return true;
// An nusw getelementptr that is an AddRec cannot wrap. If it would wrap,
@@ -1079,9 +1079,8 @@ isNoWrap(PredicatedScalarEvolution &PSE, const SCEVAddRecExpr *AR, Value *Ptr,
if (Ptr && Predicates) {
ScalarEvolution &SE = *PSE.getSE();
- SCEVWrapPredicate::IncrementWrapFlags Flags = SCEVWrapPredicate::clearFlags(
- SCEVWrapPredicate::IncrementNUSW,
- SCEVWrapPredicate::getImpliedFlags(AR, SE));
+ SCEVNoWrapFlags Flags =
+ clearFlags(SCEV::FlagNUSW, SCEVWrapPredicate::getImpliedFlags(AR, SE));
Predicates->push_back(SE.getWrapPredicate(AR, Flags));
LLVM_DEBUG(dbgs() << "LAA: Pointer may wrap:\n"
<< "LAA: Pointer: " << *Ptr << "\n"
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 27a1a20bcdf79..9604ddae11d8e 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -1382,8 +1382,7 @@ static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
// `Step`:
// 1. NSW/NUW flags on the step increment.
- auto PreStartFlags =
- ScalarEvolution::maskFlags(SA->getNoWrapFlags(), SCEV::FlagNUW);
+ auto PreStartFlags = maskFlags(SA->getNoWrapFlags(), SCEV::FlagNUW);
const SCEV *PreStart = SE->getAddExpr(DiffOps, PreStartFlags);
const SCEVAddRecExpr *PreAR = dyn_cast<SCEVAddRecExpr>(
SE->getAddRecExpr(PreStart, Step, L, SCEV::FlagAnyWrap));
@@ -2427,9 +2426,9 @@ ScalarEvolution::getStrengthenedNoWrapFlagsFromBinOp(
SCEV::NoWrapFlags Flags = SCEV::NoWrapFlags::FlagAnyWrap;
if (OBO->hasNoUnsignedWrap())
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
if (OBO->hasNoSignedWrap())
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
+ Flags = setFlags(Flags, SCEV::FlagNSW);
bool Deduced = false;
@@ -2458,13 +2457,13 @@ ScalarEvolution::getStrengthenedNoWrapFlagsFromBinOp(
UseContextForNoWrapFlagInference ? dyn_cast<Instruction>(OBO) : nullptr;
if (!OBO->hasNoUnsignedWrap() &&
willNotOverflow(Opcode, /* Signed */ false, LHS, RHS, CtxI)) {
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
Deduced = true;
}
if (CanUseNSW && !OBO->hasNoSignedWrap() &&
willNotOverflow(Opcode, /* Signed */ true, LHS, RHS, CtxI)) {
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
+ Flags = setFlags(Flags, SCEV::FlagNSW);
Deduced = true;
}
@@ -2490,8 +2489,7 @@ static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE,
assert(CanAnalyze && "don't call from other places!");
SCEV::NoWrapFlags SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
- SCEV::NoWrapFlags SignOrUnsignWrap =
- ScalarEvolution::maskFlags(Flags, SignOrUnsignMask);
+ SCEV::NoWrapFlags SignOrUnsignWrap = maskFlags(Flags, SignOrUnsignMask);
// If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
auto IsKnownNonNegative = [&](SCEVUse U) {
@@ -2499,9 +2497,9 @@ static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE,
};
if (SignOrUnsignWrap == SCEV::FlagNSW && all_of(Ops, IsKnownNonNegative))
- Flags = ScalarEvolution::setFlags(Flags, SignOrUnsignMask);
+ Flags = setFlags(Flags, SignOrUnsignMask);
- SignOrUnsignWrap = ScalarEvolution::maskFlags(Flags, SignOrUnsignMask);
+ SignOrUnsignWrap = maskFlags(Flags, SignOrUnsignMask);
if (SignOrUnsignWrap != SignOrUnsignMask &&
(Type == scAddExpr || Type == scMulExpr) && Ops.size() == 2 &&
@@ -2525,7 +2523,7 @@ static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE,
auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
Opcode, C, OBO::NoSignedWrap);
if (NSWRegion.contains(SE->getSignedRange(Ops[1])))
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
+ Flags = setFlags(Flags, SCEV::FlagNSW);
}
// (A <opcode> C) --> (A <opcode> C)<nuw> if the op doesn't unsign overflow.
@@ -2533,26 +2531,25 @@ static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE,
auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
Opcode, C, OBO::NoUnsignedWrap);
if (NUWRegion.contains(SE->getUnsignedRange(Ops[1])))
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
}
}
// <0,+,nonnegative><nw> is also nuw
// TODO: Add corresponding nsw case
- if (Type == scAddRecExpr && ScalarEvolution::hasFlags(Flags, SCEV::FlagNW) &&
- !ScalarEvolution::hasFlags(Flags, SCEV::FlagNUW) && Ops.size() == 2 &&
- Ops[0]->isZero() && IsKnownNonNegative(Ops[1]))
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ if (Type == scAddRecExpr && hasFlags(Flags, SCEV::FlagNW) &&
+ !hasFlags(Flags, SCEV::FlagNUW) && Ops.size() == 2 && Ops[0]->isZero() &&
+ IsKnownNonNegative(Ops[1]))
+ Flags = setFlags(Flags, SCEV::FlagNUW);
// both (udiv X, Y) * Y and Y * (udiv X, Y) are always NUW
- if (Type == scMulExpr && !ScalarEvolution::hasFlags(Flags, SCEV::FlagNUW) &&
- Ops.size() == 2) {
+ if (Type == scMulExpr && !hasFlags(Flags, SCEV::FlagNUW) && Ops.size() == 2) {
if (auto *UDiv = dyn_cast<SCEVUDivExpr>(Ops[0]))
if (UDiv->getOperand(1) == Ops[1])
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
if (auto *UDiv = dyn_cast<SCEVUDivExpr>(Ops[1]))
if (UDiv->getOperand(1) == Ops[0])
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
}
return Flags;
@@ -2712,19 +2709,16 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
APInt ConstAdd = C1 + C2;
auto AddFlags = AddExpr->getNoWrapFlags();
// Adding a smaller constant is NUW if the original AddExpr was NUW.
- if (ScalarEvolution::hasFlags(AddFlags, SCEV::FlagNUW) &&
- ConstAdd.ule(C1)) {
- PreservedFlags =
- ScalarEvolution::setFlags(PreservedFlags, SCEV::FlagNUW);
+ if (hasFlags(AddFlags, SCEV::FlagNUW) && ConstAdd.ule(C1)) {
+ PreservedFlags = setFlags(PreservedFlags, SCEV::FlagNUW);
}
// Adding a constant with the same sign and small magnitude is NSW, if the
// original AddExpr was NSW.
- if (ScalarEvolution::hasFlags(AddFlags, SCEV::FlagNSW) &&
+ if (hasFlags(AddFlags, SCEV::FlagNSW) &&
C1.isSignBitSet() == ConstAdd.isSignBitSet() &&
ConstAdd.abs().ule(C1.abs())) {
- PreservedFlags =
- ScalarEvolution::setFlags(PreservedFlags, SCEV::FlagNSW);
+ PreservedFlags = setFlags(PreservedFlags, SCEV::FlagNSW);
}
if (PreservedFlags != SCEV::FlagAnyWrap) {
@@ -5507,9 +5501,10 @@ static const Loop *isIntegerLoopHeaderPHI(const PHINode *PN, LoopInfo &LI) {
// will return the pair {NewAddRec, SmallPredsVec} where:
// NewAddRec = {%Start,+,%Step}
// SmallPredsVec = {P1, P2, P3} as follows:
-// P1(WrapPred): AR: {trunc(%Start),+,(trunc %Step)}<nsw> Flags: <nssw>
-// P2(EqualPred): %Start == (sext i32 (trunc i64 %Start to i32) to i64)
-// P3(EqualPred): %Step == (sext i32 (trunc i64 %Step to i32) to i64)
+// P1(WrapPred): AR: {trunc(%Start),+,(trunc %Step)}<nsw> Flags: <nsw>
+// P2(EqualPred): %Start == (sext i32 (trunc i64 %Start to i32) to
+// i64) P3(EqualPred): %Step == (sext i32 (trunc i64 %Step to i32) to
+// i64)
// The returned pair means that SymbolicPHI can be rewritten into NewAddRec
// under the predicates {P1,P2,P3}.
// This predicated rewrite will be cached in PredicatedSCEVRewrites:
@@ -5671,9 +5666,7 @@ ScalarEvolution::createAddRecFromPHIWithCastsImpl(const SCEVUnknown *SymbolicPHI
// If PHISCEV is a constant, then P1 degenerates into P2 or P3, so we don't
// add P1.
if (const auto *AR = dyn_cast<SCEVAddRecExpr>(PHISCEV)) {
- SCEVWrapPredicate::IncrementWrapFlags AddedFlags =
- Signed ? SCEVWrapPredicate::IncrementNSSW
- : SCEVWrapPredicate::IncrementNUSW;
+ SCEVNoWrapFlags AddedFlags = Signed ? SCEV::FlagNSW : SCEV::FlagNUSW;
const SCEVPredicate *AddRecPred = getWrapPredicate(AR, AddedFlags);
Predicates.push_back(AddRecPred);
}
@@ -5715,7 +5708,7 @@ ScalarEvolution::createAddRecFromPHIWithCastsImpl(const SCEVUnknown *SymbolicPHI
}
// The Step is always Signed (because the overflow checks are either
- // NSSW or NUSW)
+ // NSW or NUSW)
const SCEV *AccumExtended = getExtendedExpr(Accum, /*CreateSignExtend=*/true);
if (PredIsKnownFalse(Accum, AccumExtended)) {
LLVM_DEBUG(dbgs() << "P3 is compile-time false\n";);
@@ -7226,9 +7219,9 @@ ScalarEvolution::getRangeForAffineAR(const SCEV *Start, const SCEV *Step,
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
if (NUW)
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
if (NSW1 && NSW2)
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
+ Flags = setFlags(Flags, SCEV::FlagNSW);
// Finally, intersect signed and unsigned ranges.
return {SR.intersectWith(UR, ConstantRange::Smallest), Flags};
@@ -7424,12 +7417,12 @@ SCEV::NoWrapFlags ScalarEvolution::getNoWrapFlagsFromUB(const Value *V) {
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
if (auto *PDI = dyn_cast<PossiblyDisjointInst>(BinOp);
PDI && PDI->isDisjoint()) {
- Flags = ScalarEvolution::setFlags(SCEV::FlagNUW, SCEV::FlagNSW);
+ Flags = setFlags(SCEV::FlagNUW, SCEV::FlagNSW);
} else {
if (BinOp->hasNoUnsignedWrap())
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ Flags = setFlags(Flags, SCEV::FlagNUW);
if (BinOp->hasNoSignedWrap())
- Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
+ Flags = setFlags(Flags, SCEV::FlagNSW);
}
if (Flags == SCEV::FlagAnyWrap)
return SCEV::FlagAnyWrap;
@@ -15204,14 +15197,14 @@ ScalarEvolution::getComparePredicate(const ICmpInst::Predicate Pred,
return Eq;
}
-const SCEVPredicate *ScalarEvolution::getWrapPredicate(
- const SCEVAddRecExpr *AR,
- SCEVWrapPredicate::IncrementWrapFlags AddedFlags) {
+const SCEVPredicate *
+ScalarEvolution::getWrapPredicate(const SCEVAddRecExpr *AR,
+ SCEVNoWrapFlags AddedFlags) {
FoldingSetNodeID ID;
// Unique this node based on the arguments
ID.AddInteger(SCEVPredicate::P_Wrap);
ID.AddPointer(AR);
- ID.AddInteger(AddedFlags);
+ ID.AddInteger(static_cast<int>(AddedFlags));
void *IP = nullptr;
if (const auto *S = UniquePreds.FindNodeOrInsertPos(ID, IP))
return S;
@@ -15266,7 +15259,7 @@ class SCEVPredicateRewriter : public SCEVRewriteVisitor<SCEVPredicateRewriter> {
// flag. Add the nusw flag as an assumption that we could make.
const SCEV *Step = AR->getStepRecurrence(SE);
Type *Ty = Expr->getType();
- if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNUSW))
+ if (addOverflowAssumption(AR, SCEV::FlagNUSW))
return SE.getAddRecExpr(SE.getZeroExtendExpr(AR->getStart(), Ty),
SE.getSignExtendExpr(Step, Ty), L,
AR->getNoWrapFlags());
@@ -15279,10 +15272,10 @@ class SCEVPredicateRewriter : public SCEVRewriteVisitor<SCEVPredicateRewriter> {
const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Operand);
if (AR && AR->getLoop() == L && AR->isAffine()) {
// This couldn't be folded because the operand didn't have the nsw
- // flag. Add the nssw flag as an assumption that we could make.
+ // flag. Add the nsw flag as an assumption that we could make.
const SCEV *Step = AR->getStepRecurrence(SE);
Type *Ty = Expr->getType();
- if (addOverflowAssumption(AR, SCEVWrapPredicate::IncrementNSSW))
+ if (addOverflowAssumption(AR, SCEV::FlagNSW))
return SE.getAddRecExpr(SE.getSignExtendExpr(AR->getStart(), Ty),
SE.getSignExtendExpr(Step, Ty), L,
AR->getNoWrapFlags());
@@ -15307,7 +15300,7 @@ class SCEVPredicateRewriter : public SCEVRewriteVisitor<SCEVPredicateRewriter> {...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/214743
More information about the llvm-commits
mailing list