diff options
29 files changed, 658 insertions, 482 deletions
diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp index 2a322a6..389c3c7 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/different-access-types-rt-checks.ll b/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll index 58844c1..809472c 100644 --- a/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll +++ b/llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll @@ -10,16 +10,16 @@ define void @loads_of_same_pointer_with_different_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_different_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_different_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 d5abf82..e235b73 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 0436c1b..906bf5c 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 286af49..c28dd58 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_different_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_different_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_different_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_different_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_different_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_different_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 723d01b..8328591 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 fd4f417..3518d92 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 322723b..8c69b2e 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 20fc0be..a338a33 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 f939680..b444c06 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 c502c7c..7e7bc1d 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_different_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_different_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 d428761..44a4721c 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 ab40a22..9cd6d1f 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 202f975..74b65ac 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 48586ee..bd38c50 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-different-access-sizes.ll b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll index 08e0bae..1a6e258 100644 --- a/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll +++ b/llvm/test/Analysis/LoopAccessAnalysis/positive-dependence-distance-different-access-sizes.ll @@ -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 021447d5..0763fd2 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 114637e..595fb021 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 cce6f82..510799c 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 8603417..1c48b0e 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 23ab92d..98a9fa5 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 d0b1010..5051cb7 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 7ba90c5..b7d8404 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 0000000..c35d4f3 --- /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 0000000..f2703e8 --- /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 58655ff..6d7b065 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 eba378c..5751738 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 0000000..425aa5f --- /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 d150612..0074858 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( |