[llvm-branch-commits] [llvm] [LAA] Use SCEVUse to add extra NUW flags to pointer bounds. (WIP) (PR #91962)
Florian Hahn via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Jun 25 06:35:20 PDT 2024
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/91962
>From 9a8305b0041586627b3c3c8a1dc954306767cadc Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 1 May 2024 11:03:42 +0100
Subject: [PATCH 1/3] [SCEV,LAA] Add tests to make sure scoped SCEVs don't
impact other SCEVs.
---
.../LoopAccessAnalysis/scoped-scevs.ll | 182 ++++++++++++++++++
1 file changed, 182 insertions(+)
create mode 100644 llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
new file mode 100644
index 0000000000000..323ba2a739cf8
--- /dev/null
+++ b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
@@ -0,0 +1,182 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 4
+; RUN: opt -passes='print<access-info>,print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck --check-prefixes=LAA,AFTER %s
+; RUN: opt -passes='print<scalar-evolution>,print<access-info>,print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck --check-prefixes=BEFORE,LAA,AFTER %s
+
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+
+declare void @use(ptr)
+
+; Check that scoped expressions created by LAA do not interfere with non-scoped
+; SCEVs with the same operands. The tests first run print<scalar-evolution> to
+; populate the SCEV cache. They contain a GEP computing A+405, which is the end
+; of the accessed range, before and/or after the loop. No nuw flags should be
+; added to them in the second print<scalar-evolution> output.
+
+define ptr @test_ptr_range_end_computed_before_and_after_loop(ptr %A) {
+; BEFORE-LABEL: 'test_ptr_range_end_computed_before_and_after_loop'
+; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_and_after_loop
+; BEFORE: %x = getelementptr inbounds i8, ptr %A, i64 405
+; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set
+; BEFORE: %y = getelementptr inbounds i8, ptr %A, i64 405
+; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set
+;
+; LAA-LABEL: 'test_ptr_range_end_computed_before_and_after_loop'
+; LAA-NEXT: loop:
+; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Dependences:
+; LAA-NEXT: Run-time memory checks:
+; LAA-NEXT: Check 0:
+; LAA-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+; LAA-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+; LAA-NEXT: Grouped accesses:
+; LAA-NEXT: Group [[GRP1]]:
+; LAA-NEXT: (Low: (1 + %A) High: (405 + %A))
+; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop>
+; LAA-NEXT: Group [[GRP2]]:
+; LAA-NEXT: (Low: %A High: (101 + %A))
+; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
+; LAA-EMPTY:
+; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; LAA-NEXT: SCEV assumptions:
+; LAA-EMPTY:
+; LAA-NEXT: Expressions re-written:
+;
+; AFTER-LABEL: 'test_ptr_range_end_computed_before_and_after_loop'
+; AFTER-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_and_after_loop
+; AFTER: %x = getelementptr inbounds i8, ptr %A, i64 405
+; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set
+; AFTER: %y = getelementptr inbounds i8, ptr %A, i64 405
+; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set
+entry:
+ %A.1 = getelementptr inbounds i8, ptr %A, i64 1
+ %x = getelementptr inbounds i8, ptr %A, i64 405
+ call void @use(ptr %x)
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+ %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+ %l = load i8, ptr %gep.A, align 1
+ %ext = zext i8 %l to i32
+ store i32 %ext, ptr %gep.A.400, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %ec = icmp eq i64 %iv, 100
+ br i1 %ec, label %exit, label %loop
+
+exit:
+ %y = getelementptr inbounds i8, ptr %A, i64 405
+ ret ptr %y
+}
+
+define void @test_ptr_range_end_computed_before_loop(ptr %A) {
+; BEFORE-LABEL: 'test_ptr_range_end_computed_before_loop'
+; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_loop
+; BEFORE-NEXT: %A.1 = getelementptr inbounds i8, ptr %A, i64 1
+; BEFORE-NEXT: --> (1 + %A) U: full-set S: full-set
+; BEFORE-NEXT: %x = getelementptr inbounds i8, ptr %A, i64 405
+;
+; LAA-LABEL: 'test_ptr_range_end_computed_before_loop'
+; LAA-NEXT: loop:
+; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Dependences:
+; LAA-NEXT: Run-time memory checks:
+; LAA-NEXT: Check 0:
+; LAA-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+; LAA-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+; LAA-NEXT: Grouped accesses:
+; LAA-NEXT: Group [[GRP3]]:
+; LAA-NEXT: (Low: (1 + %A) High: (405 + %A))
+; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop>
+; LAA-NEXT: Group [[GRP4]]:
+; LAA-NEXT: (Low: %A High: (101 + %A))
+; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
+; LAA-EMPTY:
+; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; LAA-NEXT: SCEV assumptions:
+; LAA-EMPTY:
+; LAA-NEXT: Expressions re-written:
+;
+; AFTER-LABEL: Classifying expressions for: @test_ptr_range_end_computed_before_loop
+; AFTER-NEXT: %A.1 = getelementptr inbounds i8, ptr %A, i64 1
+; AFTER-NEXT: --> (1 + %A) U: full-set S: full-set
+; AFTER-NEXT: %x = getelementptr inbounds i8, ptr %A, i64 405
+;
+entry:
+ %A.1 = getelementptr inbounds i8, ptr %A, i64 1
+ %x = getelementptr inbounds i8, ptr %A, i64 405
+ call void @use(ptr %x)
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+ %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+ %l = load i8, ptr %gep.A, align 1
+ %ext = zext i8 %l to i32
+ store i32 %ext, ptr %gep.A.400, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %ec = icmp eq i64 %iv, 100
+ br i1 %ec, label %exit, label %loop
+
+exit:
+ ret void
+}
+
+define ptr @test_ptr_range_end_computed_after_loop(ptr %A) {
+; BEFORE-LABEL: 'test_ptr_range_end_computed_after_loop'
+; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_after_loop
+; BEFORE: %y = getelementptr inbounds i8, ptr %A, i64 405
+; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set
+;
+; LAA-LABEL: 'test_ptr_range_end_computed_after_loop'
+; LAA-NEXT: loop:
+; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Dependences:
+; LAA-NEXT: Run-time memory checks:
+; LAA-NEXT: Check 0:
+; LAA-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+; LAA-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+; LAA-NEXT: Grouped accesses:
+; LAA-NEXT: Group [[GRP5]]:
+; LAA-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A))
+; LAA-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop>
+; LAA-NEXT: Group [[GRP6]]:
+; LAA-NEXT: (Low: %A High: (101 + %A))
+; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
+; LAA-EMPTY:
+; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; LAA-NEXT: SCEV assumptions:
+; LAA-EMPTY:
+; LAA-NEXT: Expressions re-written:
+;
+; AFTER-LABEL: 'test_ptr_range_end_computed_after_loop'
+; AFTER-NEXT: Classifying expressions for: @test_ptr_range_end_computed_after_loop
+; AFTER: %y = getelementptr inbounds i8, ptr %A, i64 405
+; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set
+;
+entry:
+ %A.1 = getelementptr inbounds i8, ptr %A, i64 1
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
+ %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+ %l = load i8, ptr %gep.A, align 1
+ %ext = zext i8 %l to i32
+ store i32 %ext, ptr %gep.A.400, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %ec = icmp eq i64 %iv, 100
+ br i1 %ec, label %exit, label %loop
+
+exit:
+ %y = getelementptr inbounds i8, ptr %A, i64 405
+ ret ptr %y
+}
>From eed10c99497b8181a912e11fd9e26b31208809d3 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 13 May 2024 13:05:39 +0100
Subject: [PATCH 2/3] [SCEV] Don't require NUW at first add when checking A+C1
< (A+C2)<nuw>
Relax the NUW requirements for isKnownPredicateViaNoOverflow, if the
second operand (Y) is a BinOp. The code only simplifies the condition if
C1 < C2, so if the BinOp is NUW, it doesn't matter whether the first
operand also has the NUW flag, as it cannot wrap if C1 < C2.
---
llvm/lib/Analysis/ScalarEvolution.cpp | 18 +++++++++++++-----
1 file changed, 13 insertions(+), 5 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index eb4ab2e66d92a..3e0f38ad387c4 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -11292,8 +11292,7 @@ bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
XNonConstOp = X;
XFlagsPresent = ExpectedFlags;
}
- if (!isa<SCEVConstant>(XConstOp) ||
- (XFlagsPresent & ExpectedFlags) != ExpectedFlags)
+ if (!isa<SCEVConstant>(XConstOp))
return false;
if (!splitBinaryAdd(Y, YConstOp, YNonConstOp, YFlagsPresent)) {
@@ -11302,13 +11301,22 @@ bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred,
YFlagsPresent = ExpectedFlags;
}
- if (!isa<SCEVConstant>(YConstOp) ||
- (YFlagsPresent & ExpectedFlags) != ExpectedFlags)
+ if (YNonConstOp != XNonConstOp)
return false;
- if (YNonConstOp != XNonConstOp)
+ if (!isa<SCEVConstant>(YConstOp))
return false;
+ if (YNonConstOp != Y && ExpectedFlags == SCEV::FlagNUW) {
+ if ((YFlagsPresent & ExpectedFlags) != ExpectedFlags)
+ return false;
+ } else {
+ if ((XFlagsPresent & ExpectedFlags) != ExpectedFlags)
+ return false;
+ if ((YFlagsPresent & ExpectedFlags) != ExpectedFlags)
+ return false;
+ }
+
OutC1 = cast<SCEVConstant>(XConstOp)->getAPInt();
OutC2 = cast<SCEVConstant>(YConstOp)->getAPInt();
>From c6f0b74e48a09ecb6031f3d934f505a8ab3cc5d6 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sun, 12 May 2024 10:32:11 +0100
Subject: [PATCH 3/3] [LAA] Use SCEVUse to add extra NUW flags to pointer
bounds.
Use SCEVUse to add a NUW flag to the upper bound of an accessed pointer.
We must already have proved that the pointers do not wrap, as otherwise
we could not use them for runtime check computations.
By adding the use-specific NUW flag, we can detect cases where SCEV can
prove that the compared pointers must overlap, so the runtime checks
will always be false. In that case, there is no point in vectorizing
with runtime checks.
Note that this depends c2895cd27fbf200d1da056bc66d77eeb62690bf0, which
could be submitted separately if desired; without the current change, I
don't think it triggers in practice though.
---
.../llvm/Analysis/LoopAccessAnalysis.h | 14 +-
llvm/lib/Analysis/LoopAccessAnalysis.cpp | 22 ++-
llvm/lib/Analysis/ScalarEvolution.cpp | 2 +
...es-safe-dep-due-to-backedge-taken-count.ll | 11 +-
.../LoopAccessAnalysis/forked-pointers.ll | 134 +++++++++---------
...invariant-dep-with-backedge-taken-count.ll | 4 +-
.../loops-with-indirect-reads-and-writes.ll | 8 +-
.../offset-range-known-via-assume.ll | 12 +-
.../LoopAccessAnalysis/pointer-phis.ll | 24 ++--
...endence-distance-different-access-sizes.ll | 38 ++---
.../LoopAccessAnalysis/scoped-scevs.ll | 39 +----
...wn-dependence-retry-with-runtime-checks.ll | 63 +-------
12 files changed, 132 insertions(+), 239 deletions(-)
diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
index 7a54fe55014be..d205e0a5e89a3 100644
--- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -406,10 +406,10 @@ struct RuntimeCheckingPtrGroup {
/// The SCEV expression which represents the upper bound of all the
/// pointers in this group.
- const SCEV *High;
+ SCEVUse High;
/// The SCEV expression which represents the lower bound of all the
/// pointers in this group.
- const SCEV *Low;
+ SCEVUse Low;
/// Indices of all the pointers that constitute this grouping.
SmallVector<unsigned, 2> Members;
/// Address space of the involved pointers.
@@ -447,10 +447,10 @@ class RuntimePointerChecking {
TrackingVH<Value> PointerValue;
/// Holds the smallest byte address accessed by the pointer throughout all
/// iterations of the loop.
- const SCEV *Start;
+ SCEVUse Start;
/// Holds the largest byte address accessed by the pointer throughout all
/// iterations of the loop, plus 1.
- const SCEV *End;
+ SCEVUse End;
/// Holds the information if this pointer is used for writing to memory.
bool IsWritePtr;
/// Holds the id of the set of pointers that could be dependent because of a
@@ -463,7 +463,7 @@ class RuntimePointerChecking {
/// True if the pointer expressions needs to be frozen after expansion.
bool NeedsFreeze;
- PointerInfo(Value *PointerValue, const SCEV *Start, const SCEV *End,
+ PointerInfo(Value *PointerValue, SCEVUse Start, SCEVUse End,
bool IsWritePtr, unsigned DependencySetId, unsigned AliasSetId,
const SCEV *Expr, bool NeedsFreeze)
: PointerValue(PointerValue), Start(Start), End(End),
@@ -477,8 +477,10 @@ class RuntimePointerChecking {
/// Reset the state of the pointer runtime information.
void reset() {
Need = false;
+ AlwaysFalse = false;
Pointers.clear();
Checks.clear();
+ CheckingGroups.clear();
}
/// Insert a pointer and calculate the start and end SCEVs.
@@ -535,6 +537,8 @@ class RuntimePointerChecking {
/// This flag indicates if we need to add the runtime check.
bool Need = false;
+ bool AlwaysFalse = false;
+
/// Information about the pointers that may require checking.
SmallVector<PointerInfo, 2> Pointers;
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index bbbe6a1a8437e..7bf20166e1e63 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -203,13 +203,13 @@ RuntimeCheckingPtrGroup::RuntimeCheckingPtrGroup(
///
/// There is no conflict when the intervals are disjoint:
/// NoConflict = (P2.Start >= P1.End) || (P1.Start >= P2.End)
-static std::pair<const SCEV *, const SCEV *>
+static std::pair<SCEVUse, SCEVUse>
getStartAndEndForAccess(const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy,
PredicatedScalarEvolution &PSE) {
ScalarEvolution *SE = PSE.getSE();
- const SCEV *ScStart;
- const SCEV *ScEnd;
+ SCEVUse ScStart;
+ SCEVUse ScEnd;
if (SE->isLoopInvariant(PtrExpr, Lp)) {
ScStart = ScEnd = PtrExpr;
@@ -219,6 +219,8 @@ getStartAndEndForAccess(const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy,
ScStart = AR->getStart();
ScEnd = AR->evaluateAtIteration(Ex, *SE);
const SCEV *Step = AR->getStepRecurrence(*SE);
+ if (auto *Comm = dyn_cast<SCEVCommutativeExpr>(ScEnd))
+ ScEnd = SCEVUse(ScEnd, 2);
// For expressions with negative step, the upper bound is ScStart and the
// lower bound is ScEnd.
@@ -242,7 +244,10 @@ getStartAndEndForAccess(const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy,
auto &DL = Lp->getHeader()->getModule()->getDataLayout();
Type *IdxTy = DL.getIndexType(PtrExpr->getType());
const SCEV *EltSizeSCEV = SE->getStoreSizeOfExpr(IdxTy, AccessTy);
- ScEnd = SE->getAddExpr(ScEnd, EltSizeSCEV);
+ // TODO: this computes one-past-the-end. ScEnd + EltSizeSCEV - 1 is the last
+ // accessed byte. Not entirely sure if one-past-the-end must also not wrap? If
+ // it does, could compute and use last accessed byte instead.
+ ScEnd = SCEVUse(SE->getAddExpr(ScEnd, EltSizeSCEV), 2);
return {ScStart, ScEnd};
}
@@ -377,6 +382,11 @@ SmallVector<RuntimePointerCheck, 4> RuntimePointerChecking::generateChecks() {
if (needsChecking(CGI, CGJ)) {
CanUseDiffCheck = CanUseDiffCheck && tryToCreateDiffCheck(CGI, CGJ);
Checks.push_back(std::make_pair(&CGI, &CGJ));
+ if (SE->isKnownPredicate(CmpInst::ICMP_UGT, CGI.High, CGJ.Low) &&
+ SE->isKnownPredicate(CmpInst::ICMP_ULE, CGI.Low, CGJ.High)) {
+ AlwaysFalse = true;
+ return {};
+ }
}
}
}
@@ -631,8 +641,7 @@ void RuntimePointerChecking::print(raw_ostream &OS, unsigned Depth) const {
const auto &CG = CheckingGroups[I];
OS.indent(Depth + 2) << "Group " << &CG << ":\n";
- OS.indent(Depth + 4) << "(Low: " << *CG.Low << " High: " << *CG.High
- << ")\n";
+ OS.indent(Depth + 4) << "(Low: " << CG.Low << " High: " << CG.High << ")\n";
for (unsigned J = 0; J < CG.Members.size(); ++J) {
OS.indent(Depth + 6) << "Member: " << *Pointers[CG.Members[J]].Expr
<< "\n";
@@ -1268,6 +1277,7 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
// If we can do run-time checks, but there are no checks, no runtime checks
// are needed. This can happen when all pointers point to the same underlying
// object for example.
+ CanDoRT &= !RtCheck.AlwaysFalse;
RtCheck.Need = CanDoRT ? RtCheck.getNumberOfChecks() != 0 : MayNeedRTCheck;
bool CanDoRTIfNeeded = !RtCheck.Need || CanDoRT;
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 3e0f38ad387c4..d763ed193805f 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -11950,6 +11950,8 @@ bool ScalarEvolution::splitBinaryAdd(SCEVUse Expr, SCEVUse &L, SCEVUse &R,
L = AE->getOperand(0);
R = AE->getOperand(1);
Flags = AE->getNoWrapFlags();
+ Flags = setFlags(AE->getNoWrapFlags(),
+ static_cast<SCEV::NoWrapFlags>(Expr.getInt()));
return true;
}
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/different-strides-safe-dep-due-to-backedge-taken-count.ll b/llvm/test/Analysis/LoopAccessAnalysis/different-strides-safe-dep-due-to-backedge-taken-count.ll
index 8c7df4bdf5a5a..93dca30cd11d9 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/different-strides-safe-dep-due-to-backedge-taken-count.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/different-strides-safe-dep-due-to-backedge-taken-count.ll
@@ -41,10 +41,6 @@ define void @forward_dep_not_known_safe_due_to_backedge_taken_count(ptr %A) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe
; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Forward:
-; CHECK-NEXT: %l = load i32, ptr %gep.mul.2, align 4 ->
-; CHECK-NEXT: store i32 %add, ptr %gep, align 4
-; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
; CHECK-EMPTY:
@@ -109,13 +105,8 @@ exit:
define void @unknown_dep_not_known_safe_due_to_backedge_taken_count(ptr %A) {
; CHECK-LABEL: 'unknown_dep_not_known_safe_due_to_backedge_taken_count'
; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
-; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Memory dependences are safe
; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep, align 4 ->
-; CHECK-NEXT: store i32 %add, ptr %gep.mul.2, align 4
-; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
index cd388b4ee87f2..2f9f6dc39b19d 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
@@ -24,14 +24,14 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -58,14 +58,14 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea
; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP4]]:
-; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; RECURSE-NEXT: Group [[GRP5]]:
-; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%loop>
; RECURSE-NEXT: Group [[GRP6]]:
-; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%loop>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -132,16 +132,16 @@ define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture read
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP7]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP8]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP9]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; CHECK-NEXT: Group [[GRP10]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -171,16 +171,16 @@ define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture read
; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP11]]:
-; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP12]]:
-; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP13]]:
-; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP14]]:
-; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -232,16 +232,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture
; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP15]]:
-; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (800 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP16]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP17]]:
-; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
; CHECK-NEXT: Group [[GRP18]]:
-; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -271,16 +271,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture
; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP19]]:
-; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP20]]:
-; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP21]]:
-; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,8}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP22]]:
-; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -332,16 +332,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture
; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP23]]:
-; CHECK-NEXT: (Low: %Dest High: (399 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (399 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP24]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP25]]:
-; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; CHECK-NEXT: Group [[GRP26]]:
-; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -371,16 +371,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture
; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP27]]:
-; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP28]]:
-; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP29]]:
-; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP30]]:
-; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -432,16 +432,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture r
; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP31]]:
-; CHECK-NEXT: (Low: %Dest High: (100 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (100 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP32]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP33]]:
-; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body>
; CHECK-NEXT: Group [[GRP34]]:
-; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -471,16 +471,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture r
; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP35]]:
-; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP36]]:
-; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP37]]:
-; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,1}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP38]]:
-; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,1}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -532,16 +532,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(pt
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP39]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body>
; CHECK-NEXT: Group [[GRP40]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP41]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; CHECK-NEXT: Group [[GRP42]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -571,16 +571,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(pt
; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP43]]:
-; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; RECURSE-NEXT: Member: {%Dest,+,4}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP44]]:
-; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP45]]:
-; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP46]]:
-; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw))
; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -696,13 +696,13 @@ define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, p
; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP47]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP48]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP49]]:
-; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
+; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base)(u nuw))
; CHECK-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
@@ -764,13 +764,13 @@ define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base,
; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP50]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP51]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP52]]:
-; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base))
+; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base)(u nuw))
; CHECK-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
@@ -832,13 +832,13 @@ define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base,
; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP53]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP54]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP55]]:
-; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base))
+; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base)(u nuw))
; CHECK-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
; CHECK-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
@@ -1256,10 +1256,10 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP56]]:
-; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1))
+; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1)(u nuw))
; CHECK-NEXT: Member: %Base1
; CHECK-NEXT: Group [[GRP57]]:
-; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
+; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)(u nuw))
; CHECK-NEXT: Member: {%Base2,+,8}<%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -1283,10 +1283,10 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
; RECURSE-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP58]]:
-; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1))
+; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1)(u nuw))
; RECURSE-NEXT: Member: %Base1
; RECURSE-NEXT: Group [[GRP59]]:
-; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
+; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)(u nuw))
; RECURSE-NEXT: Member: {%Base2,+,8}<%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -1345,16 +1345,16 @@ define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP60]]:
-; CHECK-NEXT: (Low: %1 High: (63992 + %1))
+; CHECK-NEXT: (Low: %1 High: (63992 + %1)(u nuw))
; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body>
; CHECK-NEXT: Group [[GRP63]]:
-; CHECK-NEXT: (Low: %2 High: (63992 + %2))
+; CHECK-NEXT: (Low: %2 High: (63992 + %2)(u nuw))
; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body>
; CHECK-NEXT: Group [[GRP61]]:
-; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds))
+; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds)(u nuw))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; CHECK-NEXT: Group [[GRP62]]:
-; CHECK-NEXT: (Low: %0 High: (63992 + %0))
+; CHECK-NEXT: (Low: %0 High: (63992 + %0)(u nuw))
; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -1389,16 +1389,16 @@ define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr
; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
; RECURSE-NEXT: Grouped accesses:
; RECURSE-NEXT: Group [[GRP64]]:
-; RECURSE-NEXT: (Low: %1 High: (63992 + %1))
+; RECURSE-NEXT: (Low: %1 High: (63992 + %1)(u nuw))
; RECURSE-NEXT: Member: {%1,+,8}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP67]]:
-; RECURSE-NEXT: (Low: %2 High: (63992 + %2))
+; RECURSE-NEXT: (Low: %2 High: (63992 + %2)(u nuw))
; RECURSE-NEXT: Member: {%2,+,8}<nw><%for.body>
; RECURSE-NEXT: Group [[GRP65]]:
-; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds))
+; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds)(u nuw))
; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
; RECURSE-NEXT: Group [[GRP66]]:
-; RECURSE-NEXT: (Low: %0 High: (63992 + %0))
+; RECURSE-NEXT: (Low: %0 High: (63992 + %0)(u nuw))
; RECURSE-NEXT: Member: {%0,+,8}<nw><%for.body>
; RECURSE-EMPTY:
; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll b/llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll
index 723d01b38f453..f57b0995ae46f 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll
@@ -182,10 +182,10 @@ define void @test_btc_is_unknown_value(ptr %a, i32 %N) {
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP1:0x[0-9a-f]+]]:
-; CHECK-NEXT: (Low: (400 + %a) High: (404 + %a))
+; CHECK-NEXT: (Low: (400 + %a) High: (404 + %a)(u nuw))
; CHECK-NEXT: Member: (400 + %a)
; CHECK-NEXT: Group [[GRP2:0x[0-9a-f]+]]:
-; CHECK-NEXT: (Low: %a High: (4 + (4 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %a))
+; CHECK-NEXT: (Low: %a High: (4 + (4 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %a)(u nuw))
; CHECK-NEXT: Member: {%a,+,4}<nw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/loops-with-indirect-reads-and-writes.ll b/llvm/test/Analysis/LoopAccessAnalysis/loops-with-indirect-reads-and-writes.ll
index fd4f417e57b63..bd50a92484504 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/loops-with-indirect-reads-and-writes.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/loops-with-indirect-reads-and-writes.ll
@@ -98,10 +98,10 @@ define void @test_indirect_read_loop_also_modifies_pointer_array(ptr noundef %ar
; CHECK-NEXT: %gep.iv.1 = getelementptr inbounds ptr, ptr %arr, i64 %iv.1
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>)
+; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>(u nuw))
; CHECK-NEXT: Member: {{\{\{}}(64 + %arr),+,64}<%loop.1>,+,8}<%loop.2>
; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: %arr High: (8000 + %arr))
+; CHECK-NEXT: (Low: %arr High: (8000 + %arr)(u nuw))
; CHECK-NEXT: Member: {%arr,+,8}<nuw><%loop.2>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -166,10 +166,10 @@ define void @test_indirect_write_loop_also_modifies_pointer_array(ptr noundef %a
; CHECK-NEXT: %gep.iv.1 = getelementptr inbounds ptr, ptr %arr, i64 %iv.1
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>)
+; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>(u nuw))
; CHECK-NEXT: Member: {{\{\{}}(64 + %arr),+,64}<%loop.1>,+,8}<%loop.2>
; CHECK-NEXT: Group [[GRP4]]:
-; CHECK-NEXT: (Low: %arr High: (8000 + %arr))
+; CHECK-NEXT: (Low: %arr High: (8000 + %arr)(u nuw))
; CHECK-NEXT: Member: {%arr,+,8}<nuw><%loop.2>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll b/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
index c358b00dad22a..7ce6657ed0dec 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
@@ -61,10 +61,10 @@ define void @offset_i32_known_positive_via_assume_forward_dep_1(ptr %A, i64 %off
; CHECK-NEXT: %gep.off = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: %A High: (-3 + (4 * %N) + %A))
+; CHECK-NEXT: (Low: %A High: (-3 + (4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: (-3 + (4 * %offset)<nsw> + (4 * %N) + %A))
+; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: (-3 + (4 * %offset)<nsw> + (4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -152,10 +152,10 @@ define void @offset_may_be_negative_via_assume_unknown_dep(ptr %A, i64 %offset,
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A))
+; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
; CHECK-NEXT: Group [[GRP4]]:
-; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A))
+; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -199,10 +199,10 @@ define void @offset_no_assumes(ptr %A, i64 %offset, i64 %N) {
; CHECK-NEXT: %gep.off = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP5]]:
-; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A))
+; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
; CHECK-NEXT: Group [[GRP6]]:
-; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A))
+; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A)(u nuw))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
index a214451bfd3fd..4cf5ed2242ac0 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
@@ -112,13 +112,13 @@ define i32 @store_with_pointer_phi_runtime_checks(ptr %A, ptr %B, ptr %C) {
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: %B High: (256000 + %B))
+; CHECK-NEXT: (Low: %B High: (256000 + %B)(u nuw))
; CHECK-NEXT: Member: {%B,+,8}<nw><%loop.header>
; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: %C High: (256000 + %C))
+; CHECK-NEXT: (Low: %C High: (256000 + %C)(u nuw))
; CHECK-NEXT: Member: {%C,+,8}<nw><%loop.header>
; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: (Low: %A High: (256000 + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,8}<nw><%loop.header>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -278,13 +278,13 @@ define i32 @store_with_pointer_phi_incoming_phi(ptr %A, ptr %B, ptr %C, i1 %c.0,
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP4]]:
-; CHECK-NEXT: (Low: %C High: (8 + %C))
+; CHECK-NEXT: (Low: %C High: (8 + %C)(u nuw))
; CHECK-NEXT: Member: %C
; CHECK-NEXT: Group [[GRP5]]:
-; CHECK-NEXT: (Low: %B High: (8 + %B))
+; CHECK-NEXT: (Low: %B High: (8 + %B)(u nuw))
; CHECK-NEXT: Member: %B
; CHECK-NEXT: Group [[GRP6]]:
-; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: (Low: %A High: (256000 + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
; CHECK-NEXT: Member: %A
; CHECK-EMPTY:
@@ -361,13 +361,13 @@ define i32 @store_with_pointer_phi_incoming_phi_irreducible_cycle(ptr %A, ptr %B
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP7]]:
-; CHECK-NEXT: (Low: %C High: (8 + %C))
+; CHECK-NEXT: (Low: %C High: (8 + %C)(u nuw))
; CHECK-NEXT: Member: %C
; CHECK-NEXT: Group [[GRP8]]:
-; CHECK-NEXT: (Low: %B High: (8 + %B))
+; CHECK-NEXT: (Low: %B High: (8 + %B)(u nuw))
; CHECK-NEXT: Member: %B
; CHECK-NEXT: Group [[GRP9]]:
-; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: (Low: %A High: (256000 + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
; CHECK-NEXT: Member: %A
; CHECK-EMPTY:
@@ -533,15 +533,15 @@ define void @phi_load_store_memdep_check(i1 %c, ptr %A, ptr %B, ptr %C) {
; CHECK-NEXT: ptr %B
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group [[GRP10]]:
-; CHECK-NEXT: (Low: %A High: (2 + %A))
+; CHECK-NEXT: (Low: %A High: (2 + %A)(u nuw))
; CHECK-NEXT: Member: %A
; CHECK-NEXT: Member: %A
; CHECK-NEXT: Group [[GRP11]]:
-; CHECK-NEXT: (Low: %C High: (2 + %C))
+; CHECK-NEXT: (Low: %C High: (2 + %C)(u nuw))
; CHECK-NEXT: Member: %C
; CHECK-NEXT: Member: %C
; CHECK-NEXT: Group [[GRP12]]:
-; CHECK-NEXT: (Low: %B High: (2 + %B))
+; CHECK-NEXT: (Low: %B High: (2 + %B)(u nuw))
; CHECK-NEXT: Member: %B
; CHECK-NEXT: Member: %B
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll
index 08e0bae7f05ba..52f23b487dcf8 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll
@@ -8,21 +8,10 @@ target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
define void @test_distance_positive_independent_via_trip_count(ptr %A) {
; CHECK-LABEL: 'test_distance_positive_independent_via_trip_count'
; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Memory dependences are safe
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.400, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: (400 + %A)<nuw> High: (804 + %A))
-; CHECK-NEXT: Member: {(400 + %A)<nuw>,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: %A High: (101 + %A))
-; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
; CHECK-NEXT: SCEV assumptions:
@@ -53,21 +42,10 @@ exit:
define void @test_distance_positive_backwards(ptr %A) {
; CHECK-LABEL: 'test_distance_positive_backwards'
; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Report: cannot check memory dependencies at runtime
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A))
-; CHECK-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
-; CHECK-NEXT: (Low: %A High: (101 + %A))
-; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
; CHECK-NEXT: SCEV assumptions:
@@ -100,16 +78,16 @@ define void @test_distance_positive_via_assume(ptr %A, i64 %off) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
-; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
+; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A)(u nuw))
; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
-; CHECK-NEXT: (Low: %A High: (101 + %A))
+; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: (Low: %A High: (101 + %A)(u nuw))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
index 323ba2a739cf8..ea354f468c0ef 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll
@@ -22,21 +22,10 @@ define ptr @test_ptr_range_end_computed_before_and_after_loop(ptr %A) {
;
; LAA-LABEL: 'test_ptr_range_end_computed_before_and_after_loop'
; LAA-NEXT: loop:
-; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Report: cannot check memory dependencies at runtime
; LAA-NEXT: Dependences:
; LAA-NEXT: Run-time memory checks:
-; LAA-NEXT: Check 0:
-; LAA-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
-; LAA-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; LAA-NEXT: Grouped accesses:
-; LAA-NEXT: Group [[GRP1]]:
-; LAA-NEXT: (Low: (1 + %A) High: (405 + %A))
-; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop>
-; LAA-NEXT: Group [[GRP2]]:
-; LAA-NEXT: (Low: %A High: (101 + %A))
-; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
; LAA-EMPTY:
; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
; LAA-NEXT: SCEV assumptions:
@@ -80,21 +69,10 @@ define void @test_ptr_range_end_computed_before_loop(ptr %A) {
;
; LAA-LABEL: 'test_ptr_range_end_computed_before_loop'
; LAA-NEXT: loop:
-; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Report: cannot check memory dependencies at runtime
; LAA-NEXT: Dependences:
; LAA-NEXT: Run-time memory checks:
-; LAA-NEXT: Check 0:
-; LAA-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
-; LAA-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; LAA-NEXT: Grouped accesses:
-; LAA-NEXT: Group [[GRP3]]:
-; LAA-NEXT: (Low: (1 + %A) High: (405 + %A))
-; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop>
-; LAA-NEXT: Group [[GRP4]]:
-; LAA-NEXT: (Low: %A High: (101 + %A))
-; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
; LAA-EMPTY:
; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
; LAA-NEXT: SCEV assumptions:
@@ -135,21 +113,10 @@ define ptr @test_ptr_range_end_computed_after_loop(ptr %A) {
;
; LAA-LABEL: 'test_ptr_range_end_computed_after_loop'
; LAA-NEXT: loop:
-; LAA-NEXT: Memory dependences are safe with run-time checks
+; LAA-NEXT: Report: cannot check memory dependencies at runtime
; LAA-NEXT: Dependences:
; LAA-NEXT: Run-time memory checks:
-; LAA-NEXT: Check 0:
-; LAA-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
-; LAA-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
-; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; LAA-NEXT: Grouped accesses:
-; LAA-NEXT: Group [[GRP5]]:
-; LAA-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A))
-; LAA-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop>
-; LAA-NEXT: Group [[GRP6]]:
-; LAA-NEXT: (Low: %A High: (101 + %A))
-; LAA-NEXT: Member: {%A,+,1}<nuw><%loop>
; LAA-EMPTY:
; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop.
; LAA-NEXT: SCEV assumptions:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/unknown-dependence-retry-with-runtime-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/unknown-dependence-retry-with-runtime-checks.ll
index 23ab92d75cbcd..fa863d6c4577c 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/unknown-dependence-retry-with-runtime-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/unknown-dependence-retry-with-runtime-checks.ll
@@ -10,32 +10,10 @@ declare void @llvm.assume(i1)
define void @test_dependence_with_non_constant_offset_and_other_accesses_to_noalias_pointers(ptr %A, ptr noalias %B, i64 %off) {
; CHECK-LABEL: 'test_dependence_with_non_constant_offset_and_other_accesses_to_noalias_pointers'
; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Report: cannot check memory dependencies at runtime
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
-; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
-; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
-; CHECK-NEXT: (Low: %A High: (101 + %A))
-; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP3]]:
-; CHECK-NEXT: (Low: %B High: (101 + %B))
-; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
-; CHECK-NEXT: (Low: (1 + %B)<nuw> High: (102 + %B))
-; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
; CHECK-NEXT: SCEV assumptions:
@@ -70,47 +48,10 @@ exit:
define void @test_dependence_with_non_constant_offset_and_other_accesses_to_mayalias_pointers(ptr %A, ptr %B, i64 %off) {
; CHECK-LABEL: 'test_dependence_with_non_constant_offset_and_other_accesses_to_mayalias_pointers'
; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Report: cannot check memory dependencies at runtime
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
-; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
-; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
-; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
-; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7]]):
-; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
-; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8]]):
-; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
-; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
-; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
-; CHECK-NEXT: (Low: %B High: (101 + %B))
-; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP7]]:
-; CHECK-NEXT: (Low: %A High: (101 + %A))
-; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP8]]:
-; CHECK-NEXT: (Low: (1 + %B)<nuw> High: (102 + %B))
-; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
; CHECK-NEXT: SCEV assumptions:
More information about the llvm-branch-commits
mailing list