[llvm] [LAA] Always use DepCands when grouping runtime checks. (PR #91196)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Wed Aug 20 13:51:39 PDT 2025
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/91196
>From 1059eb7d20b071289250c6e95e9ac51e6f2c6524 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sun, 5 May 2024 13:00:23 +0100
Subject: [PATCH 1/4] [LAA] Always use DepCands when grouping runtime checks.
Update groupChecks to always use DepCands to try and merge runtime
checks. DepCands contains the dependency partition, grouping together
all accessed pointers to he same underlying objects.
If we computed the dependencies, We only need to check accesses to the
same underlying object, if there is an unknown dependency for this
underlying object; otherwise we already proved that all accesses withing
the underlying object are safe w.r.t. vectorization and we only need
to check that accesses to the underlying object don't overlap with
accesses to other underlying objects.
To ensure runtime checks are generated for the case with unknown
dependencies, remove equivalence classes containing accesses involved in
unknown dependencies.
This reduces the number of runtime checks needed in case non-constant
dependence distances are found, and is in preparation for removing the
restriction that the accesses need to have the same stride which was
added in https://github.com/llvm/llvm-project/pull/88039.
---
llvm/include/llvm/ADT/EquivalenceClasses.h | 12 +++
.../llvm/Analysis/LoopAccessAnalysis.h | 11 +--
llvm/lib/Analysis/LoopAccessAnalysis.cpp | 96 +++++++++++--------
.../loops-with-indirect-reads-and-writes.ll | 8 ++
.../multiple-strides-rt-memory-checks.ll | 12 +++
...endence-distance-different-access-sizes.ll | 12 +++
.../resort-to-memchecks-only.ll | 4 +
...wn-dependence-retry-with-runtime-checks.ll | 61 ++++++------
.../Inputs/loop-access-analysis.ll.expected | 4 +
9 files changed, 142 insertions(+), 78 deletions(-)
diff --git a/llvm/include/llvm/ADT/EquivalenceClasses.h b/llvm/include/llvm/ADT/EquivalenceClasses.h
index 4f98b84cf97d2..ef54c068d245d 100644
--- a/llvm/include/llvm/ADT/EquivalenceClasses.h
+++ b/llvm/include/llvm/ADT/EquivalenceClasses.h
@@ -233,6 +233,18 @@ class EquivalenceClasses {
return findLeader(TheMapping.find(V));
}
+ /// Erase the class containing \p V.
+ void eraseClass(const ElemTy &V) {
+ if (TheMapping.find(V) == TheMapping.end())
+ return;
+ auto LeaderI = findValue(getLeaderValue(V));
+ for (auto MI = member_begin(LeaderI), ME = member_end(); MI != ME;) {
+ const auto &ToErase = *MI;
+ ++MI;
+ TheMapping.erase(ToErase);
+ }
+ }
+
/// union - Merge the two equivalence sets for the specified values, inserting
/// them if they do not already exist in the equivalence set.
member_iterator unionSets(const ElemTy &V1, const ElemTy &V2) {
diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
index cf998e66ee486..11e185a687cab 100644
--- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -453,8 +453,8 @@ class RuntimePointerChecking {
/// Generate the checks and store it. This also performs the grouping
/// of pointers to reduce the number of memchecks necessary.
- void generateChecks(MemoryDepChecker::DepCandidates &DepCands,
- bool UseDependencies);
+ void generateChecks(const MemoryDepChecker &DepChecker,
+ MemoryDepChecker::DepCandidates &DepCands);
/// Returns the checks that generateChecks created. They can be used to ensure
/// no read/write accesses overlap across all loop iterations.
@@ -521,10 +521,9 @@ class RuntimePointerChecking {
private:
/// Groups pointers such that a single memcheck is required
/// between two different groups. This will clear the CheckingGroups vector
- /// and re-compute it. We will only group dependecies if \p UseDependencies
- /// is true, otherwise we will create a separate group for each pointer.
- void groupChecks(MemoryDepChecker::DepCandidates &DepCands,
- bool UseDependencies);
+ /// and re-compute it.
+ void groupChecks(const MemoryDepChecker &DepChecker,
+ MemoryDepChecker::DepCandidates &DepCands);
/// Generate the checks and return them.
SmallVector<RuntimePointerCheck, 4> generateChecks();
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index ae7f0373c4e84..77b44b4894f37 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -385,9 +385,10 @@ SmallVector<RuntimePointerCheck, 4> RuntimePointerChecking::generateChecks() {
}
void RuntimePointerChecking::generateChecks(
- MemoryDepChecker::DepCandidates &DepCands, bool UseDependencies) {
+ const MemoryDepChecker &DepChecker,
+ MemoryDepChecker::DepCandidates &DepCands) {
assert(Checks.empty() && "Checks is not empty");
- groupChecks(DepCands, UseDependencies);
+ groupChecks(DepChecker, DepCands);
Checks = generateChecks();
}
@@ -454,7 +455,8 @@ bool RuntimeCheckingPtrGroup::addPointer(unsigned Index, const SCEV *Start,
}
void RuntimePointerChecking::groupChecks(
- MemoryDepChecker::DepCandidates &DepCands, bool UseDependencies) {
+ const MemoryDepChecker &DepChecker,
+ MemoryDepChecker::DepCandidates &DepCands) {
// We build the groups from dependency candidates equivalence classes
// because:
// - We know that pointers in the same equivalence class share
@@ -490,21 +492,11 @@ void RuntimePointerChecking::groupChecks(
// us to perform an accurate check in this case.
//
// The above case requires that we have an UnknownDependence between
- // accesses to the same underlying object. This cannot happen unless
- // FoundNonConstantDistanceDependence is set, and therefore UseDependencies
- // is also false. In this case we will use the fallback path and create
- // separate checking groups for all pointers.
-
- // If we don't have the dependency partitions, construct a new
- // checking pointer group for each pointer. This is also required
- // for correctness, because in this case we can have checking between
- // pointers to the same underlying object.
- if (!UseDependencies) {
- for (unsigned I = 0; I < Pointers.size(); ++I)
- CheckingGroups.push_back(RuntimeCheckingPtrGroup(I, *this));
- return;
- }
-
+ // accesses to the same underlying object. It is the caller's responsibility
+ // to clear any entries for accesses with unknown dependencies from the
+ // dependency partition (DepCands). This is required for correctness, because
+ // in this case we can have checking between pointers to the same underlying
+ // object.
unsigned TotalComparisons = 0;
DenseMap<Value *, SmallVector<unsigned>> PositionMap;
@@ -529,6 +521,13 @@ void RuntimePointerChecking::groupChecks(
MemoryDepChecker::MemAccessInfo Access(Pointers[I].PointerValue,
Pointers[I].IsWritePtr);
+ // If there is no entry in the dependency partition, there are no potential
+ // accesses to merge; simply add a new pointer checking group.
+ if (DepCands.findValue(Access) == DepCands.end()) {
+ CheckingGroups.push_back(RuntimeCheckingPtrGroup(I, *this));
+ continue;
+ }
+
SmallVector<RuntimeCheckingPtrGroup, 2> Groups;
auto LeaderI = DepCands.findValue(DepCands.getLeaderValue(Access));
@@ -700,8 +699,10 @@ class AccessAnalysis {
///
/// Returns true if we need no check or if we do and we can generate them
/// (i.e. the pointers have computable bounds).
- bool canCheckPtrAtRT(RuntimePointerChecking &RtCheck, ScalarEvolution *SE,
- Loop *TheLoop, const DenseMap<Value *, const SCEV *> &Strides,
+ bool canCheckPtrAtRT(const MemoryDepChecker &DepChecker,
+ RuntimePointerChecking &RtCheck, ScalarEvolution *SE,
+ Loop *TheLoop,
+ const DenseMap<Value *, const SCEV *> &Strides,
Value *&UncomputablePtr, bool ShouldCheckWrap = false);
/// Goes over all memory accesses, checks whether a RT check is needed
@@ -717,12 +718,6 @@ class AccessAnalysis {
/// dependency checking (i.e. FoundNonConstantDistanceDependence).
bool isDependencyCheckNeeded() { return !CheckDeps.empty(); }
- /// We decided that no dependence analysis would be used. Reset the state.
- void resetDepChecks(MemoryDepChecker &DepChecker) {
- CheckDeps.clear();
- DepChecker.clearDependences();
- }
-
MemAccessInfoList &getDependenciesToCheck() { return CheckDeps; }
const DenseMap<Value *, SmallVector<const Value *, 16>> &
@@ -1107,7 +1102,8 @@ bool AccessAnalysis::createCheckForAccess(RuntimePointerChecking &RtCheck,
// The id of the dependence set.
unsigned DepId;
- if (isDependencyCheckNeeded()) {
+ if (isDependencyCheckNeeded() &&
+ DepCands.findValue(Access) != DepCands.end()) {
Value *Leader = DepCands.getLeaderValue(Access).getPointer();
unsigned &LeaderId = DepSetId[Leader];
if (!LeaderId)
@@ -1126,10 +1122,11 @@ bool AccessAnalysis::createCheckForAccess(RuntimePointerChecking &RtCheck,
return true;
}
-bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
- ScalarEvolution *SE, Loop *TheLoop,
- const DenseMap<Value *, const SCEV *> &StridesMap,
- Value *&UncomputablePtr, bool ShouldCheckWrap) {
+bool AccessAnalysis::canCheckPtrAtRT(
+ const MemoryDepChecker &DepChecker, RuntimePointerChecking &RtCheck,
+ ScalarEvolution *SE, Loop *TheLoop,
+ const DenseMap<Value *, const SCEV *> &StridesMap, Value *&UncomputablePtr,
+ bool ShouldCheckWrap) {
// Find pointers with computable bounds. We are going to use this information
// to place a runtime bound check.
bool CanDoRT = true;
@@ -1137,7 +1134,26 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
bool MayNeedRTCheck = false;
if (!IsRTCheckAnalysisNeeded) return true;
- bool IsDepCheckNeeded = isDependencyCheckNeeded();
+ if (auto *Deps = DepChecker.getDependences()) {
+ // If there are unknown dependences, this means runtime checks are needed to
+ // ensure there's no overlap between accesses to the same underlying object.
+ // Remove the equivalence classes containing both source and destination
+ // accesses from DepCands. This ensures runtime checks will be generated
+ // between those accesses and prevents them from being grouped together.
+ for (const auto &Dep : *Deps) {
+ if (Dep.Type != MemoryDepChecker::Dependence::Unknown) {
+ assert(MemoryDepChecker::Dependence::isSafeForVectorization(Dep.Type) ==
+ MemoryDepChecker::VectorizationSafetyStatus::Safe &&
+ "Should only skip safe dependences");
+ continue;
+ }
+ Instruction *Src = Dep.getSource(DepChecker);
+ Instruction *Dst = Dep.getDestination(DepChecker);
+ DepCands.eraseClass({getPointerOperand(Src), Src->mayWriteToMemory()});
+ DepCands.eraseClass({getPointerOperand(Dst), Dst->mayWriteToMemory()});
+ }
+ } else
+ CheckDeps.clear();
// We assign a consecutive id to access from different alias sets.
// Accesses between different groups doesn't need to be checked.
@@ -1265,7 +1281,7 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck,
}
if (MayNeedRTCheck && CanDoRT)
- RtCheck.generateChecks(DepCands, IsDepCheckNeeded);
+ RtCheck.generateChecks(DepChecker, DepCands);
LLVM_DEBUG(dbgs() << "LAA: We need to do " << RtCheck.getNumberOfChecks()
<< " pointer comparisons.\n");
@@ -2625,9 +2641,9 @@ void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
// Find pointers with computable bounds. We are going to use this information
// to place a runtime bound check.
Value *UncomputablePtr = nullptr;
- bool CanDoRTIfNeeded =
- Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop,
- SymbolicStrides, UncomputablePtr, false);
+ bool CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(
+ getDepChecker(), *PtrRtChecking, PSE->getSE(), TheLoop, SymbolicStrides,
+ UncomputablePtr, false);
if (!CanDoRTIfNeeded) {
auto *I = dyn_cast_or_null<Instruction>(UncomputablePtr);
recordAnalysis("CantIdentifyArrayBounds", I)
@@ -2651,16 +2667,14 @@ void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
if (!CanVecMem && DepChecker->shouldRetryWithRuntimeCheck()) {
LLVM_DEBUG(dbgs() << "LAA: Retrying with memory checks\n");
- // Clear the dependency checks. We assume they are not needed.
- Accesses.resetDepChecks(*DepChecker);
-
PtrRtChecking->reset();
PtrRtChecking->Need = true;
auto *SE = PSE->getSE();
UncomputablePtr = nullptr;
- CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(
- *PtrRtChecking, SE, TheLoop, SymbolicStrides, UncomputablePtr, true);
+ CanDoRTIfNeeded =
+ Accesses.canCheckPtrAtRT(getDepChecker(), *PtrRtChecking, SE, TheLoop,
+ SymbolicStrides, UncomputablePtr, true);
// Check that we found the bounds for the pointer.
if (!CanDoRTIfNeeded) {
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..4143c70c7b610 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
@@ -90,6 +90,10 @@ define void @test_indirect_read_loop_also_modifies_pointer_array(ptr noundef %ar
; CHECK-NEXT: loop.2:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l.1 = load ptr, ptr %gep.iv.1, align 8, !tbaa !0 ->
+; CHECK-NEXT: store i64 %l.2, ptr %gep.iv.2, align 8, !tbaa !0
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
@@ -158,6 +162,10 @@ define void @test_indirect_write_loop_also_modifies_pointer_array(ptr noundef %a
; CHECK-NEXT: loop.2:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l.1 = load ptr, ptr %gep.iv.1, align 8, !tbaa !0 ->
+; CHECK-NEXT: store ptr %l.1, ptr %gep.iv.2, align 8, !tbaa !0
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
index 3b4f2a170d8cb..12e69cd0cdbe3 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
@@ -25,6 +25,18 @@
; CHECK: .inner:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %4 = load i32, ptr %1, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %3 = load i32, ptr %2, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %7 = load i32, ptr %6, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK: Check 0:
; CHECK: Check 1:
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..41f6f676a108f 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
@@ -10,6 +10,10 @@ define void @test_distance_positive_independent_via_trip_count(ptr %A) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
+; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
@@ -55,6 +59,10 @@ define void @test_distance_positive_backwards(ptr %A) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
+; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
@@ -98,6 +106,10 @@ define void @test_distance_positive_via_assume(ptr %A, i64 %off) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
+; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll b/llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll
index b5ba85c6e3fa8..7cf334c246a9a 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll
@@ -13,6 +13,10 @@ target triple = "x86_64-apple-macosx10.10.0"
; CHECK: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %loadA = load i16, ptr %arrayidxA, align 2 ->
+; CHECK-NEXT: store i16 %mul1, ptr %arrayidxA2, align 2
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: 0:
; CHECK-NEXT: Comparing group
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..54a966c56f0df 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
@@ -12,17 +12,20 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_noal
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
+; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l.2 = load i8, ptr %gep.B.1, align 1 ->
+; CHECK-NEXT: store i8 %l.2, ptr %gep.B, align 1
+; CHECK-EMPTY:
; 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))
@@ -30,12 +33,10 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_noal
; 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: Group [[GRP3:0x[0-9a-f]+]]:
+; CHECK-NEXT: (Low: %B High: (102 + %B))
; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
+; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
; CHECK-EMPTY:
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
; CHECK-NEXT: SCEV assumptions:
@@ -72,45 +73,43 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_maya
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l.2 = load i8, ptr %gep.B.1, align 1 ->
+; CHECK-NEXT: store i8 %l.2, ptr %gep.B, align 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
+; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group ([[GRP4: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 ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group ([[GRP4]]):
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group ([[GRP6: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: Against group ([[GRP6]]):
; 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: Group [[GRP4]]:
; 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: Group [[GRP5]]:
+; CHECK-NEXT: (Low: %B High: (102 + %B))
+; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group [[GRP6]]:
; 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:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
index 58655ff979afc..a11317140daaa 100644
--- a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
@@ -72,6 +72,10 @@ define void @test_brace_escapes(ptr noundef %arr) {
; CHECK-NEXT: loop.2:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l.1 = load ptr, ptr %gep.iv.1, align 8 ->
+; CHECK-NEXT: store ptr %l.1, ptr %gep.iv.2, align 8
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
>From 2943e8873437be62d2ed097fb17dd2bf64729de1 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 22 May 2024 14:38:11 +0100
Subject: [PATCH 2/4] !fixup update new tests.
---
.../non-constant-distance-backward.ll | 16 ++++++++++++++++
.../offset-range-known-via-assume.ll | 12 ++++++++++++
2 files changed, 28 insertions(+)
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
index 0058135a30d67..2b3861330a568 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
@@ -14,6 +14,10 @@ define void @backward_min_distance_8(ptr %A, i64 %N) {
; COMMON-NEXT: loop:
; COMMON-NEXT: Memory dependences are safe with run-time checks
; COMMON-NEXT: Dependences:
+; COMMON-NEXT: Unknown:
+; COMMON-NEXT: %l = load i8, ptr %gep, align 4 ->
+; COMMON-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; COMMON-EMPTY:
; COMMON-NEXT: Run-time memory checks:
; COMMON-NEXT: Check 0:
; COMMON-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
@@ -76,6 +80,10 @@ define void @backward_min_distance_120(ptr %A, i64 %N) {
; COMMON-NEXT: loop:
; COMMON-NEXT: Memory dependences are safe with run-time checks
; COMMON-NEXT: Dependences:
+; COMMON-NEXT: Unknown:
+; COMMON-NEXT: %l = load i8, ptr %gep, align 4 ->
+; COMMON-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; COMMON-EMPTY:
; COMMON-NEXT: Run-time memory checks:
; COMMON-NEXT: Check 0:
; COMMON-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
@@ -138,6 +146,10 @@ define void @backward_min_distance_128(ptr %A, i64 %N) {
; COMMON-NEXT: loop:
; COMMON-NEXT: Memory dependences are safe with run-time checks
; COMMON-NEXT: Dependences:
+; COMMON-NEXT: Unknown:
+; COMMON-NEXT: %l = load i8, ptr %gep, align 4 ->
+; COMMON-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; COMMON-EMPTY:
; COMMON-NEXT: Run-time memory checks:
; COMMON-NEXT: Check 0:
; COMMON-NEXT: Comparing group ([[GRP13:0x[0-9a-f]+]]):
@@ -200,6 +212,10 @@ define void @backward_min_distance_256(ptr %A, i64 %N) {
; MAXLEN-NEXT: loop:
; MAXLEN-NEXT: Memory dependences are safe with run-time checks
; MAXLEN-NEXT: Dependences:
+; MAXLEN-NEXT: Unknown:
+; MAXLEN-NEXT: %l = load i8, ptr %gep, align 4 ->
+; MAXLEN-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; MAXLEN-EMPTY:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
; MAXLEN-NEXT: Comparing group ([[GRP17:0x[0-9a-f]+]]):
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..7b965add38313 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
@@ -53,6 +53,10 @@ define void @offset_i32_known_positive_via_assume_forward_dep_1(ptr %A, i64 %off
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i8, ptr %gep.off, align 4 ->
+; CHECK-NEXT: store i8 %add, ptr %gep, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
@@ -144,6 +148,10 @@ define void @offset_may_be_negative_via_assume_unknown_dep(ptr %A, i64 %offset,
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; 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: Check 0:
; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
@@ -191,6 +199,10 @@ define void @offset_no_assumes(ptr %A, i64 %offset, i64 %N) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.off, align 4 ->
+; CHECK-NEXT: store i32 %add, ptr %gep, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]):
>From a12665a9ed7e44ae4a95ff9c9a5381162cc4fab9 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 19 Aug 2025 16:06:13 +0100
Subject: [PATCH 3/4] Update after merge.
---
llvm/include/llvm/ADT/EquivalenceClasses.h | 4 +--
llvm/lib/Analysis/LoopAccessAnalysis.cpp | 17 +++++-----
.../multiple-strides-rt-memory-checks.ll | 12 +++++++
...ter-dependence-analysis-forked-pointers.ll | 30 ++++++++++-------
.../runtime-checks-difference.ll | 32 ++++++++-----------
5 files changed, 54 insertions(+), 41 deletions(-)
diff --git a/llvm/include/llvm/ADT/EquivalenceClasses.h b/llvm/include/llvm/ADT/EquivalenceClasses.h
index db21f47db4ee2..985a58668d1d6 100644
--- a/llvm/include/llvm/ADT/EquivalenceClasses.h
+++ b/llvm/include/llvm/ADT/EquivalenceClasses.h
@@ -297,8 +297,8 @@ template <class ElemTy> class EquivalenceClasses {
void eraseClass(const ElemTy &V) {
if (TheMapping.find(V) == TheMapping.end())
return;
- auto LeaderI = findValue(getLeaderValue(V));
- for (auto MI = member_begin(LeaderI), ME = member_end(); MI != ME;) {
+ auto LeaderI = members(V);
+ for (auto MI = LeaderI.begin(), ME = LeaderI.end(); MI != ME;) {
const auto &ToErase = *MI;
++MI;
TheMapping.erase(ToErase);
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index f904c0705abbc..543dd735fe8cb 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -640,7 +640,7 @@ void RuntimePointerChecking::groupChecks(
// If there is no entry in the dependency partition, there are no potential
// accesses to merge; simply add a new pointer checking group.
- if (DepCands.findValue(Access) == DepCands.end()) {
+ if (!DepCands.contains(Access)) {
CheckingGroups.push_back(RuntimeCheckingPtrGroup(I, *this));
continue;
}
@@ -848,7 +848,6 @@ class AccessAnalysis {
getUnderlyingObjects() {
return UnderlyingObjects;
}
- }
private:
typedef MapVector<MemAccessInfo, SmallSetVector<Type *, 1>> PtrAccessMap;
@@ -1284,8 +1283,7 @@ bool AccessAnalysis::createCheckForAccess(
// The id of the dependence set.
unsigned DepId;
- if (isDependencyCheckNeeded() &&
- DepCands.findValue(Access) != DepCands.end()) {
+ if (isDependencyCheckNeeded() && DepCands.contains(Access)) {
Value *Leader = DepCands.getLeaderValue(Access).getPointer();
unsigned &LeaderId = DepSetId[Leader];
if (!LeaderId)
@@ -1305,7 +1303,8 @@ bool AccessAnalysis::createCheckForAccess(
}
bool AccessAnalysis::canCheckPtrAtRT(
- RuntimePointerChecking &RtCheck, , RuntimePointerChecking &RtCheck, ScalarEvolution *SE,Loop *TheLoop,
+ const MemoryDepChecker &DepChecker, RuntimePointerChecking &RtCheck,
+ ScalarEvolution *SE, Loop *TheLoop,
const DenseMap<Value *, const SCEV *> &StridesMap, Value *&UncomputablePtr,
bool AllowPartial) {
// Find pointers with computable bounds. We are going to use this information
@@ -1461,7 +1460,7 @@ bool AccessAnalysis::canCheckPtrAtRT(
}
if (MayNeedRTCheck && (CanDoRT || AllowPartial))
- RtCheck.generateChecks(DepCands);
+ RtCheck.generateChecks(DepChecker, DepCands);
LLVM_DEBUG(dbgs() << "LAA: We need to do " << RtCheck.getNumberOfChecks()
<< " pointer comparisons.\n");
@@ -2762,9 +2761,9 @@ bool LoopAccessInfo::analyzeLoop(AAResults *AA, const LoopInfo *LI,
PtrRtChecking->Need = true;
UncomputablePtr = nullptr;
- HasCompletePtrRtChecking =
- Accesses.canCheckPtrAtRT(getDepChecker(),*PtrRtChecking, TheLoop, SymbolicStrides,
- UncomputablePtr, AllowPartial);
+ HasCompletePtrRtChecking = Accesses.canCheckPtrAtRT(
+ getDepChecker(), *PtrRtChecking, PSE->getSE(), TheLoop,
+ SymbolicStrides, UncomputablePtr, AllowPartial);
// Check that we found the bounds for the pointer.
if (!HasCompletePtrRtChecking) {
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
index a338a339575a4..ec194508326e1 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
@@ -31,6 +31,18 @@ define void @Test(ptr nocapture %obj, i64 %z) #0 {
; CHECK-NEXT: .inner:
; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 2048 bits with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %4 = load i32, ptr %1, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: BackwardVectorizable:
+; CHECK-NEXT: %3 = load i32, ptr %2, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %7 = load i32, ptr %6, align 4 ->
+; CHECK-NEXT: store i32 %8, ptr %6, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis-forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis-forked-pointers.ll
index d1d1ecb2af888..d463b7d6f2c29 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis-forked-pointers.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis-forked-pointers.ll
@@ -7,6 +7,14 @@ define void @dependency_check_and_runtime_checks_needed_select_of_invariant_ptrs
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -26,14 +34,9 @@ define void @dependency_check_and_runtime_checks_needed_select_of_invariant_ptrs
; CHECK-NEXT: Check 3:
; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
-; CHECK-NEXT: Against group GRP2:
-; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
-; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group GRP1:
-; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
-; CHECK-NEXT: Check 5:
+; CHECK-NEXT: Check 4:
; CHECK-NEXT: Comparing group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
; CHECK-NEXT: Against group GRP3:
@@ -85,6 +88,14 @@ define void @dependency_check_and_runtime_checks_needed_select_of_ptr_add_recs(p
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -104,14 +115,9 @@ define void @dependency_check_and_runtime_checks_needed_select_of_ptr_add_recs(p
; CHECK-NEXT: Check 3:
; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
-; CHECK-NEXT: Against group GRP2:
-; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
-; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group GRP1:
-; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
-; CHECK-NEXT: Check 5:
+; CHECK-NEXT: Check 4:
; CHECK-NEXT: Comparing group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
; CHECK-NEXT: Against group GRP3:
diff --git a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
index b640c1911cb0d..2e42c9fdb82b8 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
@@ -388,28 +388,24 @@ define void @use_diff_checks_when_retrying_with_rt_checks(i64 %off, ptr %dst, pt
; CHECK-LABEL: define void @use_diff_checks_when_retrying_with_rt_checks(
; CHECK-SAME: i64 [[OFF:%.*]], ptr [[DST:%.*]], ptr [[SRC:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[SRC2:%.*]] = ptrtoint ptr [[SRC]] to i64
-; CHECK-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64
; CHECK-NEXT: br i1 false, [[SCALAR_PH:label %.*]], label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
-; CHECK-NEXT: [[TMP0:%.*]] = mul i64 [[OFF]], -8
-; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP0]], 32
; CHECK-NEXT: [[TMP1:%.*]] = shl i64 [[OFF]], 3
-; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[DST1]], [[TMP1]]
-; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[TMP2]], [[SRC2]]
-; CHECK-NEXT: [[DIFF_CHECK3:%.*]] = icmp ult i64 [[TMP3]], 32
-; CHECK-NEXT: [[CONFLICT_RDX:%.*]] = or i1 [[DIFF_CHECK]], [[DIFF_CHECK3]]
-; CHECK-NEXT: [[TMP4:%.*]] = add i64 [[SRC2]], 8
-; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[TMP4]], [[DST1]]
-; CHECK-NEXT: [[TMP6:%.*]] = sub i64 [[TMP5]], [[TMP1]]
-; CHECK-NEXT: [[DIFF_CHECK4:%.*]] = icmp ult i64 [[TMP6]], 32
-; CHECK-NEXT: [[CONFLICT_RDX5:%.*]] = or i1 [[CONFLICT_RDX]], [[DIFF_CHECK4]]
-; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[DST1]], [[SRC2]]
-; CHECK-NEXT: [[DIFF_CHECK6:%.*]] = icmp ult i64 [[TMP7]], 32
+; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[DST]], i64 [[TMP1]]
+; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[TMP1]], 8000
+; CHECK-NEXT: [[SCEVGEP1:%.*]] = getelementptr i8, ptr [[DST]], i64 [[TMP2]]
+; CHECK-NEXT: [[SCEVGEP2:%.*]] = getelementptr i8, ptr [[DST]], i64 8000
+; CHECK-NEXT: [[SCEVGEP3:%.*]] = getelementptr i8, ptr [[SRC]], i64 8008
+; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[SCEVGEP]], [[SCEVGEP2]]
+; CHECK-NEXT: [[BOUND1:%.*]] = icmp ult ptr [[DST]], [[SCEVGEP1]]
+; CHECK-NEXT: [[CONFLICT_RDX5:%.*]] = and i1 [[BOUND0]], [[BOUND1]]
+; CHECK-NEXT: [[BOUND04:%.*]] = icmp ult ptr [[SCEVGEP]], [[SCEVGEP3]]
+; CHECK-NEXT: [[BOUND15:%.*]] = icmp ult ptr [[SRC]], [[SCEVGEP1]]
+; CHECK-NEXT: [[DIFF_CHECK6:%.*]] = and i1 [[BOUND04]], [[BOUND15]]
; CHECK-NEXT: [[CONFLICT_RDX7:%.*]] = or i1 [[CONFLICT_RDX5]], [[DIFF_CHECK6]]
-; CHECK-NEXT: [[TMP8:%.*]] = add i64 [[DST1]], -8
-; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[TMP8]], [[SRC2]]
-; CHECK-NEXT: [[DIFF_CHECK8:%.*]] = icmp ult i64 [[TMP9]], 32
+; CHECK-NEXT: [[BOUND07:%.*]] = icmp ult ptr [[DST]], [[SCEVGEP3]]
+; CHECK-NEXT: [[BOUND18:%.*]] = icmp ult ptr [[SRC]], [[SCEVGEP2]]
+; CHECK-NEXT: [[DIFF_CHECK8:%.*]] = and i1 [[BOUND07]], [[BOUND18]]
; CHECK-NEXT: [[CONFLICT_RDX9:%.*]] = or i1 [[CONFLICT_RDX7]], [[DIFF_CHECK8]]
; CHECK-NEXT: br i1 [[CONFLICT_RDX9]], [[SCALAR_PH]], [[VECTOR_PH:label %.*]]
;
>From 9329501682a6f10886ac2e157ef3fadf4ddd3f2f Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 20 Aug 2025 20:35:04 +0100
Subject: [PATCH 4/4] !fixup update after udpating to main.
---
llvm/include/llvm/ADT/EquivalenceClasses.h | 9 ++--
.../llvm/Analysis/LoopAccessAnalysis.h | 6 +--
llvm/lib/Analysis/LoopAccessAnalysis.cpp | 34 ++++++-------
.../accesses-completely-before-or-after.ll | 8 ++++
.../different-access-types-rt-checks.ll | 18 +++----
.../non-constant-distance-backward.ll | 26 ++++++++--
...endence-distance-different-access-sizes.ll | 4 --
...untime-checks-after-dependence-analysis.ll | 48 +++++++++++++++++++
...wn-dependence-retry-with-runtime-checks.ll | 29 +++++++++++
9 files changed, 135 insertions(+), 47 deletions(-)
diff --git a/llvm/include/llvm/ADT/EquivalenceClasses.h b/llvm/include/llvm/ADT/EquivalenceClasses.h
index 985a58668d1d6..ebf160c49296a 100644
--- a/llvm/include/llvm/ADT/EquivalenceClasses.h
+++ b/llvm/include/llvm/ADT/EquivalenceClasses.h
@@ -293,13 +293,14 @@ template <class ElemTy> class EquivalenceClasses {
return member_iterator(ECV.getLeader());
}
- /// Erase the class containing \p V.
+ /// Erase the class containing \p V, i.e. erase all members of the class from
+ /// the set.
void eraseClass(const ElemTy &V) {
if (TheMapping.find(V) == TheMapping.end())
return;
- auto LeaderI = members(V);
- for (auto MI = LeaderI.begin(), ME = LeaderI.end(); MI != ME;) {
- const auto &ToErase = *MI;
+ iterator_range<member_iterator> LeaderI = members(V);
+ for (member_iterator MI = LeaderI.begin(), ME = LeaderI.end(); MI != ME;) {
+ const ElemTy &ToErase = *MI;
++MI;
TheMapping.erase(ToErase);
}
diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
index fcd950e04200f..b81b259b0fcd7 100644
--- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -559,8 +559,7 @@ class RuntimePointerChecking {
/// Generate the checks and store it. This also performs the grouping
/// of pointers to reduce the number of memchecks necessary.
- LLVM_ABI void generateChecks(const MemoryDepChecker &DepChecker,
- MemoryDepChecker::DepCandidates &DepCands);
+ LLVM_ABI void generateChecks(MemoryDepChecker::DepCandidates &DepCands);
/// Returns the checks that generateChecks created. They can be used to ensure
/// no read/write accesses overlap across all loop iterations.
@@ -628,8 +627,7 @@ class RuntimePointerChecking {
/// Groups pointers such that a single memcheck is required
/// between two different groups. This will clear the CheckingGroups vector
/// and re-compute it.
- void groupChecks(const MemoryDepChecker &DepChecker,
- MemoryDepChecker::DepCandidates &DepCands);
+ void groupChecks(MemoryDepChecker::DepCandidates &DepCands);
/// Generate the checks and return them.
SmallVector<RuntimePointerCheck, 4> generateChecks();
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index 543dd735fe8cb..4f64e56ae72cc 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -508,10 +508,9 @@ SmallVector<RuntimePointerCheck, 4> RuntimePointerChecking::generateChecks() {
}
void RuntimePointerChecking::generateChecks(
- const MemoryDepChecker &DepChecker,
MemoryDepChecker::DepCandidates &DepCands) {
assert(Checks.empty() && "Checks is not empty");
- groupChecks(DepChecker, DepCands);
+ groupChecks(DepCands);
Checks = generateChecks();
}
@@ -574,7 +573,6 @@ bool RuntimeCheckingPtrGroup::addPointer(unsigned Index, const SCEV *Start,
}
void RuntimePointerChecking::groupChecks(
- const MemoryDepChecker &DepChecker,
MemoryDepChecker::DepCandidates &DepCands) {
// We build the groups from dependency candidates equivalence classes
// because:
@@ -822,12 +820,13 @@ class AccessAnalysis {
/// (i.e. the pointers have computable bounds). A return value of false means
/// we couldn't analyze and generate runtime checks for all pointers in the
/// loop, but if \p AllowPartial is set then we will have checks for those
- /// pointers we could analyze.
- bool canCheckPtrAtRT(const MemoryDepChecker &DepChecker,
- RuntimePointerChecking &RtCheck, ScalarEvolution *SE,
+ /// pointers we could analyze. \p DepChecker is used to remove unknown
+ /// dependences from DepCands.
+ bool canCheckPtrAtRT(RuntimePointerChecking &RtCheck, ScalarEvolution *SE,
Loop *TheLoop,
const DenseMap<Value *, const SCEV *> &Strides,
- Value *&UncomputablePtr, bool AllowPartial );
+ Value *&UncomputablePtr, bool AllowPartial,
+ const MemoryDepChecker &DepChecker);
/// Goes over all memory accesses, checks whether a RT check is needed
/// and builds sets of dependent accesses.
@@ -844,11 +843,6 @@ class AccessAnalysis {
const MemAccessInfoList &getDependenciesToCheck() const { return CheckDeps; }
- const DenseMap<Value *, SmallVector<const Value *, 16>> &
- getUnderlyingObjects() {
- return UnderlyingObjects;
- }
-
private:
typedef MapVector<MemAccessInfo, SmallSetVector<Type *, 1>> PtrAccessMap;
@@ -1283,7 +1277,7 @@ bool AccessAnalysis::createCheckForAccess(
// The id of the dependence set.
unsigned DepId;
- if (isDependencyCheckNeeded() && DepCands.contains(Access)) {
+ if (DepCands.contains(Access)) {
Value *Leader = DepCands.getLeaderValue(Access).getPointer();
unsigned &LeaderId = DepSetId[Leader];
if (!LeaderId)
@@ -1303,10 +1297,9 @@ bool AccessAnalysis::createCheckForAccess(
}
bool AccessAnalysis::canCheckPtrAtRT(
- const MemoryDepChecker &DepChecker, RuntimePointerChecking &RtCheck,
- ScalarEvolution *SE, Loop *TheLoop,
+ RuntimePointerChecking &RtCheck, ScalarEvolution *SE, Loop *TheLoop,
const DenseMap<Value *, const SCEV *> &StridesMap, Value *&UncomputablePtr,
- bool AllowPartial) {
+ bool AllowPartial, const MemoryDepChecker &DepChecker) {
// Find pointers with computable bounds. We are going to use this information
// to place a runtime bound check.
bool CanDoRT = true;
@@ -1460,7 +1453,7 @@ bool AccessAnalysis::canCheckPtrAtRT(
}
if (MayNeedRTCheck && (CanDoRT || AllowPartial))
- RtCheck.generateChecks(DepChecker, DepCands);
+ RtCheck.generateChecks(DepCands);
LLVM_DEBUG(dbgs() << "LAA: We need to do " << RtCheck.getNumberOfChecks()
<< " pointer comparisons.\n");
@@ -2735,7 +2728,8 @@ bool LoopAccessInfo::analyzeLoop(AAResults *AA, const LoopInfo *LI,
// to place a runtime bound check.
Value *UncomputablePtr = nullptr;
HasCompletePtrRtChecking = Accesses.canCheckPtrAtRT(
- getDepChecker(), *PtrRtChecking, PSE->getSE(), TheLoop, SymbolicStrides, UncomputablePtr, AllowPartial);
+ *PtrRtChecking, PSE->getSE(), TheLoop, SymbolicStrides, UncomputablePtr,
+ AllowPartial, getDepChecker());
if (!HasCompletePtrRtChecking) {
const auto *I = dyn_cast_or_null<Instruction>(UncomputablePtr);
recordAnalysis("CantIdentifyArrayBounds", I)
@@ -2762,8 +2756,8 @@ bool LoopAccessInfo::analyzeLoop(AAResults *AA, const LoopInfo *LI,
UncomputablePtr = nullptr;
HasCompletePtrRtChecking = Accesses.canCheckPtrAtRT(
- getDepChecker(), *PtrRtChecking, PSE->getSE(), TheLoop,
- SymbolicStrides, UncomputablePtr, AllowPartial);
+ *PtrRtChecking, PSE->getSE(), TheLoop, SymbolicStrides,
+ UncomputablePtr, AllowPartial, getDepChecker());
// Check that we found the bounds for the pointer.
if (!HasCompletePtrRtChecking) {
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/accesses-completely-before-or-after.ll b/llvm/test/Analysis/LoopAccessAnalysis/accesses-completely-before-or-after.ll
index 9a329b70338bd..36acaf225a29f 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/accesses-completely-before-or-after.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/accesses-completely-before-or-after.ll
@@ -37,6 +37,10 @@ define i32 @may_overlap_true_dep_different_size(ptr %d) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: store i64 0, ptr %gep.128.iv, align 8 ->
+; CHECK-NEXT: %l = load i32, ptr %gep.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -111,6 +115,10 @@ define void @may_overlap_stores_with_different_sizes(ptr %dst) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: store i16 0, ptr %gep.iv, align 2 ->
+; CHECK-NEXT: store i8 0, ptr %gep.dst.128.iv, align 1
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll
index 809472cb543ac..981677f0f4530 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll
@@ -104,6 +104,10 @@ define void @loads_of_same_pointer_with_different_sizes_retry_with_runtime_check
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: store i32 %sub.0, ptr %gep.B.iv, align 4 ->
+; CHECK-NEXT: store i32 %sub.1, ptr %gep.B.inc, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -115,20 +119,12 @@ define void @loads_of_same_pointer_with_different_sizes_retry_with_runtime_check
; CHECK-NEXT: %gep.B.iv = getelementptr inbounds i32, ptr %B, i64 %iv
; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group GRP0:
-; CHECK-NEXT: %gep.B.iv = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 3:
+; CHECK-NEXT: Check 2:
; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.B.inc = getelementptr inbounds i32, ptr %B, i64 %inc
; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
-; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group GRP1:
-; CHECK-NEXT: %gep.B.inc = getelementptr inbounds i32, ptr %B, i64 %inc
-; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
; CHECK-NEXT: Group GRP0:
@@ -138,11 +134,9 @@ define void @loads_of_same_pointer_with_different_sizes_retry_with_runtime_check
; CHECK-NEXT: (Low: ((4 * %off) + %B) High: ((4 * %N) + (4 * %off) + %B))
; CHECK-NEXT: Member: {((4 * %off) + %B),+,4}<%loop>
; CHECK-NEXT: Group GRP2:
-; CHECK-NEXT: (Low: %A High: (%N + %A))
-; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %A High: (3 + %N + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
+; 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:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
index 6a84a06f74e96..d687db58e4805 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
@@ -19,9 +19,9 @@ define void @backward_min_distance_8(ptr %A, i64 %N) {
; COMMON-NEXT: loop:
; COMMON-NEXT: Memory dependences are safe with run-time checks
; COMMON-NEXT: Dependences:
-; COMMON-NEXT: Unknown:
-; COMMON-NEXT: %l = load i8, ptr %gep, align 4 ->
-; COMMON-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; COMMON-NEXT: Unknown:
+; COMMON-NEXT: %l = load i8, ptr %gep, align 4 ->
+; COMMON-NEXT: store i8 %add, ptr %gep.off.iv, align 4
; COMMON-EMPTY:
; COMMON-NEXT: Run-time memory checks:
; COMMON-NEXT: Check 0:
@@ -111,6 +111,10 @@ define void @backward_min_distance_120(ptr %A, i64 %N) {
; VW128-NEXT: loop:
; VW128-NEXT: Memory dependences are safe with run-time checks
; VW128-NEXT: Dependences:
+; VW128-NEXT: Unknown:
+; VW128-NEXT: %l = load i8, ptr %gep, align 4 ->
+; VW128-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; VW128-EMPTY:
; VW128-NEXT: Run-time memory checks:
; VW128-NEXT: Check 0:
; VW128-NEXT: Comparing group GRP0:
@@ -144,6 +148,10 @@ define void @backward_min_distance_120(ptr %A, i64 %N) {
; MAXLEN-NEXT: loop:
; MAXLEN-NEXT: Memory dependences are safe with run-time checks
; MAXLEN-NEXT: Dependences:
+; MAXLEN-NEXT: Unknown:
+; MAXLEN-NEXT: %l = load i8, ptr %gep, align 4 ->
+; MAXLEN-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; MAXLEN-EMPTY:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
; MAXLEN-NEXT: Comparing group GRP0:
@@ -232,6 +240,10 @@ define void @backward_min_distance_128(ptr %A, i64 %N) {
; VW128-NEXT: loop:
; VW128-NEXT: Memory dependences are safe with run-time checks
; VW128-NEXT: Dependences:
+; VW128-NEXT: Unknown:
+; VW128-NEXT: %l = load i8, ptr %gep, align 4 ->
+; VW128-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; VW128-EMPTY:
; VW128-NEXT: Run-time memory checks:
; VW128-NEXT: Check 0:
; VW128-NEXT: Comparing group GRP0:
@@ -265,6 +277,10 @@ define void @backward_min_distance_128(ptr %A, i64 %N) {
; MAXLEN-NEXT: loop:
; MAXLEN-NEXT: Memory dependences are safe with run-time checks
; MAXLEN-NEXT: Dependences:
+; MAXLEN-NEXT: Unknown:
+; MAXLEN-NEXT: %l = load i8, ptr %gep, align 4 ->
+; MAXLEN-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; MAXLEN-EMPTY:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
; MAXLEN-NEXT: Comparing group GRP0:
@@ -379,6 +395,10 @@ define void @backward_min_distance_256(ptr %A, i64 %N) {
; MAXLEN-NEXT: loop:
; MAXLEN-NEXT: Memory dependences are safe with run-time checks
; MAXLEN-NEXT: Dependences:
+; MAXLEN-NEXT: Unknown:
+; MAXLEN-NEXT: %l = load i8, ptr %gep, align 4 ->
+; MAXLEN-NEXT: store i8 %add, ptr %gep.off.iv, align 4
+; MAXLEN-EMPTY:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
; MAXLEN-NEXT: Comparing group GRP0:
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 4044425b14c50..38b0663175284 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
@@ -10,10 +10,6 @@ define void @test_distance_positive_independent_via_trip_count(ptr %A) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe
; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i8, ptr %gep.A, align 1 ->
-; CHECK-NEXT: store i32 %ext, ptr %gep.A.400, align 4
-; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis.ll b/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis.ll
index 63abd4ef70d63..4f3177a2e2910 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis.ll
@@ -6,6 +6,14 @@ define void @dependency_check_and_runtime_checks_needed_gepb_is_inbounds_iv2_ste
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -67,6 +75,14 @@ define void @dependency_check_and_runtime_checks_needed_gepb_not_inbounds_iv2_st
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -129,6 +145,14 @@ define void @dependency_check_and_runtime_checks_needed_gepb_is_inbounds_iv2_ste
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -195,6 +219,14 @@ define void @dependency_check_and_runtime_checks_needed_gepb_not_inbounds_iv2_st
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -260,6 +292,14 @@ define void @dependency_check_and_runtime_checks_needed_gepb_may_wrap(ptr %a, pt
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l2 = load float, ptr %gep.a.iv.off, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Forward:
+; CHECK-NEXT: %l1 = load float, ptr %gep.a.iv, align 4 ->
+; CHECK-NEXT: store float %ad, ptr %gep.a.iv, align 4
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
@@ -322,6 +362,14 @@ define void @retry_after_dep_check_with_unknown_offset(ptr %A, i32 %offset) {
; CHECK-NEXT: loop:
; CHECK-NEXT: Memory dependences are safe with run-time checks
; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l.A = load float, ptr %A, align 4 ->
+; CHECK-NEXT: store float 0.000000e+00, ptr %A.100.iv.offset.3, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l.A = load float, ptr %A, align 4 ->
+; CHECK-NEXT: store float %l.A, ptr %A.100.iv, align 8
+; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
; CHECK-NEXT: Comparing group GRP0:
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 c09a6bf7e12b8..388dec0fca286 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
@@ -33,6 +33,8 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_noal
; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
+; CHECK-NEXT: Group GRP2:
+; CHECK-NEXT: (Low: %B High: (102 + %B))
; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
; CHECK-EMPTY:
@@ -81,6 +83,33 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_maya
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group GRP0:
+; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
+; CHECK-NEXT: Against group GRP1:
+; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
+; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group GRP0:
+; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
+; CHECK-NEXT: Against group GRP2:
+; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group GRP1:
+; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
+; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
+; CHECK-NEXT: Against group GRP2:
+; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group GRP0:
+; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
+; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
+; CHECK-NEXT: Group GRP1:
+; CHECK-NEXT: (Low: %B High: (102 + %B))
+; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
+; CHECK-NEXT: Member: {%B,+,1}<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:
More information about the llvm-commits
mailing list