[llvm] [delinearize] use update_analyze_test_checks.py in delinearization testcases (PR #153831)
Sebastian Pop via llvm-commits
llvm-commits at lists.llvm.org
Thu Aug 21 09:49:37 PDT 2025
https://github.com/sebpop updated https://github.com/llvm/llvm-project/pull/153831
>From a2541cadb06f5488cd2b2814622646def25a08c9 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Wed, 16 Jul 2025 12:42:02 +0200
Subject: [PATCH] use update_analyze_test_checks.py in delinearization
testcases
After adapting the output of printDelinearization() to match what the script
expects to see, "Printing analysis 'Delinearization' for function", and
registering the "Delinearization" pass in the update script, the rest of the
patch automatically removes the existing CHECK statements and update the tests
with a run of:
```
$ ~/llvm-project/llvm/utils/update_analyze_test_checks.py
--opt=~/llvm-project/build/bin/opt
~/llvm-project/llvm/test/Analysis/Delinearization/*.ll
```
The patch also drops llvm/test/Analysis/Delinearization/undef.ll because the
test does not pass the github-actions "undef deprecator."
---
llvm/lib/Analysis/Delinearization.cpp | 60 ++++----
llvm/test/Analysis/Delinearization/a.ll | 14 +-
.../Analysis/Delinearization/byte_offset.ll | 10 +-
.../constant_functions_multi_dim.ll | 32 ++--
.../Analysis/Delinearization/divide_by_one.ll | 28 ++--
.../Delinearization/fixed_size_array.ll | 123 ++++++++++-----
.../Delinearization/gcd_multiply_expr.ll | 144 +++++++++++++++++-
.../test/Analysis/Delinearization/himeno_1.ll | 14 +-
.../test/Analysis/Delinearization/himeno_2.ll | 14 +-
.../iv_times_constant_in_subscript.ll | 15 +-
.../multidim_ivs_and_integer_offsets_3d.ll | 14 +-
...multidim_ivs_and_integer_offsets_nts_3d.ll | 14 +-
...multidim_ivs_and_parameteric_offsets_3d.ll | 14 +-
.../Delinearization/multidim_only_ivs_2d.ll | 30 ++--
.../multidim_only_ivs_2d_nested.ll | 13 +-
.../Delinearization/multidim_only_ivs_3d.ll | 14 +-
.../multidim_only_ivs_3d_cast.ll | 14 +-
..._two_accesses_different_delinearization.ll | 18 ++-
.../parameter_addrec_product.ll | 25 ++-
.../terms_with_identity_factor.ll | 30 ++--
.../Analysis/Delinearization/type_mismatch.ll | 19 ++-
llvm/test/Analysis/Delinearization/undef.ll | 38 -----
llvm/utils/UpdateTestChecks/common.py | 1 +
23 files changed, 469 insertions(+), 229 deletions(-)
delete mode 100644 llvm/test/Analysis/Delinearization/undef.ll
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 761c566eae794..762d9191aab1e 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -744,45 +744,48 @@ namespace {
void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
ScalarEvolution *SE) {
- O << "Delinearization on function " << F->getName() << ":\n";
+ O << "Printing analysis 'Delinearization' for function '" << F->getName()
+ << "':";
for (Instruction &Inst : instructions(F)) {
// Only analyze loads and stores.
- if (!isa<StoreInst>(&Inst) && !isa<LoadInst>(&Inst) &&
- !isa<GetElementPtrInst>(&Inst))
+ if (!isa<StoreInst>(&Inst) && !isa<LoadInst>(&Inst))
continue;
const BasicBlock *BB = Inst.getParent();
- // Delinearize the memory access as analyzed in all the surrounding loops.
+ Loop *L = LI->getLoopFor(BB);
+ // Only delinearize the memory access in the innermost loop.
// Do not analyze memory accesses outside loops.
- for (Loop *L = LI->getLoopFor(BB); L != nullptr; L = L->getParentLoop()) {
- const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
+ if (!L)
+ continue;
- const SCEVUnknown *BasePointer =
- dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
- // Do not delinearize if we cannot find the base pointer.
- if (!BasePointer)
- break;
- AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
+ const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
- O << "\n";
- O << "Inst:" << Inst << "\n";
- O << "In Loop with Header: " << L->getHeader()->getName() << "\n";
- O << "AccessFunction: " << *AccessFn << "\n";
+ const SCEVUnknown *BasePointer =
+ dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
+ // Do not delinearize if we cannot find the base pointer.
+ if (!BasePointer)
+ break;
+ AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
- SmallVector<const SCEV *, 3> Subscripts, Sizes;
+ O << "\n";
+ O << "Inst:" << Inst << "\n";
+ O << "In Loop with Header: " << L->getHeader()->getName() << "\n";
+ O << "AccessFunction: " << *AccessFn << "\n";
- auto IsDelinearizationFailed = [&]() {
- return Subscripts.size() == 0 || Sizes.size() == 0 ||
- Subscripts.size() != Sizes.size();
- };
+ SmallVector<const SCEV *, 3> Subscripts, Sizes;
- delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
- if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
- Subscripts.clear();
- Sizes.clear();
- delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
- SE->getElementSize(&Inst));
- }
+ auto IsDelinearizationFailed = [&]() {
+ return Subscripts.size() == 0 || Sizes.size() == 0 ||
+ Subscripts.size() != Sizes.size();
+ };
+
+ delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
+ if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
+ Subscripts.clear();
+ Sizes.clear();
+ delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
+ SE->getElementSize(&Inst));
+ }
if (IsDelinearizationFailed()) {
O << "failed to delinearize\n";
@@ -800,7 +803,6 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
for (int i = 0; i < Size; i++)
O << "[" << *Subscripts[i] << "]";
O << "\n";
- }
}
}
diff --git a/llvm/test/Analysis/Delinearization/a.ll b/llvm/test/Analysis/Delinearization/a.ll
index 02ba3fde695c3..755c9baef9b8f 100644
--- a/llvm/test/Analysis/Delinearization/a.ll
+++ b/llvm/test/Analysis/Delinearization/a.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
;
; void foo(long n, long m, long o, int A[n][m][o]) {
@@ -7,12 +8,15 @@
; A[2*i+3][3*j-4][5*k+7] = 1;
; }
-; AddRec: {{{(28 + (4 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
-; CHECK: ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
-
define void @foo(i64 %n, i64 %m, i64 %o, ptr nocapture %A) #0 {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store i32 1, ptr %arrayidx11.us.us, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
+;
entry:
%cmp32 = icmp sgt i64 %n, 0
br i1 %cmp32, label %for.cond1.preheader.lr.ph, label %for.end17
diff --git a/llvm/test/Analysis/Delinearization/byte_offset.ll b/llvm/test/Analysis/Delinearization/byte_offset.ll
index 6534d3ea6c05b..90b1f03329e44 100644
--- a/llvm/test/Analysis/Delinearization/byte_offset.ll
+++ b/llvm/test/Analysis/Delinearization/byte_offset.ll
@@ -1,8 +1,6 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
-; CHECK: AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
-; CHECK-NEXT: failed to delinearize
-
; void foo(char A[], long i2, bool c) {
; for (long i = 0; ; ++i) {
; char *tmp = &A[i * i2];
@@ -13,6 +11,12 @@
; }
define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store float 0.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: inner.loop
+; CHECK-NEXT: AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
+; CHECK-NEXT: failed to delinearize
+;
entry:
br label %outer.loop
diff --git a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
index 3044a4868260b..c0b1a0b9cddaf 100644
--- a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
+++ b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
@@ -1,23 +1,25 @@
-; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-; CHECK: Inst: %tmp = load float, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
-; CHECK-NEXT: Base offset: %A
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
-
-; CHECK: Inst: %tmp5 = load float, ptr %arrayidx4, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
-; CHECK-NEXT: Base offset: %B
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
-
; Function Attrs: noinline nounwind uwtable
define void @mat_mul(ptr %C, ptr %A, ptr %B, i64 %N) #0 !kernel_arg_addr_space !2 !kernel_arg_access_qual !3 !kernel_arg_type !4 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
+; CHECK-LABEL: 'mat_mul'
+; CHECK-NEXT: Inst: %tmp = load float, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.inc
+; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %tmp5 = load float, ptr %arrayidx4, align 4
+; CHECK-NEXT: In Loop with Header: for.inc
+; CHECK-NEXT: AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
+; CHECK-NEXT: Base offset: %B
+; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
+;
entry:
br label %entry.split
diff --git a/llvm/test/Analysis/Delinearization/divide_by_one.ll b/llvm/test/Analysis/Delinearization/divide_by_one.ll
index 8c531b78f2bcf..28fe5c50ae779 100644
--- a/llvm/test/Analysis/Delinearization/divide_by_one.ll
+++ b/llvm/test/Analysis/Delinearization/divide_by_one.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
@@ -10,19 +11,22 @@ target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
; dst[r * stride + c] = dst[(r + 1) * stride + c - 1];
; }
-; AddRec: {{(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK: Inst: %0 = load i8, ptr %arrayidx, align 1
-; CHECK: Base offset: %dst
-; CHECK: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
-; CHECK: ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
-
-; AddRec: {{(ptr %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK: Inst: store i8 %0, ptr %arrayidx7, align 1
-; CHECK: Base offset: %dst
-; CHECK: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
-; CHECK: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
-
define void @test(ptr nocapture %dst, i32 %stride, i32 %bs) {
+; CHECK-LABEL: 'test'
+; CHECK-NEXT: Inst: %0 = load i8, ptr %arrayidx, align 1
+; CHECK-NEXT: In Loop with Header: for.body3
+; CHECK-NEXT: AccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
+; CHECK-NEXT: Base offset: %dst
+; CHECK-NEXT: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
+; CHECK-NEXT: ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i8 %0, ptr %arrayidx7, align 1
+; CHECK-NEXT: In Loop with Header: for.body3
+; CHECK-NEXT: AccessFunction: {{\{\{}}(%stride * %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nsw><%for.body3>
+; CHECK-NEXT: Base offset: %dst
+; CHECK-NEXT: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
+; CHECK-NEXT: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
+;
entry:
%cmp20 = icmp sgt i32 %bs, -1
br i1 %cmp20, label %for.cond1.preheader.lr.ph, label %for.end9
diff --git a/llvm/test/Analysis/Delinearization/fixed_size_array.ll b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
index 0512044990163..634850bb4a5a2 100644
--- a/llvm/test/Analysis/Delinearization/fixed_size_array.ll
+++ b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output -delinearize-use-fixed-size-array-heuristic 2>&1 | FileCheck %s
; void f(int A[][8][32]) {
@@ -7,11 +8,15 @@
; A[i][j][k] = 1;
; }
-; CHECK: Delinearization on function a_i_j_k:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
define void @a_i_j_k(ptr %a) {
+; CHECK-LABEL: 'a_i_j_k'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i.header
@@ -52,11 +57,15 @@ exit:
; A[i][7-j][k] = 1;
; }
-; CHECK: Delinearization on function a_i_nj_k:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{7,+,-1}<nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
define void @a_i_nj_k(ptr %a) {
+; CHECK-LABEL: 'a_i_nj_k'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}896,+,1024}<nuw><nsw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{7,+,-1}<nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i.header
@@ -104,14 +113,22 @@ exit:
; }
; }
-; CHECK: Delinearization on function a_ijk_b_i2jk:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
-; CHECK: Base offset: %b
-; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
define void @a_ijk_b_i2jk(ptr %a, ptr %b) {
+; CHECK-LABEL: 'a_ijk_b_i2jk'
+; CHECK-NEXT: Inst: store i32 1, ptr %a.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %b.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %b
+; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i.header
@@ -160,11 +177,15 @@ exit:
; A[i][2*j+1][k] = 1;
; }
-; CHECK: Delinearization on function a_i_2j1_k:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><%for.j.header>][{32,+,1}<nw><%for.k>]
define void @a_i_2j1_k(ptr %a) {
+; CHECK-LABEL: 'a_i_2j1_k'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}128,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][4][64] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><%for.j.header>][{32,+,1}<nw><%for.k>]
+;
entry:
br label %for.i.header
@@ -210,10 +231,13 @@ exit:
; A[i][3*j][k] = 1;
; }
-; CHECK: Delinearization on function a_i_3j_k:
-; CHECK: AccessFunction: {{...}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: failed to delinearize
define void @a_i_3j_k(ptr %a) {
+; CHECK-LABEL: 'a_i_3j_k'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: failed to delinearize
+;
entry:
br label %for.i.header
@@ -259,11 +283,15 @@ exit:
; A[i][j][3*k] = 1;
; }
-; CHECK: Delinearization on function a_i_j_3k:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,3}<nuw><nsw><%for.k>]
define void @a_i_j_3k(ptr %a) {
+; CHECK-LABEL: 'a_i_j_3k'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,3}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i.header
@@ -307,10 +335,13 @@ exit:
; A[i][2*j+k][i] = 1;
; }
-; CHECK: Delinearization on function a_i_j2k_i:
-; CHECK: AccessFunction: {{...}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
-; CHECK-NEXT: failed to delinearize
define void @a_i_j2k_i(ptr %a) {
+; CHECK-LABEL: 'a_i_j2k_i'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
+; CHECK-NEXT: failed to delinearize
+;
entry:
br label %for.i.header
@@ -356,11 +387,15 @@ exit:
; A[i][i][j+k] = 1;
; }
-; CHECK: Delinearization on function a_i_i_jk:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][288] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{..}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k>]
define void @a_i_i_jk(ptr %a) {
+; CHECK-LABEL: 'a_i_i_jk'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][288] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i.header
@@ -403,12 +438,15 @@ exit:
; A[i][j+k][l] = 1;
; }
-; CHECK: Delinearization on function a_i_jk_l:
-; CHECK: Base offset: %a
-; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{..}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k.header>][{0,+,1}<nuw><nsw><%for.l>]
-
define void @a_i_jk_l(ptr %a) {
+; CHECK-LABEL: 'a_i_jk_l'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.l
+; CHECK-NEXT: AccessFunction: {{\{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,128}<nw><%for.k.header>,+,4}<nw><%for.l>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][8][32] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k.header>][{0,+,1}<nuw><nsw><%for.l>]
+;
entry:
br label %for.i.header
@@ -461,10 +499,13 @@ exit:
; *((int *)((char *)A + i*256 + j*32 + k)) = 1;
; }
-; CHECK: Delinearization on function non_divisible_by_element_size:
-; CHECK: AccessFunction: {{...}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
-; CHECK-NEXT: failed to delinearize
define void @non_divisible_by_element_size(ptr %a) {
+; CHECK-LABEL: 'non_divisible_by_element_size'
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
+; CHECK-NEXT: failed to delinearize
+;
entry:
br label %for.i.header
diff --git a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
index 95fefed7082f5..3e4545289a450 100644
--- a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
+++ b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
@@ -1,4 +1,5 @@
-; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
;
; a, b, c, d, g, h;
; char *f;
@@ -26,6 +27,147 @@
@d = common global i32 0, align 4
define i32 @fn2() {
+; CHECK-LABEL: 'fn2'
+; CHECK-NEXT: Inst: store i32 %storemerge.i, ptr @a, align 4
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %9 = load i8, ptr %arrayidx.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %10 = load i8, ptr %arrayidx.1.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.1.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.1.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %11 = load i8, ptr %arrayidx.2.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.2.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.2.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %12 = load i8, ptr %arrayidx.3.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.3.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.3.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %13 = load i8, ptr %arrayidx.4.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.4.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.4.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %14 = load i8, ptr %arrayidx.5.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.5.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.5.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %15 = load i8, ptr %arrayidx.6.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.6.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.6.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %16 = load i8, ptr %arrayidx.7.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.7.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.7.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %21 = load i8, ptr %arrayidx.ur.i, align 1
+; CHECK-NEXT: In Loop with Header: for.body4.ur.i
+; CHECK-NEXT: AccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64)
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %conv.ur.i, ptr @c, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.ur.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.ur.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.body4.ur.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+;
entry:
%.pr = load i32, ptr @d, align 4
%phitmp = icmp eq i32 %.pr, 0
diff --git a/llvm/test/Analysis/Delinearization/himeno_1.ll b/llvm/test/Analysis/Delinearization/himeno_1.ll
index 879284498350a..292dca61d0592 100644
--- a/llvm/test/Analysis/Delinearization/himeno_1.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_1.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; #define MR(mt,n,r,c,d) mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
@@ -26,14 +27,17 @@
; MR(a,0,i,j,k) = i + j + k;
; }
-; AddRec: {{{(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j>,+,4}<%for.k>
-; CHECK: Base offset: %a.base
-; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
-; CHECK: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
-
%struct.Mat = type { ptr, i32, i32, i32, i32 }
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
+; CHECK-LABEL: 'jacobi'
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
+; CHECK-NEXT: Base offset: %a.base
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
+;
entry:
%p.rows.ptr = getelementptr inbounds %struct.Mat, ptr %p, i64 0, i32 2
%p.rows = load i32, ptr %p.rows.ptr
diff --git a/llvm/test/Analysis/Delinearization/himeno_2.ll b/llvm/test/Analysis/Delinearization/himeno_2.ll
index 30b2154abbc83..d210539d67d8b 100644
--- a/llvm/test/Analysis/Delinearization/himeno_2.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_2.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; #define MR(mt,n,r,c,d) mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
@@ -26,14 +27,17 @@
; MR(a,0,i,j,k) = i + j + k;
; }
-; AddRec: {{{(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j>,+,4}<%for.k>
-; CHECK: Base offset: %a.base
-; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
-; CHECK: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
-
%struct.Mat = type { ptr, i32, i32, i32, i32 }
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
+; CHECK-LABEL: 'jacobi'
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
+; CHECK-NEXT: Base offset: %a.base
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
+;
entry:
%p.rows.ptr = getelementptr inbounds %struct.Mat, ptr %p, i64 0, i32 2
%p.rows = load i32, ptr %p.rows.ptr
diff --git a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
index 84ac1a39cc96e..cbe3ec8a19acd 100644
--- a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
+++ b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; Derived from the following code:
@@ -8,13 +9,15 @@
; A[2i+b][2j] = 1.0;
; }
-; AddRec: {{((%m * %b * 8) + %A),+,(2 * %m * 8)}<%for.i>,+,(2 * 8)}<%for.j>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
-; CHECK: ArrayRef[{%b,+,2}<nsw><%for.i>][{0,+,2}<nuw><%for.j>]
-
-
define void @foo(i64 %n, i64 %m, i64 %b, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * %m * %b),+,(16 * %m)}<%for.i>,+,16}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{%b,+,2}<nsw><%for.i>][{0,+,2}<nuw><%for.j>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
index 4ebac31d5ccf5..3d21d97438462 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; void foo(long n, long m, long o, double A[n][m][o]) {
@@ -8,12 +9,15 @@
; A[i+3][j-4][k+7] = 1.0;
; }
-; AddRec: {{{(56 + (8 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
-; CHECK: ArrayRef[{3,+,1}<nuw><%for.i>][{-4,+,1}<nsw><%for.j>][{7,+,1}<nuw><nsw><%for.k>]
-
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{3,+,1}<nuw><%for.i>][{-4,+,1}<nsw><%for.j>][{7,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
index 0265fb71449f8..3dbd71b1c9ac5 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; void foo(long n, long m, long o, long p, double A[n][m][o+p]) {
@@ -8,12 +9,15 @@
; A[i+3][j-4][k+7] = 1.0;
; }
-; AddRec: {{{(56 + (8 * (-4 + (3 * %m)) * (%o + %p)) + %A),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][(%o + %p)] with elements of 8 bytes.
-; CHECK: ArrayRef[{3,+,1}<nuw><%for.cond4.preheader.lr.ph.us>][{-4,+,1}<nw><%for.body6.lr.ph.us.us>][{7,+,1}<nw><%for.body6.us.us>]
-
define void @foo(i64 %n, i64 %m, i64 %o, i64 %p, ptr nocapture %A) nounwind uwtable {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.body6.us.us
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * (%o + %p))),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][(%o + %p)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{3,+,1}<nuw><%for.cond4.preheader.lr.ph.us>][{-4,+,1}<nw><%for.body6.lr.ph.us.us>][{7,+,1}<nw><%for.body6.us.us>]
+;
entry:
%add = add nsw i64 %p, %o
%cmp22 = icmp sgt i64 %n, 0
diff --git a/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll b/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
index 51e01010cdb7a..a2d64a5b40bc9 100644
--- a/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
@@ -8,12 +9,15 @@
; A[i+p][j+q][k+r] = 1.0;
; }
-; AddRec: {{{((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
-; CHECK: ArrayRef[{%p,+,1}<nw><%for.i>][{%q,+,1}<nsw><%for.j>][{%r,+,1}<nsw><%for.k>]
-
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A, i64 %p, i64 %q, i64 %r) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}(8 * ((((%m * %p) + %q) * %o) + %r)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{%p,+,1}<nw><%for.i>][{%q,+,1}<nsw><%for.j>][{%r,+,1}<nsw><%for.k>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
index b92abfc8d3aba..ac83ba19b252d 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; Derived from the following code:
@@ -8,21 +9,22 @@
; A[i][j] = 1.0;
; }
-; Inst: %val = load double, ptr %arrayidx
-; In Loop with Header: for.j
-; AddRec: {{0,+,(%m * 8)}<%for.i>,+,8}<%for.j>
-; Base offset: %A
-; ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
-; ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
-
-; Inst: store double %val, ptr %arrayidx
-; In Loop with Header: for.j
-; AddRec: {{%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
-; CHECK: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
-
define void @foo(i64 %n, i64 %m, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %val = load double, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double %val, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
index cc4c4eb403d80..262a092794cb1 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
@@ -1,5 +1,5 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
-; XFAIL: *
; We do not recognize anymore variable size arrays.
; extern void bar(long n, long m, double A[n][m]);
@@ -15,12 +15,13 @@
; }
; }
-; AddRec: {{%vla.us,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
-; CHECK: Base offset: %vla.us
-; CHECK: ArrayDecl[UnknownSize][{1,+,1}<%for.cond7.preheader.lr.ph.split.us.us>] with elements of sizeof(double) bytes.
-; CHECK: ArrayRef[{0,+,1}<nuw><nsw><%for.body9.lr.ph.us.us>][{0,+,1}<nuw><nsw><%for.body9.us.us>]
-
define void @foo(i64 %a, i64 %b) nounwind uwtable {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.body9.us.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
+; CHECK-NEXT: failed to delinearize
+;
entry:
%cmp43 = icmp sgt i64 %a, 1
br i1 %cmp43, label %for.cond1.preheader.lr.ph, label %for.end19
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
index 252743b287788..b1405db81a787 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; void foo(long n, long m, long o, double A[n][m][o]) {
@@ -8,12 +9,15 @@
; A[i][j][k] = 1.0;
; }
-; AddRec: {{{%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
-; CHECK: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
-
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
index e8ee7283e4040..6de072ebaee13 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; void foo(int n, int m, int o, double A[n][m][o]) {
;
@@ -7,15 +8,18 @@
; A[i][j][k] = 1.0;
; }
-; AddRec: {{{%A,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))}<%for.j>,+,8}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][(zext i32 %m to i64)][(zext i32 %o to i64)] with elements of 8 bytes.
-; CHECK: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
-
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define void @foo(i32 %n, i32 %m, i32 %o, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))<nuw><nsw>}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(zext i32 %m to i64)][(zext i32 %o to i64)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
entry:
%m_zext = zext i32 %m to i64
%n_zext = zext i32 %o to i64
diff --git a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
index ba32401e4bb84..d7148c5216462 100644
--- a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
@@ -1,4 +1,5 @@
-; RUN: opt -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output < %s
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
@@ -12,6 +13,21 @@ target triple = "x86_64-unknown-linux-gnu"
; }
define void @foo(i64 %n, i64 %m, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx1, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,8}<%for.i>,+,(8 * %n)}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%n] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.i>]
+;
entry:
br label %for.i
diff --git a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
index b8d4b3c20ce4e..cbccafd1e6546 100644
--- a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
+++ b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
;
; void foo(float *A, long *p) {
@@ -5,13 +6,29 @@
; for (long j = 0; j < 100; j++)
; A[i * (*p) + j] += i + j;
; }
-;
-; CHECK: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
-; CHECK: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
-;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(ptr %A, ptr %p) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %pval = load i64, ptr %p, align 8
+; CHECK-NEXT: In Loop with Header: bb4
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %tmp11 = load float, ptr %tmp10, align 4
+; CHECK-NEXT: In Loop with Header: bb4
+; CHECK-NEXT: AccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float %tmp12, ptr %tmp10, align 4
+; CHECK-NEXT: In Loop with Header: bb4
+; CHECK-NEXT: AccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
+;
bb:
br label %bb2
diff --git a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
index ab5ae056e02ce..86adcc8a1957c 100644
--- a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
+++ b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
@@ -1,23 +1,27 @@
-; REQUIRES: asserts
-; RUN: opt < %s -passes='print<delinearization>' -disable-output -debug 2>&1 2>&1 | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 2>&1 | FileCheck %s
; void foo (int m, int n, char *A) {
; for (int i=0; i < m; i++)
; for(int j=0; j< n; j++)
; A[i*n+j] += 1;
;}
-; ModuleID = 'delin.cpp'
-;target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
-;target triple = "aarch64--linux-gnu"
-
-; CHECK-LABEL: Delinearization on function foo
-; CHECK: Inst: %4 = load i8, ptr %arrayidx.us, align 1
-; CHECK: Subscripts
-; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
-; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.us>
-; CHECK: succeeded to delinearize
-
define void @foo(i32 %m, i32 %n, ptr nocapture %A) #0 {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %4 = load i8, ptr %arrayidx.us, align 1
+; CHECK-NEXT: In Loop with Header: for.body3.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i8 %add4.us, ptr %arrayidx.us, align 1
+; CHECK-NEXT: In Loop with Header: for.body3.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
+;
entry:
br label %entry.split
diff --git a/llvm/test/Analysis/Delinearization/type_mismatch.ll b/llvm/test/Analysis/Delinearization/type_mismatch.ll
index a9501519d0316..1b78f24485743 100644
--- a/llvm/test/Analysis/Delinearization/type_mismatch.ll
+++ b/llvm/test/Analysis/Delinearization/type_mismatch.ll
@@ -1,4 +1,5 @@
-; RUN: opt < %s -passes='print<delinearization>' -disable-output
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
; REQUIRES: asserts
; Test that SCEV divide code doesn't crash when attempting to create a SCEV
@@ -8,19 +9,25 @@
target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"
-define fastcc void @test(i1 %arg) {
+define fastcc void @test(i1 %arg, ptr %x) {
+; CHECK-LABEL: 'test'
+; CHECK-NEXT: Inst: store i8 42, ptr %arrayidx.phi, align 1
+; CHECK-NEXT: In Loop with Header: for.body11
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+;
entry:
- %0 = load i16, ptr undef, align 2
+ %0 = load i16, ptr %x, align 2
%conv21 = zext i16 %0 to i32
br label %for.cond7.preheader
for.cond7.preheader:
- %p1.022 = phi ptr [ undef, %entry ], [ %add.ptr, %for.end ]
+ %p1.022 = phi ptr [ %x, %entry ], [ %add.ptr, %for.end ]
br label %for.body11
for.body11:
- %arrayidx.phi = phi ptr [ %p1.022, %for.cond7.preheader ], [ undef, %for.body11 ]
- store i8 undef, ptr %arrayidx.phi, align 1
+ %arrayidx.phi = phi ptr [ %p1.022, %for.cond7.preheader ], [ %x, %for.body11 ]
+ store i8 42, ptr %arrayidx.phi, align 1
br i1 %arg, label %for.body11, label %for.end
for.end:
diff --git a/llvm/test/Analysis/Delinearization/undef.ll b/llvm/test/Analysis/Delinearization/undef.ll
deleted file mode 100644
index 1e62c4579c9c6..0000000000000
--- a/llvm/test/Analysis/Delinearization/undef.ll
+++ /dev/null
@@ -1,38 +0,0 @@
-; RUN: opt < %s -passes='print<delinearization>' -disable-output
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-define void @foo(ptr %Ey, i1 %arg) {
-entry:
- br i1 %arg, label %for.cond55.preheader, label %for.end324
-
-for.cond55.preheader:
- %iz.069 = phi i64 [ %inc323, %for.inc322 ], [ 0, %entry ]
- br i1 %arg, label %for.cond58.preheader, label %for.inc322
-
-for.cond58.preheader:
- %iy.067 = phi i64 [ %inc320, %for.end ], [ 0, %for.cond55.preheader ]
- br i1 %arg, label %for.body60, label %for.end
-
-for.body60:
- %ix.062 = phi i64 [ %inc, %for.body60 ], [ 0, %for.cond58.preheader ]
- %0 = mul i64 %iz.069, undef
- %tmp5 = add i64 %iy.067, %0
- %tmp6 = mul i64 %tmp5, undef
- %arrayidx69.sum = add i64 undef, %tmp6
- %arrayidx70 = getelementptr inbounds double, ptr %Ey, i64 %arrayidx69.sum
- %1 = load double, ptr %arrayidx70, align 8
- %inc = add nsw i64 %ix.062, 1
- br i1 false, label %for.body60, label %for.end
-
-for.end:
- %inc320 = add nsw i64 %iy.067, 1
- br i1 %arg, label %for.cond58.preheader, label %for.inc322
-
-for.inc322:
- %inc323 = add nsw i64 %iz.069, 1
- br i1 %arg, label %for.cond55.preheader, label %for.end324
-
-for.end324:
- ret void
-}
diff --git a/llvm/utils/UpdateTestChecks/common.py b/llvm/utils/UpdateTestChecks/common.py
index a5d4375dc655a..835092c468695 100644
--- a/llvm/utils/UpdateTestChecks/common.py
+++ b/llvm/utils/UpdateTestChecks/common.py
@@ -36,6 +36,7 @@
"Branch Probability Analysis",
"Cost Model Analysis",
"Dependence Analysis",
+ "Delinearization",
"Loop Access Analysis",
"Scalar Evolution Analysis",
}
More information about the llvm-commits
mailing list