[llvm] update_analyze_test_checks: support output from LAA (PR #67584)
Ramkumar Ramachandra via llvm-commits
llvm-commits at lists.llvm.org
Tue Oct 31 05:43:20 PDT 2023
https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/67584
>From 516c36fd86cb30bf0fb3dc4b5e7f006dd6830adc Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <Ramkumar.Ramachandra at imgtec.com>
Date: Mon, 25 Sep 2023 12:58:23 +0100
Subject: [PATCH] update_analyze_test_checks: support output from LAA
update_analyze_test_checks.py is an invaluable tool in updating tests.
Unfortunately, it only supports output from the CostModel,
ScalarEvolution, and LoopVectorize analyses. Many LoopAccessAnalysis
tests use hand-crafted CHECK lines, and it is moreover tedious to
generate these CHECK lines, as the output fom the analysis is not
stable, and requires the test-writer to hand-craft FileCheck matches.
Alleviate this pain, and support output from:
$ opt -passes='print<loop-accesses>'
This patch includes several non-trivial changes including:
- Preserving whitespace at the beginning of the line, so that the LAA
output can be properly indented.
- Regexes matching the unstable output, which is basically a pointer
address hex.
- Separate is_analyze from preserve_names clearly, as the former was
formerly used as an overload for the latter.
To demonstate the utility of this patch, several tests in
LoopAccessAnalysis have been auto-generated by
update_analyze_test_checks.py.
---
.../Scalar/LoopAccessAnalysisPrinter.cpp | 3 +-
.../LoopAccessAnalysis/forked-pointers.ll | 1434 +++++++++++------
...invariant-dep-with-backedge-taken-count.ll | 168 +-
.../max_safe_dep_dist_non_unit_stride.ll | 25 +-
.../LoopAccessAnalysis/pointer-phis.ll | 425 +++--
.../LoopAccessAnalysis/symbolic-stride.ll | 111 +-
.../LoopUnroll/unroll-loop-invalidation.ll | 2 +-
.../Inputs/dotvariable-laa.ll | 23 +
.../Inputs/dotvariable-laa.ll.expected | 63 +
.../Inputs/loop-access-analysis.ll | 23 +
.../Inputs/loop-access-analysis.ll.expected | 58 +
.../dotvariable-laa.test | 6 +
.../loop-access-analysis.test | 6 +
llvm/utils/UpdateTestChecks/common.py | 175 +-
llvm/utils/update_analyze_test_checks.py | 4 -
15 files changed, 1671 insertions(+), 855 deletions(-)
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/dotvariable-laa.test
create mode 100644 llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis.test
diff --git a/llvm/lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp b/llvm/lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp
index 9ae55b9018dad34..3d3f22d686e32ed 100644
--- a/llvm/lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp
@@ -20,7 +20,8 @@ PreservedAnalyses LoopAccessInfoPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
auto &LAIs = AM.getResult<LoopAccessAnalysis>(F);
auto &LI = AM.getResult<LoopAnalysis>(F);
- OS << "Loop access info in function '" << F.getName() << "':\n";
+ OS << "Printing analysis 'Loop Access Analysis' for function '" << F.getName()
+ << "':\n";
SmallPriorityWorklist<Loop *, 4> Worklist;
appendLoopsToWorklist(LI, Worklist);
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
index 30ffc4cb5e1e85f..848302bc24025f4 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll
@@ -1,43 +1,78 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
; RUN: opt -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s
; RUN: opt -disable-output -passes='print<access-info>' -max-forked-scev-depth=2 %s 2>&1 | FileCheck -check-prefix=RECURSE %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-; CHECK-LABEL: function 'forked_ptrs_simple':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; 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 ([[G2:.+]]):
-; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; 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 ([[G3:.+]]):
-; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
+define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr %Dest) {
+; CHECK-LABEL: 'forked_ptrs_simple'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: %gep.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: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP1]]):
+; 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: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
+; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr %Dest) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_simple'
+; RECURSE-NEXT: loop:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+; RECURSE-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP4]]):
+; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+; RECURSE-NEXT: %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+; RECURSE-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP4]]:
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; RECURSE-NEXT: Group [[GRP5]]:
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%loop>
+; RECURSE-NEXT: Group [[GRP6]]:
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%loop>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %loop
@@ -59,59 +94,9 @@ exit:
ret void
}
-; CHECK-LABEL: function 'forked_ptrs_different_base_same_offset':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
-; 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:
-
;; We have a limit on the recursion depth for finding a loop invariant or
;; addrec term; confirm we won't exceed that depth by forcing a lower
;; limit via -max-forked-scev-depth=2
-; RECURSE-LABEL: Loop access info in function 'forked_ptrs_same_base_different_offset':
-; RECURSE-NEXT: for.body:
-; RECURSE-NEXT: Report: cannot identify array bounds
-; RECURSE-NEXT: Dependences:
-; RECURSE-NEXT: Run-time memory checks:
-; RECURSE-NEXT: Grouped accesses:
-; RECURSE-EMPTY:
-; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; RECURSE-NEXT: SCEV assumptions:
-; RECURSE-EMPTY:
-; RECURSE-NEXT: Expressions re-written:
;;;; Derived from the following C code
;; void forked_ptrs_different_base_same_offset(float *A, float *B, float *C, int *D) {
@@ -125,6 +110,84 @@ exit:
;; }
define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_different_base_same_offset'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP7]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP7]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP11:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP11]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP13:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP11]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP14:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP11]]:
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP12]]:
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP13]]:
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP14]]:
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -146,46 +209,85 @@ for.body:
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_different_base_same_offset_64b':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
+define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_64b'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP15:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP16:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP15]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP17:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP15]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP18:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP15]]:
+; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP16]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP17]]:
+; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP18]]:
+; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_64b'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP19:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP20:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP19]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP21:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP19]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP22:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP19]]:
+; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP20]]:
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP21]]:
+; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,8}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP22]]:
+; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,8}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -207,46 +309,85 @@ for.body:
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_different_base_same_offset_23b':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (399 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_23b'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP23:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP24:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP23]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP25:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP23]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP26:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP23]]:
+; CHECK-NEXT: (Low: %Dest High: (399 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP24]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP25]]:
+; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP26]]:
+; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_23b'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP27:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP28:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP27]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP29:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP27]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i23, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP30:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP27]]:
+; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP28]]:
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP29]]:
+; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP30]]:
+; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -268,46 +409,85 @@ for.body:
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_different_base_same_offset_6b':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (100 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body>
+define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_6b'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP31:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP32:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP31]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP33:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP31]]):
+; CHECK-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP34:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP31]]:
+; CHECK-NEXT: (Low: %Dest High: (100 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP32]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP33]]:
+; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP34]]:
+; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_6b'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP35:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP36:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP35]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP37:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP35]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds i6, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP38:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP35]]:
+; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,1}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP36]]:
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP37]]:
+; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,1}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP38]]:
+; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,1}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -329,46 +509,85 @@ for.body:
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_different_base_same_offset_possible_poison':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
-; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds, i1 %c) {
+; CHECK-LABEL: 'forked_ptrs_different_base_same_offset_possible_poison'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP39:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP40:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP39]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP41:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP39]]):
+; CHECK-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP42:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP39]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP40]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP41]]:
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP42]]:
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds, i1 %c) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_different_base_same_offset_possible_poison'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP43:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP44:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP43]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP45:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP43]]):
+; RECURSE-NEXT: %1 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP46:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP43]]:
+; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest))
+; RECURSE-NEXT: Member: {%Dest,+,4}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP44]]:
+; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP45]]:
+; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP46]]:
+; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1))
+; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -396,18 +615,6 @@ latch:
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_same_base_different_offset':
-; 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:
-
;;;; Derived from the following C code
;; void forked_ptrs_same_base_different_offset(float *A, float *B, int *C) {
;; int offset;
@@ -421,6 +628,30 @@ latch:
;; }
define dso_local void @forked_ptrs_same_base_different_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_same_base_different_offset'
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_same_base_different_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -446,40 +677,52 @@ for.body: ; preds = %entry, %for.body
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_add_to_offset'
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
-; CHECK-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
-; CHECK-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
+define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-LABEL: 'forked_ptrs_add_to_offset'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP47:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP48:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP47]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP49:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP47]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP48]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP49]]:
+; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base))
+; CHECK-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body>
+; CHECK-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_add_to_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -502,40 +745,52 @@ for.body: ; preds = %entry, %for.body
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_sub_from_offset'
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base))
-; CHECK-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body>
-; CHECK-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body>
+define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-LABEL: 'forked_ptrs_sub_from_offset'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP50:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP51:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP50]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP52:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP50]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP51]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP52]]:
+; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base))
+; CHECK-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body>
+; CHECK-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_sub_from_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -558,40 +813,52 @@ for.body: ; preds = %entry, %for.body
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_add_sub_offset'
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G3:.+]]):
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
-; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base))
-; CHECK-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
-; CHECK-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
+define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %to_add, i64 %to_sub) {
+; CHECK-LABEL: 'forked_ptrs_add_sub_offset'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP53:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP54:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP53]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds float, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP55:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP53]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP54]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP55]]:
+; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base))
+; CHECK-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
+; CHECK-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body>
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %to_add, i64 %to_sub) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_add_sub_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -617,19 +884,31 @@ for.body: ; preds = %entry, %for.body
;;;; Cases that can be handled by a forked pointer but are not currently allowed.
-; CHECK-LABEL: function 'forked_ptrs_mul_by_offset'
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Report: cannot identify array bounds
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+define dso_local void @forked_ptrs_mul_by_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-LABEL: 'forked_ptrs_mul_by_offset'
+; 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-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_mul_by_offset(ptr nocapture readonly %Base, ptr nocapture %Dest, ptr nocapture readonly %Preds, i64 %extra_offset) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_mul_by_offset'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -652,22 +931,34 @@ for.body: ; preds = %entry, %for.body
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_uniform_and_strided_forks':
-; 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:
-
;;;; Derived from forked_ptrs_same_base_different_offset with a manually
;;;; added uniform offset and a mul to provide a stride
define dso_local void @forked_ptrs_uniform_and_strided_forks(float* nocapture readonly %Base, float* nocapture %Dest, i32* nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_uniform_and_strided_forks'
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_uniform_and_strided_forks'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -694,23 +985,35 @@ for.body: ; preds = %entry, %for.body
br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
}
-; CHECK-LABEL: function 'forked_ptrs_gather_and_contiguous_forks':
-; 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:
-
;;;; Derived from forked_ptrs_same_base_different_offset with a gather
;;;; added using Preds as an index array in addition to the per-iteration
;;;; condition.
define dso_local void @forked_ptrs_gather_and_contiguous_forks(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_gather_and_contiguous_forks'
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_gather_and_contiguous_forks'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -737,19 +1040,31 @@ for.body: ; preds = %entry, %for.body
;; We don't currently handle a fork in both the base and the offset of a
;; GEP instruction.
-; CHECK-LABEL: Loop access info in function 'forked_ptrs_two_forks_gep':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Report: cannot identify array bounds
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+define dso_local void @forked_ptrs_two_forks_gep(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_two_forks_gep'
+; 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-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define dso_local void @forked_ptrs_two_forks_gep(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_two_forks_gep'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -774,19 +1089,31 @@ for.body:
;; We don't handle forks as children of a select
-; CHECK-LABEL: Loop access info in function 'forked_ptrs_two_select':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: cannot identify array bounds
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+define void @forked_ptrs_two_select(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture readonly %Base3, ptr %Dest) {
+; CHECK-LABEL: 'forked_ptrs_two_select'
+; CHECK-NEXT: loop:
+; 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-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-
-define void @forked_ptrs_two_select(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture readonly %Base3, ptr %Dest) {
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_two_select'
+; RECURSE-NEXT: loop:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %loop
@@ -812,19 +1139,32 @@ exit:
}
;; We don't yet handle geps with more than 2 operands
-; CHECK-LABEL: Loop access info in function 'forked_ptrs_too_many_gep_ops':
-; 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:
define void @forked_ptrs_too_many_gep_ops(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_too_many_gep_ops'
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_too_many_gep_ops'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -847,19 +1187,32 @@ for.cond.cleanup:
}
;; We don't currently handle vector GEPs
-; CHECK-LABEL: Loop access info in function 'forked_ptrs_vector_gep':
-; 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:
define void @forked_ptrs_vector_gep(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'forked_ptrs_vector_gep'
+; 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:
+;
+; RECURSE-LABEL: 'forked_ptrs_vector_gep'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
br label %for.body
@@ -881,33 +1234,6 @@ for.cond.cleanup:
ret void
}
-; CHECK-LABEL: Loop access info in function 'sc_add_expr_ice':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: ptr %Base1
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1))
-; CHECK-NEXT: Member: %Base1
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
-; CHECK-NEXT: Member: {%Base2,+,8}<%for.body>
-; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
-; CHECK-NEXT: SCEV assumptions:
-; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
-; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-; CHECK-NEXT: [PSE] %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel:
-; CHECK-NEXT: ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw>
-; CHECK-NEXT: --> {%Base2,+,8}<%for.body>
-
;;; The following test caused an ICE with the initial forked pointers work.
;;; One fork is loop invariant (%Base2 + 0), the other is an scAddExpr that
;;; contains an scAddRecExpr inside it:
@@ -918,6 +1244,60 @@ for.cond.cleanup:
;;; forks only, but we should be able to do better.
define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) {
+; CHECK-LABEL: 'sc_add_expr_ice'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP56:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %Base1
+; CHECK-NEXT: Against group ([[GRP57:0x[0-9a-f]+]]):
+; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP56]]:
+; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1))
+; CHECK-NEXT: Member: %Base1
+; CHECK-NEXT: Group [[GRP57]]:
+; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,8}<%for.body>
+; CHECK-EMPTY:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
+; CHECK-EMPTY:
+; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: [PSE] %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel:
+; CHECK-NEXT: ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw>
+; CHECK-NEXT: --> {%Base2,+,8}<%for.body>
+;
+; RECURSE-LABEL: 'sc_add_expr_ice'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP58:0x[0-9a-f]+]]):
+; RECURSE-NEXT: ptr %Base1
+; RECURSE-NEXT: Against group ([[GRP59:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP58]]:
+; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1))
+; RECURSE-NEXT: Member: %Base1
+; RECURSE-NEXT: Group [[GRP59]]:
+; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2))
+; RECURSE-NEXT: Member: {%Base2,+,8}<%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+; RECURSE-NEXT: [PSE] %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel:
+; RECURSE-NEXT: ((8 * (zext i32 {0,+,1}<%for.body> to i64))<nuw><nsw> + %Base2)<nuw>
+; RECURSE-NEXT: --> {%Base2,+,8}<%for.body>
+;
entry:
br label %for.body
@@ -938,45 +1318,94 @@ exit:
}
define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr nocapture %a, ptr nocapture %b, ptr nocapture readonly %c) {
-; CHECK: for.body:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[G1:.+]]):
-; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[G1]]):
-; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4:.+]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[G3:.+]]):
-; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G2]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
-; CHECK-NEXT: Check 3:
-; CHECK-NEXT: Comparing group ([[G3]]):
-; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
-; CHECK-NEXT: Against group ([[G4]]):
-; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[G1]]:
-; CHECK-NEXT: (Low: %1 High: (63992 + %1))
-; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[G3]]:
-; CHECK-NEXT: (Low: %2 High: (63992 + %2))
-; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body>
-; CHECK-NEXT: Group [[G2]]:
-; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds))
-; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
-; CHECK-NEXT: Group [[G4]]:
-; CHECK-NEXT: (Low: %0 High: (63992 + %0))
-; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body>
+; CHECK-LABEL: 'forked_ptrs_with_different_base'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP60:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP61:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP60]]):
+; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP62:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP63:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP61]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 3:
+; CHECK-NEXT: Comparing group ([[GRP63]]):
+; CHECK-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP62]]):
+; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP60]]:
+; CHECK-NEXT: (Low: %1 High: (63992 + %1))
+; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP63]]:
+; CHECK-NEXT: (Low: %2 High: (63992 + %2))
+; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP61]]:
+; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP62]]:
+; CHECK-NEXT: (Low: %0 High: (63992 + %0))
+; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body>
+; CHECK-EMPTY:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_with_different_base'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Memory dependences are safe with run-time checks
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Check 0:
+; RECURSE-NEXT: Comparing group ([[GRP64:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP65:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 1:
+; RECURSE-NEXT: Comparing group ([[GRP64]]):
+; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP66:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
+; RECURSE-NEXT: Check 2:
+; RECURSE-NEXT: Comparing group ([[GRP67:0x[0-9a-f]+]]):
+; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP65]]):
+; RECURSE-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; RECURSE-NEXT: Check 3:
+; RECURSE-NEXT: Comparing group ([[GRP67]]):
+; RECURSE-NEXT: %arrayidx7 = getelementptr inbounds double, ptr %.sink, i64 %indvars.iv
+; RECURSE-NEXT: Against group ([[GRP66]]):
+; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-NEXT: Group [[GRP64]]:
+; RECURSE-NEXT: (Low: %1 High: (63992 + %1))
+; RECURSE-NEXT: Member: {%1,+,8}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP67]]:
+; RECURSE-NEXT: (Low: %2 High: (63992 + %2))
+; RECURSE-NEXT: Member: {%2,+,8}<nw><%for.body>
+; RECURSE-NEXT: Group [[GRP65]]:
+; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds))
+; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; RECURSE-NEXT: Group [[GRP66]]:
+; RECURSE-NEXT: (Low: %0 High: (63992 + %0))
+; RECURSE-NEXT: Member: {%0,+,8}<nw><%for.body>
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
%0 = load ptr, ptr %c, align 64
%1 = load ptr, ptr %a, align 64
@@ -1017,13 +1446,30 @@ for.inc: ; preds = %if.then, %if.else
; Negative test: the operator number of PhiNode is not 2.
define void @forked_ptrs_with_different_base3(ptr nocapture readonly %Preds, ptr nocapture %a, ptr nocapture %b, ptr nocapture readonly %c) {
-; CHECK: for.body:
-; CHECK-NEXT: Report: cannot identify array bounds
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'forked_ptrs_with_different_base3'
+; 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: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: Expressions re-written:
+;
+; RECURSE-LABEL: 'forked_ptrs_with_different_base3'
+; RECURSE-NEXT: for.body:
+; RECURSE-NEXT: Report: cannot identify array bounds
+; RECURSE-NEXT: Dependences:
+; RECURSE-NEXT: Run-time memory checks:
+; RECURSE-NEXT: Grouped accesses:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; RECURSE-NEXT: SCEV assumptions:
+; RECURSE-EMPTY:
+; RECURSE-NEXT: Expressions re-written:
+;
entry:
%ld.c = load ptr, ptr %c, align 64
%ld.a = load ptr, ptr %a, align 64
@@ -1058,4 +1504,4 @@ for.inc: ; preds = %if.br1, %if.br0
for.cond.cleanup: ; preds = %for.inc
ret void
-}
\ No newline at end of file
+}
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 63e483dd72ff19f..02285031f628b35 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
@@ -1,21 +1,26 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
; RUN: opt -passes='print<access-info>' -disable-output %s 2>&1 | FileCheck %s
; Test cases for using the backedge-taken-count to rule out dependencies between
; an invariant and strided accesses.
define void @test_distance_greater_than_BTC_100(ptr %a) {
-; CHECK-LABEL: Loop access info in function 'test_distance_greater_than_BTC_100':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_distance_greater_than_BTC_100'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
; CHECK-EMPTY:
+; 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:
%gep.x = getelementptr i32, ptr %a, i32 100
@@ -35,18 +40,22 @@ exit:
}
define void @test_distance_much_greater_than_BTC_100(ptr %a) {
-; CHECK-LABEL: Loop access info in function 'test_distance_much_greater_than_BTC_100':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_distance_much_greater_than_BTC_100'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
+; CHECK-EMPTY:
+; 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:
%gep.x = getelementptr i32, ptr %a, i32 200
@@ -66,18 +75,22 @@ exit:
}
define void @test_distance_equal_BTC_100(ptr %a) {
-; CHECK-LABEL: Loop access info in function 'test_distance_equal_BTC_100':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_distance_equal_BTC_100'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
; CHECK-EMPTY:
+; 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:
%gep.x = getelementptr i32, ptr %a, i32 99
@@ -97,18 +110,22 @@ exit:
}
define void @test_distance_greater_than_BTC_10000(ptr %a) {
-; CHECK-LABEL: Loop access info in function 'test_distance_greater_than_BTC_10000':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_distance_greater_than_BTC_10000'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
+; CHECK-EMPTY:
+; 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:
%gep.x = getelementptr i32, ptr %a, i32 10000
@@ -128,18 +145,22 @@ exit:
}
define void @test_distance_equal_to_BTC_10000(ptr %a) {
-; CHECK-LABEL: Loop access info in function 'test_distance_equal_to_BTC_10000':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_distance_equal_to_BTC_10000'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
+; CHECK-EMPTY:
+; 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:
%gep.x = getelementptr i32, ptr %a, i32 9999
@@ -159,17 +180,32 @@ exit:
}
define void @test_btc_is_unknown_value(ptr %a, i32 %N) {
-; CHECK-LABEL: Loop access info in function 'test_btc_is_unknown_value':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
-; CHECK-NEXT: store i32 %l, ptr %gep, align 4
-; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'test_btc_is_unknown_value'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %l = load i32, ptr %gep.x, align 4 ->
+; CHECK-NEXT: store i32 %l, ptr %gep, align 4
+; CHECK-EMPTY:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP1:0x[0-9a-f]+]]:
+; CHECK-NEXT: (Low: (400 + %a) High: (404 + %a))
+; CHECK-NEXT: Member: (400 + %a)
+; CHECK-NEXT: Group [[GRP2:0x[0-9a-f]+]]:
+; CHECK-NEXT: (Low: %a High: (4 + (4 * (zext i32 (-1 + %N) to i64))<nuw><nsw> + %a))
+; CHECK-NEXT: Member: {%a,+,4}<nw><%loop>
+; CHECK-EMPTY:
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: {0,+,1}<nuw><%loop> Added Flags: <nssw>
+; CHECK-EMPTY:
+; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: [PSE] %gep = getelementptr i32, ptr %a, i32 %iv:
+; CHECK-NEXT: ((4 * (sext i32 {0,+,1}<nuw><%loop> to i64))<nsw> + %a)
+; CHECK-NEXT: --> {%a,+,4}<nw><%loop>
;
entry:
%gep.x = getelementptr i32, ptr %a, i32 100
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/max_safe_dep_dist_non_unit_stride.ll b/llvm/test/Analysis/LoopAccessAnalysis/max_safe_dep_dist_non_unit_stride.ll
index 0364248b004cf88..54445c018243501 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/max_safe_dep_dist_non_unit_stride.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/max_safe_dep_dist_non_unit_stride.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
; RUN: opt -S -disable-output -passes='print<access-info>' < %s 2>&1 | FileCheck %s
; Generated from following C program:
@@ -8,21 +9,21 @@
; }
; }
define void @foo(i64 %len, ptr %a) {
-; CHECK-LABEL: Loop access info in function 'foo':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: BackwardVectorizable:
-; CHECK-NEXT: store i32 %0, ptr %arrayidx2, align 4 ->
-; CHECK-NEXT: %1 = load i32, ptr %arrayidx5, align 4
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Memory dependences are safe with a maximum safe vector width of 64 bits
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: BackwardVectorizable:
+; CHECK-NEXT: store i32 %0, ptr %arrayidx2, align 4 ->
+; CHECK-NEXT: %1 = load i32, ptr %arrayidx5, align 4
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; 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-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: Expressions re-written:
;
loop.preheader:
br label %loop
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
index b912a476651a2ea..a214451bfd3fd4c 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll
@@ -1,11 +1,20 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
; RUN: opt -passes='print<access-info>' -disable-output < %s 2>&1 | FileCheck %s
%s1 = type { [32000 x double], [32000 x double], [32000 x double] }
define i32 @load_with_pointer_phi_no_runtime_checks(ptr %data) {
-; CHECK-LABEL: load_with_pointer_phi_no_runtime_checks
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Memory dependences are safe
+; CHECK-LABEL: 'load_with_pointer_phi_no_runtime_checks'
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Memory dependences are safe
+; 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 %loop.header
@@ -39,8 +48,16 @@ exit: ; preds = %loop.latch
define i32 @store_with_pointer_phi_no_runtime_checks(ptr %data) {
; CHECK-LABEL: 'store_with_pointer_phi_no_runtime_checks'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Memory dependences are safe
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Memory dependences are safe
+; 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 %loop.header
@@ -74,24 +91,40 @@ exit: ; preds = %loop.latch
define i32 @store_with_pointer_phi_runtime_checks(ptr %A, ptr %B, ptr %C) {
; CHECK-LABEL: 'store_with_pointer_phi_runtime_checks'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Memory dependences are safe with run-time checks
-; CHECK: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GROUP_B:.+]]):
-; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GROUP_C:.+]]):
-; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GROUP_B]]):
-; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
-; CHECK-NEXT: Against group ([[GROUP_A:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GROUP_C]]):
-; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
-; CHECK-NEXT: Against group ([[GROUP_A]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
+; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: %gep.1 = getelementptr inbounds double, ptr %B, i64 %iv
+; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP2]]):
+; CHECK-NEXT: %gep.2 = getelementptr inbounds double, ptr %C, i64 %iv
+; CHECK-NEXT: Against group ([[GRP3]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: (Low: %B High: (256000 + %B))
+; CHECK-NEXT: Member: {%B,+,8}<nw><%loop.header>
+; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: (Low: %C High: (256000 + %C))
+; CHECK-NEXT: Member: {%C,+,8}<nw><%loop.header>
+; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: Member: {%A,+,8}<nw><%loop.header>
+; 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 %loop.header
@@ -125,13 +158,21 @@ exit: ; preds = %loop.latch
define i32 @load_with_pointer_phi_outside_loop(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
; CHECK-LABEL: 'load_with_pointer_phi_outside_loop'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %v8 = load double, ptr %ptr, align 8 ->
-; CHECK-NEXT: store double %mul16, ptr %arrayidx, align 8
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %v8 = load double, ptr %ptr, align 8 ->
+; CHECK-NEXT: store double %mul16, ptr %arrayidx, align 8
+; CHECK-EMPTY:
+; 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 i1 %c.0, label %if.then, label %if.else
@@ -163,13 +204,21 @@ exit: ; preds = %loop.latch
define i32 @store_with_pointer_phi_outside_loop(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
; CHECK-LABEL: 'store_with_pointer_phi_outside_loop'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
-; CHECK-NEXT: store double %mul16, ptr %ptr, align 8
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
+; CHECK-NEXT: store double %mul16, ptr %ptr, align 8
+; CHECK-EMPTY:
+; 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 i1 %c.0, label %if.then, label %if.else
@@ -201,43 +250,49 @@ exit: ; preds = %loop.latch
define i32 @store_with_pointer_phi_incoming_phi(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
-; CHECK-NEXT: store double %mul16, ptr %ptr.2, align 8
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
+; CHECK-NEXT: store double %mul16, ptr %ptr.2, align 8
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GROUP_C:.+]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GROUP_B:.+]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GROUP_C]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GROUP_A:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GROUP_B]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Against group ([[GROUP_A]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GROUP_C]]:
-; CHECK-NEXT: (Low: %C High: (8 + %C))
-; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GROUP_B]]:
-; CHECK-NEXT: (Low: %B High: (8 + %B))
-; CHECK-NEXT: Member: %B
-; CHECK-NEXT: Group [[GROUP_A]]:
-; CHECK-NEXT: (Low: %A High: (256000 + %A))
-; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
-; CHECK-NEXT: Member: %A
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Against group ([[GRP5:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP4]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]):
+; 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: ptr %B
+; CHECK-NEXT: Against group ([[GRP6]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: (Low: %C High: (8 + %C))
+; CHECK-NEXT: Member: %C
+; CHECK-NEXT: Group [[GRP5]]:
+; CHECK-NEXT: (Low: %B High: (8 + %B))
+; CHECK-NEXT: Member: %B
+; CHECK-NEXT: Group [[GRP6]]:
+; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
+; CHECK-NEXT: Member: %A
+; 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:
+;
; CHECK-EMPTY
entry:
br label %loop.header
@@ -278,43 +333,49 @@ exit: ; preds = %loop.latch
; Test cases with pointer phis forming a cycle.
define i32 @store_with_pointer_phi_incoming_phi_irreducible_cycle(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi_irreducible_cycle'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
-; CHECK-NEXT: store double %mul16, ptr %ptr.3, align 8
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
+; CHECK-NEXT: store double %mul16, ptr %ptr.3, align 8
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GROUP_C:.+]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GROUP_B:.+]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GROUP_C]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GROUP_A:.+]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GROUP_B]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Against group ([[GROUP_A]]):
-; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GROUP_C]]
-; CHECK-NEXT: (Low: %C High: (8 + %C))
-; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GROUP_B]]
-; CHECK-NEXT: (Low: %B High: (8 + %B))
-; CHECK-NEXT: Member: %B
-; CHECK-NEXT: Group [[GROUP_A]]
-; CHECK-NEXT: (Low: %A High: (256000 + %A))
-; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
-; CHECK-NEXT: Member: %A
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP7:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Against group ([[GRP8:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP7]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Against group ([[GRP9:0x[0-9a-f]+]]):
+; 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: ptr %B
+; CHECK-NEXT: Against group ([[GRP9]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds double, ptr %A, i64 %iv
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP7]]:
+; CHECK-NEXT: (Low: %C High: (8 + %C))
+; CHECK-NEXT: Member: %C
+; CHECK-NEXT: Group [[GRP8]]:
+; CHECK-NEXT: (Low: %B High: (8 + %B))
+; CHECK-NEXT: Member: %B
+; CHECK-NEXT: Group [[GRP9]]:
+; CHECK-NEXT: (Low: %A High: (256000 + %A))
+; CHECK-NEXT: Member: {%A,+,8}<nuw><%loop.header>
+; CHECK-NEXT: Member: %A
+; 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:
+;
; CHECK-EMPTY
entry:
br label %loop.header
@@ -350,13 +411,21 @@ exit: ; preds = %loop.latch
define i32 @store_with_pointer_phi_outside_loop_select(ptr %A, ptr %B, ptr %C, i1 %c.0, i1 %c.1) {
; CHECK-LABEL: 'store_with_pointer_phi_outside_loop_select'
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
-; CHECK-NEXT: store double %mul16, ptr %ptr, align 8
+; CHECK-NEXT: loop.header:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %v8 = load double, ptr %arrayidx, align 8 ->
+; CHECK-NEXT: store double %mul16, ptr %ptr, align 8
+; CHECK-EMPTY:
+; 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 i1 %c.0, label %if.then, label %if.else
@@ -387,13 +456,17 @@ exit: ; preds = %loop.latch
}
define i32 @store_with_pointer_phi_in_same_bb_use_other_phi(ptr %A, ptr %B, ptr %C, ptr %D, i1 %c.0, i1 %c.1) {
-; CHECK-LABEL: Loop access info in function 'store_with_pointer_phi_in_same_bb_use_other_phi':
-; CHECK-NEXT: loop.header:
-; CHECK-NEXT: Report: cannot identify array bounds
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; CHECK-LABEL: 'store_with_pointer_phi_in_same_bb_use_other_phi'
+; CHECK-NEXT: loop.header:
+; 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 %loop.header
@@ -415,63 +488,67 @@ exit: ; preds = %loop.latch
}
define void @phi_load_store_memdep_check(i1 %c, ptr %A, ptr %B, ptr %C) {
-; CHECK-LABEL: Loop access info in function 'phi_load_store_memdep_check':
-; CHECK-NEXT: for.body:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
-; CHECK-NEXT: Unknown data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %lv3 = load i16, ptr %c.sink, align 2 ->
-; CHECK-NEXT: store i16 %add, ptr %c.sink, align 1
+; CHECK-LABEL: 'phi_load_store_memdep_check'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Unknown data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %lv3 = load i16, ptr %c.sink, align 2 ->
+; CHECK-NEXT: store i16 %add, ptr %c.sink, align 1
+; CHECK-EMPTY:
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %lv3 = load i16, ptr %c.sink, align 2 ->
+; CHECK-NEXT: store i16 %add, ptr %c.sink, align 1
; CHECK-EMPTY:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %lv3 = load i16, ptr %c.sink, align 2 ->
-; CHECK-NEXT: store i16 %add, ptr %c.sink, align 1
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: %lv = load i16, ptr %A, align 1 ->
+; CHECK-NEXT: store i16 %lv, ptr %A, align 1
; CHECK-EMPTY:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: %lv = load i16, ptr %A, align 1 ->
-; CHECK-NEXT: store i16 %lv, ptr %A, align 1
+; CHECK-NEXT: Unknown:
+; CHECK-NEXT: store i16 %lv, ptr %A, align 1 ->
+; CHECK-NEXT: %lv2 = load i16, ptr %A, align 1
; CHECK-EMPTY:
-; CHECK-NEXT: Unknown:
-; CHECK-NEXT: store i16 %lv, ptr %A, align 1 ->
-; CHECK-NEXT: %lv2 = load i16, ptr %A, align 1
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP10:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: Against group ([[GRP11:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP10]]):
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: ptr %A
+; CHECK-NEXT: Against group ([[GRP12:0x[0-9a-f]+]]):
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP11]]):
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: ptr %C
+; CHECK-NEXT: Against group ([[GRP12]]):
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: ptr %B
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP10]]:
+; CHECK-NEXT: (Low: %A High: (2 + %A))
+; CHECK-NEXT: Member: %A
+; CHECK-NEXT: Member: %A
+; CHECK-NEXT: Group [[GRP11]]:
+; CHECK-NEXT: (Low: %C High: (2 + %C))
+; CHECK-NEXT: Member: %C
+; CHECK-NEXT: Member: %C
+; CHECK-NEXT: Group [[GRP12]]:
+; CHECK-NEXT: (Low: %B High: (2 + %B))
+; CHECK-NEXT: Member: %B
+; CHECK-NEXT: Member: %B
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Check 0:
-; CHECK-NEXT: Comparing group ([[GROUP_A:.+]]):
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GROUP_C:.+]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Check 1:
-; CHECK-NEXT: Comparing group ([[GROUP_A]]):
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: ptr %A
-; CHECK-NEXT: Against group ([[GROUP_B:.+]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Check 2:
-; CHECK-NEXT: Comparing group ([[GROUP_C]]):
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: ptr %C
-; CHECK-NEXT: Against group ([[GROUP_B]]):
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: ptr %B
-; CHECK-NEXT: Grouped accesses:
-; CHECK-NEXT: Group [[GROUP_A]]
-; CHECK-NEXT: (Low: %A High: (2 + %A))
-; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Member: %A
-; CHECK-NEXT: Group [[GROUP_C]]
-; CHECK-NEXT: (Low: %C High: (2 + %C))
-; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Member: %C
-; CHECK-NEXT: Group [[GROUP_B]]
-; CHECK-NEXT: (Low: %B High: (2 + %B))
-; CHECK-NEXT: Member: %B
-; CHECK-NEXT: Member: %B
+; CHECK-NEXT: Non vectorizable stores to invariant address were found in loop.
+; CHECK-NEXT: SCEV assumptions:
; CHECK-EMPTY:
+; CHECK-NEXT: Expressions re-written:
;
entry:
br label %for.body
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll b/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
index 016c574b3b7cb1d..6cc045d7a681b0e 100644
--- a/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
+++ b/llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
; RUN: opt -S -disable-output -passes='print<access-info>' %s 2>&1 | FileCheck %s
;
@@ -5,26 +6,26 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; A forwarding in the presence of symbolic strides.
define void @single_stride(ptr noalias %A, ptr noalias %B, i64 %N, i64 %stride) {
-; CHECK-LABEL: Loop access info in function 'single_stride':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Backward loop carried data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Backward:
-; CHECK-NEXT: %load = load i32, ptr %gep.A, align 4 ->
-; CHECK-NEXT: store i32 %add, ptr %gep.A.next, align 4
+; CHECK-LABEL: 'single_stride'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Backward loop carried data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Backward:
+; CHECK-NEXT: %load = load i32, ptr %gep.A, align 4 ->
+; CHECK-NEXT: store i32 %add, ptr %gep.A.next, align 4
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; 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-NEXT: Equal predicate: %stride == 1
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Equal predicate: %stride == 1
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds i32, ptr %A, i64 %mul:
-; CHECK-NEXT: {%A,+,(4 * %stride)}<%loop>
-; CHECK-NEXT: --> {%A,+,4}<%loop>
+; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds i32, ptr %A, i64 %mul:
+; CHECK-NEXT: {%A,+,(4 * %stride)}<%loop>
+; CHECK-NEXT: --> {%A,+,4}<%loop>
;
entry:
br label %loop
@@ -49,26 +50,26 @@ exit: ; preds = %loop
; Similar to @single_stride, but with struct types.
define void @single_stride_struct(ptr noalias %A, ptr noalias %B, i64 %N, i64 %stride) {
-; CHECK-LABEL: Loop access info in function 'single_stride_struct':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Backward loop carried data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Backward:
-; CHECK-NEXT: %load = load { i32, i8 }, ptr %gep.A, align 4 ->
-; CHECK-NEXT: store { i32, i8 } %ins, ptr %gep.A.next, align 4
+; CHECK-LABEL: 'single_stride_struct'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Backward loop carried data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Backward:
+; CHECK-NEXT: %load = load { i32, i8 }, ptr %gep.A, align 4 ->
+; CHECK-NEXT: store { i32, i8 } %ins, ptr %gep.A.next, align 4
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; 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-NEXT: Equal predicate: %stride == 1
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Equal predicate: %stride == 1
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds { i32, i8 }, ptr %A, i64 %mul:
-; CHECK-NEXT: {%A,+,(8 * %stride)}<%loop>
-; CHECK-NEXT: --> {%A,+,8}<%loop>
+; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds { i32, i8 }, ptr %A, i64 %mul:
+; CHECK-NEXT: {%A,+,(8 * %stride)}<%loop>
+; CHECK-NEXT: --> {%A,+,8}<%loop>
;
entry:
br label %loop
@@ -96,30 +97,30 @@ exit:
; A loop with two symbolic strides.
define void @two_strides(ptr noalias %A, ptr noalias %B, i64 %N, i64 %stride.1, i64 %stride.2) {
-; CHECK-LABEL: Loop access info in function 'two_strides':
-; CHECK-NEXT: loop:
-; CHECK-NEXT: Report: unsafe dependent memory operations in loop.
-; CHECK-NEXT: Backward loop carried data dependence.
-; CHECK-NEXT: Dependences:
-; CHECK-NEXT: Backward:
-; CHECK-NEXT: %load = load i32, ptr %gep.A, align 4 ->
-; CHECK-NEXT: store i32 %add, ptr %gep.A.next, align 4
+; CHECK-LABEL: 'two_strides'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK-NEXT: Backward loop carried data dependence.
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Backward:
+; CHECK-NEXT: %load = load i32, ptr %gep.A, align 4 ->
+; CHECK-NEXT: store i32 %add, ptr %gep.A.next, align 4
; CHECK-EMPTY:
-; CHECK-NEXT: Run-time memory checks:
-; CHECK-NEXT: Grouped accesses:
+; 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-NEXT: Equal predicate: %stride.2 == 1
-; CHECK-NEXT: Equal predicate: %stride.1 == 1
+; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
+; CHECK-NEXT: SCEV assumptions:
+; CHECK-NEXT: Equal predicate: %stride.2 == 1
+; CHECK-NEXT: Equal predicate: %stride.1 == 1
; CHECK-EMPTY:
-; CHECK-NEXT: Expressions re-written:
-; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds i32, ptr %A, i64 %mul:
-; CHECK-NEXT: {%A,+,(4 * %stride.1)}<%loop>
-; CHECK-NEXT: --> {%A,+,4}<%loop>
-; CHECK-NEXT: [PSE] %gep.A.next = getelementptr inbounds i32, ptr %A, i64 %mul.2:
-; CHECK-NEXT: {((4 * %stride.2) + %A),+,(4 * %stride.2)}<%loop>
-; CHECK-NEXT: --> {(4 + %A),+,4}<%loop>
+; CHECK-NEXT: Expressions re-written:
+; CHECK-NEXT: [PSE] %gep.A = getelementptr inbounds i32, ptr %A, i64 %mul:
+; CHECK-NEXT: {%A,+,(4 * %stride.1)}<%loop>
+; CHECK-NEXT: --> {%A,+,4}<%loop>
+; CHECK-NEXT: [PSE] %gep.A.next = getelementptr inbounds i32, ptr %A, i64 %mul.2:
+; CHECK-NEXT: {((4 * %stride.2) + %A),+,(4 * %stride.2)}<%loop>
+; CHECK-NEXT: --> {(4 + %A),+,4}<%loop>
;
entry:
br label %loop
diff --git a/llvm/test/Transforms/LoopUnroll/unroll-loop-invalidation.ll b/llvm/test/Transforms/LoopUnroll/unroll-loop-invalidation.ll
index bd77e98df31b08a..643cf653115dd99 100644
--- a/llvm/test/Transforms/LoopUnroll/unroll-loop-invalidation.ll
+++ b/llvm/test/Transforms/LoopUnroll/unroll-loop-invalidation.ll
@@ -11,7 +11,7 @@
; CHECK: Invalidating analysis: LoopAccessAnalysis on test
; CHECK: Running pass: LoopAccessInfoPrinterPass
; CHECK: Running analysis: LoopAccessAnalysis on test
-; CHECK: Loop access info in function 'test':
+; CHECK: Printing analysis 'Loop Access Analysis' for function 'test':
; CHECK: inner1.header:
; CHECK: inner1.header.1:
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll
new file mode 100644
index 000000000000000..5d34df638aaea8e
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll
@@ -0,0 +1,23 @@
+; RUN: opt -passes='print<access-info>' < %s -disable-output 2>&1 | FileCheck %s
+
+define dso_local void @dotvariable_laa(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+entry:
+ br label %for.body
+
+for.cond.cleanup:
+ ret void
+
+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
+ %cmp1.not = icmp eq i32 %0, 0
+ %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1
+ %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+ %.sink = load double, ptr %.sink.in, align 8
+ %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+ store double %.sink, ptr %1, align 8
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %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/dotvariable-laa.ll.expected b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
new file mode 100644
index 000000000000000..7ba90c5088752cf
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/dotvariable-laa.ll.expected
@@ -0,0 +1,63 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
+; RUN: opt -passes='print<access-info>' < %s -disable-output 2>&1 | FileCheck %s
+
+define dso_local void @dotvariable_laa(ptr nocapture readonly nonnull %Base1, ptr nocapture readonly %Base2, ptr nocapture %Dest, ptr nocapture readonly %Preds) {
+; CHECK-LABEL: 'dotvariable_laa'
+; CHECK-NEXT: for.body:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]):
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, ptr %Preds, i64 %indvars.iv
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP3:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Check 2:
+; CHECK-NEXT: Comparing group ([[GRP1]]):
+; CHECK-NEXT: %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+; CHECK-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]):
+; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: (Low: %Dest High: (800 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: (Low: %Preds High: (400 + %Preds))
+; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body>
+; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body>
+; CHECK-NEXT: Group [[GRP4]]:
+; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body>
+; 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:
+ ret void
+
+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
+ %cmp1.not = icmp eq i32 %0, 0
+ %spec.select = select i1 %cmp1.not, ptr %Base2, ptr %Base1
+ %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv
+ %.sink = load double, ptr %.sink.in, align 8
+ %1 = getelementptr inbounds double, ptr %Dest, i64 %indvars.iv
+ store double %.sink, ptr %1, align 8
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %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 b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll
new file mode 100644
index 000000000000000..618c8f11cde9c86
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll
@@ -0,0 +1,23 @@
+; RUN: opt -passes='print<access-info>' < %s -disable-output 2>&1 | FileCheck %s
+
+define void @laa(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr %Dest) {
+entry:
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+ %l.Dest = load float, ptr %gep.Dest
+ %cmp = fcmp une float %l.Dest, 0.0
+ %gep.1 = getelementptr inbounds float, ptr %Base1, i64 %iv
+ %gep.2 = getelementptr inbounds float, ptr %Base2, i64 %iv
+ %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+ %sink = load float, ptr %select, align 4
+ store float %sink, ptr %gep.Dest, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %exitcond.not = icmp eq i64 %iv.next, 100
+ br i1 %exitcond.not, label %exit, label %loop
+
+exit:
+ ret void
+}
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
new file mode 100644
index 000000000000000..2741336d6c8ed89
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/loop-access-analysis.ll.expected
@@ -0,0 +1,58 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
+; RUN: opt -passes='print<access-info>' < %s -disable-output 2>&1 | FileCheck %s
+
+define void @laa(ptr nocapture readonly %Base1, ptr nocapture readonly %Base2, ptr %Dest) {
+; CHECK-LABEL: 'laa'
+; CHECK-NEXT: loop:
+; CHECK-NEXT: Memory dependences are safe with run-time checks
+; CHECK-NEXT: Dependences:
+; CHECK-NEXT: Run-time memory checks:
+; CHECK-NEXT: Check 0:
+; CHECK-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]):
+; CHECK-NEXT: %gep.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: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; CHECK-NEXT: Check 1:
+; CHECK-NEXT: Comparing group ([[GRP1]]):
+; 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: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+; CHECK-NEXT: Grouped accesses:
+; CHECK-NEXT: Group [[GRP1]]:
+; CHECK-NEXT: (Low: %Dest High: (400 + %Dest))
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop>
+; CHECK-NEXT: Group [[GRP2]]:
+; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1))
+; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop>
+; CHECK-NEXT: Group [[GRP3]]:
+; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2))
+; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop>
+; 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 %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %gep.Dest = getelementptr inbounds float, ptr %Dest, i64 %iv
+ %l.Dest = load float, ptr %gep.Dest
+ %cmp = fcmp une float %l.Dest, 0.0
+ %gep.1 = getelementptr inbounds float, ptr %Base1, i64 %iv
+ %gep.2 = getelementptr inbounds float, ptr %Base2, i64 %iv
+ %select = select i1 %cmp, ptr %gep.1, ptr %gep.2
+ %sink = load float, ptr %select, align 4
+ store float %sink, ptr %gep.Dest, align 4
+ %iv.next = add nuw nsw i64 %iv, 1
+ %exitcond.not = icmp eq i64 %iv.next, 100
+ br i1 %exitcond.not, label %exit, label %loop
+
+exit:
+ ret void
+}
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/dotvariable-laa.test b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/dotvariable-laa.test
new file mode 100644
index 000000000000000..5ede66ec6e100e4
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/dotvariable-laa.test
@@ -0,0 +1,6 @@
+## Basic test checking that update_analyze_test_checks.py works correctly
+# RUN: cp -f %S/Inputs/dotvariable-laa.ll %t.ll && %update_analyze_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/dotvariable-laa.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/dotvariable-laa.ll.expected
diff --git a/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis.test b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis.test
new file mode 100644
index 000000000000000..6531f0610660ad7
--- /dev/null
+++ b/llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/loop-access-analysis.test
@@ -0,0 +1,6 @@
+## Basic test checking that update_analyze_test_checks.py works correctly
+# RUN: cp -f %S/Inputs/loop-access-analysis.ll %t.ll && %update_analyze_test_checks %t.ll
+# RUN: diff -u %t.ll %S/Inputs/loop-access-analysis.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.ll.expected
diff --git a/llvm/utils/UpdateTestChecks/common.py b/llvm/utils/UpdateTestChecks/common.py
index 33da7b3b8665dd5..74044f925aadde4 100644
--- a/llvm/utils/UpdateTestChecks/common.py
+++ b/llvm/utils/UpdateTestChecks/common.py
@@ -502,6 +502,7 @@ def invoke_tool(exe, cmd_args, ir, preprocess_cmd=None, verbose=False):
SCRUB_LEADING_WHITESPACE_RE = re.compile(r"^(\s+)")
SCRUB_WHITESPACE_RE = re.compile(r"(?!^(| \w))[ \t]+", flags=re.M)
+SCRUB_PRESERVE_LEADING_WHITESPACE_RE = re.compile(r"((?!^)[ \t]*(\S))[ \t]+")
SCRUB_TRAILING_WHITESPACE_RE = re.compile(r"[ \t]+$", flags=re.M)
SCRUB_TRAILING_WHITESPACE_TEST_RE = SCRUB_TRAILING_WHITESPACE_RE
SCRUB_TRAILING_WHITESPACE_AND_ATTRIBUTES_RE = re.compile(
@@ -592,7 +593,8 @@ def do_filter(body, filters):
def scrub_body(body):
# Scrub runs of whitespace out of the assembly, but leave the leading
# whitespace in place.
- body = SCRUB_WHITESPACE_RE.sub(r" ", body)
+ body = SCRUB_PRESERVE_LEADING_WHITESPACE_RE.sub(lambda m: m.group(2) + " ", body)
+
# Expand the tabs used for indentation.
body = str.expandtabs(body, 2)
# Strip trailing whitespace.
@@ -770,6 +772,7 @@ def process_run_line(
supported_analyses = {
"cost model analysis",
"scalar evolution analysis",
+ "loop access analysis",
}
if analysis.lower() not in supported_analyses:
warn("Unsupported analysis mode: %r!" % (analysis,))
@@ -931,7 +934,7 @@ def get_ir_regex_from_ir_value_re_match(self, match):
def get_value_name(self, var: str, check_prefix: str):
var = var.replace("!", "")
if self.replace_number_with_counter:
- assert var.isdigit(), var
+ assert var
replacement = self.variable_mapping.get(var, None)
if replacement is None:
# Replace variable with an incrementing counter
@@ -1023,6 +1026,16 @@ def get_value_use(self, var, match, var_prefix=None):
),
]
+analyze_nameless_values = [
+ NamelessValue(
+ r"GRP",
+ "#",
+ r"",
+ r"0x[0-9a-f]+",
+ None,
+ replace_number_with_counter=True,
+ ),
+]
def createOrRegexp(old, new):
if not old:
@@ -1066,6 +1079,20 @@ def createPrefixMatch(prefix_str, prefix_re):
r"((?:#|//)\s*)" + "(" + ASM_VALUE_REGEXP_STRING + ")" + ASM_VALUE_REGEXP_SUFFIX
)
+ANALYZE_VALUE_REGEXP_PREFIX = r"(\s*)"
+ANALYZE_VALUE_REGEXP_STRING = r""
+for nameless_value in analyze_nameless_values:
+ match = createPrefixMatch(nameless_value.ir_prefix, nameless_value.ir_regexp)
+ ANALYZE_VALUE_REGEXP_STRING = createOrRegexp(ANALYZE_VALUE_REGEXP_STRING, match)
+ANALYZE_VALUE_REGEXP_SUFFIX = r"(\)?:)"
+ANALYZE_VALUE_RE = re.compile(
+ ANALYZE_VALUE_REGEXP_PREFIX
+ + r"("
+ + ANALYZE_VALUE_REGEXP_STRING
+ + r")"
+ + ANALYZE_VALUE_REGEXP_SUFFIX
+)
+
# The entire match is group 0, the prefix has one group (=1), the entire
# IR_VALUE_REGEXP_STRING is one group (=2), and then the nameless values start.
first_nameless_group_in_ir_value_match = 3
@@ -1110,6 +1137,7 @@ def generalize_check_lines_common(
nameless_values,
nameless_value_regex,
is_asm,
+ preserve_names,
):
# This gets called for each match that occurs in
# a line. We transform variables we haven't seen
@@ -1145,7 +1173,7 @@ def transform_line_vars(match):
lines_with_def = []
for i, line in enumerate(lines):
- if not is_asm:
+ if not is_asm and not is_analyze:
# An IR variable named '%.' matches the FileCheck regex string.
line = line.replace("%.", "%dot")
for regex in _global_hex_value_regex:
@@ -1163,7 +1191,7 @@ def transform_line_vars(match):
# Ignore any comments, since the check lines will too.
scrubbed_line = SCRUB_IR_COMMENT_RE.sub(r"", line)
lines[i] = scrubbed_line
- if is_asm or not is_analyze:
+ if not preserve_names:
# It can happen that two matches are back-to-back and for some reason sub
# will not replace both of them. For now we work around this by
# substituting until there is no more match.
@@ -1176,7 +1204,9 @@ def transform_line_vars(match):
# Replace IR value defs and uses with FileCheck variables.
-def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
+def generalize_check_lines(
+ lines, is_analyze, vars_seen, global_vars_seen, preserve_names
+):
return generalize_check_lines_common(
lines,
is_analyze,
@@ -1185,6 +1215,7 @@ def generalize_check_lines(lines, is_analyze, vars_seen, global_vars_seen):
ir_nameless_values,
IR_VALUE_RE,
False,
+ preserve_names,
)
@@ -1197,9 +1228,22 @@ def generalize_asm_check_lines(lines, vars_seen, global_vars_seen):
asm_nameless_values,
ASM_VALUE_RE,
True,
+ False,
)
+def generalize_analyze_check_lines(lines, vars_seen, global_vars_seen):
+ return generalize_check_lines_common(
+ lines,
+ True,
+ vars_seen,
+ global_vars_seen,
+ analyze_nameless_values,
+ ANALYZE_VALUE_RE,
+ False,
+ False,
+ )
+
def add_checks(
output_lines,
comment_marker,
@@ -1212,6 +1256,7 @@ def add_checks(
version,
global_vars_seen_dict,
is_filtered,
+ preserve_names=False,
):
# prefix_exclusions are prefixes we cannot use to print the function because it doesn't exist in run lines that use these prefixes as well.
prefix_exclusions = set()
@@ -1279,7 +1324,11 @@ def add_checks(
args_and_sig = str(func_dict[checkprefix][func_name].args_and_sig)
if args_and_sig:
args_and_sig = generalize_check_lines(
- [args_and_sig], is_analyze, vars_seen, global_vars_seen
+ [args_and_sig],
+ is_analyze,
+ vars_seen,
+ global_vars_seen,
+ preserve_names,
)[0]
func_name_separator = func_dict[checkprefix][func_name].func_name_separator
if "[[" in args_and_sig:
@@ -1356,56 +1405,85 @@ def add_checks(
if key not in global_vars_seen_before:
global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
break
+ # For analyze output, generalize the output, and emit CHECK-EMPTY lines as well.
+ elif is_analyze:
+ func_body = generalize_analyze_check_lines(
+ func_body, vars_seen, global_vars_seen
+ )
+ for func_line in func_body:
+ if func_line.strip() == "":
+ output_lines.append(
+ "{} {}-EMPTY:".format(comment_marker, checkprefix)
+ )
+ else:
+ check_suffix = "-NEXT" if not is_filtered else ""
+ output_lines.append(
+ "{} {}{}: {}".format(
+ comment_marker, checkprefix, check_suffix, func_line
+ )
+ )
+ # Add space between different check prefixes and also before the first
+ # line of code in the test function.
+ output_lines.append(comment_marker)
+
+ # Remember new global variables we have not seen before
+ for key in global_vars_seen:
+ if key not in global_vars_seen_before:
+ global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
+ break
# For IR output, change all defs to FileCheck variables, so we're immune
# to variable naming fashions.
- func_body = generalize_check_lines(
- func_body, is_analyze, vars_seen, global_vars_seen
- )
+ else:
+ func_body = generalize_check_lines(
+ func_body, False, vars_seen, global_vars_seen, preserve_names
+ )
- # This could be selectively enabled with an optional invocation argument.
- # Disabled for now: better to check everything. Be safe rather than sorry.
+ # This could be selectively enabled with an optional invocation argument.
+ # Disabled for now: better to check everything. Be safe rather than sorry.
- # Handle the first line of the function body as a special case because
- # it's often just noise (a useless asm comment or entry label).
- # if func_body[0].startswith("#") or func_body[0].startswith("entry:"):
- # is_blank_line = True
- # else:
- # output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0]))
- # is_blank_line = False
+ # Handle the first line of the function body as a special case because
+ # it's often just noise (a useless asm comment or entry label).
+ # if func_body[0].startswith("#") or func_body[0].startswith("entry:"):
+ # is_blank_line = True
+ # else:
+ # output_lines.append('%s %s: %s' % (comment_marker, checkprefix, func_body[0]))
+ # is_blank_line = False
- is_blank_line = False
+ is_blank_line = False
- for func_line in func_body:
- if func_line.strip() == "":
- is_blank_line = True
- continue
- # Do not waste time checking IR comments.
- func_line = SCRUB_IR_COMMENT_RE.sub(r"", func_line)
+ for func_line in func_body:
+ if func_line.strip() == "":
+ is_blank_line = True
+ continue
+ # Do not waste time checking IR comments.
+ func_line = SCRUB_IR_COMMENT_RE.sub(r"", func_line)
- # Skip blank lines instead of checking them.
- if is_blank_line:
- output_lines.append(
- "{} {}: {}".format(comment_marker, checkprefix, func_line)
- )
- else:
- check_suffix = "-NEXT" if not is_filtered else ""
- output_lines.append(
- "{} {}{}: {}".format(
- comment_marker, checkprefix, check_suffix, func_line
+ # Skip blank lines instead of checking them.
+ if is_blank_line:
+ output_lines.append(
+ "{} {}: {}".format(
+ comment_marker, checkprefix, func_line
+ )
)
- )
- is_blank_line = False
+ else:
+ check_suffix = "-NEXT" if not is_filtered else ""
+ output_lines.append(
+ "{} {}{}: {}".format(
+ comment_marker, checkprefix, check_suffix, func_line
+ )
+ )
+ is_blank_line = False
- # Add space between different check prefixes and also before the first
- # line of code in the test function.
- output_lines.append(comment_marker)
+ # Add space between different check prefixes and also before the first
+ # line of code in the test function.
+ output_lines.append(comment_marker)
- # Remember new global variables we have not seen before
- for key in global_vars_seen:
- if key not in global_vars_seen_before:
- global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
- break
+ # Remember new global variables we have not seen before
+ for key in global_vars_seen:
+ if key not in global_vars_seen_before:
+ global_vars_seen_dict[checkprefix][key] = global_vars_seen[key]
+ break
return printed_prefixes
@@ -1439,10 +1517,11 @@ def add_ir_checks(
func_name,
check_label_format,
False,
- preserve_names,
+ False,
version,
global_vars_seen_dict,
is_filtered,
+ preserve_names,
)
@@ -1500,7 +1579,7 @@ def add_global_checks(
prefix_list,
output_lines,
global_vars_seen_dict,
- is_analyze,
+ preserve_names,
is_before_functions,
):
printed_prefixes = set()
@@ -1540,7 +1619,7 @@ def add_global_checks(
if not matched:
continue
tmp = generalize_check_lines(
- [line], is_analyze, set(), global_vars_seen
+ [line], False, set(), global_vars_seen, preserve_names
)
check_line = "%s %s: %s" % (comment_marker, checkprefix, tmp[0])
check_lines.append(check_line)
diff --git a/llvm/utils/update_analyze_test_checks.py b/llvm/utils/update_analyze_test_checks.py
index ac0df3c51176dd4..03053e5447d1197 100755
--- a/llvm/utils/update_analyze_test_checks.py
+++ b/llvm/utils/update_analyze_test_checks.py
@@ -187,10 +187,6 @@ def main():
if is_in_function:
if common.should_add_line_to_output(input_line, prefix_set):
# This input line of the function body will go as-is into the output.
- # Except make leading whitespace uniform: 2 spaces.
- input_line = common.SCRUB_LEADING_WHITESPACE_RE.sub(
- r" ", input_line
- )
output_lines.append(input_line)
else:
continue
More information about the llvm-commits
mailing list