[llvm] [polly] [SCEV] Infer addrec nowrap flags during range analysis (PR #202964)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jun 11 02:49:36 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-risc-v
Author: Nikita Popov (nikic)
<details>
<summary>Changes</summary>
When we're computing the range of the addrec, we already have to reason about whether it wraps, so we may as well determine the nowrap flags at the same time.
This is more precise than the previous logic that took the addrec range and checked whether adding a step to it does not wrap. For example, an `{0,+,1}` addrec with a full range can still be non-wrapping.
Note that I removed some assertions in the SCEV printed that predicated exit counts actually have predicates. Due to SCEV's query order dependence, this can happen, also prior to this change, see for example https://llvm.godbolt.org/z/cWK1MMEqv. While this indicates suboptimal results, it's not a bug, and we should not assert.
---
Patch is 225.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/202964.diff
40 Files Affected:
- (modified) llvm/include/llvm/Analysis/ScalarEvolution.h (+5-4)
- (modified) llvm/lib/Analysis/ScalarEvolution.cpp (+55-51)
- (modified) llvm/test/Analysis/Delinearization/global_array_bounds.ll (+1-1)
- (modified) llvm/test/Analysis/DependenceAnalysis/Banerjee.ll (+11-11)
- (modified) llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll (+1-1)
- (modified) llvm/test/Analysis/DependenceAnalysis/Constraints.ll (+18-18)
- (modified) llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll (+1-1)
- (modified) llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll (+1-1)
- (modified) llvm/test/Analysis/DependenceAnalysis/Propagating.ll (+10-10)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/clamped-access-pattern.ll (+3-3)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/inbounds-gep-in-predicated-blocks.ll (+5-5)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll (+26-26)
- (modified) llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll (+6-6)
- (modified) llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/backedge-taken-count-guard-info.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll (+2-2)
- (modified) llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll (+16-16)
- (modified) llvm/test/Analysis/ScalarEvolution/exit-count-non-strict.ll (+10-20)
- (modified) llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll (+54-54)
- (modified) llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll (+7-7)
- (modified) llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll (+3-3)
- (modified) llvm/test/Analysis/ScalarEvolution/limit-depth.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-operand-order.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll (+2-2)
- (modified) llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/mul-udiv-folds.ll (+2-2)
- (modified) llvm/test/Analysis/ScalarEvolution/pr123550.ll (+4-4)
- (modified) llvm/test/Analysis/ScalarEvolution/pr22641.ll (+1-1)
- (modified) llvm/test/Analysis/ScalarEvolution/ptrtoint.ll (+2-2)
- (modified) llvm/test/Analysis/ScalarEvolution/sext-iv-2.ll (+2-2)
- (modified) llvm/test/Analysis/ScalarEvolution/sext-mul.ll (+4-4)
- (modified) llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll (+6-6)
- (modified) llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll (+6-6)
- (modified) llvm/test/CodeGen/PowerPC/mma-intrinsics.ll (+102-110)
- (modified) llvm/test/Transforms/IndVarSimplify/eliminate-exit-no-dl.ll (+2-1)
- (modified) llvm/test/Transforms/LoopVectorize/RISCV/masked_gather_scatter.ll (+12-27)
- (modified) llvm/test/Transforms/LoopVectorize/X86/cast-costs.ll (+6-23)
- (modified) llvm/test/Transforms/LoopVectorize/iv-select-cmp-no-wrap.ll (+10-12)
- (modified) llvm/test/Transforms/LoopVectorize/iv-select-cmp-trunc.ll (+123-133)
- (modified) polly/test/ScopInfo/NonAffine/non_affine_conditional_surrounding_non_affine_loop.ll (+1-1)
``````````diff
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 50af763614a31..247bca9b10d99 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -1983,10 +1983,11 @@ class ScalarEvolution {
/// operands iteratively first.
const ConstantRange &getRangeRefIter(const SCEV *S, RangeSignHint Hint);
- /// Determines the range for the affine SCEVAddRecExpr {\p Start,+,\p Step}.
- /// Helper for \c getRange.
- ConstantRange getRangeForAffineAR(const SCEV *Start, const SCEV *Step,
- const APInt &MaxBECount);
+ /// Determines the range for the affine SCEVAddRecExpr {\p Start,+,\p Step},
+ /// and whether it may wrap. Helper for \c getRange.
+ std::pair<ConstantRange, SCEV::NoWrapFlags>
+ getRangeForAffineAR(const SCEV *Start, const SCEV *Step,
+ const APInt &MaxBECount);
/// Determines the range for the affine non-self-wrapping SCEVAddRecExpr {\p
/// Start,+,\p Step}<nw>.
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index c93838ffdc50d..e7a03c9f0c4ad 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -5249,8 +5249,6 @@ ScalarEvolution::proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR) {
if (!AR->isAffine())
return SCEV::FlagAnyWrap;
- using OBO = OverflowingBinaryOperator;
-
SCEV::NoWrapFlags Result = SCEV::FlagAnyWrap;
if (!AR->hasNoSelfWrap()) {
@@ -5265,25 +5263,13 @@ ScalarEvolution::proveNoWrapViaConstantRanges(const SCEVAddRecExpr *AR) {
}
}
- if (!AR->hasNoSignedWrap()) {
- ConstantRange AddRecRange = getSignedRange(AR);
- ConstantRange IncRange = getSignedRange(AR->getStepRecurrence(*this));
+ // Force computation of ranges, which will also perform range-based flag
+ // inference.
+ if (!AR->hasNoSignedWrap())
+ (void)getSignedRange(AR);
- auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Add, IncRange, OBO::NoSignedWrap);
- if (NSWRegion.contains(AddRecRange))
- Result = ScalarEvolution::setFlags(Result, SCEV::FlagNSW);
- }
-
- if (!AR->hasNoUnsignedWrap()) {
- ConstantRange AddRecRange = getUnsignedRange(AR);
- ConstantRange IncRange = getUnsignedRange(AR->getStepRecurrence(*this));
-
- auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
- Instruction::Add, IncRange, OBO::NoUnsignedWrap);
- if (NUWRegion.contains(AddRecRange))
- Result = ScalarEvolution::setFlags(Result, SCEV::FlagNUW);
- }
+ if (!AR->hasNoUnsignedWrap())
+ (void)getUnsignedRange(AR);
return Result;
}
@@ -7042,10 +7028,11 @@ const ConstantRange &ScalarEvolution::getRangeRef(
MaxBECount = MaxBECount.zext(BitWidth);
if (MaxBECount.getBitWidth() == BitWidth) {
- auto RangeFromAffine = getRangeForAffineAR(
+ auto [RangeFromAffine, Flags] = getRangeForAffineAR(
AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount);
ConservativeResult =
ConservativeResult.intersectWith(RangeFromAffine, RangeType);
+ const_cast<SCEVAddRecExpr *>(AddRec)->setNoWrapFlags(Flags);
auto RangeFromFactoring = getRangeViaFactoring(
AddRec->getStart(), AddRec->getStepRecurrence(*this), MaxBECount);
@@ -7223,24 +7210,24 @@ const ConstantRange &ScalarEvolution::getRangeRef(
// Given a StartRange, Step and MaxBECount for an expression compute a range of
// values that the expression can take. Initially, the expression has a value
// from StartRange and then is changed by Step up to MaxBECount times. Signed
-// argument defines if we treat Step as signed or unsigned.
-static ConstantRange getRangeForAffineARHelper(APInt Step,
- const ConstantRange &StartRange,
- const APInt &MaxBECount,
- bool Signed) {
+// argument defines if we treat Step as signed or unsigned. The second return
+// value indicates that no wrapping occurred.
+static std::pair<ConstantRange, bool>
+getRangeForAffineARHelper(APInt Step, const ConstantRange &StartRange,
+ const APInt &MaxBECount, bool Signed) {
unsigned BitWidth = Step.getBitWidth();
assert(BitWidth == StartRange.getBitWidth() &&
BitWidth == MaxBECount.getBitWidth() && "mismatched bit widths");
// If either Step or MaxBECount is 0, then the expression won't change, and we
// just need to return the initial range.
if (Step == 0 || MaxBECount == 0)
- return StartRange;
+ return {StartRange, true};
// If we don't know anything about the initial value (i.e. StartRange is
// FullRange), then we don't know anything about the final range either.
// Return FullRange.
if (StartRange.isFullSet())
- return ConstantRange::getFull(BitWidth);
+ return {ConstantRange::getFull(BitWidth), false};
// If Step is signed and negative, then we use its absolute value, but we also
// note that we're moving in the opposite direction.
@@ -7256,7 +7243,7 @@ static ConstantRange getRangeForAffineARHelper(APInt Step,
// Check if Offset is more than full span of BitWidth. If it is, the
// expression is guaranteed to overflow.
if (APInt::getMaxValue(StartRange.getBitWidth()).udiv(Step).ult(MaxBECount))
- return ConstantRange::getFull(BitWidth);
+ return {ConstantRange::getFull(BitWidth), false};
// Offset is by how much the expression can change. Checks above guarantee no
// overflow here.
@@ -7268,14 +7255,28 @@ static ConstantRange getRangeForAffineARHelper(APInt Step,
// if the expression is decreasing and will be increased by Offset otherwise.
APInt StartLower = StartRange.getLower();
APInt StartUpper = StartRange.getUpper() - 1;
- APInt MovedBoundary = Descending ? (StartLower - std::move(Offset))
- : (StartUpper + std::move(Offset));
+ bool Overflow;
+ APInt MovedBoundary;
+ if (Signed) {
+ // This does not use sadd_ov, as we want to check overflow for a signed
+ // start with an unsigned offset.
+ if (Descending) {
+ MovedBoundary = StartLower - std::move(Offset);
+ Overflow = MovedBoundary.sgt(StartLower) || StartRange.isSignWrappedSet();
+ } else {
+ MovedBoundary = StartUpper + std::move(Offset);
+ Overflow = MovedBoundary.slt(StartUpper) || StartRange.isSignWrappedSet();
+ }
+ } else {
+ MovedBoundary = StartUpper.uadd_ov(std::move(Offset), Overflow);
+ Overflow |= StartRange.isWrappedSet();
+ }
// It's possible that the new minimum/maximum value will fall into the initial
// range (due to wrap around). This means that the expression can take any
// value in this bitwidth, and we have to return full range.
if (StartRange.contains(MovedBoundary))
- return ConstantRange::getFull(BitWidth);
+ return {ConstantRange::getFull(BitWidth), false};
APInt NewLower =
Descending ? std::move(MovedBoundary) : std::move(StartLower);
@@ -7284,12 +7285,13 @@ static ConstantRange getRangeForAffineARHelper(APInt Step,
NewUpper += 1;
// No overflow detected, return [StartLower, StartUpper + Offset + 1) range.
- return ConstantRange::getNonEmpty(std::move(NewLower), std::move(NewUpper));
+ return {ConstantRange::getNonEmpty(std::move(NewLower), std::move(NewUpper)),
+ !Overflow};
}
-ConstantRange ScalarEvolution::getRangeForAffineAR(const SCEV *Start,
- const SCEV *Step,
- const APInt &MaxBECount) {
+std::pair<ConstantRange, SCEV::NoWrapFlags>
+ScalarEvolution::getRangeForAffineAR(const SCEV *Start, const SCEV *Step,
+ const APInt &MaxBECount) {
assert(getTypeSizeInBits(Start->getType()) ==
getTypeSizeInBits(Step->getType()) &&
getTypeSizeInBits(Start->getType()) == MaxBECount.getBitWidth() &&
@@ -7301,19 +7303,26 @@ ConstantRange ScalarEvolution::getRangeForAffineAR(const SCEV *Start,
// If Step can be both positive and negative, we need to find ranges for the
// maximum absolute step values in both directions and union them.
- ConstantRange SR = getRangeForAffineARHelper(
- StepSRange.getSignedMin(), StartSRange, MaxBECount, /* Signed = */ true);
- SR = SR.unionWith(getRangeForAffineARHelper(StepSRange.getSignedMax(),
- StartSRange, MaxBECount,
- /* Signed = */ true));
+ auto [SR1, NSW1] = getRangeForAffineARHelper(
+ StepSRange.getSignedMin(), StartSRange, MaxBECount, /*Signed=*/true);
+ auto [SR2, NSW2] = getRangeForAffineARHelper(StepSRange.getSignedMax(),
+ StartSRange, MaxBECount,
+ /*Signed=*/true);
+ ConstantRange SR = SR1.unionWith(SR2);
// Next, consider step unsigned.
- ConstantRange UR = getRangeForAffineARHelper(
+ auto [UR, NUW] = getRangeForAffineARHelper(
getUnsignedRangeMax(Step), getUnsignedRange(Start), MaxBECount,
- /* Signed = */ false);
+ /*Signed=*/false);
+
+ SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
+ if (NUW)
+ Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNUW);
+ if (NSW1 && NSW2)
+ Flags = ScalarEvolution::setFlags(Flags, SCEV::FlagNSW);
// Finally, intersect signed and unsigned ranges.
- return SR.intersectWith(UR, ConstantRange::Smallest);
+ return {SR.intersectWith(UR, ConstantRange::Smallest), Flags};
}
ConstantRange ScalarEvolution::getRangeForAffineNoSelfWrappingAR(
@@ -7491,9 +7500,9 @@ ConstantRange ScalarEvolution::getRangeViaFactoring(const SCEV *Start,
const SCEV *FalseStep = this->getConstant(StepPattern.FalseValue);
ConstantRange TrueRange =
- this->getRangeForAffineAR(TrueStart, TrueStep, MaxBECount);
+ this->getRangeForAffineAR(TrueStart, TrueStep, MaxBECount).first;
ConstantRange FalseRange =
- this->getRangeForAffineAR(FalseStart, FalseStep, MaxBECount);
+ this->getRangeForAffineAR(FalseStart, FalseStep, MaxBECount).first;
return TrueRange.unionWith(FalseRange);
}
@@ -14168,7 +14177,6 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
SmallVector<const SCEVPredicate *, 4> Preds;
auto *PBT = SE->getPredicatedBackedgeTakenCount(L, Preds);
if (PBT != BTC) {
- assert(!Preds.empty() && "Different predicated BTC, but no predicates");
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
@@ -14187,8 +14195,6 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
auto *PredConstantMax =
SE->getPredicatedConstantMaxBackedgeTakenCount(L, Preds);
if (PredConstantMax != ConstantBTC) {
- assert(!Preds.empty() &&
- "different predicated constant max BTC but no predicates");
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
@@ -14207,8 +14213,6 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
auto *PredSymbolicMax =
SE->getPredicatedSymbolicMaxBackedgeTakenCount(L, Preds);
if (SymbolicBTC != PredSymbolicMax) {
- assert(!Preds.empty() &&
- "Different predicated symbolic max BTC, but no predicates");
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
diff --git a/llvm/test/Analysis/Delinearization/global_array_bounds.ll b/llvm/test/Analysis/Delinearization/global_array_bounds.ll
index 2e13fd66eb930..218038f9a9ac4 100644
--- a/llvm/test/Analysis/Delinearization/global_array_bounds.ll
+++ b/llvm/test/Analysis/Delinearization/global_array_bounds.ll
@@ -19,7 +19,7 @@ define void @test_2d_array(i64 %i, i64 %j, i64 %N, i64 %M) {
; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,80}<%for.i>,+,4}<%for.j>
; CHECK-NEXT: Base offset: @test_array_10x20
; CHECK-NEXT: ArrayDecl[UnknownSize][20] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
; CHECK-NEXT: Delinearization validation: Failed
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
index 6572a8bc0cadb..bb89ad55554ff 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
@@ -52,11 +52,11 @@ define void @banerjee0(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - input [0 *]!
+; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
-; DELIN-NEXT: da analyze - output [0 *]!
+; DELIN-NEXT: da analyze - none!
;
entry:
br label %for.cond1.preheader
@@ -802,11 +802,11 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; CHECK-NEXT: da analyze - output [* *]!
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: da analyze - flow [<= 0|<]!
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
@@ -816,11 +816,11 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; NORMALIZE-NEXT: da analyze - output [* *]!
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; NORMALIZE-NEXT: da analyze - flow [* *|<]!
+; NORMALIZE-NEXT: da analyze - flow [<= 0|<]!
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; NORMALIZE-NEXT: da analyze - confused!
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; NORMALIZE-NEXT: da analyze - input [* *]!
+; NORMALIZE-NEXT: da analyze - none!
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; NORMALIZE-NEXT: da analyze - confused!
; NORMALIZE-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
@@ -830,7 +830,7 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - output [* *]!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - flow [* *|<]!
+; DELIN-NEXT: da analyze - flow [<= 0|<]!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
@@ -888,11 +888,11 @@ define void @banerjee10(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx6, align 8
-; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: da analyze - flow [<> 0]!
; CHECK-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: %1 = load i64, ptr %arrayidx6, align 8
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
@@ -902,11 +902,11 @@ define void @banerjee10(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; NORMALIZE-NEXT: da analyze - none!
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx6, align 8
-; NORMALIZE-NEXT: da analyze - flow [* *|<]!
+; NORMALIZE-NEXT: da analyze - flow [<> 0]!
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; NORMALIZE-NEXT: da analyze - confused!
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: %1 = load i64, ptr %arrayidx6, align 8
-; NORMALIZE-NEXT: da analyze - input [* *]!
+; NORMALIZE-NEXT: da analyze - none!
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; NORMALIZE-NEXT: da analyze - confused!
; NORMALIZE-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
diff --git a/llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll b/llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll
index b4eba4d35b2f4..dd35508b93ddd 100644
--- a/llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll
@@ -22,7 +22,7 @@ define void @test1(ptr nocapture %A, ptr nocapture %B, i32 %N) #0 {
; CHECK-NEXT: Src: %0 = load i32, ptr %gep.0, align 4 --> Dst: store i32 %add, ptr %gep.B, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %1 = load i32, ptr %gep.1, align 4 --> Dst: %1 = load i32, ptr %gep.1, align 4
-; CHECK-NEXT: da analyze - input [*]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %1 = load i32, ptr %gep.1, align 4 --> Dst: store i32 %add, ptr %gep.B, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %add, ptr %gep.B, align 4 --> Dst: store i32 %add, ptr %gep.B, align 4
diff --git a/llvm/test/Analysis/DependenceAnalysis/Constraints.ll b/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
index e4063186ac73e..f8f8c5d7f5501 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
@@ -37,15 +37,15 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %out_l.promoted = load i32, ptr @out_l, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - anti [|<]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: store i32 0, ptr %13, align 4
-; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: da analyze - output [S * *]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %18 = load i32, ptr %17, align 4
-; CHECK-NEXT: da analyze - flow [* * *|<]!
+; CHECK-NEXT: da analyze - flow [S * *|<]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %20 = load i32, ptr %19, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %23 = load i32, ptr %22, align 4
; CHECK-NEXT: da analyze - none!
; C...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/202964
More information about the llvm-commits
mailing list