[llvm] [SCEV] Return a SCEVUse from getAddExpr and propagate use flags. (PR #220007)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 31 08:37:34 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-powerpc
Author: Florian Hahn (fhahn)
<details>
<summary>Changes</summary>
Add option to pass SCEVUse-specific flags to getAddExpr and propagate them through, if valid conservatively. That is, the final expression adds the same operands (potentially in different order). For example, it is not valid to propagate the use flags if other (sub-)expressions have been inlined.
It also includes a few mechanical changes, to update users that still expected const SCEV *.
This slightly simplifies https://github.com/llvm/llvm-project/pull/217378, which introduces the first end-to-end user of SCEVUse.
---
Full diff: https://github.com/llvm/llvm-project/pull/220007.diff
8 Files Affected:
- (modified) llvm/include/llvm/Analysis/ScalarEvolution.h (+14-11)
- (modified) llvm/lib/Analysis/LoopAccessAnalysis.cpp (+2-1)
- (modified) llvm/lib/Analysis/ScalarEvolution.cpp (+41-26)
- (modified) llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp (+1)
- (modified) llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp (+14-17)
- (modified) llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp (+5-5)
- (modified) llvm/lib/Transforms/Vectorize/VPlanUtils.cpp (+1-1)
- (modified) llvm/unittests/Analysis/ScalarEvolutionTest.cpp (+78)
``````````diff
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index f31475dca4686..270f6cf791150 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -752,20 +752,23 @@ class ScalarEvolution {
LLVM_ABI const SCEV *getCastExpr(SCEVTypes Kind, SCEVUse Op, Type *Ty);
LLVM_ABI const SCEV *getAnyExtendExpr(SCEVUse Op, Type *Ty);
- LLVM_ABI const SCEV *getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
- SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
- unsigned Depth = 0);
- const SCEV *getAddExpr(SCEVUse LHS, SCEVUse RHS,
- SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
- unsigned Depth = 0) {
+ LLVM_ABI SCEVUse getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
+ SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
+ unsigned Depth = 0,
+ SCEV::NoWrapFlags UseFlags = SCEV::FlagAnyWrap);
+ SCEVUse getAddExpr(SCEVUse LHS, SCEVUse RHS,
+ SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
+ unsigned Depth = 0,
+ SCEV::NoWrapFlags UseFlags = SCEV::FlagAnyWrap) {
SmallVector<SCEVUse, 2> Ops = {LHS, RHS};
- return getAddExpr(Ops, Flags, Depth);
+ return getAddExpr(Ops, Flags, Depth, UseFlags);
}
- const SCEV *getAddExpr(SCEVUse Op0, SCEVUse Op1, SCEVUse Op2,
- SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
- unsigned Depth = 0) {
+ SCEVUse getAddExpr(SCEVUse Op0, SCEVUse Op1, SCEVUse Op2,
+ SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
+ unsigned Depth = 0,
+ SCEV::NoWrapFlags UseFlags = SCEV::FlagAnyWrap) {
SmallVector<SCEVUse, 3> Ops = {Op0, Op1, Op2};
- return getAddExpr(Ops, Flags, Depth);
+ return getAddExpr(Ops, Flags, Depth, UseFlags);
}
LLVM_ABI const SCEV *getMulExpr(SmallVectorImpl<SCEVUse> &Ops,
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap,
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index 3d763a452267e..20ec58d320efe 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -1150,7 +1150,8 @@ static void findForkedSCEVs(
return get<1>(S);
};
- auto GetBinOpExpr = [&SE](unsigned Opcode, const SCEV *L, const SCEV *R) {
+ auto GetBinOpExpr = [&SE](unsigned Opcode, const SCEV *L,
+ const SCEV *R) -> const SCEV * {
switch (Opcode) {
case Instruction::Add:
return SE->getAddExpr(L, R);
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 2fd8b9a2eb4fd..a50774d2d91ea 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -2285,21 +2285,18 @@ static bool CollectAddOperandsWithScales(SmallDenseMap<SCEVUse, APInt, 16> &M,
bool ScalarEvolution::willNotOverflow(Instruction::BinaryOps BinOp, bool Signed,
const SCEV *LHS, const SCEV *RHS,
const Instruction *CtxI) {
- const SCEV *(ScalarEvolution::*Operation)(SCEVUse, SCEVUse, SCEV::NoWrapFlags,
- unsigned);
- switch (BinOp) {
- default:
- llvm_unreachable("Unsupported binary op");
- case Instruction::Add:
- Operation = &ScalarEvolution::getAddExpr;
- break;
- case Instruction::Sub:
- Operation = &ScalarEvolution::getMinusSCEV;
- break;
- case Instruction::Mul:
- Operation = &ScalarEvolution::getMulExpr;
- break;
- }
+ auto Operation = [this, BinOp](SCEVUse L, SCEVUse R) -> const SCEV * {
+ switch (BinOp) {
+ default:
+ llvm_unreachable("Unsupported binary op");
+ case Instruction::Add:
+ return getAddExpr(L, R);
+ case Instruction::Sub:
+ return getMinusSCEV(L, R);
+ case Instruction::Mul:
+ return getMulExpr(L, R);
+ }
+ };
const SCEV *(ScalarEvolution::*Extension)(SCEVUse, Type *, unsigned) =
Signed ? &ScalarEvolution::getSignExtendExpr
@@ -2310,11 +2307,10 @@ bool ScalarEvolution::willNotOverflow(Instruction::BinaryOps BinOp, bool Signed,
auto *WideTy =
IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2);
- const SCEV *A = (this->*Extension)(
- (this->*Operation)(LHS, RHS, SCEV::FlagAnyWrap, 0), WideTy, 0);
+ const SCEV *A = (this->*Extension)(Operation(LHS, RHS), WideTy, 0);
const SCEV *LHSB = (this->*Extension)(LHS, WideTy, 0);
const SCEV *RHSB = (this->*Extension)(RHS, WideTy, 0);
- const SCEV *B = (this->*Operation)(LHSB, RHSB, SCEV::FlagAnyWrap, 0);
+ const SCEV *B = Operation(LHSB, RHSB);
if (A == B)
return true;
// Can we use context to prove the fact we need?
@@ -2504,11 +2500,13 @@ bool ScalarEvolution::isAvailableAtLoopEntry(const SCEV *S, const Loop *L) {
}
/// Get a canonical add expression, or something simpler if possible.
-const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
- SCEV::NoWrapFlags OrigFlags,
- unsigned Depth) {
+SCEVUse ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
+ SCEV::NoWrapFlags OrigFlags, unsigned Depth,
+ SCEV::NoWrapFlags UseFlags) {
assert(!(OrigFlags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
"only nuw or nsw allowed");
+ assert(!(UseFlags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
+ "only nuw or nsw allowed");
assert(!Ops.empty() && "Cannot get empty add!");
if (Ops.size() == 1) return Ops[0];
#ifndef NDEBUG
@@ -2520,6 +2518,10 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
Ops, [](const SCEV *Op) { return Op->getType()->isPointerTy(); });
assert(NumPtrs <= 1 && "add has at most one pointer operand");
#endif
+ // Keep track of original ops, if use-specific flags have been provided.
+ SmallVector<SCEVUse, 8> OrigOps;
+ if (UseFlags != SCEV::FlagAnyWrap)
+ OrigOps.assign(Ops.begin(), Ops.end());
const SCEV *Folded = constantFoldAndGroupOps(
*this, LI, DT, Ops,
@@ -2529,6 +2531,15 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
if (Folded)
return Folded;
+ // Conservatively drop use-specific flags if operands changed after constant
+ // folding, i.e. we are building a different expression than the initial one,
+ // for which the use-specific flags hold.
+ // TODO: In some cases, this is overly conservative.
+ if (UseFlags != SCEV::FlagAnyWrap &&
+ !std::is_permutation(OrigOps.begin(), OrigOps.end(), Ops.begin(),
+ Ops.end()))
+ UseFlags = SCEV::FlagAnyWrap;
+
unsigned Idx = isa<SCEVConstant>(Ops[0]) ? 1 : 0;
// Delay expensive flag strengthening until necessary.
@@ -2538,14 +2549,14 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
// Limit recursion calls depth.
if (Depth > MaxArithDepth || hasHugeExpression(Ops))
- return getOrCreateAddExpr(Ops, ComputeFlags(Ops));
+ return {getOrCreateAddExpr(Ops, ComputeFlags(Ops)), UseFlags};
if (SCEV *S = findExistingSCEVInCache(scAddExpr, Ops)) {
// Don't strengthen flags if we have no new information.
SCEVAddExpr *Add = static_cast<SCEVAddExpr *>(S);
if (Add->getNoWrapFlags(OrigFlags) != OrigFlags)
Add->setNoWrapFlags(ComputeFlags(Ops));
- return S;
+ return {S, UseFlags};
}
// Okay, check to see if the same value occurs in the operand list more than
@@ -2967,7 +2978,11 @@ const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<SCEVUse> &Ops,
// Okay, it looks like we really DO need an add expr. Check to see if we
// already have one, otherwise create a new one.
- return getOrCreateAddExpr(Ops, ComputeFlags(Ops));
+ assert((UseFlags == SCEV::FlagAnyWrap ||
+ std::is_permutation(OrigOps.begin(), OrigOps.end(), Ops.begin(),
+ Ops.end())) &&
+ "Tried to add SCEVUse flags after operands changed");
+ return {getOrCreateAddExpr(Ops, ComputeFlags(Ops)), UseFlags};
}
const SCEV *ScalarEvolution::getOrCreateAddExpr(ArrayRef<SCEVUse> Ops,
@@ -3820,7 +3835,7 @@ const SCEV *ScalarEvolution::getGEPExpr(SCEVUse BaseExpr,
bool NUW = NW.hasNoUnsignedWrap() ||
(NW.hasNoUnsignedSignedWrap() && isKnownNonNegative(Offset));
SCEV::NoWrapFlags BaseWrap = NUW ? SCEV::FlagNUW : SCEV::FlagAnyWrap;
- auto *GEPExpr = getAddExpr(BaseExpr, Offset, BaseWrap);
+ const SCEV *GEPExpr = getAddExpr(BaseExpr, Offset, BaseWrap);
assert(BaseExpr->getType() == GEPExpr->getType() &&
"GEP should not change type mid-flight.");
return GEPExpr;
@@ -13614,7 +13629,7 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS,
//
// FIXME: Should isLoopEntryGuardedByCond do this for us?
auto CondGT = IsSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
- auto *StartMinusOne =
+ const SCEV *StartMinusOne =
getAddExpr(OrigStart, getMinusOne(OrigStart->getType()));
return isLoopEntryGuardedByCond(L, CondGT, OrigRHS, StartMinusOne);
};
diff --git a/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp b/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp
index c8f96bf6f3044..ea8de04d6c222 100644
--- a/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp
+++ b/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp
@@ -553,6 +553,7 @@ bool PPCLoopInstrFormPrep::rewriteLoadStoresForCommoningChains(
const SCEV *BaseSCEV =
ChainIdx ? SE->getAddExpr(Bucket.BaseSCEV,
Bucket.Elements[BaseElemIdx].Offset)
+ .getPointer()
: Bucket.BaseSCEV;
const SCEVAddRecExpr *BasePtrSCEV = cast<SCEVAddRecExpr>(BaseSCEV);
diff --git a/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp b/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
index 6d2af61de000f..6d4d16825e6fc 100644
--- a/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
@@ -425,22 +425,20 @@ bool InductiveRangeCheck::reassociateSubLHS(
auto getExprScaledIfOverflow = [&](Instruction::BinaryOps BinOp,
const SCEV *LHS,
const SCEV *RHS) -> const SCEV * {
- const SCEV *(ScalarEvolution::*Operation)(SCEVUse, SCEVUse,
- SCEV::NoWrapFlags, unsigned);
- switch (BinOp) {
- default:
- llvm_unreachable("Unsupported binary op");
- case Instruction::Add:
- Operation = &ScalarEvolution::getAddExpr;
- break;
- case Instruction::Sub:
- Operation = &ScalarEvolution::getMinusSCEV;
- break;
- }
+ auto Operation = [&SE, BinOp](SCEVUse L, SCEVUse R) -> const SCEV * {
+ switch (BinOp) {
+ default:
+ llvm_unreachable("Unsupported binary op");
+ case Instruction::Add:
+ return SE.getAddExpr(L, R);
+ case Instruction::Sub:
+ return SE.getMinusSCEV(L, R);
+ }
+ };
if (SE.willNotOverflow(BinOp, ICmpInst::isSigned(Pred), LHS, RHS,
cast<Instruction>(VariantLHS)))
- return (SE.*Operation)(LHS, RHS, SCEV::FlagAnyWrap, 0);
+ return Operation(LHS, RHS);
// We couldn't prove that the expression does not overflow.
// Than scale it to a wider type to check overflow at runtime.
@@ -449,9 +447,8 @@ bool InductiveRangeCheck::reassociateSubLHS(
return nullptr;
auto WideTy = IntegerType::get(Ty->getContext(), Ty->getBitWidth() * 2);
- return (SE.*Operation)(SE.getSignExtendExpr(LHS, WideTy),
- SE.getSignExtendExpr(RHS, WideTy), SCEV::FlagAnyWrap,
- 0);
+ return Operation(SE.getSignExtendExpr(LHS, WideTy),
+ SE.getSignExtendExpr(RHS, WideTy));
};
if (OffsetSubtracted)
@@ -767,7 +764,7 @@ InductiveRangeCheck::computeSafeIterationSpace(ScalarEvolution &SE,
const SCEV *Zero = SE.getZero(M->getType());
// This function returns SCEV equal to 1 if X is non-negative 0 otherwise.
- auto SCEVCheckNonNegative = [&](const SCEV *X) {
+ auto SCEVCheckNonNegative = [&](const SCEV *X) -> const SCEV * {
const Loop *L = IndVar->getLoop();
const SCEV *Zero = SE.getZero(X->getType());
const SCEV *One = SE.getOne(X->getType());
diff --git a/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index e2ca5f166dbb5..0528f9877804a 100644
--- a/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -3506,8 +3506,9 @@ void LSRInstance::GenerateIVChain(const IVChain &Chain,
// be signed.
const SCEV *IncExpr = SE.getNoopOrSignExtend(Inc.IncExpr, IntTy);
Accum = SE.getAddExpr(Accum, IncExpr);
- LeftOverExpr = LeftOverExpr ?
- SE.getAddExpr(LeftOverExpr, IncExpr) : IncExpr;
+ LeftOverExpr = LeftOverExpr
+ ? SE.getAddExpr(LeftOverExpr, IncExpr).getPointer()
+ : IncExpr;
}
// Look through each base to see if any can produce a nice addressing mode.
@@ -5971,9 +5972,8 @@ Value *LSRInstance::Expand(const LSRUse &LU, const LSRFixup &LF,
}
// Emit instructions summing all the operands.
- const SCEV *FullS = Ops.empty() ?
- SE.getConstant(IntTy, 0) :
- SE.getAddExpr(Ops);
+ const SCEV *FullS =
+ Ops.empty() ? SE.getConstant(IntTy, 0) : SE.getAddExpr(Ops).getPointer();
Value *FullV = Rewriter.expandCodeFor(FullS, Ty);
// We're done expanding now, so reset the rewriter.
diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
index 58e221765b7b7..c36b3e01569cc 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp
@@ -327,7 +327,7 @@ const SCEV *vputils::getSCEVExprForVPValue(const VPValue *V,
return SE.getCouldNotCompute();
return SE.getAddRecExpr(Start, Step, L, SCEV::FlagAnyWrap);
})
- .Case([&SE, &PSE, L](const VPDerivedIVRecipe *R) {
+ .Case([&SE, &PSE, L](const VPDerivedIVRecipe *R) -> const SCEV * {
const SCEV *Start = getSCEVExprForVPValue(R->getOperand(0), PSE, L);
const SCEV *IV = getSCEVExprForVPValue(R->getOperand(1), PSE, L);
const SCEV *Scale = getSCEVExprForVPValue(R->getOperand(2), PSE, L);
diff --git a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
index a50566cb64093..6e271ba5e4085 100644
--- a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
+++ b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
@@ -2374,4 +2374,82 @@ TEST_F(ScalarEvolutionsTest, ExtendFoldCacheKeysUseFlags) {
EXPECT_EQ(cast<SCEVZeroExtendExpr>(SExtPlain)->getOperand(), Mul);
});
}
+
+TEST_F(ScalarEvolutionsTest, AddExprUseFlags) {
+ LLVMContext C;
+ SMDiagnostic Err;
+ std::unique_ptr<Module> M = parseAssemblyString(
+ R"(define void @f(i32 %a, i32 %b, i32 %c) {
+ entry:
+ ret void
+ })",
+ Err, C);
+
+ if (!M) {
+ Err.print("ScalarEvolutionTest", errs());
+ ASSERT_TRUE(M && "Could not parse module?");
+ }
+ ASSERT_TRUE(!verifyModule(*M, &errs()) && "Must have been well formed!");
+
+ runWithSE(*M, "f", [](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
+ const SCEV *A = SE.getSCEV(getArgByName(F, "a"));
+ const SCEV *B = SE.getSCEV(getArgByName(F, "b"));
+ const SCEV *Cc = SE.getSCEV(getArgByName(F, "c"));
+ Type *I32 = A->getType();
+
+ // The sum is built as-is, so the use carries the requested flags.
+ SCEVUse Sum = SE.getAddExpr(A, B, SCEV::FlagAnyWrap, 0, SCEV::FlagNUW);
+ EXPECT_TRUE(Sum.hasUseFlags());
+ EXPECT_EQ(Sum.getUseNoWrapFlags(), SCEV::FlagNUW | SCEV::FlagNW);
+
+ // Same as Sun, but without NUW use flags.
+ const SCEV *BareSum = SE.getAddExpr(A, B);
+ EXPECT_EQ(Sum.getPointer(), BareSum);
+ EXPECT_EQ(cast<SCEVAddExpr>(BareSum)->getNoWrapFlags(SCEV::FlagNUW),
+ SCEV::FlagAnyWrap);
+ EXPECT_EQ(Sum.getCanonical(), BareSum);
+ EXPECT_FALSE(SCEVUse(BareSum).hasUseFlags());
+
+ // Operands get sorted by complexity, so their order does not matter.
+ EXPECT_EQ(SE.getAddExpr(B, A, SCEV::FlagAnyWrap, 0, SCEV::FlagNUW), Sum);
+
+ // The same holds for sums of more than two operands.
+ SmallVector<SCEVUse, 3> Ops = {Cc, B, A};
+ SCEVUse Sum3 = SE.getAddExpr(Ops, SCEV::FlagAnyWrap, 0, SCEV::FlagNSW);
+ EXPECT_EQ(Sum3.getUseNoWrapFlags(), SCEV::FlagNSW | SCEV::FlagNW);
+ EXPECT_EQ(Sum3.getCanonical(), SE.getAddExpr(A, B, Cc));
+
+ // Flags the expression already carries add nothing to the use.
+ SCEVUse NUWSum = SE.getAddExpr(A, Cc, SCEV::FlagNUW, 0, SCEV::FlagNUW);
+ ASSERT_TRUE(cast<SCEVAddExpr>(NUWSum.getPointer())->hasNoUnsignedWrap());
+ EXPECT_FALSE(NUWSum.hasUseFlags());
+
+ // A folded-away operand, a flattened nested sum and a sum distributed into
+ // a product all describe a different computation than the requested sum,
+ // so none of them may carry its flags.
+ auto CheckNoUseFlags = [](SCEVUse U) {
+ EXPECT_FALSE(U.hasUseFlags());
+ EXPECT_EQ(U.getUseNoWrapFlags(), SCEV::FlagAnyWrap);
+ };
+ CheckNoUseFlags(SE.getAddExpr(SE.getConstant(APInt(32, 1)),
+ SE.getConstant(APInt(32, 2)),
+ SCEV::FlagAnyWrap, 0, SCEV::FlagNUW));
+ CheckNoUseFlags(
+ SE.getAddExpr(A, SE.getZero(I32), SCEV::FlagAnyWrap, 0, SCEV::FlagNUW));
+ CheckNoUseFlags(SE.getAddExpr(A, SE.getAddExpr(B, Cc), SCEV::FlagAnyWrap, 0,
+ SCEV::FlagNUW));
+ CheckNoUseFlags(SE.getAddExpr(A, A, SCEV::FlagAnyWrap, 0, SCEV::FlagNUW));
+
+ // Constants folding together still leave a sum, but not the requested one.
+ SmallVector<SCEVUse, 3> FoldedOps = {SE.getConstant(APInt(32, 1)),
+ SE.getConstant(APInt(32, 2)), A};
+ CheckNoUseFlags(
+ SE.getAddExpr(FoldedOps, SCEV::FlagAnyWrap, 0, SCEV::FlagNUW));
+
+#ifndef NDEBUG
+ EXPECT_DEATH((void)SE.getAddExpr(A, B, SCEV::FlagAnyWrap, 0, SCEV::FlagNW),
+ "only nuw or nsw allowed");
+#endif
+ });
+}
} // end namespace llvm
``````````
</details>
https://github.com/llvm/llvm-project/pull/220007
More information about the llvm-commits
mailing list