Skip to content

[LAA] Tweak debug output for UTC stability #140764

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
May 21, 2025
Merged

[LAA] Tweak debug output for UTC stability #140764

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 16 additions & 6 deletions llvm/lib/Analysis/LoopAccessAnalysis.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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";
}
Expand All @@ -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) {
Expand Down
44 changes: 22 additions & 22 deletions llvm/test/Analysis/LoopAccessAnalysis/different-access-types-rt-checks.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down Expand Up @@ -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>
Expand Down Expand Up @@ -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:
Expand Down
48 changes: 24 additions & 24 deletions llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down
24 changes: 12 additions & 12 deletions ...est/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down
Loading
Loading