[llvm-branch-commits] [llvm] ValueTracking: Use SimplifyQuery for computeKnownConstantRange (PR #191726)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sun Apr 12 09:04:13 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Does introduce new context passing in a few of the updated contexts.
---
Patch is 23.60 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/191726.diff
10 Files Affected:
- (modified) llvm/include/llvm/Analysis/ValueTracking.h (+1-4)
- (modified) llvm/lib/Analysis/BasicAliasAnalysis.cpp (+4-2)
- (modified) llvm/lib/Analysis/InstructionSimplify.cpp (+1-2)
- (modified) llvm/lib/Analysis/ValueTracking.cpp (+23-28)
- (modified) llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp (+3-2)
- (modified) llvm/lib/Transforms/IPO/FunctionAttrs.cpp (+3-2)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp (+3-1)
- (modified) llvm/lib/Transforms/Utils/SimplifyCFG.cpp (+5-3)
- (modified) llvm/lib/Transforms/Vectorize/VectorCombine.cpp (+20-20)
- (modified) llvm/unittests/Analysis/ValueTrackingTest.cpp (+18-10)
``````````diff
diff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h
index 5f1e7773be8d3..ff2712efe1ef5 100644
--- a/llvm/include/llvm/Analysis/ValueTracking.h
+++ b/llvm/include/llvm/Analysis/ValueTracking.h
@@ -682,10 +682,7 @@ LLVM_ABI ConstantRange getVScaleRange(const Function *F, unsigned BitWidth);
/// Determine the possible constant range of an integer or vector of integer
/// value. This is intended as a cheap, non-recursive check.
LLVM_ABI ConstantRange computeConstantRange(const Value *V, bool ForSigned,
- bool UseInstrInfo = true,
- AssumptionCache *AC = nullptr,
- const Instruction *CtxI = nullptr,
- const DominatorTree *DT = nullptr,
+ const SimplifyQuery &SQ,
unsigned Depth = 0);
/// Combine constant ranges from computeConstantRange() and computeKnownBits().
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index d74075db18df8..fe8e1ddba4310 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -1317,8 +1317,10 @@ AliasResult BasicAAResult::aliasGEP(
else
GCD = APIntOps::GreatestCommonDivisor(GCD, ScaleForGCD.abs());
- ConstantRange CR = computeConstantRange(Index.Val.V, /* ForSigned */ false,
- true, &AC, Index.CxtI);
+ ConstantRange CR =
+ computeConstantRange(Index.Val.V, /*ForSigned=*/false,
+ SimplifyQuery(DL, DT, &AC, Index.CxtI,
+ /*UseInstrInfo=*/true));
CR = CR.intersectWith(
ConstantRange::fromKnownBits(Known, /* Signed */ true),
ConstantRange::Signed);
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index 4b7e23d3025aa..94166aecb3e13 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -3113,8 +3113,7 @@ static Value *simplifyICmpWithConstant(CmpPredicate Pred, Value *LHS,
if (RHS_CR.isFullSet())
return ConstantInt::getTrue(ITy);
- ConstantRange LHS_CR =
- computeConstantRange(LHS, CmpInst::isSigned(Pred), Q.IIQ.UseInstrInfo);
+ ConstantRange LHS_CR = computeConstantRange(LHS, CmpInst::isSigned(Pred), Q);
if (!LHS_CR.isFullSet()) {
if (RHS_CR.contains(LHS_CR))
return ConstantInt::getTrue(ITy);
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 5b52efb9e1dc6..d841ebd0dd216 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -7368,7 +7368,7 @@ llvm::computeConstantRangeIncludingKnownBits(const WithCache<const Value *> &V,
const SimplifyQuery &SQ) {
ConstantRange CR1 =
ConstantRange::fromKnownBits(V.getKnownBits(SQ), ForSigned);
- ConstantRange CR2 = computeConstantRange(V, ForSigned, SQ.IIQ.UseInstrInfo);
+ ConstantRange CR2 = computeConstantRange(V, ForSigned, SQ);
ConstantRange::PreferredRangeType RangeType =
ForSigned ? ConstantRange::Signed : ConstantRange::Unsigned;
return CR1.intersectWith(CR2, RangeType);
@@ -9661,12 +9661,13 @@ isImpliedCondICmps(CmpPredicate LPred, const Value *L0, const Value *L1,
// further constraint the constant ranges. At the moment this leads to
// several regressions related to not transforming `multi_use(A + C0) eq/ne
// C1` (see discussion: D58633).
- ConstantRange LCR = computeConstantRange(
- L1, ICmpInst::isSigned(LPred), /* UseInstrInfo=*/true, /*AC=*/nullptr,
- /*CxtI=*/nullptr, /*DT=*/nullptr, MaxAnalysisRecursionDepth - 1);
- ConstantRange RCR = computeConstantRange(
- R1, ICmpInst::isSigned(RPred), /* UseInstrInfo=*/true, /*AC=*/nullptr,
- /*CxtI=*/nullptr, /*DT=*/nullptr, MaxAnalysisRecursionDepth - 1);
+ SimplifyQuery SQ(DL, /*DT=*/nullptr, /*AC=*/nullptr, /*CXTI=*/nullptr,
+ /*UseInstrInfo=*/true);
+ ConstantRange LCR = computeConstantRange(L1, ICmpInst::isSigned(LPred), SQ,
+ MaxAnalysisRecursionDepth - 1);
+ ConstantRange RCR = computeConstantRange(R1, ICmpInst::isSigned(RPred), SQ,
+ MaxAnalysisRecursionDepth - 1);
+
// Even if L1/R1 are not both constant, we can still sometimes deduce
// relationship from a single constant. For example X u> Y implies X != 0.
if (auto R = isImpliedCondCommonOperandWithCR(LPred, LCR, RPred, RCR))
@@ -10407,9 +10408,7 @@ static void setLimitForFPToI(const Instruction *I, APInt &Lower, APInt &Upper) {
}
ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
- bool UseInstrInfo, AssumptionCache *AC,
- const Instruction *CtxI,
- const DominatorTree *DT,
+ const SimplifyQuery &SQ,
unsigned Depth) {
assert(V->getType()->isIntOrIntVectorTy() && "Expected integer instruction");
@@ -10420,23 +10419,22 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
return C->toConstantRange();
unsigned BitWidth = V->getType()->getScalarSizeInBits();
- InstrInfoQuery IIQ(UseInstrInfo);
ConstantRange CR = ConstantRange::getFull(BitWidth);
if (auto *BO = dyn_cast<BinaryOperator>(V)) {
APInt Lower = APInt(BitWidth, 0);
APInt Upper = APInt(BitWidth, 0);
// TODO: Return ConstantRange.
- setLimitsForBinOp(*BO, Lower, Upper, IIQ, ForSigned);
+ setLimitsForBinOp(*BO, Lower, Upper, SQ.IIQ, ForSigned);
CR = ConstantRange::getNonEmpty(Lower, Upper);
} else if (auto *II = dyn_cast<IntrinsicInst>(V))
- CR = getRangeForIntrinsic(*II, UseInstrInfo);
+ CR = getRangeForIntrinsic(*II, SQ.IIQ.UseInstrInfo);
else if (auto *SI = dyn_cast<SelectInst>(V)) {
- ConstantRange CRTrue = computeConstantRange(
- SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
- ConstantRange CRFalse = computeConstantRange(
- SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
+ ConstantRange CRTrue =
+ computeConstantRange(SI->getTrueValue(), ForSigned, SQ, Depth + 1);
+ ConstantRange CRFalse =
+ computeConstantRange(SI->getFalseValue(), ForSigned, SQ, Depth + 1);
CR = CRTrue.unionWith(CRFalse);
- CR = CR.intersectWith(getRangeForSelectPattern(*SI, IIQ));
+ CR = CR.intersectWith(getRangeForSelectPattern(*SI, SQ.IIQ));
} else if (isa<FPToUIInst>(V) || isa<FPToSIInst>(V)) {
APInt Lower = APInt(BitWidth, 0);
APInt Upper = APInt(BitWidth, 0);
@@ -10448,7 +10446,7 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
CR = *Range;
if (auto *I = dyn_cast<Instruction>(V)) {
- if (auto *Range = IIQ.getMetadata(I, LLVMContext::MD_range))
+ if (auto *Range = SQ.IIQ.getMetadata(I, LLVMContext::MD_range))
CR = CR.intersectWith(getConstantRangeFromMetadata(*Range));
Value *FrexpSrc;
@@ -10462,9 +10460,6 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
// It should be possible to implement this for any type, but this logic
// only computes the range assuming standard subnormal handling.
if (APFloat::isIEEELikeFP(FltSem)) {
- const DataLayout &DL = I->getFunction()->getDataLayout();
- SimplifyQuery SQ(DL, nullptr, DT, AC, CtxI, UseInstrInfo);
-
KnownFPClass KnownSrc =
computeKnownFPClass(FrexpSrc, fcSubnormal, SQ, Depth + 1);
@@ -10484,18 +10479,18 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
}
}
- if (CtxI && AC) {
+ if (SQ.CxtI && SQ.AC) {
// Try to restrict the range based on information from assumptions.
- for (auto &AssumeVH : AC->assumptionsFor(V)) {
+ for (auto &AssumeVH : SQ.AC->assumptionsFor(V)) {
if (!AssumeVH)
continue;
CallInst *I = cast<CallInst>(AssumeVH);
- assert(I->getParent()->getParent() == CtxI->getParent()->getParent() &&
+ assert(I->getParent()->getParent() == SQ.CxtI->getParent()->getParent() &&
"Got assumption for the wrong function!");
assert(I->getIntrinsicID() == Intrinsic::assume &&
"must be an assume intrinsic");
- if (!isValidAssumeForContext(I, CtxI, DT))
+ if (!isValidAssumeForContext(I, SQ.CxtI, SQ.DT))
continue;
Value *Arg = I->getArgOperand(0);
ICmpInst *Cmp = dyn_cast<ICmpInst>(Arg);
@@ -10504,8 +10499,8 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
continue;
// TODO: Set "ForSigned" parameter via Cmp->isSigned()?
ConstantRange RHS =
- computeConstantRange(Cmp->getOperand(1), /* ForSigned */ false,
- UseInstrInfo, AC, I, DT, Depth + 1);
+ computeConstantRange(Cmp->getOperand(1), /*ForSigned=*/false,
+ SQ.getWithInstruction(I), Depth + 1);
CR = CR.intersectWith(
ConstantRange::makeAllowedICmpRegion(Cmp->getPredicate(), RHS));
}
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
index 463d63a88f690..b973e5da87b15 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
@@ -1428,8 +1428,9 @@ GCNTTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
return IC.replaceInstUsesWith(II, II.getArgOperand(1));
[[fallthrough]];
case Intrinsic::amdgcn_mbcnt_lo: {
- ConstantRange AccRange = computeConstantRange(II.getArgOperand(1),
- /*ForSigned=*/false);
+ ConstantRange AccRange =
+ computeConstantRange(II.getArgOperand(1),
+ /*ForSigned=*/false, IC.getSimplifyQuery());
if (AccRange.isFullSet())
return nullptr;
diff --git a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
index c5e20c766ad52..ce6e00431c457 100644
--- a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
+++ b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp
@@ -1739,8 +1739,9 @@ static void addNoUndefAttrs(const SCCNodeSet &SCCNodes,
Attribute Attr = Attrs.getRetAttr(Attribute::Range);
if (Attr.isValid() &&
- !Attr.getRange().contains(
- computeConstantRange(RetVal, /*ForSigned=*/false)))
+ !Attr.getRange().contains(computeConstantRange(
+ RetVal, /*ForSigned=*/false,
+ SimplifyQuery(F->getParent()->getDataLayout()))))
return false;
}
return true;
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
index 362bd663434df..611e6982ac42d 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -3178,7 +3178,9 @@ Instruction *InstCombinerImpl::foldICmpAddConstant(ICmpInst &Cmp,
if (ICmpInst::isUnsigned(Pred) && Add->hasNoSignedWrap() &&
C.isNonNegative() && (C - *C2).isNonNegative() &&
- computeConstantRange(X, /*ForSigned=*/true).add(*C2).isAllNonNegative())
+ computeConstantRange(X, /*ForSigned=*/true, SimplifyQuery(DL))
+ .add(*C2)
+ .isAllNonNegative())
return new ICmpInst(ICmpInst::getSignedPredicate(Pred), X,
ConstantInt::get(Ty, C - *C2));
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index e7a6c9354953a..f35e16425b41a 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -5836,7 +5836,9 @@ findContiguousCases(Value *Condition, SmallVectorImpl<ConstantInt *> &Cases,
/*OtherCases=*/&OtherCases,
};
}
- ConstantRange CR = computeConstantRange(Condition, /*ForSigned=*/false);
+ ConstantRange CR = computeConstantRange(
+ Condition, /*ForSigned=*/false,
+ SimplifyQuery(Dest->getParent()->getParent()->getDataLayout()));
// If this is a wrapping contiguous range, that is, [Min, OtherMin] +
// [OtherMax, Max] (also [OtherMax, OtherMin]), [OtherMin+1, OtherMax-1] is a
// contiguous range for the other destination. N.B. If CR is not a full range,
@@ -7316,8 +7318,8 @@ static bool simplifySwitchLookup(SwitchInst *SI, IRBuilder<> &Builder,
// Grow the table to cover all possible index values to avoid the range
// check. It will use the default result to fill in the table hole later,
// so make sure it exist.
- ConstantRange CR =
- computeConstantRange(TableIndex, /* ForSigned */ false);
+ ConstantRange CR = computeConstantRange(TableIndex, /*ForSigned=*/false,
+ SimplifyQuery(DL));
// Grow the table shouldn't have any size impact by checking
// wouldFitInRegister.
// TODO: Consider growing the table also when it doesn't fit in a register
diff --git a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp
index 194e3477815f4..29eced7ee9de1 100644
--- a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp
+++ b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp
@@ -78,7 +78,8 @@ class VectorCombine {
const DataLayout *DL, TTI::TargetCostKind CostKind,
bool TryEarlyFoldsOnly)
: F(F), Builder(F.getContext(), InstSimplifyFolder(*DL)), TTI(TTI),
- DT(DT), AA(AA), AC(AC), DL(DL), CostKind(CostKind), SQ(*DL),
+ DT(DT), AA(AA), DL(DL), CostKind(CostKind),
+ SQ(*DL, /*TLI=*/nullptr, &DT, &AC),
TryEarlyFoldsOnly(TryEarlyFoldsOnly) {}
bool run();
@@ -89,7 +90,6 @@ class VectorCombine {
const TargetTransformInfo &TTI;
const DominatorTree &DT;
AAResults &AA;
- AssumptionCache &AC;
const DataLayout *DL;
TTI::TargetCostKind CostKind;
const SimplifyQuery SQ;
@@ -267,8 +267,8 @@ bool VectorCombine::vectorizeLoadInsert(Instruction &I) {
auto *MinVecTy = VectorType::get(ScalarTy, MinVecNumElts, false);
unsigned OffsetEltIndex = 0;
Align Alignment = Load->getAlign();
- if (!isSafeToLoadUnconditionally(SrcPtr, MinVecTy, Align(1), *DL, Load, &AC,
- &DT)) {
+ if (!isSafeToLoadUnconditionally(SrcPtr, MinVecTy, Align(1), *DL, Load, SQ.AC,
+ SQ.DT)) {
// It is not safe to load directly from the pointer, but we can still peek
// through gep offsets and check if it safe to load from a base address with
// updated alignment. If it is, we can shuffle the element(s) into place
@@ -293,8 +293,8 @@ bool VectorCombine::vectorizeLoadInsert(Instruction &I) {
if (OffsetEltIndex >= MinVecNumElts)
return false;
- if (!isSafeToLoadUnconditionally(SrcPtr, MinVecTy, Align(1), *DL, Load, &AC,
- &DT))
+ if (!isSafeToLoadUnconditionally(SrcPtr, MinVecTy, Align(1), *DL, Load,
+ SQ.AC, SQ.DT))
return false;
// Update alignment with offset value. Note that the offset could be negated
@@ -379,7 +379,8 @@ bool VectorCombine::widenSubvectorLoad(Instruction &I) {
Value *SrcPtr = Load->getPointerOperand()->stripPointerCasts();
assert(isa<PointerType>(SrcPtr->getType()) && "Expected a pointer type");
Align Alignment = Load->getAlign();
- if (!isSafeToLoadUnconditionally(SrcPtr, Ty, Align(1), *DL, Load, &AC, &DT))
+ if (!isSafeToLoadUnconditionally(SrcPtr, Ty, Align(1), *DL, Load, SQ.AC,
+ SQ.DT))
return false;
Alignment = std::max(SrcPtr->getPointerAlignment(*DL), Alignment);
@@ -1265,9 +1266,9 @@ bool VectorCombine::scalarizeVPIntrinsic(Instruction &I) {
.hasAttribute(Attribute::AttrKind::Speculatable);
else
SafeToSpeculate = isSafeToSpeculativelyExecuteWithOpcode(
- *FunctionalOpcode, &VPI, nullptr, &AC, &DT);
+ *FunctionalOpcode, &VPI, nullptr, SQ.AC, SQ.DT);
if (!SafeToSpeculate &&
- !isKnownNonZero(EVL, SimplifyQuery(*DL, &DT, &AC, &VPI)))
+ !isKnownNonZero(EVL, SimplifyQuery(*DL, SQ.DT, SQ.AC, &VPI)))
return false;
Value *ScalarVal =
@@ -1873,9 +1874,7 @@ class ScalarizationResult {
/// Check if it is legal to scalarize a memory access to \p VecTy at index \p
/// Idx. \p Idx must access a valid vector element.
static ScalarizationResult canScalarizeAccess(VectorType *VecTy, Value *Idx,
- Instruction *CtxI,
- AssumptionCache &AC,
- const DominatorTree &DT) {
+ const SimplifyQuery &SQ) {
// We do checks for both fixed vector types and scalable vector types.
// This is the number of elements of fixed vector types,
// or the minimum number of elements of scalable vector types.
@@ -1897,9 +1896,9 @@ static ScalarizationResult canScalarizeAccess(VectorType *VecTy, Value *Idx,
ConstantRange ValidIndices(Zero, MaxElts);
ConstantRange IdxRange(IntWidth, true);
- if (isGuaranteedNotToBePoison(Idx, &AC)) {
- if (ValidIndices.contains(computeConstantRange(Idx, /* ForSigned */ false,
- true, &AC, CtxI, &DT)))
+ if (isGuaranteedNotToBePoison(Idx, SQ.AC, SQ.CxtI, SQ.DT)) {
+ if (ValidIndices.contains(
+ computeConstantRange(Idx, /*ForSigned=*/false, SQ)))
return ScalarizationResult::safe();
return ScalarizationResult::unsafe();
}
@@ -1967,7 +1966,8 @@ bool VectorCombine::foldSingleElementStore(Instruction &I) {
SrcAddr != SI->getPointerOperand()->stripPointerCasts())
return false;
- auto ScalarizableIdx = canScalarizeAccess(VecTy, Idx, Load, AC, DT);
+ auto ScalarizableIdx =
+ canScalarizeAccess(VecTy, Idx, SQ.getWithInstruction(Load));
if (ScalarizableIdx.isUnsafe() ||
isMemModifiedBetween(Load->getIterator(), SI->getIterator(),
MemoryLocation::get(SI), AA))
@@ -2073,8 +2073,8 @@ bool VectorCombine::scalarizeLoadExtract(LoadInst *LI, VectorType *VecTy,
for (User *U : LI->users()) {
auto *UI = cast<ExtractElementInst>(U);
- auto ScalarIdx =
- canScalarizeAccess(VecTy, UI->getIndexOperand(), LI, AC, DT);
+ auto ScalarIdx = canScalarizeAccess(VecTy, UI->getIndexOperand(),
+ SQ.getWithInstruction(LI));
if (ScalarIdx.isUnsafe())
return false;
if (ScalarIdx.isSafeWithFreeze()) {
@@ -2255,8 +2255,8 @@ bool VectorCombine::scalarizeExtExtract(Instruction &I) {
return false;
Value *ScalarV = Ext->getOperand(0);
- if (!isGuaranteedNotToBePoison(ScalarV, &AC, dyn_cast<Instruction>(ScalarV),
- &DT)) {
+ if (!isGuaranteedNotToBePoison(ScalarV, SQ.AC, dyn_cast<Instruction>(ScalarV),
+ SQ.DT)) {
// Check wether all lanes are extracted, all extracts trigger UB
// on poison, and the last extract (and hence all previous ones)
// are guaranteed to execute if Ext executes. If so, we do not
diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp b/llvm/unittests/Analysis/ValueTrackingTest.cpp
index de481e39307cb..6898d784a15b3 100644
--- a/llvm/unittests/Analysis/ValueTrackingTest.cpp
+++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp
@@ -3392,11 +3392,13 @@ TEST_F(ValueTrackingTest, ComputeConstantRange) {
AssumptionCache AC(*F);
Value *Stride = &*F->arg_begin();
- ConstantRange CR1 = computeConstantRange(Stride, false, true, &AC, nullptr);
+ SimplifyQuery SQ(M->getDataLayout(), /*DT=*/nullptr, &AC);
+ ConstantRange CR1 = computeConstantRange(Stride, /*ForSigned=*/false, SQ);
EXPECT_TRUE(CR1.isFullSet()...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/191726
More information about the llvm-branch-commits
mailing list