[llvm] [delinearize] use update_analyze_test_checks.py in delinearization testcases (PR #153831)
Sebastian Pop via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 15 09:44:05 PDT 2025
https://github.com/sebpop created https://github.com/llvm/llvm-project/pull/153831
After adapting the output of printDelinearization() to match what the script expects to see, "Printing analysis 'Delinearization' for function", the rest of the patch is the automatic run of:
$ ~/llvm-project/llvm/utils/update_analyze_test_checks.py --opt=~/llvm-project/build/bin/opt ~/llvm-project/llvm/test/Analysis/Delinearization/*.ll
>From 495b0ab03f1a2e72adb17d0ee68aaf7d918f734c 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
---
llvm/lib/Analysis/Delinearization.cpp | 3 +-
llvm/test/Analysis/Delinearization/a.ll | 43 +-
.../Analysis/Delinearization/byte_offset.ll | 15 +-
.../constant_functions_multi_dim.ll | 42 +-
.../Analysis/Delinearization/divide_by_one.ll | 62 ++-
.../Delinearization/fixed_size_array.ll | 450 ++++++++++++++++--
.../Delinearization/gcd_multiply_expr.ll | 369 +++++++++++++-
.../test/Analysis/Delinearization/himeno_1.ll | 43 +-
.../test/Analysis/Delinearization/himeno_2.ll | 43 +-
.../iv_times_constant_in_subscript.ll | 32 +-
.../multidim_ivs_and_integer_offsets_3d.ll | 43 +-
...multidim_ivs_and_integer_offsets_nts_3d.ll | 43 +-
...multidim_ivs_and_parameteric_offsets_3d.ll | 43 +-
.../Delinearization/multidim_only_ivs_2d.ll | 54 ++-
.../multidim_only_ivs_2d_nested.ll | 50 +-
.../Delinearization/multidim_only_ivs_3d.ll | 43 +-
.../multidim_only_ivs_3d_cast.ll | 43 +-
..._two_accesses_different_delinearization.ll | 50 +-
.../parameter_addrec_product.ll | 54 ++-
.../terms_with_identity_factor.ll | 165 ++++++-
.../Analysis/Delinearization/type_mismatch.ll | 19 +-
llvm/test/Analysis/Delinearization/undef.ll | 34 +-
llvm/utils/UpdateTestChecks/common.py | 1 +
23 files changed, 1587 insertions(+), 157 deletions(-)
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 761c566eae794..3481e572c43e6 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -744,7 +744,8 @@ 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) &&
diff --git a/llvm/test/Analysis/Delinearization/a.ll b/llvm/test/Analysis/Delinearization/a.ll
index 02ba3fde695c3..fd96e778ea1bf 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,44 @@
; 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: %arrayidx11.us.us = getelementptr inbounds i32, ptr %A, i64 %arrayidx10.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx11.us.us = getelementptr inbounds i32, ptr %A, i64 %arrayidx10.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx11.us.us = getelementptr inbounds i32, ptr %A, i64 %arrayidx10.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %arrayidx11.us.us, align 4
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 + ((4 + (12 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{3,+,2}<nuw><%for.i>][{1,+,3}<%for.j>][2]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %arrayidx11.us.us, align 4
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(8 + ((-8 + (24 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(%m * %o)] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[0][{(2 + ((-2 + (6 * %m)) * %o)),+,(2 * %m * %o)}<%for.i>]
+;
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..04b0dcd2ee1d8 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,17 @@
; }
define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %tmp = getelementptr inbounds i8, ptr %A, i64 %i414
+; CHECK-NEXT: In Loop with Header: outer.loop
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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..0ea499fc55352 100644
--- a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
+++ b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
@@ -1,23 +1,35 @@
-; 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: %arrayidx = getelementptr inbounds float, ptr %A, i64 %add
+; CHECK-NEXT: In Loop with Header: for.inc
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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: %arrayidx4 = getelementptr inbounds float, ptr %B, i64 %add3
+; CHECK-NEXT: In Loop with Header: for.inc
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; 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..ff5f178d5a88b 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,56 @@ 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: %arrayidx = getelementptr inbounds i8, ptr %dst, i32 %sub
+; CHECK-NEXT: In Loop with Header: for.body3
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds i8, ptr %dst, i32 %sub
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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: %0 = load i8, ptr %arrayidx, align 1
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: {(-2 + ((1 + %bs) * %stride) + %bs),+,(-1 * %stride)}<%for.cond1.preheader>
+; 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>][(-2 + %bs)]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx7 = getelementptr inbounds i8, ptr %dst, i32 %add6
+; CHECK-NEXT: In Loop with Header: for.body3
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx7 = getelementptr inbounds i8, ptr %dst, i32 %add6
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i8 %0, ptr %arrayidx7, align 1
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: {(-1 + ((1 + %stride) * %bs)),+,(-1 * %stride)}<%for.cond1.preheader>
+; CHECK-NEXT: Base offset: %dst
+; CHECK-NEXT: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
+; CHECK-NEXT: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][(-1 + %bs)]
+;
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..d22d9b106e53a 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,44 @@
; 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}124,+,1024}<%for.i.header>,+,128}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{31,+,32}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {1020,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{255,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -52,11 +86,44 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}1020,+,1024}<%for.i.header>,+,-128}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{255,+,-32}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {124,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{31,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -104,14 +171,80 @@ 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: %a.idx = getelementptr [4 x [64 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %a.idx = getelementptr [4 x [64 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %a.idx = getelementptr [4 x [64 x i32]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %b.idx = getelementptr [8 x [32 x i32]], ptr %b, i32 %i, i32 %j2, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %b.idx = getelementptr [8 x [32 x i32]], ptr %b, i32 %i, i32 %j2, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %b.idx = getelementptr [8 x [32 x i32]], ptr %b, i32 %i, i32 %j2, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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 %a.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}124,+,1024}<%for.i.header>,+,256}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{31,+,64}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %a.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {892,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{223,+,256}<%for.i.header>]
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %b.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}124,+,1024}<%for.i.header>,+,256}<%for.j.header>
+; CHECK-NEXT: Base offset: %b
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{31,+,64}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %b.idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {892,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %b
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{223,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -160,11 +293,44 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}252,+,1024}<%for.i.header>,+,256}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{63,+,64}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {764,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{191,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -210,10 +376,42 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j.subscript, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}164,+,1024}<%for.i.header>,+,384}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{41,+,96}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {548,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{137,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -259,11 +457,44 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k.subscript
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k.subscript
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j, i32 %k.subscript
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}108,+,1024}<%for.i.header>,+,128}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{27,+,32}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {1004,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{251,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -307,10 +538,42 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j2.k, i32 %i
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j2.k, i32 %i
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %j2.k, i32 %i
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}384,+,1028}<%for.i.header>,+,256}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][257] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{96,+,64}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {640,+,1028}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{160,+,257}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -356,11 +619,44 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %i, i32 %jk
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %i, i32 %jk
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %i, i32 %jk
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}36,+,1152}<%for.i.header>,+,4}<%for.j.header>
+; 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>][{9,+,1}<nuw><nsw><%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {72,+,1152}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{18,+,288}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -403,12 +699,56 @@ 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: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %jk, i32 %l
+; CHECK-NEXT: In Loop with Header: for.l
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %jk, i32 %l
+; CHECK-NEXT: In Loop with Header: for.k.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %jk, i32 %l
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i32]], ptr %a, i32 %i, i32 %jk, i32 %l
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.k.header
+; CHECK-NEXT: AccessFunction: {{\{\{\{}}124,+,1024}<%for.i.header>,+,128}<%for.j.header>,+,128}<%for.k.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}31,+,32}<%for.j.header>,+,32}<%for.k.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}508,+,1024}<%for.i.header>,+,128}<%for.j.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize][256] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{127,+,32}<%for.j.header>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {892,+,1024}<%for.i.header>
+; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: ArrayDecl[UnknownSize] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{223,+,256}<%for.i.header>]
+;
entry:
br label %for.i.header
@@ -461,10 +801,38 @@ 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: %idx = getelementptr [8 x [32 x i8]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i8]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr [8 x [32 x i8]], ptr %a, i32 %i, i32 %j, i32 %k
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.j.header
+; CHECK-NEXT: AccessFunction: {{\{\{}}31,+,256}<%for.i.header>,+,32}<%for.j.header>
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
+; CHECK-NEXT: In Loop with Header: for.i.header
+; CHECK-NEXT: AccessFunction: {255,+,256}<%for.i.header>
+; 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..0dbb01ebfe8b1 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 -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output 2>&1 | FileCheck %s
;
; a, b, c, d, g, h;
; char *f;
@@ -26,6 +27,372 @@
@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: %arrayidx.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum1
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum1
+; 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: %9 = load i8, ptr %arrayidx.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.i, ptr @c, 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: 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: store i32 %inc.i, ptr @b, 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: %arrayidx.1.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum2
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.1.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum2
+; 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: %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: %10 = load i8, ptr %arrayidx.1.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.1.i, ptr @c, 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: 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: store i32 %inc.1.i, ptr @b, 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: %arrayidx.2.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum3
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.2.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum3
+; 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: %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: %11 = load i8, ptr %arrayidx.2.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.2.i, ptr @c, 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: 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: store i32 %inc.2.i, ptr @b, 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: %arrayidx.3.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum4
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.3.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum4
+; 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: %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: %12 = load i8, ptr %arrayidx.3.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.3.i, ptr @c, 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: 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: store i32 %inc.3.i, ptr @b, 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: %arrayidx.4.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum5
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.4.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum5
+; 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: %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: %13 = load i8, ptr %arrayidx.4.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.4.i, ptr @c, 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: 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: store i32 %inc.4.i, ptr @b, 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: %arrayidx.5.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum6
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.5.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum6
+; 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: %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: %14 = load i8, ptr %arrayidx.5.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.5.i, ptr @c, 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: 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: store i32 %inc.5.i, ptr @b, 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: %arrayidx.6.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum7
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.6.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum7
+; 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: %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: %15 = load i8, ptr %arrayidx.6.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.6.i, ptr @c, 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: 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: store i32 %inc.6.i, ptr @b, 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: %arrayidx.7.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum8
+; CHECK-NEXT: In Loop with Header: for.body4.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.7.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum8
+; 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: %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: %16 = load i8, ptr %arrayidx.7.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 ((8 * ((-1 + (-1 * %.pr.i) + (-7 smax (8 + %.pr.i))) /u 8))<nuw> + {(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.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 %conv.7.i, ptr @c, 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: 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: store i32 %inc.7.i, ptr @b, 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: %arrayidx.ur.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.body4.ur.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.ur.i = getelementptr inbounds i8, ptr %3, i32 %arrayidx.sum
+; 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: %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: %21 = load i8, ptr %arrayidx.ur.i, align 1
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.i
+; CHECK-NEXT: AccessFunction: (sext i32 {(-1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.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 %conv.ur.i, ptr @c, 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: 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
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %inc.ur.i, ptr @b, align 4
+; CHECK-NEXT: In Loop with Header: for.cond2thread-pre-split.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..795e670b9e39f 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,46 @@
; 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: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(-4 + (4 * (sext i32 (-1 + %p.deps) to i64))<nsw> + (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>
+; 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 + (sext i32 (-1 + %p.deps) to i64))<nsw>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-4 + (4 * (sext i32 (-1 + %p.deps) to i64))<nsw> + ((sext i32 %a.deps to i64) * (-4 + (4 * (sext i32 (-1 + %p.cols) to i64))<nsw> + (4 * (sext i32 %a.cols to i64))<nsw>))),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>
+; CHECK-NEXT: Base offset: %a.base
+; CHECK-NEXT: ArrayDecl[UnknownSize][((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[0][{(-1 + (sext i32 (-1 + %p.deps) to i64) + ((sext i32 %a.deps to i64) * (-1 + (sext i32 (-1 + %p.cols) to i64) + (sext i32 %a.cols to i64)))),+,((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>]
+;
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..bdf92837adb04 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,46 @@
; 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: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds float, ptr %a.base, i64 %tmp4
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(-4 + (4 * (sext i32 (-1 + %p.deps) to i64))<nsw> + (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>
+; 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 + (sext i32 (-1 + %p.deps) to i64))<nsw>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-4 + (4 * (sext i32 (-1 + %p.deps) to i64))<nsw> + ((sext i32 %a.deps to i64) * (-4 + (4 * (sext i32 (-1 + %p.cols) to i64))<nsw> + (4 * (sext i32 %a.cols to i64))<nsw>))),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>
+; CHECK-NEXT: Base offset: %a.base
+; CHECK-NEXT: ArrayDecl[UnknownSize][((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[0][{(-1 + (sext i32 (-1 + %p.deps) to i64) + ((sext i32 %a.deps to i64) * (-1 + (sext i32 (-1 + %p.cols) to i64) + (sext i32 %a.cols to i64)))),+,((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>]
+;
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..21f0e77b08b20 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,32 @@
; 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: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-16 + ((16 + (8 * %b)) * %m)),+,(16 * %m)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{(2 + %b),+,2}<%for.i>][-2]
+;
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..709f196141cc4 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,44 @@
; 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: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(48 + ((-24 + (24 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{3,+,1}<nuw><%for.i>][{-3,+,1}<%for.j>][6]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(48 + ((-32 + (32 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(%m * %o)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[0][{(6 + ((-4 + (4 * %m)) * %o)),+,(%m * %o)}<%for.i>]
+;
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..0b6f03e961d77 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,44 @@
; 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: %arrayidx10.us.us = getelementptr inbounds double, ptr %A, i64 %arrayidx9.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.body6.us.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx10.us.us = getelementptr inbounds double, ptr %A, i64 %arrayidx9.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.body6.lr.ph.us.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx10.us.us = getelementptr inbounds double, ptr %A, i64 %arrayidx9.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.cond4.preheader.lr.ph.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.body6.lr.ph.us.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}(48 + (8 * %o) + (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>
+; 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>][(6 + %o)]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.cond4.preheader.lr.ph.us
+; CHECK-NEXT: AccessFunction: {(48 + (8 * %o) + ((-40 + (32 * %m)) * (%o + %p))),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][((%o + %p) * %m)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[0][{(6 + ((-5 + (4 * %m)) * (%o + %p)) + %o),+,((%o + %p) * %m)}<%for.cond4.preheader.lr.ph.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..709e7afd8a601 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,44 @@
; 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: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(-8 + (8 * ((((%m * %p) + %q) * %o) + %r)) + (8 * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m][%o] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{%p,+,1}<nw><%for.i>][{(1 + %q),+,1}<%for.j>][(-1 + %r)]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-8 + (8 * ((((%m * %p) + %q) * %o) + %r)) + (8 * %m * %o)),+,(8 * %m * %o)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(%m * %o)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[0][{(-1 + ((((1 + %p) * %m) + %q) * %o) + %r),+,(%m * %o)}<%for.i>]
+;
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..477418bdb5a8d 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,46 @@
; 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: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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: %val = load double, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-8 + (8 * %m)),+,(8 * %m)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][-1]
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double %val, ptr %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-8 + (8 * %m)),+,(8 * %m)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][-1]
+;
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..b0e22978f8411 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,50 @@
; }
; }
-; 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: %arrayidx10.us.us = getelementptr inbounds double, ptr %vla.us, i64 %arrayidx.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.body9.us.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx10.us.us = getelementptr inbounds double, ptr %vla.us, i64 %arrayidx.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.body9.lr.ph.us.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx10.us.us = getelementptr inbounds double, ptr %vla.us, i64 %arrayidx.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.cond7.preheader.lr.ph.split.us.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx10.us.us = getelementptr inbounds double, ptr %vla.us, i64 %arrayidx.sum.us.us
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.body9.lr.ph.us.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,8}<%for.cond7.preheader.lr.ph.split.us.us>,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.cond7.preheader.lr.ph.split.us.us
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,8}<%for.cond1.preheader>,+,{8,+,8}<%for.cond1.preheader>}<%for.cond7.preheader.lr.ph.split.us.us>
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
+; CHECK-NEXT: In Loop with Header: for.cond1.preheader
+; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(-8 + (8 * %b))}<%for.cond1.preheader>,+,8}<%for.cond7.preheader.lr.ph.split.us.us>
+; CHECK-NEXT: Base offset: %vla.us
+; CHECK-NEXT: ArrayDecl[UnknownSize][%b] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.cond1.preheader>][{{\{\{}}0,+,-1}<nsw><%for.cond1.preheader>,+,1}<%for.cond7.preheader.lr.ph.split.us.us>]
+;
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..96693a18206bc 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,44 @@
; 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: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(-8 + (8 * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>
+; 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>][{1,+,1}<nuw><nsw><%for.j>][-1]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-8 + (8 * %m * %o)),+,(8 * %m * %o)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][(%m * %o)] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[0][{(-1 + (%m * %o)),+,(%m * %o)}<%for.i>]
+;
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..d102737946d8e 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,47 @@
; 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: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.k
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %idx = getelementptr inbounds double, ptr %A, i64 %subscript
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * (zext i32 (-1 + %o) to i64))<nuw><nsw>,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))<nuw><nsw>}<%for.j>
+; 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>][(zext i32 (-1 + %o) to i64)]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {((8 * (zext i32 (-1 + %o) to i64))<nuw><nsw> + (8 * (zext i32 (-1 + %m) to i64) * (zext i32 %o to i64))),+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>
+; 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][{((zext i32 (-1 + %o) to i64) + ((zext i32 (-1 + %m) to i64) * (zext i32 %o to i64))),+,((zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>]
+;
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..3b2da37aa50a1 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 -aa-pipeline=basic-aa -passes='require<da>,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,53 @@ target triple = "x86_64-unknown-linux-gnu"
; }
define void @foo(i64 %n, i64 %m, ptr %A) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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 %arrayidx, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(-8 + (8 * %m)),+,(8 * %m)}<%for.i>
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%m] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][-1]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx1 = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum1
+; CHECK-NEXT: In Loop with Header: for.j
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx1 = getelementptr inbounds double, ptr %A, i64 %vlaarrayidx.sum1
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx1, align 8
+; CHECK-NEXT: In Loop with Header: for.i
+; CHECK-NEXT: AccessFunction: {(8 * (-1 + %m) * %n),+,8}<%for.i>
+; CHECK-NEXT: failed to delinearize
+;
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..3c3d58a58046f 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,58 @@
; 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: %pval = load i64, ptr %p, align 8
+; CHECK-NEXT: In Loop with Header: bb2
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %tmp10 = getelementptr inbounds float, ptr %A, i64 %tmp9
+; CHECK-NEXT: In Loop with Header: bb4
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %tmp10 = getelementptr inbounds float, ptr %A, i64 %tmp9
+; CHECK-NEXT: In Loop with Header: bb2
+; 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: %tmp11 = load float, ptr %tmp10, align 4
+; CHECK-NEXT: In Loop with Header: bb2
+; CHECK-NEXT: AccessFunction: (400 + ({0,+,4}<nuw><nsw><%bb2> * %pval))
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][100]
+; 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>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store float %tmp12, ptr %tmp10, align 4
+; CHECK-NEXT: In Loop with Header: bb2
+; CHECK-NEXT: AccessFunction: (400 + ({0,+,4}<nuw><nsw><%bb2> * %pval))
+; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][100]
+;
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..bb25efd8fd8a9 100644
--- a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
+++ b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
; REQUIRES: asserts
; RUN: opt < %s -passes='print<delinearization>' -disable-output -debug 2>&1 2>&1 | FileCheck %s
; void foo (int m, int n, char *A) {
@@ -6,18 +7,160 @@
; 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: %arrayidx.us = getelementptr inbounds i8, ptr %A, i64 %3
+; CHECK-NEXT: In Loop with Header: for.body3.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: Strides:
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx.us = getelementptr inbounds i8, ptr %A, i64 %3
+; CHECK-NEXT: In Loop with Header: for.body3.lr.ph.us
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: Strides:
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; 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: Strides:
+; CHECK-NEXT: 1
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms after sorting:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Sizes:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: 1
+; CHECK-NEXT: Res: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Sizes[i]: 1
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Remainder: 0
+; CHECK-NEXT: Res: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Sizes[i]: (sext i32 %n to i64)
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: {0,+,1}<nuw><nsw><%for.body3.us>
+; CHECK-NEXT: Subscripts:
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.us>
+; CHECK-NEXT: succeeded to delinearize {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)][1]
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><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: %4 = load i8, ptr %arrayidx.us, align 1
+; CHECK-NEXT: In Loop with Header: for.body3.lr.ph.us
+; CHECK-NEXT: AccessFunction: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Strides:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms after sorting:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Sizes:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: 1
+; CHECK-NEXT: Res: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Sizes[i]: 1
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: 0
+; CHECK-NEXT: Res: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Sizes[i]: (sext i32 %n to i64)
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: (zext i32 (-1 + %n) to i64)
+; CHECK-NEXT: Subscripts:
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: (zext i32 (-1 + %n) to i64)
+; CHECK-NEXT: succeeded to delinearize {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)][1]
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][(zext i32 (-1 + %n) to i64)]
+; 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>][(zext i32 (-1 + %n) to i64)]
+; 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: Strides:
+; CHECK-NEXT: 1
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms after sorting:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Sizes:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: 1
+; CHECK-NEXT: Res: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Sizes[i]: 1
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Remainder: 0
+; CHECK-NEXT: Res: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: Sizes[i]: (sext i32 %n to i64)
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: {0,+,1}<nuw><nsw><%for.body3.us>
+; CHECK-NEXT: Subscripts:
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.us>
+; CHECK-NEXT: succeeded to delinearize {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)][1]
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><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.lr.ph.us
+; CHECK-NEXT: AccessFunction: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Strides:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Terms after sorting:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: Sizes:
+; CHECK-NEXT: (sext i32 %n to i64)
+; CHECK-NEXT: 1
+; CHECK-NEXT: Res: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Sizes[i]: 1
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: 0
+; CHECK-NEXT: Res: {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: Sizes[i]: (sext i32 %n to i64)
+; CHECK-NEXT: Res divided by Sizes[i]:
+; CHECK-NEXT: Quotient: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: Remainder: (zext i32 (-1 + %n) to i64)
+; CHECK-NEXT: Subscripts:
+; CHECK-NEXT: {0,+,1}<nuw><nsw><%for.body3.lr.ph.us>
+; CHECK-NEXT: (zext i32 (-1 + %n) to i64)
+; CHECK-NEXT: succeeded to delinearize {(zext i32 (-1 + %n) to i64),+,(sext i32 %n to i64)}<%for.body3.lr.ph.us>
+; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)][1]
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][(zext i32 (-1 + %n) to i64)]
+; 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>][(zext i32 (-1 + %n) to i64)]
+;
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..ff1dc7264f516 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
@@ -9,6 +10,22 @@
target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"
define fastcc void @test(i1 %arg) {
+; CHECK-LABEL: 'test'
+; CHECK-NEXT: Inst: store i8 undef, ptr %arrayidx.phi, align 1
+; CHECK-NEXT: In Loop with Header: for.body11
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i8 undef, ptr %arrayidx.phi, align 1
+; CHECK-NEXT: In Loop with Header: for.cond7.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %add.ptr = getelementptr inbounds i8, ptr %p1.022, i32 %conv21
+; CHECK-NEXT: In Loop with Header: for.cond7.preheader
+; CHECK-NEXT: AccessFunction: {0,+,(zext i16 %0 to i32)}<%for.cond7.preheader>
+; CHECK-NEXT: failed to delinearize
+;
entry:
%0 = load i16, ptr undef, align 2
%conv21 = zext i16 %0 to i32
diff --git a/llvm/test/Analysis/Delinearization/undef.ll b/llvm/test/Analysis/Delinearization/undef.ll
index 1e62c4579c9c6..828ba3bc32c4e 100644
--- a/llvm/test/Analysis/Delinearization/undef.ll
+++ b/llvm/test/Analysis/Delinearization/undef.ll
@@ -1,8 +1,40 @@
-; 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
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) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Inst: %arrayidx70 = getelementptr inbounds double, ptr %Ey, i64 %arrayidx69.sum
+; CHECK-NEXT: In Loop with Header: for.body60
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx70 = getelementptr inbounds double, ptr %Ey, i64 %arrayidx69.sum
+; CHECK-NEXT: In Loop with Header: for.cond58.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %arrayidx70 = getelementptr inbounds double, ptr %Ey, i64 %arrayidx69.sum
+; CHECK-NEXT: In Loop with Header: for.cond55.preheader
+; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %1 = load double, ptr %arrayidx70, align 8
+; CHECK-NEXT: In Loop with Header: for.body60
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * undef),+,(8 * undef * undef)}<%for.cond55.preheader>,+,(8 * undef)}<%for.cond58.preheader>
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %1 = load double, ptr %arrayidx70, align 8
+; CHECK-NEXT: In Loop with Header: for.cond58.preheader
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * undef),+,(8 * undef * undef)}<%for.cond55.preheader>,+,(8 * undef)}<%for.cond58.preheader>
+; CHECK-NEXT: failed to delinearize
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: %1 = load double, ptr %arrayidx70, align 8
+; CHECK-NEXT: In Loop with Header: for.cond55.preheader
+; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * undef),+,(8 * undef * undef)}<%for.cond55.preheader>,+,(8 * undef)}<%for.cond58.preheader>
+; CHECK-NEXT: failed to delinearize
+;
entry:
br i1 %arg, label %for.cond55.preheader, label %for.end324
diff --git a/llvm/utils/UpdateTestChecks/common.py b/llvm/utils/UpdateTestChecks/common.py
index 178c623e33e0e..9502b8f5c54ca 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