[llvm] bb27916 - [LAA] Tweak debug output for UTC stability (#140764)
via llvm-commits
llvm-commits at lists.llvm.org
Wed May 21 04:01:52 PDT 2025
Author: Ramkumar Ramachandra
Date: 2025-05-21T12:01:49+01:00
New Revision: bb2791609db5da24e51d0bc50fedff654da9a1a8
URL: https://github.com/llvm/llvm-project/commit/bb2791609db5da24e51d0bc50fedff654da9a1a8
DIFF: https://github.com/llvm/llvm-project/commit/bb2791609db5da24e51d0bc50fedff654da9a1a8.diff
LOG: [LAA] Tweak debug output for UTC stability (#140764)
UpdateTestChecks has a make_analyzer_generalizer to replace pointer
addressess from the debug output of LAA with a pattern, which is an
acceptable solution when there is one RUN line. However, when there are
multiple RUN lines with a common pattern, UTC fails to recognize common
output due to mismatched pointer addresses. Instead of hacking UTC scrub
the output before comparing the outputs from the different RUN lines,
fix the issue once and for all by making LAA not output unstable pointer
addresses in the first place.
The removal of the now-dead make_analyzer_generalizer is left as a
non-trivial exercise for a follow-up.
Added:
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll.expected
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis-common-output.test
Modified:
llvm/lib/Analysis/LoopAccessAnalysis.cpp
llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll
llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll
llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll
llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
llvm/test/Analysis/LoopAccessAnalysis/loop-invariant-dep-with-backedge-taken-count.ll
llvm/test/Analysis/LoopAccessAnalysis/loops-with-indirect-reads-and-writes.ll
llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll
llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll
llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll
llvm/test/Analysis/LoopAccessAnalysis/nusw-predicates.ll
llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll
llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis-forked-pointers.ll
llvm/test/Analysis/LoopAccessAnalysis/retry-runtime-checks-after-dependence-analysis.ll
llvm/test/Analysis/LoopAccessAnalysis/runtime-checks-may-wrap.ll
llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
llvm/test/Analysis/LoopAccessAnalysis/unknown-dependence-retry-with-runtime-checks.ll
llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-distribute.ll.expected
llvm/utils/UpdateTestChecks/common.py
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
index 2a322a69a0dbf..389c3c7932859 100644
--- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp
@@ -591,20 +591,29 @@ bool RuntimePointerChecking::needsChecking(unsigned I, unsigned J) const {
return PointerI.AliasSetId == PointerJ.AliasSetId;
}
+/// Assign each RuntimeCheckingPtrGroup pointer an index for stable UTC output.
+static DenseMap<const RuntimeCheckingPtrGroup *, unsigned>
+getPtrToIdxMap(ArrayRef<RuntimeCheckingPtrGroup> CheckingGroups) {
+ DenseMap<const RuntimeCheckingPtrGroup *, unsigned> PtrIndices;
+ for (const auto &[Idx, CG] : enumerate(CheckingGroups))
+ PtrIndices[&CG] = Idx;
+ return PtrIndices;
+}
+
void RuntimePointerChecking::printChecks(
raw_ostream &OS, const SmallVectorImpl<RuntimePointerCheck> &Checks,
unsigned Depth) const {
unsigned N = 0;
+ auto PtrIndices = getPtrToIdxMap(CheckingGroups);
for (const auto &[Check1, Check2] : Checks) {
const auto &First = Check1->Members, &Second = Check2->Members;
-
OS.indent(Depth) << "Check " << N++ << ":\n";
-
- OS.indent(Depth + 2) << "Comparing group (" << Check1 << "):\n";
+ OS.indent(Depth + 2) << "Comparing group GRP" << PtrIndices.at(Check1)
+ << ":\n";
for (unsigned K : First)
OS.indent(Depth + 2) << *Pointers[K].PointerValue << "\n";
-
- OS.indent(Depth + 2) << "Against group (" << Check2 << "):\n";
+ OS.indent(Depth + 2) << "Against group GRP" << PtrIndices.at(Check2)
+ << ":\n";
for (unsigned K : Second)
OS.indent(Depth + 2) << *Pointers[K].PointerValue << "\n";
}
@@ -616,8 +625,9 @@ void RuntimePointerChecking::print(raw_ostream &OS, unsigned Depth) const {
printChecks(OS, Checks, Depth);
OS.indent(Depth) << "Grouped accesses:\n";
+ auto PtrIndices = getPtrToIdxMap(CheckingGroups);
for (const auto &CG : CheckingGroups) {
- OS.indent(Depth + 2) << "Group " << &CG << ":\n";
+ OS.indent(Depth + 2) << "Group GRP" << PtrIndices.at(&CG) << ":\n";
OS.indent(Depth + 4) << "(Low: " << *CG.Low << " High: " << *CG.High
<< ")\n";
for (unsigned Member : CG.Members) {
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/
diff erent-access-types-rt-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/
diff erent-access-types-rt-checks.ll
index 58844c10cdcb9..809472cb543ac 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/
diff erent-access-types-rt-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/
diff erent-access-types-rt-checks.ll
@@ -10,16 +10,16 @@ define void @loads_of_same_pointer_with_
diff erent_sizes1(ptr %A, ptr %B, i64 %N)
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: ((4 * %N) + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (3 + %N + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
@@ -58,16 +58,16 @@ define void @loads_of_same_pointer_with_
diff erent_sizes2(ptr %A, ptr %B, i64 %N)
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: ((4 * %N) + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (3 + %N + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
@@ -106,41 +106,41 @@ define void @loads_of_same_pointer_with_
diff erent_sizes_retry_with_runtime_check
; 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 GRP0:
; CHECK-NEXT: %gep.B.iv = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.B.inc = getelementptr inbounds i32, ptr %B, i64 %inc
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B.iv = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B.iv = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.B.inc = getelementptr inbounds i32, ptr %B, i64 %inc
-; CHECK-NEXT: Against group ([[GRP7]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.B.inc = getelementptr inbounds i32, ptr %B, i64 %inc
-; CHECK-NEXT: Against group ([[GRP8]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: ((4 * %N) + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: ((4 * %off) + %B) High: ((4 * %N) + (4 * %off) + %B))
; CHECK-NEXT: Member: {((4 * %off) + %B),+,4}<%loop>
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %A High: (%N + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %A High: (3 + %N + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll
index d5abf8279f69d..e235b73daa6a7 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll
@@ -8,15 +8,15 @@ define void @all_exits_dominate_latch_countable_exits_at_most_500_iterations_kno
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (2000 + %B)<nuw>)
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (2000 + %A)<nuw>)
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
@@ -66,15 +66,15 @@ define void @all_exits_dominate_latch_countable_exits_at_most_500_iterations_not
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (2000 + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (2000 + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
@@ -124,15 +124,15 @@ define i32 @all_exits_dominate_latch_countable_exits_at_most_1000_iterations_kno
; 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 GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (4004 + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (4004 + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
@@ -182,15 +182,15 @@ define i32 @all_exits_dominate_latch_countable_exits_at_most_1000_iterations_not
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (4004 + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (4004 + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
@@ -284,15 +284,15 @@ define i32 @b3_does_not_dominate_latch_known_deref(ptr dereferenceable(4000) %A,
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (4004 + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (4004 + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
@@ -339,15 +339,15 @@ define i32 @b3_does_not_dominate_latch_not_known_deref(ptr %A, ptr %B) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.B = getelementptr inbounds i32, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (4004 + %B))
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (4004 + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll b/llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll
index 0436c1b7ee04b..906bf5ce845f1 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll
@@ -11,15 +11,15 @@ define void @runtime_checks_with_symbolic_max_btc_neg_1(ptr %P, ptr %S, i32 %x,
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv = getelementptr inbounds i32, ptr %P, i32 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %S
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: ((4 * %y) + %P))
; CHECK-NEXT: Member: {((4 * %y) + %P),+,4}<%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %S High: (4 + %S))
; CHECK-NEXT: Member: %S
; CHECK-EMPTY:
@@ -52,15 +52,15 @@ define void @runtime_check_with_symbolic_max_btc_neg_2(ptr %P, ptr %S, i32 %x, i
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv = getelementptr inbounds i32, ptr %P, i32 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %S
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: (-4 + (4 * %y) + %P))
; CHECK-NEXT: Member: {((4 * %y) + %P),+,4}<%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %S High: (4 + %S))
; CHECK-NEXT: Member: %S
; CHECK-EMPTY:
@@ -146,15 +146,15 @@ define void @runtime_check_with_symbolic_max_wraps_to_positive_offset(ptr %P, pt
; 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 GRP0:
; CHECK-NEXT: %gep.iv = getelementptr inbounds i16, ptr %P, i32 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %S
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((2 * %y) + %P) High: (2 + (2 * %y) + %P))
; CHECK-NEXT: Member: {((2 * %y) + %P),+,2}<%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %S High: (4 + %S))
; CHECK-NEXT: Member: %S
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
index 286af49ab1ae6..c28dd58fcb204 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
@@ -11,26 +11,26 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
; CHECK-EMPTY:
@@ -82,31 +82,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset(ptr nocapture read
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP4]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP4]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -143,31 +143,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_64b(ptr nocapture
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP8]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP8]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; CHECK-EMPTY:
@@ -204,31 +204,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_23b(ptr nocapture
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP13:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP12]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP14:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP12]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP15:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (399 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP13]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP14]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP15]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -265,31 +265,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_6b(ptr nocapture r
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP16:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP17:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP16]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP18:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP16]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP19:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP16]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (100 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP17]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP18]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP19]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body>
; CHECK-EMPTY:
@@ -326,31 +326,31 @@ define dso_local void @forked_ptrs_
diff erent_base_same_offset_possible_poison(pt
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP20:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP21:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP20]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP22:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP20]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP23:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP20]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP21]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP22]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP23]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
@@ -443,24 +443,24 @@ define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, p
; FULLDEPTH-NEXT: Dependences:
; FULLDEPTH-NEXT: Run-time memory checks:
; FULLDEPTH-NEXT: Check 0:
-; FULLDEPTH-NEXT: Comparing group ([[GRP47:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP48:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP1:
; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; FULLDEPTH-NEXT: Check 1:
-; FULLDEPTH-NEXT: Comparing group ([[GRP47]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP49:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP2:
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: Grouped accesses:
-; FULLDEPTH-NEXT: Group [[GRP47]]:
+; FULLDEPTH-NEXT: Group GRP0:
; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP48]]:
+; FULLDEPTH-NEXT: Group GRP1:
; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP49]]:
+; FULLDEPTH-NEXT: Group GRP2:
; FULLDEPTH-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
; FULLDEPTH-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
; FULLDEPTH-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
@@ -511,24 +511,24 @@ define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base,
; FULLDEPTH-NEXT: Dependences:
; FULLDEPTH-NEXT: Run-time memory checks:
; FULLDEPTH-NEXT: Check 0:
-; FULLDEPTH-NEXT: Comparing group ([[GRP50:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP51:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP1:
; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; FULLDEPTH-NEXT: Check 1:
-; FULLDEPTH-NEXT: Comparing group ([[GRP50]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP52:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP2:
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: Grouped accesses:
-; FULLDEPTH-NEXT: Group [[GRP50]]:
+; FULLDEPTH-NEXT: Group GRP0:
; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP51]]:
+; FULLDEPTH-NEXT: Group GRP1:
; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP52]]:
+; FULLDEPTH-NEXT: Group GRP2:
; FULLDEPTH-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base))
; FULLDEPTH-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body>
; FULLDEPTH-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body>
@@ -579,24 +579,24 @@ define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base,
; FULLDEPTH-NEXT: Dependences:
; FULLDEPTH-NEXT: Run-time memory checks:
; FULLDEPTH-NEXT: Check 0:
-; FULLDEPTH-NEXT: Comparing group ([[GRP53:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP54:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP1:
; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; FULLDEPTH-NEXT: Check 1:
-; FULLDEPTH-NEXT: Comparing group ([[GRP53]]):
+; FULLDEPTH-NEXT: Comparing group GRP0:
; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; FULLDEPTH-NEXT: Against group ([[GRP55:0x[0-9a-f]+]]):
+; FULLDEPTH-NEXT: Against group GRP2:
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
; FULLDEPTH-NEXT: Grouped accesses:
-; FULLDEPTH-NEXT: Group [[GRP53]]:
+; FULLDEPTH-NEXT: Group GRP0:
; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP54]]:
+; FULLDEPTH-NEXT: Group GRP1:
; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; FULLDEPTH-NEXT: Group [[GRP55]]:
+; FULLDEPTH-NEXT: Group GRP2:
; FULLDEPTH-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base))
; FULLDEPTH-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
; FULLDEPTH-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
@@ -925,15 +925,15 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP24:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %Base1
-; CHECK-NEXT: Against group ([[GRP25:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP24]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1))
; CHECK-NEXT: Member: %Base1
-; CHECK-NEXT: Group [[GRP25]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
; CHECK-NEXT: Member: {%Base2,+,8}<%for.body>
; CHECK-EMPTY:
@@ -972,36 +972,36 @@ define void @forked_ptrs_with_
diff erent_base(ptr nocapture readonly %Preds, ptr
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP26:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP27:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP26]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP28:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP29:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP27]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP29]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP28]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP26]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %1 High: (63992 + %1))
; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP29]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %2 High: (63992 + %2))
; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP27]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP28]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %0 High: (63992 + %0))
; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body>
; CHECK-EMPTY:
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..8328591a3c7f4 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
@@ -181,10 +181,10 @@ define void @test_btc_is_unknown_value(ptr %a, i32 %N) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (400 + %a) High: (404 + %a))
; CHECK-NEXT: Member: (400 + %a)
-; CHECK-NEXT: Group [[GRP2:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %a High: (4 + (4 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %a))
; CHECK-NEXT: Member: {%a,+,4}<nw><%loop>
; CHECK-EMPTY:
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..3518d92c3511f 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
@@ -92,15 +92,15 @@ define void @test_indirect_read_loop_also_modifies_pointer_array(ptr noundef %ar
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i64, ptr %arr, i64 %iv.2
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.1 = getelementptr inbounds ptr, ptr %arr, i64 %iv.1
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>)
; CHECK-NEXT: Member: {{\{\{}}(64 + %arr),+,64}<%loop.1>,+,8}<%loop.2>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %arr High: (8000 + %arr))
; CHECK-NEXT: Member: {%arr,+,8}<nuw><%loop.2>
; CHECK-EMPTY:
@@ -160,15 +160,15 @@ define void @test_indirect_write_loop_also_modifies_pointer_array(ptr noundef %a
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds ptr, ptr %arr, i64 %iv.2
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.1 = getelementptr inbounds ptr, ptr %arr, i64 %iv.1
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>)
; CHECK-NEXT: Member: {{\{\{}}(64 + %arr),+,64}<%loop.1>,+,8}<%loop.2>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %arr High: (8000 + %arr))
; CHECK-NEXT: Member: {%arr,+,8}<nuw><%loop.2>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll b/llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll
index 322723bb9a009..8c69b2eb73d54 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll
@@ -12,9 +12,9 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Memory dependences are safe with run-time checks
; CHECK: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ({{.*}}):
+; CHECK-NEXT: Comparing group
; CHECK-NEXT: %arrayidxA = getelementptr inbounds i32, ptr %a, i64 %ind
-; CHECK-NEXT: Against group ({{.*}}):
+; CHECK-NEXT: Against group
; CHECK-NEXT: ptr %b
define void @f(ptr %a, ptr %b) {
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 20fc0bea43b71..a338a339575a4 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll
@@ -33,23 +33,23 @@ define void @Test(ptr nocapture %obj, i64 %z) #0 {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %6 = getelementptr inbounds %struct.s, ptr %obj, i64 0, i32 2, i64 %i, i64 %j
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %2 = getelementptr inbounds %struct.s, ptr %obj, i64 0, i32 0, i64 %j
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %6 = getelementptr inbounds %struct.s, ptr %obj, i64 0, i32 2, i64 %i, i64 %j
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %1 = getelementptr inbounds %struct.s, ptr %obj, i64 0, i32 1, i64 %i
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: {(256 + %obj)<nuw>,+,128}<nuw><%.outer.preheader> High: {(256 + (4 * %z) + %obj),+,128}<nw><%.outer.preheader>)
; CHECK-NEXT: Member: {{\{\{}}(256 + %obj)<nuw>,+,128}<nuw><%.outer.preheader>,+,4}<nuw><%.inner>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %obj High: ((4 * %z) + %obj))
; CHECK-NEXT: Member: {%obj,+,4}<nuw><%.inner>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: {(128 + %obj)<nuw>,+,4}<nuw><%.outer.preheader> High: {(132 + %obj),+,4}<nw><%.outer.preheader>)
; CHECK-NEXT: Member: {(128 + %obj)<nuw>,+,4}<nuw><%.outer.preheader>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
index f939680aa279d..b444c061c2632 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/non-constant-distance-backward.ll
@@ -21,15 +21,15 @@ define void @backward_min_distance_8(ptr %A, i64 %N) {
; COMMON-NEXT: Dependences:
; COMMON-NEXT: Run-time memory checks:
; COMMON-NEXT: Check 0:
-; COMMON-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; COMMON-NEXT: Comparing group GRP0:
; COMMON-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; COMMON-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; COMMON-NEXT: Against group GRP1:
; COMMON-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; COMMON-NEXT: Grouped accesses:
-; COMMON-NEXT: Group [[GRP1]]:
+; COMMON-NEXT: Group GRP0:
; COMMON-NEXT: (Low: {(1 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(257 + %A),+,1}<nw><%outer.header>)
; COMMON-NEXT: Member: {{\{\{}}(1 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; COMMON-NEXT: Group [[GRP2]]:
+; COMMON-NEXT: Group GRP1:
; COMMON-NEXT: (Low: %A High: (256 + %A))
; COMMON-NEXT: Member: {%A,+,1}<nuw><%loop>
; COMMON-EMPTY:
@@ -109,15 +109,15 @@ define void @backward_min_distance_120(ptr %A, i64 %N) {
; VW128-NEXT: Dependences:
; VW128-NEXT: Run-time memory checks:
; VW128-NEXT: Check 0:
-; VW128-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; VW128-NEXT: Comparing group GRP0:
; VW128-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; VW128-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; VW128-NEXT: Against group GRP1:
; VW128-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; VW128-NEXT: Grouped accesses:
-; VW128-NEXT: Group [[GRP7]]:
+; VW128-NEXT: Group GRP0:
; VW128-NEXT: (Low: {(15 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(271 + %A),+,1}<nw><%outer.header>)
; VW128-NEXT: Member: {{\{\{}}(15 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; VW128-NEXT: Group [[GRP8]]:
+; VW128-NEXT: Group GRP1:
; VW128-NEXT: (Low: %A High: (256 + %A))
; VW128-NEXT: Member: {%A,+,1}<nuw><%loop>
; VW128-EMPTY:
@@ -142,15 +142,15 @@ define void @backward_min_distance_120(ptr %A, i64 %N) {
; MAXLEN-NEXT: Dependences:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
-; MAXLEN-NEXT: Comparing group ([[GRP9:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Comparing group GRP0:
; MAXLEN-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; MAXLEN-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Against group GRP1:
; MAXLEN-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; MAXLEN-NEXT: Grouped accesses:
-; MAXLEN-NEXT: Group [[GRP9]]:
+; MAXLEN-NEXT: Group GRP0:
; MAXLEN-NEXT: (Low: {(15 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(271 + %A),+,1}<nw><%outer.header>)
; MAXLEN-NEXT: Member: {{\{\{}}(15 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; MAXLEN-NEXT: Group [[GRP10]]:
+; MAXLEN-NEXT: Group GRP1:
; MAXLEN-NEXT: (Low: %A High: (256 + %A))
; MAXLEN-NEXT: Member: {%A,+,1}<nuw><%loop>
; MAXLEN-EMPTY:
@@ -230,15 +230,15 @@ define void @backward_min_distance_128(ptr %A, i64 %N) {
; VW128-NEXT: Dependences:
; VW128-NEXT: Run-time memory checks:
; VW128-NEXT: Check 0:
-; VW128-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
+; VW128-NEXT: Comparing group GRP0:
; VW128-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; VW128-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; VW128-NEXT: Against group GRP1:
; VW128-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; VW128-NEXT: Grouped accesses:
-; VW128-NEXT: Group [[GRP11]]:
+; VW128-NEXT: Group GRP0:
; VW128-NEXT: (Low: {(16 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(272 + %A),+,1}<nw><%outer.header>)
; VW128-NEXT: Member: {{\{\{}}(16 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; VW128-NEXT: Group [[GRP12]]:
+; VW128-NEXT: Group GRP1:
; VW128-NEXT: (Low: %A High: (256 + %A))
; VW128-NEXT: Member: {%A,+,1}<nuw><%loop>
; VW128-EMPTY:
@@ -263,15 +263,15 @@ define void @backward_min_distance_128(ptr %A, i64 %N) {
; MAXLEN-NEXT: Dependences:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
-; MAXLEN-NEXT: Comparing group ([[GRP13:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Comparing group GRP0:
; MAXLEN-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; MAXLEN-NEXT: Against group ([[GRP14:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Against group GRP1:
; MAXLEN-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; MAXLEN-NEXT: Grouped accesses:
-; MAXLEN-NEXT: Group [[GRP13]]:
+; MAXLEN-NEXT: Group GRP0:
; MAXLEN-NEXT: (Low: {(16 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(272 + %A),+,1}<nw><%outer.header>)
; MAXLEN-NEXT: Member: {{\{\{}}(16 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; MAXLEN-NEXT: Group [[GRP14]]:
+; MAXLEN-NEXT: Group GRP1:
; MAXLEN-NEXT: (Low: %A High: (256 + %A))
; MAXLEN-NEXT: Member: {%A,+,1}<nuw><%loop>
; MAXLEN-EMPTY:
@@ -377,15 +377,15 @@ define void @backward_min_distance_256(ptr %A, i64 %N) {
; MAXLEN-NEXT: Dependences:
; MAXLEN-NEXT: Run-time memory checks:
; MAXLEN-NEXT: Check 0:
-; MAXLEN-NEXT: Comparing group ([[GRP15:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Comparing group GRP0:
; MAXLEN-NEXT: %gep.off.iv = getelementptr inbounds i8, ptr %gep.off, i64 %iv
-; MAXLEN-NEXT: Against group ([[GRP16:0x[0-9a-f]+]]):
+; MAXLEN-NEXT: Against group GRP1:
; MAXLEN-NEXT: %gep = getelementptr inbounds i8, ptr %A, i64 %iv
; MAXLEN-NEXT: Grouped accesses:
-; MAXLEN-NEXT: Group [[GRP15]]:
+; MAXLEN-NEXT: Group GRP0:
; MAXLEN-NEXT: (Low: {(32 + %A)<nuw>,+,1}<nuw><%outer.header> High: {(288 + %A),+,1}<nw><%outer.header>)
; MAXLEN-NEXT: Member: {{\{\{}}(32 + %A)<nuw>,+,1}<nuw><%outer.header>,+,1}<nuw><%loop>
-; MAXLEN-NEXT: Group [[GRP16]]:
+; MAXLEN-NEXT: Group GRP1:
; MAXLEN-NEXT: (Low: %A High: (256 + %A))
; MAXLEN-NEXT: Member: {%A,+,1}<nuw><%loop>
; MAXLEN-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll b/llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll
index c502c7c1176c0..7e7bc1d4f3dda 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/nssw-predicate-implied.ll
@@ -11,15 +11,15 @@ define void @wrap_check_iv.3_implies_iv.2(i32 noundef %N, ptr %dst, ptr %src) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.3
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %dst High: (4 + (12 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %dst))
; CHECK-NEXT: Member: {%dst,+,12}<%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (4 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {%src,+,8}<%loop>
; CHECK-EMPTY:
@@ -66,15 +66,15 @@ define void @wrap_check_iv.3_implies_iv.2_
diff erent_start(i32 noundef %N, ptr %d
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.3
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (12 + %dst) High: (16 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %dst))
; CHECK-NEXT: Member: {(12 + %dst),+,8}<%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (4 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {%src,+,8}<%loop>
; CHECK-EMPTY:
@@ -121,15 +121,15 @@ define void @wrap_check_iv.3_implies_iv.2_predicates_added_in_
diff erent_order(i3
; 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 GRP0:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.2
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.3
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %dst High: (4 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %dst))
; CHECK-NEXT: Member: {%dst,+,8}<%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (4 + (12 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {%src,+,12}<%loop>
; CHECK-EMPTY:
@@ -175,15 +175,15 @@ define void @wrap_check_iv.3_does_not_implies_iv.2_due_to_start(i32 noundef %N,
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.3
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %dst High: (4 + (12 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %dst))
; CHECK-NEXT: Member: {%dst,+,12}<%loop>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (40 + %src) High: (44 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {(40 + %src),+,8}<%loop>
; CHECK-EMPTY:
@@ -230,15 +230,15 @@ define void @wrap_check_iv.3_does_not_imply_iv.2_due_to_start_negative(i32 nound
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.3
-; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (-4 + %dst) High: ((12 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %dst))
; CHECK-NEXT: Member: {(-4 + %dst),+,12}<%loop>
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (4 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {%src,+,8}<%loop>
; CHECK-EMPTY:
@@ -285,15 +285,15 @@ define void @wrap_check_iv.3_does_not_imply_iv.2_due_to_negative_step(i32 nounde
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.3 = getelementptr inbounds i32, ptr %dst, i64 %ext.iv.3
-; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds i32, ptr %src, i64 %ext.iv.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((-4 * (zext i32 (-1 + %N) to i64))<nsw> + %dst) High: (4 + %dst))
; CHECK-NEXT: Member: {%dst,+,-4}<%loop>
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (4 + (8 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %src))
; CHECK-NEXT: Member: {%src,+,8}<%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll b/llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll
index d4287612399ba..44a4721c94c61 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll
@@ -81,28 +81,28 @@ for.end: ; preds = %for.body
; CHECK: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[ZERO:.+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxC1 = getelementptr inbounds i16, ptr %c, i64 %store_ind_inc
; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16, ptr %c, i64 %store_ind
-; CHECK-NEXT: Against group ([[ONE:.+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidxA1 = getelementptr inbounds i16, ptr %a, i64 %add
; CHECK-NEXT: %arrayidxA = getelementptr inbounds i16, ptr %a, i64 %ind
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ({{.*}}[[ZERO]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxC1 = getelementptr inbounds i16, ptr %c, i64 %store_ind_inc
; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16, ptr %c, i64 %store_ind
-; CHECK-NEXT: Against group ([[TWO:.+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidxB = getelementptr inbounds i16, ptr %b, i64 %ind
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group {{.*}}[[ZERO]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %c High: (80 + %c))
; CHECK-NEXT: Member: {(2 + %c)<nuw>,+,4}
; CHECK-NEXT: Member: {%c,+,4}
-; CHECK-NEXT: Group {{.*}}[[ONE]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %a High: (42 + %a))
; CHECK-NEXT: Member: {(2 + %a)<nuw>,+,2}
; CHECK-NEXT: Member: {%a,+,2}
-; CHECK-NEXT: Group {{.*}}[[TWO]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %b High: (40 + %b))
; CHECK-NEXT: Member: {%b,+,2}
@@ -153,28 +153,28 @@ for.end: ; preds = %for.body
; CHECK: function 'testh':
; CHECK: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[ZERO:.+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxC1 = getelementptr inbounds i16, ptr %c, i64 %store_ind_inc
; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16, ptr %c, i64 %store_ind
-; CHECK-NEXT: Against group ([[ONE:.+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidxA1 = getelementptr i16, ptr %a, i64 %add
; CHECK-NEXT: %arrayidxA = getelementptr i16, ptr %a, i64 %ind
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ({{.*}}[[ZERO]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxC1 = getelementptr inbounds i16, ptr %c, i64 %store_ind_inc
; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16, ptr %c, i64 %store_ind
-; CHECK-NEXT: Against group ([[TWO:.+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidxB = getelementptr i16, ptr %b, i64 %ind
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group {{.*}}[[ZERO]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %c High: (80 + %c))
; CHECK-NEXT: Member: {(2 + %c)<nuw>,+,4}
; CHECK-NEXT: Member: {%c,+,4}
-; CHECK-NEXT: Group {{.*}}[[ONE]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %a High: (42 + %a))
; CHECK-NEXT: Member: {(2 + %a),+,2}
; CHECK-NEXT: Member: {%a,+,2}
-; CHECK-NEXT: Group {{.*}}[[TWO]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %b High: (40 + %b))
; CHECK-NEXT: Member: {%b,+,2}
@@ -235,23 +235,23 @@ for.end: ; preds = %for.body
; CHECK: function 'testi':
; CHECK: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[ZERO:.+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %storeidx = getelementptr inbounds i16, ptr %a, i64 %store_ind
-; CHECK-NEXT: Against group ([[ONE:.+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidxA1 = getelementptr i16, ptr %a, i64 %ind
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ({{.*}}[[ZERO]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %storeidx = getelementptr inbounds i16, ptr %a, i64 %store_ind
-; CHECK-NEXT: Against group ([[TWO:.+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidxA2 = getelementptr i16, ptr %a, i64 %ind2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group {{.*}}[[ZERO]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((2 * %offset) + %a) High: (10000 + (2 * %offset) + %a))
; CHECK-NEXT: Member: {((2 * %offset) + %a),+,2}<%for.body>
-; CHECK-NEXT: Group {{.*}}[[ONE]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %a High: (10000 + %a))
; CHECK-NEXT: Member: {%a,+,2}<nw><%for.body>
-; CHECK-NEXT: Group {{.*}}[[TWO]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: (20000 + %a) High: (30000 + %a))
; CHECK-NEXT: Member: {(20000 + %a),+,2}<nw><%for.body>
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/nusw-predicates.ll b/llvm/test/Analysis/LoopAccessAnalysis/nusw-predicates.ll
index ab40a22a3274d..9cd6d1f3774bd 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/nusw-predicates.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/nusw-predicates.ll
@@ -15,10 +15,10 @@ define void @int_and_pointer_predicate(ptr %v, i32 %N) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %v High: (2 + %v))
; CHECK-NEXT: Member: %v
-; CHECK-NEXT: Group [[GRP2:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %v High: (6 + (4 * (trunc i32 %N to i16)) + %v))
; CHECK-NEXT: Member: {%v,+,4}<%loop>
; CHECK-EMPTY:
@@ -63,36 +63,36 @@ define void @int_and_multiple_pointer_predicates(ptr %v, ptr %w, i32 %N) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %v
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: ptr %w
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP3]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %v
-; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.w = getelementptr { i16, i16 }, ptr %w, i16 %iv.i16
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.v = getelementptr { i16, i16 }, ptr %v, i16 %iv.i16
-; CHECK-NEXT: Against group ([[GRP4]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: ptr %w
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.v = getelementptr { i16, i16 }, ptr %v, i16 %iv.i16
-; CHECK-NEXT: Against group ([[GRP5]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.w = getelementptr { i16, i16 }, ptr %w, i16 %iv.i16
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %v High: (2 + %v))
; CHECK-NEXT: Member: %v
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %v High: (6 + (4 * (trunc i32 %N to i16)) + %v))
; CHECK-NEXT: Member: {%v,+,4}<%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %w High: (2 + %w))
; CHECK-NEXT: Member: %w
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %w High: (6 + (4 * (trunc i32 %N to i16)) + %w))
; CHECK-NEXT: Member: {%w,+,4}<%loop>
; CHECK-EMPTY:
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 202f975190209..74b65acda2d01 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/offset-range-known-via-assume.ll
@@ -55,15 +55,15 @@ define void @offset_i32_known_positive_via_assume_forward_dep_1(ptr %A, i64 %off
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.off = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (-3 + (4 * %N) + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: (-3 + (4 * %offset)<nsw> + (4 * %N) + %A))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
@@ -145,15 +145,15 @@ define void @offset_may_be_negative_via_assume_unknown_dep(ptr %A, i64 %offset,
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.mul.2 = getelementptr inbounds i32, ptr %A, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
@@ -192,15 +192,15 @@ define void @offset_no_assumes(ptr %A, i64 %offset, i64 %N) {
; 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 GRP0:
; CHECK-NEXT: %gep = getelementptr inbounds i32, ptr %A, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.off = getelementptr inbounds i32, ptr %off, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: ((4 * %N) + %A))
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: ((4 * %offset)<nsw> + %A) High: ((4 * %offset)<nsw> + (4 * %N) + %A))
; CHECK-NEXT: Member: {((4 * %offset)<nsw> + %A),+,4}<nw><%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
index 48586ee9d9ed9..bd38c50cb15d5 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
@@ -96,28 +96,28 @@ define i32 @store_with_pointer_phi_runtime_checks(ptr %A, ptr %B, ptr %C) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP2]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %B High: (256000 + %B))
; CHECK-NEXT: Member: {%B,+,8}<nw><%loop.header>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %C High: (256000 + %C))
; CHECK-NEXT: Member: {%C,+,8}<nw><%loop.header>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %A High: (256000 + %A))
; CHECK-NEXT: Member: {%A,+,8}<nw><%loop.header>
; CHECK-EMPTY:
@@ -260,30 +260,30 @@ define i32 @store_with_pointer_phi_incoming_phi(ptr %A, ptr %B, ptr %C, i1 %c.0,
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %B
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP4]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Against group ([[GRP6]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %C High: (8 + %C))
; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %B High: (8 + %B))
; CHECK-NEXT: Member: %B
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %A High: (256000 + %A))
; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
; CHECK-NEXT: Member: %A
@@ -343,30 +343,30 @@ define i32 @store_with_pointer_phi_incoming_phi_irreducible_cycle(ptr %A, ptr %B
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %B
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP7]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP8]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Against group ([[GRP9]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
; CHECK-NEXT: ptr %A
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %C High: (8 + %C))
; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %B High: (8 + %B))
; CHECK-NEXT: Member: %B
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %A High: (256000 + %A))
; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
; CHECK-NEXT: Member: %A
@@ -503,36 +503,36 @@ define void @phi_load_store_memdep_check(i1 %c, ptr %A, ptr %B, ptr %C) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %C
; CHECK-NEXT: ptr %C
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP10]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: ptr %B
; CHECK-NEXT: ptr %B
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP11]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: ptr %C
; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GRP12]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: ptr %B
; CHECK-NEXT: ptr %B
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (2 + %A))
; CHECK-NEXT: Member: %A
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %C High: (2 + %C))
; CHECK-NEXT: Member: %C
; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %B High: (2 + %B))
; CHECK-NEXT: Member: %B
; CHECK-NEXT: Member: %B
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-
diff erent-access-sizes.ll b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-
diff erent-access-sizes.ll
index 08e0bae7f05ba..1a6e25859f085 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-
diff erent-access-sizes.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-
diff erent-access-sizes.ll
@@ -12,15 +12,15 @@ define void @test_distance_positive_independent_via_trip_count(ptr %A) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.400, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (400 + %A)<nuw> High: (804 + %A))
; CHECK-NEXT: Member: {(400 + %A)<nuw>,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
@@ -57,15 +57,15 @@ define void @test_distance_positive_backwards(ptr %A) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A))
; CHECK-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
@@ -100,15 +100,15 @@ 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 GRP0:
; 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 GRP1:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
; CHECK-EMPTY:
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 021447d53f943..0763fd220d023 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
@@ -9,46 +9,46 @@ define void @dependency_check_and_runtime_checks_needed_select_of_invariant_ptrs
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP2]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
-; CHECK-NEXT: Against group ([[GRP3]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group ([[GRP2]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
-; CHECK-NEXT: Against group ([[GRP4]]):
+; 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: Comparing group ([[GRP3]]):
+; CHECK-NEXT: Comparing group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %b, ptr %c
-; CHECK-NEXT: Against group ([[GRP4]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (4 + %b))
; CHECK-NEXT: Member: %b
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %c High: (4 + %c))
; CHECK-NEXT: Member: %c
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -87,46 +87,46 @@ define void @dependency_check_and_runtime_checks_needed_select_of_ptr_add_recs(p
; 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 GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
-; CHECK-NEXT: Against group ([[GRP7]]):
+; 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 ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
-; CHECK-NEXT: Against group ([[GRP8]]):
+; 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: Comparing group ([[GRP7]]):
+; CHECK-NEXT: Comparing group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.b, ptr %gep.c
-; CHECK-NEXT: Against group ([[GRP8]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: ((4 * %n) + %b))
; CHECK-NEXT: Member: {%b,+,4}<%loop>
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %c High: ((4 * %n) + %c))
; CHECK-NEXT: Member: {%c,+,4}<%loop>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; 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 114637ea3bf06..595fb021ec0ab 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
@@ -8,28 +8,28 @@ define void @dependency_check_and_runtime_checks_needed_gepb_is_inbounds_iv2_ste
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds float, ptr %b, i64 %iv2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP2]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds float, ptr %b, i64 %iv2
-; CHECK-NEXT: Against group ([[GRP3]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (-16 + (20 * %n) + %b))
; CHECK-NEXT: Member: {%b,+,20}<%loop>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -69,28 +69,28 @@ define void @dependency_check_and_runtime_checks_needed_gepb_not_inbounds_iv2_st
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.b = getelementptr i8, ptr %b, i64 %iv2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP4]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.b = getelementptr i8, ptr %b, i64 %iv2
-; CHECK-NEXT: Against group ([[GRP6]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (-1 + (5 * %n) + %b))
; CHECK-NEXT: Member: {%b,+,5}<%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -131,28 +131,28 @@ define void @dependency_check_and_runtime_checks_needed_gepb_is_inbounds_iv2_ste
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds i8, ptr %b, i64 %iv2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP7]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP8]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds i8, ptr %b, i64 %iv2
-; CHECK-NEXT: Against group ([[GRP9]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (3 + %n + %b))
; CHECK-NEXT: Member: {%b,+,1}<%loop>
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -197,28 +197,28 @@ define void @dependency_check_and_runtime_checks_needed_gepb_not_inbounds_iv2_st
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds i8, ptr %b, i64 %iv2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP10]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP11]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.b = getelementptr inbounds i8, ptr %b, i64 %iv2
-; CHECK-NEXT: Against group ([[GRP12]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (3 + %n + %b))
; CHECK-NEXT: Member: {%b,+,1}<%loop>
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -262,28 +262,28 @@ define void @dependency_check_and_runtime_checks_needed_gepb_may_wrap(ptr %a, pt
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP13:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP14:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.b = getelementptr float, ptr %b, i64 %iv2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP13]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.a.iv = getelementptr inbounds float, ptr %a, i64 %iv
-; CHECK-NEXT: Against group ([[GRP15:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP14]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.b = getelementptr float, ptr %b, i64 %iv2
-; CHECK-NEXT: Against group ([[GRP15]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.a.iv.off = getelementptr inbounds float, ptr %a, i64 %iv.offset
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP13]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: ((4 * %n) + %a))
; CHECK-NEXT: Member: {%a,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP14]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (-4 + (8 * %n) + %b))
; CHECK-NEXT: Member: {%b,+,8}<%loop>
-; CHECK-NEXT: Group [[GRP15]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: ((4 * %offset) + %a) High: ((4 * %offset) + (4 * %n) + %a))
; CHECK-NEXT: Member: {((4 * %offset) + %a),+,4}<%loop>
; CHECK-EMPTY:
@@ -333,13 +333,13 @@ define void @retry_after_dep_check_with_unknown_offset(ptr %A, i32 %offset) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP16:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (4 + %A))
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP17:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (100 + (8 * (zext i32 %offset to i64))<nuw><nsw> + %A) High: (96 + (16 * (zext i32 %offset to i64))<nuw><nsw> + %A))
; CHECK-NEXT: Member: {(100 + (8 * (zext i32 %offset to i64))<nuw><nsw> + %A),+,8}<%loop>
-; CHECK-NEXT: Group [[GRP18:0x[0-9a-f]+]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: (100 + %A) High: (96 + (8 * (zext i32 %offset to i64))<nuw><nsw> + %A))
; CHECK-NEXT: Member: {(100 + %A),+,8}<%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/runtime-checks-may-wrap.ll b/llvm/test/Analysis/LoopAccessAnalysis/runtime-checks-may-wrap.ll
index cce6f829d05af..510799c3daefa 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/runtime-checks-may-wrap.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/runtime-checks-may-wrap.ll
@@ -10,15 +10,15 @@ define void @geps_may_wrap(ptr %a, ptr %b, i64 %N) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %b
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv = getelementptr i32, ptr %a, i64 %iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %b High: (4 + %b))
; CHECK-NEXT: Member: %b
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %a High: (16 + (12 * (trunc i128 ((zext i64 %N to i128) /u 3) to i16)) + %a))
; CHECK-NEXT: Member: {%a,+,12}<%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll b/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
index 8603417081067..1c48b0ed0f967 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
@@ -194,15 +194,15 @@ define void @single_stride_castexpr(i32 %offset, ptr %src, ptr %dst, i1 %cond) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.dst = getelementptr i32, ptr %dst, i64 %iv.2
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.src = getelementptr inbounds i32, ptr %src, i32 %iv.3
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((4 * %iv.1) + %dst) High: (804 + (4 * %iv.1) + %dst))
; CHECK-NEXT: Member: {((4 * %iv.1) + %dst),+,4}<%inner.loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %src High: (804 + %src))
; CHECK-NEXT: Member: {%src,+,4}<nuw><%inner.loop>
; CHECK-EMPTY:
@@ -256,15 +256,15 @@ define void @single_stride_castexpr_multiuse(i32 %offset, ptr %src, ptr %dst, i1
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.dst = getelementptr i32, ptr %dst, i64 %iv.2
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.src = getelementptr inbounds i32, ptr %src, i64 %iv.3
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: ((4 * %iv.1) + %dst) High: (804 + (4 * %iv.1) + (-4 * (zext i32 %offset to i64))<nsw> + %dst))
; CHECK-NEXT: Member: {((4 * %iv.1) + %dst),+,4}<%inner.loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (4 + %src) High: (808 + (-4 * (zext i32 %offset to i64))<nsw> + %src))
; CHECK-NEXT: Member: {(4 + %src),+,4}<%inner.loop>
; CHECK-EMPTY:
@@ -461,15 +461,15 @@ define void @unknown_stride_equalto_tc(i32 %N, ptr %A, ptr %B, i32 %j) {
; 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 GRP0:
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i16, ptr %B, i32 %add
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (4 + %A))
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (((2 * (sext i32 %j to i64))<nsw> + %B) umin ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + %N) to i64) * (sext i32 %N to i64)) + %B)) High: (2 + (((2 * (sext i32 %j to i64))<nsw> + %B) umax ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + %N) to i64) * (sext i32 %N to i64)) + %B))))
; CHECK-NEXT: Member: {((2 * (sext i32 %j to i64))<nsw> + %B),+,(2 * (sext i32 %N to i64))<nsw>}<%loop>
; CHECK-EMPTY:
@@ -512,15 +512,15 @@ define void @unknown_stride_equalto_zext_tc(i16 zeroext %N, ptr %A, ptr %B, i32
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i16, ptr %B, i32 %add
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (4 + %A))
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (((2 * (sext i32 %j to i64))<nsw> + %B) umin ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (zext i16 %N to i32))<nsw> to i64) * (zext i16 %N to i64)) + %B)) High: (2 + (((2 * (sext i32 %j to i64))<nsw> + %B) umax ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (zext i16 %N to i32))<nsw> to i64) * (zext i16 %N to i64)) + %B))))
; CHECK-NEXT: Member: {((2 * (sext i32 %j to i64))<nsw> + %B),+,(2 * (zext i16 %N to i64))<nuw><nsw>}<%loop>
; CHECK-EMPTY:
@@ -563,15 +563,15 @@ define void @unknown_stride_equalto_sext_tc(i16 %N, ptr %A, ptr %B, i32 %j) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i16, ptr %B, i32 %add
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (4 + %A))
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (((2 * (sext i32 %j to i64))<nsw> + %B) umin ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (sext i16 %N to i32))<nsw> to i64) * (sext i16 %N to i64)) + %B)) High: (2 + (((2 * (sext i32 %j to i64))<nsw> + %B) umax ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (sext i16 %N to i32))<nsw> to i64) * (sext i16 %N to i64)) + %B))))
; CHECK-NEXT: Member: {((2 * (sext i32 %j to i64))<nsw> + %B),+,(2 * (sext i16 %N to i64))<nsw>}<%loop>
; CHECK-EMPTY:
@@ -614,15 +614,15 @@ define void @unknown_stride_equalto_trunc_tc(i64 %N, ptr %A, ptr %B, i32 %j) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i16, ptr %B, i32 %add
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %A High: (4 + %A))
; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: (((2 * (sext i32 %j to i64))<nsw> + %B) umin ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (trunc i64 %N to i32)) to i64) * (sext i32 (trunc i64 %N to i32) to i64)) + %B)) High: (2 + (((2 * (sext i32 %j to i64))<nsw> + %B) umax ((2 * (sext i32 %j to i64))<nsw> + (2 * (zext i32 (-1 + (trunc i64 %N to i32)) to i64) * (sext i32 (trunc i64 %N to i32) to i64)) + %B))))
; CHECK-NEXT: Member: {((2 * (sext i32 %j to i64))<nsw> + %B),+,(2 * (sext i32 (trunc i64 %N to i32) to i64))<nsw>}<%loop>
; CHECK-EMPTY:
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..98a9fa586080a 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
@@ -14,26 +14,26 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_noal
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; 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: Comparing group GRP2:
; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %B High: (101 + %B))
; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: (1 + %B)<nuw> High: (102 + %B))
; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-EMPTY:
@@ -74,41 +74,41 @@ define void @test_dependence_with_non_constant_offset_and_other_accesses_to_maya
; 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 GRP0:
; 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 GRP1:
; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; 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 GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP5]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.off, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP7]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv
; CHECK-NEXT: Check 4:
-; CHECK-NEXT: Comparing group ([[GRP6]]):
+; CHECK-NEXT: Comparing group GRP1:
; CHECK-NEXT: %gep.B = getelementptr inbounds i8, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GRP8]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %gep.B.1 = getelementptr inbounds i8, ptr %B, i64 %iv.next
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: (%off + %A) High: (404 + %off + %A))
; CHECK-NEXT: Member: {(%off + %A),+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %B High: (101 + %B))
; CHECK-NEXT: Member: {%B,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %A High: (101 + %A))
; CHECK-NEXT: Member: {%A,+,1}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: (1 + %B)<nuw> High: (102 + %B))
; CHECK-NEXT: Member: {(1 + %B)<nuw>,+,1}<nuw><%loop>
; CHECK-EMPTY:
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll b/llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll
index d0b101079efbf..5051cb71889f5 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll
@@ -18,26 +18,26 @@ define void @rtchecks_needed(ptr %a, ptr %b, ptr %c) {
; CHECK-EMPTY:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxA = getelementptr inbounds i16, ptr %a, i64 %storemerge3
; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16, ptr %a, i64 %add
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidxB = getelementptr inbounds i16, ptr %b, i64 %storemerge3
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %arrayidxA = getelementptr inbounds i16, ptr %a, i64 %storemerge3
; CHECK-NEXT: %arrayidxA_plus_2 = getelementptr inbounds i16, ptr %a, i64 %add
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %arrayidxC = getelementptr inbounds i16, ptr %c, i64 %storemerge3
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %a High: (42 + %a))
; CHECK-NEXT: Member: {%a,+,2}<nuw><%for.body>
; CHECK-NEXT: Member: {(2 + %a),+,2}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %b High: (40 + %b))
; CHECK-NEXT: Member: {%b,+,2}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %c High: (40 + %c))
; CHECK-NEXT: Member: {%c,+,2}<nuw><%for.body>
; CHECK-EMPTY:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
index 7ba90c5088752..b7d8404ff4604 100644
--- a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
@@ -8,31 +8,31 @@ define dso_local void @dotvariable_laa(ptr nocapture readonly nonnull %Base1, pt
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP3:
; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP3:
; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; CHECK-EMPTY:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll
new file mode 100644
index 0000000000000..c35d4f3474bb7
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll
@@ -0,0 +1,51 @@
+; RUN: opt -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s --check-prefixes=CHECK,FULLDEPTH
+; RUN: opt -disable-output -passes='print<access-info>' -max-forked-scev-depth=2 %s 2>&1 | FileCheck %s --check-prefixes=CHECK,DEPTH2
+
+define void @laa_common_output(ptr %Base, ptr %Dest, ptr %Preds) {
+entry:
+ br label %for.body
+
+for.cond.cleanup: ; preds = %for.body
+ ret void
+
+for.body: ; preds = %entry, %for.body
+ %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+ %i.014 = phi i32 [ 0, %entry ], [ %add, %for.body ]
+ %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+ %0 = load i32, ptr %arrayidx, align 4
+ %cmp1.not = icmp eq i32 %0, 0
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %add = add nuw nsw i32 %i.014, 1
+ %1 = trunc i64 %indvars.iv to i32
+ %offset.0 = select i1 %cmp1.not, i32 %add, i32 %1
+ %idxprom213 = zext i32 %offset.0 to i64
+ %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %idxprom213
+ %2 = load float, ptr %arrayidx3, align 4
+ %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+ store float %2, ptr %arrayidx5, align 4
+ %exitcond.not = icmp eq i64 %indvars.iv.next, 100
+ br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+define void @laa_divergent_output(ptr %Base, ptr %Dest, ptr %Preds, i64 %extra_offset) {
+entry:
+ br label %for.body
+
+for.cond.cleanup: ; preds = %for.body
+ ret void
+
+for.body: ; preds = %entry, %for.body
+ %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+ %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+ %0 = load i32, ptr %arrayidx, align 4
+ %cmp.not = icmp eq i32 %0, 0
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv
+ %offset = add nuw nsw i64 %sel, %extra_offset
+ %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+ %1 = load float, ptr %arrayidx3, align 4
+ %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+ store float %1, ptr %arrayidx5, align 4
+ %exitcond.not = icmp eq i64 %indvars.iv.next, 100
+ br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll.expected
new file mode 100644
index 0000000000000..f2703e856ca22
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis-common-output.ll.expected
@@ -0,0 +1,109 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
+; RUN: opt -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s --check-prefixes=CHECK,FULLDEPTH
+; RUN: opt -disable-output -passes='print<access-info>' -max-forked-scev-depth=2 %s 2>&1 | FileCheck %s --check-prefixes=CHECK,DEPTH2
+
+define void @laa_common_output(ptr %Base, ptr %Dest, ptr %Preds) {
+; CHECK-LABEL: 'laa_common_output'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Report: cannot identify array bounds
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Grouped accesses:
+; CHECK-EMPTY:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-EMPTY:
+; CHECK-NEXT: Expressions re-written:
+;
+entry:
+ br label %for.body
+
+for.cond.cleanup: ; preds = %for.body
+ ret void
+
+for.body: ; preds = %entry, %for.body
+ %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+ %i.014 = phi i32 [ 0, %entry ], [ %add, %for.body ]
+ %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+ %0 = load i32, ptr %arrayidx, align 4
+ %cmp1.not = icmp eq i32 %0, 0
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %add = add nuw nsw i32 %i.014, 1
+ %1 = trunc i64 %indvars.iv to i32
+ %offset.0 = select i1 %cmp1.not, i32 %add, i32 %1
+ %idxprom213 = zext i32 %offset.0 to i64
+ %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %idxprom213
+ %2 = load float, ptr %arrayidx3, align 4
+ %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+ store float %2, ptr %arrayidx5, align 4
+ %exitcond.not = icmp eq i64 %indvars.iv.next, 100
+ br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+define void @laa_divergent_output(ptr %Base, ptr %Dest, ptr %Preds, i64 %extra_offset) {
+; FULLDEPTH-LABEL: 'laa_divergent_output'
+; FULLDEPTH-NEXT: for.body:
+; FULLDEPTH-NEXT: Memory dependences are safe with run-time checks
+; FULLDEPTH-NEXT: Dependences:
+; FULLDEPTH-NEXT: Run-time memory checks:
+; FULLDEPTH-NEXT: Check 0:
+; FULLDEPTH-NEXT: Comparing group GRP0:
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group GRP1:
+; FULLDEPTH-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; FULLDEPTH-NEXT: Check 1:
+; FULLDEPTH-NEXT: Comparing group GRP0:
+; FULLDEPTH-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; FULLDEPTH-NEXT: Against group GRP2:
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; FULLDEPTH-NEXT: Grouped accesses:
+; FULLDEPTH-NEXT: Group GRP0:
+; FULLDEPTH-NEXT: (Low: %Dest High: (400 + %Dest))
+; FULLDEPTH-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group GRP1:
+; FULLDEPTH-NEXT: (Low: %Preds High: (400 + %Preds))
+; FULLDEPTH-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; FULLDEPTH-NEXT: Group GRP2:
+; FULLDEPTH-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
+; FULLDEPTH-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; FULLDEPTH-NEXT: SCEV assumptions:
+; FULLDEPTH-EMPTY:
+; FULLDEPTH-NEXT: Expressions re-written:
+;
+; DEPTH2-LABEL: 'laa_divergent_output'
+; DEPTH2-NEXT: for.body:
+; DEPTH2-NEXT: Report: cannot identify array bounds
+; DEPTH2-NEXT: Dependences:
+; DEPTH2-NEXT: Run-time memory checks:
+; DEPTH2-NEXT: Grouped accesses:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; DEPTH2-NEXT: SCEV assumptions:
+; DEPTH2-EMPTY:
+; DEPTH2-NEXT: Expressions re-written:
+;
+entry:
+ br label %for.body
+
+for.cond.cleanup: ; preds = %for.body
+ ret void
+
+for.body: ; preds = %entry, %for.body
+ %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+ %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+ %0 = load i32, ptr %arrayidx, align 4
+ %cmp.not = icmp eq i32 %0, 0
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %sel = select i1 %cmp.not, i64 %indvars.iv.next, i64 %indvars.iv
+ %offset = add nuw nsw i64 %sel, %extra_offset
+ %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+ %1 = load float, ptr %arrayidx3, align 4
+ %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+ store float %1, ptr %arrayidx5, align 4
+ %exitcond.not = icmp eq i64 %indvars.iv.next, 100
+ br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
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..6d7b0655acdce 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
@@ -8,26 +8,26 @@ define void @laa(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, p
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
; CHECK-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
-; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: Group GRP2:
; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
; CHECK-EMPTY:
@@ -74,15 +74,15 @@ define void @test_brace_escapes(ptr noundef %arr) {
; CHECK-NEXT: Dependences:
; CHECK-NEXT: Run-time memory checks:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: %gep.iv.2 = getelementptr inbounds ptr, ptr %arr, i64 %iv.2
-; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: %gep.iv.1 = getelementptr inbounds ptr, ptr %arr, i64 %iv.1
; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: Group GRP0:
; CHECK-NEXT: (Low: {(64 + %arr),+,64}<%loop.1> High: {(8064 + %arr),+,64}<%loop.1>)
; CHECK-NEXT: Member: {{\{\{}}(64 + %arr),+,64}<%loop.1>,+,8}<%loop.2>
-; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: Group GRP1:
; CHECK-NEXT: (Low: %arr High: (8000 + %arr))
; CHECK-NEXT: Member: {%arr,+,8}<nuw><%loop.2>
; CHECK-EMPTY:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-distribute.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-distribute.ll.expected
index eba378c175091..5751738f7bb3b 100644
--- a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-distribute.ll.expected
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-distribute.ll.expected
@@ -55,17 +55,17 @@ define void @ldist(i1 %cond, ptr %A, ptr %B, ptr %C) {
; CHECK-NEXT: LDist: Distributing loop: for.body
; CHECK-NEXT: LDist: Pointers:
; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP1:
; CHECK-NEXT: ptr %C
; CHECK-NEXT: ptr %C
; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: Comparing group GRP0:
; CHECK-NEXT: ptr %A
; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: Against group GRP2:
; CHECK-NEXT: ptr %B
; CHECK-NEXT: ptr %B
; CHECK-NEXT: LDist: After removing unused Instrs:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis-common-output.test b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis-common-output.test
new file mode 100644
index 0000000000000..425aa5f39af2d
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis-common-output.test
@@ -0,0 +1,5 @@
+# RUN: cp -f %S/Inputs/loop-access-analysis-common-output.ll %t.ll && %update_analyze_test_checks %t.ll
+# RUN:
diff -u %t.ll %S/Inputs/loop-access-analysis-common-output.ll.expected
+## Check that running the script again does not change the result:
+# RUN: %update_analyze_test_checks %t.ll
+# RUN:
diff -u %t.ll %S/Inputs/loop-access-analysis-common-output.ll.expected
diff --git a/llvm/utils/UpdateTestChecks/common.py b/llvm/utils/UpdateTestChecks/common.py
index d150612dd368e..00748586b64ef 100644
--- a/llvm/utils/UpdateTestChecks/common.py
+++ b/llvm/utils/UpdateTestChecks/common.py
@@ -1307,6 +1307,7 @@ def make_asm_generalizer(version):
return GeneralizerInfo(version, GeneralizerInfo.MODE_ASM, values, prefix, suffix)
+# TODO: This is no longer required. Generalize UTC over an empty GeneralizerInfo.
def make_analyze_generalizer(version):
values = [
NamelessValue(
More information about the llvm-commits
mailing list