[llvm] [polly] [delinearize] remove all uses of GEP instructions (PR #156215)
Sebastian Pop via llvm-commits
llvm-commits at lists.llvm.org
Sat Aug 30 17:06:08 PDT 2025
https://github.com/sebpop updated https://github.com/llvm/llvm-project/pull/156215
>From e50ccb1b850748c8136736fcf1f0c96da07f2997 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Thu, 14 Aug 2025 20:23:19 -0500
Subject: [PATCH 1/4] improve debug messages in dependence analysis
---
llvm/lib/Analysis/DependenceAnalysis.cpp | 46 +++++++++++++++++-------
1 file changed, 34 insertions(+), 12 deletions(-)
diff --git a/llvm/lib/Analysis/DependenceAnalysis.cpp b/llvm/lib/Analysis/DependenceAnalysis.cpp
index f33e04e804e3d..da86a8d2cc9c0 100644
--- a/llvm/lib/Analysis/DependenceAnalysis.cpp
+++ b/llvm/lib/Analysis/DependenceAnalysis.cpp
@@ -3419,13 +3419,24 @@ bool DependenceInfo::tryDelinearizeFixedSize(
size_t SSize = Subscripts.size();
for (size_t I = 1; I < SSize; ++I) {
const SCEV *S = Subscripts[I];
- if (!isKnownNonNegative(S, Ptr))
+ if (!isKnownNonNegative(S, Ptr)) {
+ LLVM_DEBUG({
+ dbgs() << "Check failed: !isKnownNonNegative(S, Ptr)\n";
+ dbgs() << " S: " << *S << "\n" << " Ptr: " << *Ptr << "\n";
+ });
return false;
+ }
if (auto *SType = dyn_cast<IntegerType>(S->getType())) {
const SCEV *Range = SE->getConstant(
ConstantInt::get(SType, DimensionSizes[I - 1], false));
- if (!isKnownLessThan(S, Range))
+ if (!isKnownLessThan(S, Range)) {
+ LLVM_DEBUG({
+ dbgs() << "Check failed: !isKnownLessThan(S, Range)\n";
+ dbgs() << " S: " << *S << "\n"
+ << " Range: " << *Range << "\n";
+ });
return false;
+ }
}
}
return true;
@@ -3433,6 +3444,7 @@ bool DependenceInfo::tryDelinearizeFixedSize(
if (!AllIndicesInRange(SrcSizes, SrcSubscripts, SrcPtr) ||
!AllIndicesInRange(DstSizes, DstSubscripts, DstPtr)) {
+ LLVM_DEBUG(dbgs() << "Check failed: AllIndicesInRange.\n");
SrcSubscripts.clear();
DstSubscripts.clear();
return false;
@@ -3500,17 +3512,27 @@ bool DependenceInfo::tryDelinearizeParametricSize(
// to the dependency checks.
if (!DisableDelinearizationChecks)
for (size_t I = 1; I < Size; ++I) {
- if (!isKnownNonNegative(SrcSubscripts[I], SrcPtr))
- return false;
-
- if (!isKnownLessThan(SrcSubscripts[I], Sizes[I - 1]))
- return false;
-
- if (!isKnownNonNegative(DstSubscripts[I], DstPtr))
- return false;
+ bool SNN = isKnownNonNegative(SrcSubscripts[I], SrcPtr);
+ bool DNN = isKnownNonNegative(DstSubscripts[I], DstPtr);
+ bool SLT = isKnownLessThan(SrcSubscripts[I], Sizes[I - 1]);
+ bool DLT = isKnownLessThan(DstSubscripts[I], Sizes[I - 1]);
+ if (SNN && DNN && SLT && DLT)
+ continue;
- if (!isKnownLessThan(DstSubscripts[I], Sizes[I - 1]))
- return false;
+ LLVM_DEBUG({
+ dbgs() << "Delinearization checks failed: can't prove the following\n";
+ if (!SNN)
+ dbgs() << " isKnownNonNegative(" << *SrcSubscripts[I] << ")\n";
+ if (!DNN)
+ dbgs() << " isKnownNonNegative(" << *DstSubscripts[I] << ")\n";
+ if (!SLT)
+ dbgs() << " isKnownLessThan(" << *SrcSubscripts[I] << ", "
+ << *Sizes[I - 1] << ")\n";
+ if (!DLT)
+ dbgs() << " isKnownLessThan(" << *DstSubscripts[I] << ", "
+ << *Sizes[I - 1] << ")\n";
+ });
+ return false;
}
return true;
>From c3622f02bfc9950d65ad1bd911bb2850c5086a46 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Fri, 15 Aug 2025 19:01:22 -0500
Subject: [PATCH 2/4] improve debug messages in delinearization
---
llvm/lib/Analysis/Delinearization.cpp | 113 +++++++++++-------
llvm/test/Analysis/Delinearization/a.ll | 5 +-
.../Analysis/Delinearization/byte_offset.ll | 3 +-
.../constant_functions_multi_dim.ll | 10 +-
.../Analysis/Delinearization/divide_by_one.ll | 10 +-
.../Delinearization/fixed_size_array.ll | 49 +++-----
.../Delinearization/gcd_multiply_expr.ll | 84 +++++--------
.../test/Analysis/Delinearization/himeno_1.ll | 5 +-
.../test/Analysis/Delinearization/himeno_2.ll | 5 +-
.../iv_times_constant_in_subscript.ll | 5 +-
.../multidim_ivs_and_integer_offsets_3d.ll | 5 +-
...multidim_ivs_and_integer_offsets_nts_3d.ll | 5 +-
...multidim_ivs_and_parameteric_offsets_3d.ll | 5 +-
.../Delinearization/multidim_only_ivs_2d.ll | 10 +-
.../multidim_only_ivs_2d_nested.ll | 3 +-
.../Delinearization/multidim_only_ivs_3d.ll | 5 +-
.../multidim_only_ivs_3d_cast.ll | 5 +-
..._two_accesses_different_delinearization.ll | 10 +-
.../parameter_addrec_product.ll | 13 +-
.../terms_with_identity_factor.ll | 10 +-
.../Analysis/Delinearization/type_mismatch.ll | 3 +-
21 files changed, 164 insertions(+), 199 deletions(-)
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 762d9191aab1e..ee11609662fb7 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -182,7 +182,7 @@ void llvm::collectParametricTerms(ScalarEvolution &SE, const SCEV *Expr,
LLVM_DEBUG({
dbgs() << "Strides:\n";
for (const SCEV *S : Strides)
- dbgs() << *S << "\n";
+ dbgs() << " " << *S << "\n";
});
for (const SCEV *S : Strides) {
@@ -193,7 +193,7 @@ void llvm::collectParametricTerms(ScalarEvolution &SE, const SCEV *Expr,
LLVM_DEBUG({
dbgs() << "Terms:\n";
for (const SCEV *T : Terms)
- dbgs() << *T << "\n";
+ dbgs() << " " << *T << "\n";
});
SCEVCollectAddRecMultiplies MulCollector(Terms, SE);
@@ -294,7 +294,7 @@ void llvm::findArrayDimensions(ScalarEvolution &SE,
LLVM_DEBUG({
dbgs() << "Terms:\n";
for (const SCEV *T : Terms)
- dbgs() << *T << "\n";
+ dbgs() << " " << *T << "\n";
});
// Remove duplicates.
@@ -325,7 +325,7 @@ void llvm::findArrayDimensions(ScalarEvolution &SE,
LLVM_DEBUG({
dbgs() << "Terms after sorting:\n";
for (const SCEV *T : NewTerms)
- dbgs() << *T << "\n";
+ dbgs() << " " << *T << "\n";
});
if (NewTerms.empty() || !findArrayDimensionsRec(SE, NewTerms, Sizes)) {
@@ -339,7 +339,7 @@ void llvm::findArrayDimensions(ScalarEvolution &SE,
LLVM_DEBUG({
dbgs() << "Sizes:\n";
for (const SCEV *S : Sizes)
- dbgs() << *S << "\n";
+ dbgs() << " " << *S << "\n";
});
}
@@ -354,18 +354,27 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
if (!AR->isAffine())
return;
+ // Clear output vector.
+ Subscripts.clear();
+
+ LLVM_DEBUG(dbgs() << "\ncomputeAccessFunctions\n"
+ << "Linearized Memory Access Function: " << *Expr << "\n");
+
const SCEV *Res = Expr;
int Last = Sizes.size() - 1;
+
for (int i = Last; i >= 0; i--) {
+ const SCEV *Size = Sizes[i];
const SCEV *Q, *R;
- SCEVDivision::divide(SE, Res, Sizes[i], &Q, &R);
+
+ SCEVDivision::divide(SE, Res, Size, &Q, &R);
LLVM_DEBUG({
- dbgs() << "Res: " << *Res << "\n";
- dbgs() << "Sizes[i]: " << *Sizes[i] << "\n";
- dbgs() << "Res divided by Sizes[i]:\n";
- dbgs() << "Quotient: " << *Q << "\n";
- dbgs() << "Remainder: " << *R << "\n";
+ dbgs() << "Computing 'MemAccFn / Sizes[" << i << "]':\n";
+ dbgs() << " MemAccFn: " << *Res << "\n";
+ dbgs() << " Sizes[" << i << "]: " << *Size << "\n";
+ dbgs() << " Quotient (Leftover): " << *Q << "\n";
+ dbgs() << " Remainder (Subscript Access Function): " << *R << "\n";
});
Res = Q;
@@ -385,6 +394,7 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
}
// Record the access function for the current subscript.
+ LLVM_DEBUG(dbgs() << "Subscripts push_back Remainder: " << *R << "\n");
Subscripts.push_back(R);
}
@@ -397,7 +407,8 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
LLVM_DEBUG({
dbgs() << "Subscripts:\n";
for (const SCEV *S : Subscripts)
- dbgs() << *S << "\n";
+ dbgs() << " " << *S << "\n";
+ dbgs() << "\n";
});
}
@@ -454,6 +465,10 @@ void llvm::delinearize(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
SmallVectorImpl<const SCEV *> &Sizes,
const SCEV *ElementSize) {
+ // Clear output vectors.
+ Subscripts.clear();
+ Sizes.clear();
+
// First step: collect parametric terms.
SmallVector<const SCEV *, 4> Terms;
collectParametricTerms(SE, Expr, Terms);
@@ -469,21 +484,6 @@ void llvm::delinearize(ScalarEvolution &SE, const SCEV *Expr,
// Third step: compute the access functions for each subscript.
computeAccessFunctions(SE, Expr, Subscripts, Sizes);
-
- if (Subscripts.empty())
- return;
-
- LLVM_DEBUG({
- dbgs() << "succeeded to delinearize " << *Expr << "\n";
- dbgs() << "ArrayDecl[UnknownSize]";
- for (const SCEV *S : Sizes)
- dbgs() << "[" << *S << "]";
-
- dbgs() << "\nArrayRef";
- for (const SCEV *S : Subscripts)
- dbgs() << "[" << *S << "]";
- dbgs() << "\n";
- });
}
static std::optional<APInt> tryIntoAPInt(const SCEV *S) {
@@ -646,6 +646,9 @@ bool llvm::delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
SmallVectorImpl<const SCEV *> &Sizes,
const SCEV *ElementSize) {
+ // Clear output vectors.
+ Subscripts.clear();
+ Sizes.clear();
// First step: find the fixed array size.
SmallVector<uint64_t, 4> ConstSizes;
@@ -671,6 +674,7 @@ bool llvm::getIndexExpressionsFromGEP(ScalarEvolution &SE,
assert(Subscripts.empty() && Sizes.empty() &&
"Expected output lists to be empty on entry to this function.");
assert(GEP && "getIndexExpressionsFromGEP called with a null GEP");
+ LLVM_DEBUG(dbgs() << "\nGEP to delinearize: " << *GEP << "\n");
Type *Ty = nullptr;
bool DroppedFirstDim = false;
for (unsigned i = 1; i < GEP->getNumOperands(); i++) {
@@ -683,28 +687,43 @@ bool llvm::getIndexExpressionsFromGEP(ScalarEvolution &SE,
continue;
}
Subscripts.push_back(Expr);
+ LLVM_DEBUG(dbgs() << "Subscripts push_back: " << *Expr << "\n");
continue;
}
auto *ArrayTy = dyn_cast<ArrayType>(Ty);
if (!ArrayTy) {
+ LLVM_DEBUG(dbgs() << "GEP delinearize failed: " << *Ty
+ << " is not an array type.\n");
Subscripts.clear();
Sizes.clear();
return false;
}
Subscripts.push_back(Expr);
+ LLVM_DEBUG(dbgs() << "Subscripts push_back: " << *Expr << "\n");
if (!(DroppedFirstDim && i == 2))
Sizes.push_back(ArrayTy->getNumElements());
Ty = ArrayTy->getElementType();
}
+ LLVM_DEBUG({
+ dbgs() << "Subscripts:\n";
+ for (const SCEV *S : Subscripts)
+ dbgs() << *S << "\n";
+ dbgs() << "\n";
+ });
+
return !Subscripts.empty();
}
bool llvm::tryDelinearizeFixedSizeImpl(
ScalarEvolution *SE, Instruction *Inst, const SCEV *AccessFn,
SmallVectorImpl<const SCEV *> &Subscripts, SmallVectorImpl<int> &Sizes) {
+ // Clear output vectors.
+ Subscripts.clear();
+ Sizes.clear();
+
Value *SrcPtr = getLoadStorePointerOperand(Inst);
// Check the simple case where the array dimensions are fixed size.
@@ -769,8 +788,7 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
O << "\n";
O << "Inst:" << Inst << "\n";
- O << "In Loop with Header: " << L->getHeader()->getName() << "\n";
- O << "AccessFunction: " << *AccessFn << "\n";
+ O << "LinearAccessFunction: " << *AccessFn << "\n";
SmallVector<const SCEV *, 3> Subscripts, Sizes;
@@ -787,22 +805,33 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
SE->getElementSize(&Inst));
}
- if (IsDelinearizationFailed()) {
- O << "failed to delinearize\n";
- continue;
- }
+ if (IsDelinearizationFailed()) {
+ O << "failed to delinearize\n";
+ continue;
+ }
- O << "Base offset: " << *BasePointer << "\n";
- O << "ArrayDecl[UnknownSize]";
- int Size = Subscripts.size();
- for (int i = 0; i < Size - 1; i++)
+ O << "Base offset: " << *BasePointer << "\n";
+ O << "ArrayDecl";
+ int NumSubscripts = Subscripts.size();
+ int NumSizes = Sizes.size();
+
+ // Handle different size relationships between Subscripts and Sizes.
+ if (NumSizes > 0) {
+ // Print array dimensions (all but the last size, which is element
+ // size).
+ for (int i = 0; i < NumSizes - 1; i++)
O << "[" << *Sizes[i] << "]";
- O << " with elements of " << *Sizes[Size - 1] << " bytes.\n";
- O << "ArrayRef";
- for (int i = 0; i < Size; i++)
- O << "[" << *Subscripts[i] << "]";
- O << "\n";
+ // Print element size (last element in Sizes array).
+ O << " with elements of " << *Sizes[NumSizes - 1] << " bytes.\n";
+ } else {
+ O << " unknown sizes.\n";
+ }
+
+ O << "ArrayRef";
+ for (int i = 0; i < NumSubscripts; i++)
+ O << "[" << *Subscripts[i] << "]";
+ O << "\n";
}
}
diff --git a/llvm/test/Analysis/Delinearization/a.ll b/llvm/test/Analysis/Delinearization/a.ll
index 755c9baef9b8f..7de0d37208fa0 100644
--- a/llvm/test/Analysis/Delinearization/a.ll
+++ b/llvm/test/Analysis/Delinearization/a.ll
@@ -11,10 +11,9 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr nocapture %A) #0 {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store i32 1, ptr %arrayidx11.us.us, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[%m][%o] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/byte_offset.ll b/llvm/test/Analysis/Delinearization/byte_offset.ll
index 90b1f03329e44..675e3f36f39f7 100644
--- a/llvm/test/Analysis/Delinearization/byte_offset.ll
+++ b/llvm/test/Analysis/Delinearization/byte_offset.ll
@@ -13,8 +13,7 @@
define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store float 0.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: inner.loop
-; CHECK-NEXT: AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
+; CHECK-NEXT: LinearAccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
index c0b1a0b9cddaf..30ac1b29a6ae3 100644
--- a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
+++ b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
@@ -7,17 +7,15 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @mat_mul(ptr %C, ptr %A, ptr %B, i64 %N) #0 !kernel_arg_addr_space !2 !kernel_arg_access_qual !3 !kernel_arg_type !4 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
; CHECK-LABEL: 'mat_mul'
; CHECK-NEXT: Inst: %tmp = load float, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
+; CHECK-NEXT: LinearAccessFunction: {(4 * %N * %call),+,4}<%for.inc>
; CHECK-NEXT: Base offset: %A
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT: ArrayDecl[%N] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %tmp5 = load float, ptr %arrayidx4, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
+; CHECK-NEXT: LinearAccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
; CHECK-NEXT: Base offset: %B
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT: ArrayDecl[%N] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/divide_by_one.ll b/llvm/test/Analysis/Delinearization/divide_by_one.ll
index 28fe5c50ae779..907b254097222 100644
--- a/llvm/test/Analysis/Delinearization/divide_by_one.ll
+++ b/llvm/test/Analysis/Delinearization/divide_by_one.ll
@@ -14,17 +14,15 @@ target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
define void @test(ptr nocapture %dst, i32 %stride, i32 %bs) {
; CHECK-LABEL: 'test'
; CHECK-NEXT: Inst: %0 = load i8, ptr %arrayidx, align 1
-; CHECK-NEXT: In Loop with Header: for.body3
-; CHECK-NEXT: AccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(-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: ArrayDecl[%stride] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i8 %0, ptr %arrayidx7, align 1
-; CHECK-NEXT: In Loop with Header: for.body3
-; CHECK-NEXT: AccessFunction: {{\{\{}}(%stride * %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nsw><%for.body3>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(%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: ArrayDecl[%stride] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/fixed_size_array.ll b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
index 634850bb4a5a2..87ef40f07a501 100644
--- a/llvm/test/Analysis/Delinearization/fixed_size_array.ll
+++ b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
@@ -11,10 +11,9 @@
define void @a_i_j_k(ptr %a) {
; CHECK-LABEL: 'a_i_j_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[8][32] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
;
entry:
@@ -60,10 +59,9 @@ exit:
define void @a_i_nj_k(ptr %a) {
; CHECK-LABEL: 'a_i_nj_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}896,+,1024}<nuw><nsw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[8][32] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{7,+,-1}<nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
;
entry:
@@ -116,17 +114,15 @@ exit:
define void @a_ijk_b_i2jk(ptr %a, ptr %b) {
; CHECK-LABEL: 'a_ijk_b_i2jk'
; CHECK-NEXT: Inst: store i32 1, ptr %a.idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[4][64] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 1, ptr %b.idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[4][64] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,1}<nuw><nsw><%for.k>]
;
entry:
@@ -180,10 +176,9 @@ exit:
define void @a_i_2j1_k(ptr %a) {
; CHECK-LABEL: 'a_i_2j1_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}128,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[4][64] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><%for.j.header>][{32,+,1}<nw><%for.k>]
;
entry:
@@ -234,8 +229,7 @@ exit:
define void @a_i_3j_k(ptr %a) {
; CHECK-LABEL: 'a_i_3j_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
@@ -286,10 +280,9 @@ exit:
define void @a_i_j_3k(ptr %a) {
; CHECK-LABEL: 'a_i_j_3k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[8][32] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{0,+,1}<nuw><nsw><%for.j.header>][{0,+,3}<nuw><nsw><%for.k>]
;
entry:
@@ -338,8 +331,7 @@ exit:
define void @a_i_j2k_i(ptr %a) {
; CHECK-LABEL: 'a_i_j2k_i'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
@@ -390,10 +382,9 @@ exit:
define void @a_i_i_jk(ptr %a) {
; CHECK-LABEL: 'a_i_i_jk'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[288] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k>]
;
entry:
@@ -441,10 +432,9 @@ exit:
define void @a_i_jk_l(ptr %a) {
; CHECK-LABEL: 'a_i_jk_l'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.l
-; CHECK-NEXT: AccessFunction: {{\{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,128}<nw><%for.k.header>,+,4}<nw><%for.l>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{\{}}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: ArrayDecl[8][32] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i.header>][{{\{\{}}0,+,1}<nuw><nsw><%for.j.header>,+,1}<nuw><nsw><%for.k.header>][{0,+,1}<nuw><nsw><%for.l>]
;
entry:
@@ -502,8 +492,7 @@ exit:
define void @non_divisible_by_element_size(ptr %a) {
; CHECK-LABEL: 'non_divisible_by_element_size'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
index 3e4545289a450..2a7881e71c021 100644
--- a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
+++ b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
@@ -29,143 +29,115 @@
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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.1.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.2.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.3.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.4.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.5.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.6.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.7.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 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: LinearAccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.ur.i, ptr @c, align 4
-; CHECK-NEXT: In Loop with Header: for.body4.ur.i
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 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: LinearAccessFunction: 0
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/himeno_1.ll b/llvm/test/Analysis/Delinearization/himeno_1.ll
index 292dca61d0592..deb092c14a937 100644
--- a/llvm/test/Analysis/Delinearization/himeno_1.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_1.ll
@@ -32,10 +32,9 @@
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
; CHECK-LABEL: 'jacobi'
; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/himeno_2.ll b/llvm/test/Analysis/Delinearization/himeno_2.ll
index d210539d67d8b..d1b0ac7883e3d 100644
--- a/llvm/test/Analysis/Delinearization/himeno_2.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_2.ll
@@ -32,10 +32,9 @@
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
; CHECK-LABEL: 'jacobi'
; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>)),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))<nsw>}<%for.j>,+,4}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{1,+,1}<nuw><nsw><%for.i>][{1,+,1}<nuw><nsw><%for.j>][{1,+,1}<nuw><nsw><%for.k>]
;
entry:
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 cbe3ec8a19acd..253b55ee8f62f 100644
--- a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
+++ b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
@@ -12,10 +12,9 @@
define void @foo(i64 %n, i64 %m, i64 %b, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT: In Loop with Header: for.j
-; CHECK-NEXT: AccessFunction: {{\{\{}}(8 * %m * %b),+,(16 * %m)}<%for.i>,+,16}<%for.j>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(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: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{%b,+,2}<nsw><%for.i>][{0,+,2}<nuw><%for.j>]
;
entry:
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 3d21d97438462..525e4b45cc055 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
@@ -12,10 +12,9 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[%m][%o] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{3,+,1}<nuw><%for.i>][{-4,+,1}<nsw><%for.j>][{7,+,1}<nuw><nsw><%for.k>]
;
entry:
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 3dbd71b1c9ac5..1e28665164757 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
@@ -12,10 +12,9 @@
define void @foo(i64 %n, i64 %m, i64 %o, i64 %p, ptr nocapture %A) nounwind uwtable {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT: In Loop with Header: for.body6.us.us
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * (%o + %p))),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[%m][(%o + %p)] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{3,+,1}<nuw><%for.cond4.preheader.lr.ph.us>][{-4,+,1}<nw><%for.body6.lr.ph.us.us>][{7,+,1}<nw><%for.body6.us.us>]
;
entry:
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 a2d64a5b40bc9..1dcb381640e94 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
@@ -12,10 +12,9 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A, i64 %p, i64 %q, i64 %r) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}(8 * ((((%m * %p) + %q) * %o) + %r)),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: ArrayDecl[%m][%o] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{%p,+,1}<nw><%for.i>][{%q,+,1}<nsw><%for.j>][{%r,+,1}<nsw><%for.k>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
index ac83ba19b252d..6079c0aec911d 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
@@ -12,17 +12,15 @@
define void @foo(i64 %n, i64 %m, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: %val = load double, ptr %arrayidx, align 8
-; CHECK-NEXT: In Loop with Header: for.j
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}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: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store double %val, ptr %arrayidx, align 8
-; CHECK-NEXT: In Loop with Header: for.j
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}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: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
;
entry:
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 262a092794cb1..8d6108fc6d662 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
@@ -18,8 +18,7 @@
define void @foo(i64 %a, i64 %b) nounwind uwtable {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT: In Loop with Header: for.body9.us.us
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
index b1405db81a787..4efbb68ca1850 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
@@ -12,10 +12,9 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[%m][%o] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
;
entry:
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 6de072ebaee13..5bb1b46deccc0 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
@@ -14,10 +14,9 @@ target triple = "x86_64-unknown-linux-gnu"
define void @foo(i32 %n, i32 %m, i32 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: In Loop with Header: for.k
-; CHECK-NEXT: AccessFunction: {{\{\{\{}}0,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))<nuw><nsw>}<%for.j>,+,8}<%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: ArrayDecl[(zext i32 %m to i64)][(zext i32 %o to i64)] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
;
entry:
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 d7148c5216462..f64e1680f6b94 100644
--- a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
@@ -15,17 +15,15 @@ target triple = "x86_64-unknown-linux-gnu"
define void @foo(i64 %n, i64 %m, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT: In Loop with Header: for.j
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}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: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx1, align 8
-; CHECK-NEXT: In Loop with Header: for.j
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,8}<%for.i>,+,(8 * %n)}<%for.j>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}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: ArrayDecl[%n] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.i>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
index cbccafd1e6546..952338ea94497 100644
--- a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
+++ b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
@@ -11,22 +11,19 @@ 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: LinearAccessFunction: 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: LinearAccessFunction: (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: ArrayDecl[%pval] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store float %tmp12, ptr %tmp10, align 4
-; CHECK-NEXT: In Loop with Header: bb4
-; CHECK-NEXT: AccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
+; CHECK-NEXT: LinearAccessFunction: (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: ArrayDecl[%pval] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
;
bb:
diff --git a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
index 86adcc8a1957c..9df1c85ee6e8d 100644
--- a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
+++ b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
@@ -9,17 +9,15 @@
define void @foo(i32 %m, i32 %n, ptr nocapture %A) #0 {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: %4 = load i8, ptr %arrayidx.us, align 1
-; CHECK-NEXT: In Loop with Header: for.body3.us
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
; CHECK-NEXT: Base offset: %A
-; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
+; CHECK-NEXT: ArrayDecl[(sext i32 %n to i64)] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i8 %add4.us, ptr %arrayidx.us, align 1
-; CHECK-NEXT: In Loop with Header: for.body3.us
-; CHECK-NEXT: AccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
; CHECK-NEXT: Base offset: %A
-; CHECK-NEXT: ArrayDecl[UnknownSize][(sext i32 %n to i64)] with elements of 1 bytes.
+; CHECK-NEXT: ArrayDecl[(sext i32 %n to i64)] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.body3.lr.ph.us>][{0,+,1}<nuw><nsw><%for.body3.us>]
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/type_mismatch.ll b/llvm/test/Analysis/Delinearization/type_mismatch.ll
index 1b78f24485743..d13c22362a4fb 100644
--- a/llvm/test/Analysis/Delinearization/type_mismatch.ll
+++ b/llvm/test/Analysis/Delinearization/type_mismatch.ll
@@ -12,8 +12,7 @@ target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"
define fastcc void @test(i1 %arg, ptr %x) {
; CHECK-LABEL: 'test'
; CHECK-NEXT: Inst: store i8 42, ptr %arrayidx.phi, align 1
-; CHECK-NEXT: In Loop with Header: for.body11
-; CHECK-NEXT: AccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: 0
; CHECK-NEXT: failed to delinearize
;
entry:
>From 65e9cfc202b361d6a91073c9a04eda18522d0dd3 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Fri, 15 Aug 2025 19:22:45 -0500
Subject: [PATCH 3/4] [delinearize] Extract array dimensions from alloca and
global declarations
This implements an alternative to extract multi-dimensional array information
directly from alloca instructions and global variable declarations instead of
relying on parsing the information from GEP instructions.
The functionality for GEP delinearization remains in this patch such that we can
evaluate regressions of the array_info extraction.
Next patch removes the code for GEP delinearization.
---
llvm/include/llvm/Analysis/Delinearization.h | 18 +
llvm/lib/Analysis/Delinearization.cpp | 364 ++++++++++++++++--
llvm/lib/Analysis/LoopCacheAnalysis.cpp | 5 +-
llvm/test/Analysis/Delinearization/a.ll | 3 +-
.../Delinearization/alloca-global-arrays.ll | 208 ++++++++++
.../array_info_delinearization.ll | 48 +++
.../Analysis/Delinearization/byte_offset.ll | 2 +-
.../constant_functions_multi_dim.ll | 6 +-
.../Analysis/Delinearization/divide_by_one.ll | 6 +-
.../Delinearization/fixed_size_array.ll | 30 +-
.../Delinearization/gcd_multiply_expr.ll | 56 +--
.../test/Analysis/Delinearization/himeno_1.ll | 3 +-
.../test/Analysis/Delinearization/himeno_2.ll | 3 +-
.../iv_times_constant_in_subscript.ll | 3 +-
.../multidim_ivs_and_integer_offsets_3d.ll | 3 +-
...multidim_ivs_and_integer_offsets_nts_3d.ll | 3 +-
...multidim_ivs_and_parameteric_offsets_3d.ll | 3 +-
.../Delinearization/multidim_only_ivs_2d.ll | 6 +-
.../multidim_only_ivs_2d_nested.ll | 2 +-
.../Delinearization/multidim_only_ivs_3d.ll | 3 +-
.../multidim_only_ivs_3d_cast.ll | 3 +-
..._two_accesses_different_delinearization.ll | 6 +-
.../parameter_addrec_product.ll | 8 +-
.../terms_with_identity_factor.ll | 6 +-
.../Analysis/Delinearization/type_mismatch.ll | 2 +-
.../Analysis/DependenceAnalysis/Coupled.ll | 38 +-
.../Analysis/DependenceAnalysis/DADelin.ll | 12 +-
.../DependenceAnalysis/FlipFlopBaseAddress.ll | 5 +-
.../Analysis/DependenceAnalysis/Invariant.ll | 5 +-
.../Analysis/DependenceAnalysis/PR51512.ll | 2 +-
.../PreliminaryNoValidityCheckFixedSize.ll | 5 +-
.../DependenceAnalysis/Separability.ll | 14 +-
.../SimpleSIVNoValidityCheckFixedSize.ll | 20 +-
.../interchange-cost-beneficial.ll | 18 +-
.../profitability-vectorization.ll | 3 +-
.../dependencies_multidims.ll | 2 -
polly/include/polly/ScopInfo.h | 13 +
polly/lib/Analysis/ScopBuilder.cpp | 94 +++--
polly/lib/Analysis/ScopInfo.cpp | 42 +-
polly/test/CodeGen/MemAccess/create_arrays.ll | 26 +-
.../CodeGen/MemAccess/create_arrays_heap.ll | 27 +-
polly/test/CodeGen/OpenMP/matmul-parallel.ll | 14 +-
.../test/CodeGen/invariant-load-dimension.ll | 6 +-
polly/test/DeLICM/load-in-cond-inf-loop.ll | 6 +-
polly/test/ForwardOpTree/atax.ll | 19 +-
.../ImportArrays-Mispelled-type.ll | 15 +-
.../ImportArrays-Negative-size.ll | 22 +-
.../ia4___%bb9---%bb26.jscop.transformed | 4 +-
.../GreedyFuse/fuse-double.ll | 8 +-
.../GreedyFuse/fuse-inner.ll | 8 +-
.../ensure-correct-tile-sizes.ll | 15 +-
.../full_partial_tile_separation.ll | 13 +-
...__%for.body---%for.end24.jscop.transformed | 16 +-
.../mat_mul_pattern_data_layout_2.ll | 16 +-
...attern-matching-based-opts-after-delicm.ll | 17 +-
...tern-matching-based-opts-after-delicm_2.ll | 15 +-
.../pattern-matching-based-opts.ll | 14 +-
.../pattern-matching-based-opts_11.ll | 11 +-
.../pattern-matching-based-opts_13.ll | 15 +-
.../pattern-matching-based-opts_14.ll | 15 +-
.../pattern-matching-based-opts_16.ll | 14 +-
.../pattern-matching-based-opts_17.ll | 14 +-
.../pattern-matching-based-opts_18.ll | 15 +-
.../pattern-matching-based-opts_19.ll | 14 +-
.../pattern-matching-based-opts_20.ll | 15 +-
.../pattern-matching-based-opts_24.ll | 14 +-
.../pattern-matching-based-opts_3.ll | 15 +-
.../pattern-matching-based-opts_4.ll | 15 +-
.../pattern-matching-based-opts_5.ll | 16 +-
.../pattern-matching-based-opts_6.ll | 17 +-
.../pattern-matching-based-opts_7.ll | 15 +-
.../pattern-matching-based-opts_8.ll | 16 +-
.../pattern_matching_based_opts_splitmap.ll | 17 +-
polly/test/ScopInfo/assume_gep_bounds.ll | 10 +-
polly/test/ScopInfo/assume_gep_bounds_2.ll | 13 +-
polly/test/ScopInfo/loop_affine_bound_0.ll | 10 +-
polly/test/ScopInfo/loop_affine_bound_1.ll | 13 +-
polly/test/ScopInfo/loop_affine_bound_2.ll | 12 +-
.../test/ScopInfo/many-scalar-dependences.ll | 10 +-
...idim_fixedsize_different_dimensionality.ll | 33 +-
.../multidim_fixedsize_multi_offset.ll | 13 +-
.../multidim_fold_constant_dim_zero.ll | 20 +-
polly/test/ScopInfo/multidim_with_bitcast.ll | 12 +-
polly/test/ScopInfo/non-precise-inv-load-1.ll | 1 -
.../test/ScopInfo/process_added_dimensions.ll | 7 +-
polly/test/ScopInfo/remarks.ll | 14 +-
polly/test/ScopInfo/scalar_to_array.ll | 3 -
.../stmt_with_read_but_without_sideffect.ll | 4 +-
...ser_provided_non_dominating_assumptions.ll | 9 +-
polly/test/Simplify/gemm.ll | 15 +-
polly/test/Simplify/pr33323.ll | 9 +-
91 files changed, 1231 insertions(+), 549 deletions(-)
create mode 100644 llvm/test/Analysis/Delinearization/alloca-global-arrays.ll
create mode 100644 llvm/test/Analysis/Delinearization/array_info_delinearization.ll
diff --git a/llvm/include/llvm/Analysis/Delinearization.h b/llvm/include/llvm/Analysis/Delinearization.h
index 434cfb61699d6..0dafac9102247 100644
--- a/llvm/include/llvm/Analysis/Delinearization.h
+++ b/llvm/include/llvm/Analysis/Delinearization.h
@@ -112,6 +112,13 @@ void delinearize(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
SmallVectorImpl<const SCEV *> &Sizes, const SCEV *ElementSize);
+/// Same as delinearize. TODO: only use delinearize() instead of other internal
+/// functions.
+bool delinearizeUsingArrayInfo(ScalarEvolution &SE, const SCEV *AccessFn,
+ SmallVectorImpl<const SCEV *> &Subscripts,
+ SmallVectorImpl<const SCEV *> &Sizes,
+ const SCEV *ElementSize);
+
/// Compute the dimensions of fixed size array from \Expr and save the results
/// in \p Sizes.
bool findFixedSizeArrayDimensions(ScalarEvolution &SE, const SCEV *Expr,
@@ -155,6 +162,17 @@ bool getIndexExpressionsFromGEP(ScalarEvolution &SE,
SmallVectorImpl<const SCEV *> &Subscripts,
SmallVectorImpl<int> &Sizes);
+/// Compute access functions for each subscript in a delinearized array access.
+void computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+ SmallVectorImpl<const SCEV *> &Subscripts,
+ SmallVectorImpl<const SCEV *> &Sizes,
+ const SCEV *ElementSize);
+
+/// Backward compatibility wrapper for computeAccessFunctions.
+void computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+ SmallVectorImpl<const SCEV *> &Subscripts,
+ SmallVectorImpl<const SCEV *> &Sizes);
+
/// Implementation of fixed size array delinearization. Try to delinearize
/// access function for a fixed size multi-dimensional array, by deriving
/// subscripts from GEP instructions. Returns true upon success and false
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index ee11609662fb7..1d07d632fe787 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -14,15 +14,18 @@
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/Delinearization.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionDivision.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
@@ -38,6 +41,10 @@ static cl::opt<bool> UseFixedSizeArrayHeuristic(
cl::desc("When printing analysis, use the heuristic for fixed-size arrays "
"if the default delinearizetion fails."));
+static cl::opt<bool> useGEPToDelinearize(
+ "use-gep-to-delinearize", cl::init(true), cl::Hidden,
+ cl::desc("validate both delinearization methods match."));
+
// Return true when S contains at least an undef value.
static inline bool containsUndefs(const SCEV *S) {
return SCEVExprContains(S, [](const SCEV *S) {
@@ -345,7 +352,8 @@ void llvm::findArrayDimensions(ScalarEvolution &SE,
void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
- SmallVectorImpl<const SCEV *> &Sizes) {
+ SmallVectorImpl<const SCEV *> &Sizes,
+ const SCEV *ElementSize) {
// Early exit in case this SCEV is not an affine multivariate function.
if (Sizes.empty())
return;
@@ -354,6 +362,9 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
if (!AR->isAffine())
return;
+ if (ElementSize->isZero())
+ return;
+
// Clear output vector.
Subscripts.clear();
@@ -365,10 +376,11 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
for (int i = Last; i >= 0; i--) {
const SCEV *Size = Sizes[i];
- const SCEV *Q, *R;
+ if (Size->isZero())
+ continue;
+ const SCEV *Q, *R;
SCEVDivision::divide(SE, Res, Size, &Q, &R);
-
LLVM_DEBUG({
dbgs() << "Computing 'MemAccFn / Sizes[" << i << "]':\n";
dbgs() << " MemAccFn: " << *Res << "\n";
@@ -376,7 +388,6 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
dbgs() << " Quotient (Leftover): " << *Q << "\n";
dbgs() << " Remainder (Subscript Access Function): " << *R << "\n";
});
-
Res = Q;
// Do not record the last subscript corresponding to the size of elements in
@@ -398,9 +409,15 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
Subscripts.push_back(R);
}
- // Also push in last position the remainder of the last division: it will be
- // the access function of the innermost dimension.
- Subscripts.push_back(Res);
+ // Also push in last position the quotient "Res = Q" of the last division: it
+ // will be the access function of the outermost array dimension.
+ if (!Res->isZero()) {
+ // This is only needed when the outermost array size is not known. Res = 0
+ // when the outermost array dimension is known, as for example when reading
+ // array sizes from a local or global declaration.
+ Subscripts.push_back(Res);
+ LLVM_DEBUG(dbgs() << "Subscripts push_back Res: " << *Res << "\n");
+ }
std::reverse(Subscripts.begin(), Subscripts.end());
@@ -412,6 +429,145 @@ void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
});
}
+/// Backward compatibility wrapper for the old 4-parameter version.
+void llvm::computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
+ SmallVectorImpl<const SCEV *> &Subscripts,
+ SmallVectorImpl<const SCEV *> &Sizes) {
+ // Use the element size from the last element in Sizes array (legacy behavior)
+ if (Sizes.empty()) {
+ Subscripts.clear();
+ return;
+ }
+ const SCEV *ElementSize = Sizes.back();
+ computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
+}
+
+/// Extract array dimensions from alloca or global variable declarations.
+/// Returns true if array dimensions were successfully extracted.
+static bool
+extractArrayInfoFromAllocaOrGlobal(ScalarEvolution &SE, Value *BasePtr,
+ SmallVectorImpl<const SCEV *> &Sizes,
+ const SCEV *ElementSize) {
+ // Clear output vector.
+ Sizes.clear();
+
+ LLVM_DEBUG(
+ dbgs() << "extractArrayInfoFromAllocaOrGlobal called with BasePtr: "
+ << *BasePtr << "\n");
+
+ // Distinguish between simple array accesses and complex pointer arithmetic.
+ // Only apply array_info extraction to direct array accesses to avoid
+ // incorrect delinearization of complex pointer arithmetic patterns.
+ if (auto *GEP = dyn_cast<GetElementPtrInst>(BasePtr)) {
+ // Check if this is a simple array access pattern: GEP [N x T]* @array, 0,
+ // idx This represents direct indexing like array[i], which should use array
+ // dimensions.
+ if (GEP->getNumIndices() == 2) {
+ auto *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
+ if (FirstIdx && FirstIdx->isZero()) {
+ // Simple array access: extract dimensions from the underlying array
+ // type
+ Value *Source = GEP->getPointerOperand()->stripPointerCasts();
+ return extractArrayInfoFromAllocaOrGlobal(SE, Source, Sizes,
+ ElementSize);
+ }
+ }
+ // Complex GEPs like (&array[offset])[index] represent pointer arithmetic,
+ // not simple array indexing. These should be handled by parametric
+ // delinearization to preserve the linearized byte-offset semantics rather
+ // than treating them as multidimensional array accesses.
+ return false;
+ }
+
+ // Check if BasePtr is from an alloca instruction.
+ Type *ElementType = nullptr;
+ if (auto *AI = dyn_cast<AllocaInst>(BasePtr)) {
+ ElementType = AI->getAllocatedType();
+ LLVM_DEBUG(dbgs() << "Found alloca with type: " << *ElementType << "\n");
+ } else if (auto *GV = dyn_cast<GlobalVariable>(BasePtr)) {
+ ElementType = GV->getValueType();
+ LLVM_DEBUG(dbgs() << "Found global variable with type: " << *ElementType
+ << "\n");
+ } else {
+ LLVM_DEBUG(dbgs() << "No alloca or global found for base pointer\n");
+ return false;
+ }
+
+ // Extract dimensions from nested array types.
+ Type *I64Ty = Type::getInt64Ty(SE.getContext());
+
+ while (auto *ArrayTy = dyn_cast<ArrayType>(ElementType)) {
+ uint64_t Size = ArrayTy->getNumElements();
+ const SCEV *SizeSCEV = SE.getConstant(I64Ty, Size);
+ Sizes.push_back(SizeSCEV);
+ ElementType = ArrayTy->getElementType();
+ LLVM_DEBUG(dbgs() << " Found array dimension: " << Size << "\n");
+ }
+
+ if (Sizes.empty()) {
+ LLVM_DEBUG(dbgs() << "No array dimensions found in type\n");
+ return false;
+ }
+
+ // Add element size as the last element for computeAccessFunctions algorithm.
+ Sizes.push_back(ElementSize);
+
+ LLVM_DEBUG({
+ dbgs() << "Extracted array info from alloca/global for base pointer "
+ << *BasePtr << "\n";
+ dbgs() << "Dimensions: ";
+ for (const SCEV *Size : Sizes)
+ dbgs() << *Size << " ";
+ dbgs() << "\n";
+ });
+
+ return true;
+}
+
+bool llvm::delinearizeUsingArrayInfo(ScalarEvolution &SE, const SCEV *AccessFn,
+ SmallVectorImpl<const SCEV *> &Subscripts,
+ SmallVectorImpl<const SCEV *> &Sizes,
+ const SCEV *ElementSize) {
+ // Clear output vectors.
+ Subscripts.clear();
+ Sizes.clear();
+
+ const SCEVUnknown *BasePointer =
+ dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFn));
+ if (!BasePointer) {
+ LLVM_DEBUG(dbgs() << "no BasePointer for AccessFn: " << *AccessFn << "\n");
+ return false;
+ }
+
+ Value *BasePtr = BasePointer->getValue();
+
+ // Extract array dimensions from alloca or global declarations.
+ if (!extractArrayInfoFromAllocaOrGlobal(SE, BasePtr, Sizes, ElementSize))
+ return false;
+
+ // Get the full SCEV expression and subtract the base pointer to get
+ // offset-only expression.
+ const SCEV *Expr = SE.getMinusSCEV(AccessFn, BasePointer);
+
+ computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
+ if (Sizes.empty() || Subscripts.empty())
+ return false;
+
+ // Validate dimension consistency: subscripts should match array dimensions
+ // (Sizes includes element size as last element, so array dimensions =
+ // Sizes.size() - 1)
+ unsigned ArrayDims = Sizes.size() - 1;
+ if (Subscripts.size() != ArrayDims) {
+ LLVM_DEBUG(
+ dbgs() << "delinearizeUsingArrayInfo: Dimension mismatch - "
+ << Subscripts.size() << " subscripts for " << ArrayDims
+ << " array dimensions. Falling back to parametric method.\n");
+ return false;
+ }
+
+ return true;
+}
+
/// Splits the SCEV into two vectors of SCEVs representing the subscripts and
/// sizes of an array access. Returns the remainder of the delinearization that
/// is the offset start of the array. The SCEV->delinearize algorithm computes
@@ -469,21 +625,31 @@ void llvm::delinearize(ScalarEvolution &SE, const SCEV *Expr,
Subscripts.clear();
Sizes.clear();
- // First step: collect parametric terms.
+ // Try array_info extraction.
+ if (delinearizeUsingArrayInfo(SE, Expr, Subscripts, Sizes, ElementSize))
+ return;
+ LLVM_DEBUG(dbgs() << "delinearize falling back to parametric method\n");
+
+ // Fall back to parametric delinearization.
+ const SCEVUnknown *BasePointer =
+ dyn_cast<SCEVUnknown>(SE.getPointerBase(Expr));
+ if (BasePointer)
+ Expr = SE.getMinusSCEV(Expr, BasePointer);
+
SmallVector<const SCEV *, 4> Terms;
collectParametricTerms(SE, Expr, Terms);
if (Terms.empty())
return;
- // Second step: find subscript sizes.
+ // Find subscript sizes.
findArrayDimensions(SE, Terms, Sizes, ElementSize);
if (Sizes.empty())
return;
- // Third step: compute the access functions for each subscript.
- computeAccessFunctions(SE, Expr, Subscripts, Sizes);
+ // Compute the access functions for each subscript.
+ computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
}
static std::optional<APInt> tryIntoAPInt(const SCEV *S) {
@@ -492,6 +658,21 @@ static std::optional<APInt> tryIntoAPInt(const SCEV *S) {
return std::nullopt;
}
+/// Convert cached SCEV sizes to int sizes for compatibility.
+/// TODO: Remove this after we remove GEP delinearization.
+static void convertSCEVSizesToIntSizes(ArrayRef<const SCEV *> SCEVSizes,
+ SmallVectorImpl<int> &Sizes) {
+ for (const SCEV *S : SCEVSizes) {
+ if (auto *Const = dyn_cast<SCEVConstant>(S)) {
+ const APInt &APVal = Const->getAPInt();
+ if (APVal.isSignedIntN(32)) {
+ int intValue = APVal.getSExtValue();
+ Sizes.push_back(intValue);
+ }
+ }
+ }
+}
+
/// Collects the absolute values of constant steps for all induction variables.
/// Returns true if we can prove that all step recurrences are constants and \p
/// Expr is divisible by \p ElementSize. Each step recurrence is stored in \p
@@ -662,7 +843,7 @@ bool llvm::delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
Sizes.push_back(SE.getConstant(Expr->getType(), Size));
// Second step: compute the access functions for each subscript.
- computeAccessFunctions(SE, Expr, Subscripts, Sizes);
+ computeAccessFunctions(SE, Expr, Subscripts, Sizes, ElementSize);
return !Subscripts.empty();
}
@@ -731,7 +912,140 @@ bool llvm::tryDelinearizeFixedSizeImpl(
if (!SrcGEP)
return false;
- getIndexExpressionsFromGEP(*SE, SrcGEP, Subscripts, Sizes);
+ // When flag useGEPToDelinearize is false, delinearize only using array_info.
+ if (!useGEPToDelinearize) {
+ SmallVector<const SCEV *, 4> SCEVSizes;
+ const SCEV *ElementSize = SE->getElementSize(Inst);
+ if (!delinearizeUsingArrayInfo(*SE, AccessFn, Subscripts, SCEVSizes,
+ ElementSize))
+ return false;
+
+ // TODO: Remove the following code. Convert SCEV sizes to int sizes. This
+ // conversion is only needed as long as getIndexExpressionsFromGEP is still
+ // around. Remove this code and change the interface of
+ // tryDelinearizeFixedSizeImpl to take a SmallVectorImpl<const SCEV *>
+ // &Sizes.
+ convertSCEVSizesToIntSizes(SCEVSizes, Sizes);
+ return true;
+ }
+
+ // TODO: Remove all the following code once we are satisfied with array_info.
+ // Run both methods when useGEPToDelinearize is true: validation is enabled.
+
+ // Store results from both methods.
+ SmallVector<const SCEV *, 4> GEPSubscripts, ArrayInfoSubscripts;
+ SmallVector<int, 4> GEPSizes, ArrayInfoSizes;
+
+ // GEP-based delinearization.
+ bool GEPSuccess =
+ getIndexExpressionsFromGEP(*SE, SrcGEP, GEPSubscripts, GEPSizes);
+
+ // Array_info delinearization.
+ SmallVector<const SCEV *, 4> SCEVSizes;
+ const SCEV *ElementSize = SE->getElementSize(Inst);
+ bool ArrayInfoSuccess = delinearizeUsingArrayInfo(
+ *SE, AccessFn, ArrayInfoSubscripts, SCEVSizes, ElementSize);
+
+ // TODO: Remove the following code. Convert SCEV sizes to int sizes. This
+ // conversion is only needed as long as getIndexExpressionsFromGEP is still
+ // around. Remove this code and change the interface of
+ // tryDelinearizeFixedSizeImpl to take a SmallVectorImpl<const SCEV *> &Sizes.
+ if (ArrayInfoSuccess)
+ convertSCEVSizesToIntSizes(SCEVSizes, ArrayInfoSizes);
+
+ // Validate consistency between methods.
+ if (GEPSuccess && ArrayInfoSuccess) {
+ // If both methods succeeded, validate they produce the same results.
+ // Compare sizes arrays.
+ if (GEPSizes.size() + 2 != ArrayInfoSizes.size()) {
+ LLVM_DEBUG({
+ dbgs() << "WARN: Size arrays have different lengths!\n";
+ dbgs() << "GEP sizes count: " << GEPSizes.size() << "\n"
+ << "ArrayInfo sizes count: " << ArrayInfoSizes.size() << "\n";
+ });
+ }
+
+ for (size_t i = 0; i < GEPSizes.size(); ++i) {
+ if (GEPSizes[i] != ArrayInfoSizes[i + 1]) {
+ LLVM_DEBUG({
+ dbgs() << "WARN: Size arrays differ at index " << i << "!\n";
+ dbgs() << "GEP size[" << i << "]: " << GEPSizes[i] << "\n"
+ << "ArrayInfo size[" << i + 1 << "]: " << ArrayInfoSizes[i + 1]
+ << "\n";
+ });
+ }
+ }
+
+ // Compare subscripts arrays.
+ if (GEPSubscripts.size() != ArrayInfoSubscripts.size()) {
+ LLVM_DEBUG({
+ dbgs() << "WARN: Subscript arrays have different lengths!\n";
+ dbgs() << " GEP subscripts count: " << GEPSubscripts.size() << "\n"
+ << " ArrayInfo subscripts count: " << ArrayInfoSubscripts.size()
+ << "\n";
+
+ dbgs() << " GEP subscripts:\n";
+ for (size_t i = 0; i < GEPSubscripts.size(); ++i)
+ dbgs() << " subscript[" << i << "]: " << *GEPSubscripts[i] << "\n";
+
+ dbgs() << " ArrayInfo subscripts:\n";
+ for (size_t i = 0; i < ArrayInfoSubscripts.size(); ++i)
+ dbgs() << " subscript[" << i << "]: " << *ArrayInfoSubscripts[i]
+ << "\n";
+ });
+ }
+
+ for (size_t i = 0; i < GEPSubscripts.size(); ++i) {
+ const SCEV *GEPS = GEPSubscripts[i];
+ const SCEV *AIS = ArrayInfoSubscripts[i];
+ // FIXME: there's no good way to compare two scevs: don't abort, warn.
+ if (GEPS != AIS || !SE->getMinusSCEV(GEPS, AIS)->isZero()) {
+ LLVM_DEBUG({
+ dbgs() << "WARN: Subscript arrays differ at index " << i << "!\n";
+ dbgs() << " GEP subscript[" << i << "]: " << *GEPSubscripts[i]
+ << "\n"
+ << " ArrayInfo subscript[" << i
+ << "]: " << *ArrayInfoSubscripts[i] << "\n";
+ });
+ }
+ }
+
+ LLVM_DEBUG(dbgs() << "SUCCESS: Both delinearization methods produced "
+ "identical results\n");
+ } else if (GEPSuccess && !ArrayInfoSuccess) {
+ LLVM_DEBUG({
+ dbgs() << "WARNING: array_info failed and GEP analysis succeeded.\n";
+ dbgs() << " Instruction: " << *Inst << "\n";
+ dbgs() << " Using GEP analysis results despite array_info failure\n";
+ });
+ } else if (!GEPSuccess && ArrayInfoSuccess) {
+ LLVM_DEBUG({
+ dbgs() << "WARNING: GEP failed and array_info analysis succeeded.\n";
+ dbgs() << " Instruction: " << *Inst << "\n";
+ dbgs() << " Using array_info analysis results despite GEP failure\n";
+ });
+ } else if (!GEPSuccess && !ArrayInfoSuccess) {
+ LLVM_DEBUG({
+ dbgs() << "WARNING: both GEP and array_info analysis failed.\n";
+ dbgs() << " Instruction: " << *Inst << "\n";
+ });
+ }
+
+ // Choose which result to use.
+ // Prefer array_info when available.
+ if (ArrayInfoSuccess) {
+ Subscripts = std::move(ArrayInfoSubscripts);
+ Sizes = std::move(ArrayInfoSizes);
+ return true;
+ }
+
+ // Both failed.
+ if (!GEPSuccess)
+ return false;
+
+ // Return GEP-based delinearization.
+ Subscripts = std::move(GEPSubscripts);
+ Sizes = std::move(GEPSizes);
// Check that the two size arrays are non-empty and equal in length and
// value.
@@ -776,31 +1090,30 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
// Do not analyze memory accesses outside loops.
if (!L)
continue;
-
const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
- const SCEVUnknown *BasePointer =
- dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
- // Do not delinearize if we cannot find the base pointer.
- if (!BasePointer)
- break;
- AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
-
O << "\n";
O << "Inst:" << Inst << "\n";
O << "LinearAccessFunction: " << *AccessFn << "\n";
SmallVector<const SCEV *, 3> Subscripts, Sizes;
-
auto IsDelinearizationFailed = [&]() {
- return Subscripts.size() == 0 || Sizes.size() == 0 ||
- Subscripts.size() != Sizes.size();
+ return Subscripts.size() == 0 || Sizes.size() == 0;
};
- delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
+ const SCEV *ElementSize = SE->getElementSize(&Inst);
+ delinearize(*SE, AccessFn, Subscripts, Sizes, ElementSize);
if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
Subscripts.clear();
Sizes.clear();
+
+ const SCEVUnknown *BasePointer =
+ dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
+ // Fail to delinearize if we cannot find the base pointer.
+ if (!BasePointer)
+ continue;
+ AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
+
delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
SE->getElementSize(&Inst));
}
@@ -810,7 +1123,6 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
continue;
}
- O << "Base offset: " << *BasePointer << "\n";
O << "ArrayDecl";
int NumSubscripts = Subscripts.size();
int NumSizes = Sizes.size();
diff --git a/llvm/lib/Analysis/LoopCacheAnalysis.cpp b/llvm/lib/Analysis/LoopCacheAnalysis.cpp
index 050c32707596a..13d2e56f27410 100644
--- a/llvm/lib/Analysis/LoopCacheAnalysis.cpp
+++ b/llvm/lib/Analysis/LoopCacheAnalysis.cpp
@@ -405,9 +405,6 @@ bool IndexedReference::delinearize(const LoopInfo &LI) {
<< "', AccessFn: " << *AccessFn << "\n");
}
- AccessFn = SE.getMinusSCEV(AccessFn, BasePointer);
-
- // Try to delinearize parametric-size arrays.
if (!IsFixedSize) {
LLVM_DEBUG(dbgs().indent(2) << "In Loop '" << L->getName()
<< "', AccessFn: " << *AccessFn << "\n");
@@ -415,6 +412,8 @@ bool IndexedReference::delinearize(const LoopInfo &LI) {
SE.getElementSize(&StoreOrLoadInst));
}
+ AccessFn = SE.getMinusSCEV(AccessFn, BasePointer);
+
if (Subscripts.empty() || Sizes.empty() ||
Subscripts.size() != Sizes.size()) {
// Attempt to determine whether we have a single dimensional array access.
diff --git a/llvm/test/Analysis/Delinearization/a.ll b/llvm/test/Analysis/Delinearization/a.ll
index 7de0d37208fa0..7b8e3803add88 100644
--- a/llvm/test/Analysis/Delinearization/a.ll
+++ b/llvm/test/Analysis/Delinearization/a.ll
@@ -11,8 +11,7 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr nocapture %A) #0 {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store i32 1, ptr %arrayidx11.us.us, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
; CHECK-NEXT: ArrayDecl[%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>]
;
diff --git a/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll b/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll
new file mode 100644
index 0000000000000..5768334e86e2d
--- /dev/null
+++ b/llvm/test/Analysis/Delinearization/alloca-global-arrays.ll
@@ -0,0 +1,208 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
+; RUN: opt < %s -passes="print<delinearization>" -disable-output 2>&1 | FileCheck %s
+
+define void @test_alloca_2d() {
+; CHECK-LABEL: 'test_alloca_2d'
+; CHECK-NEXT: Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {%arr,+,8}<nw><%for.cond>
+; CHECK-NEXT: ArrayDecl[2500] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.cond>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store double %mul, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {%arr,+,8}<nw><%for.cond>
+; CHECK-NEXT: ArrayDecl[2500] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.cond>]
+;
+entry:
+ %arr = alloca [2500 x double], align 8
+ br label %for.cond
+
+for.cond: ; preds = %for.inc, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %inc, %for.inc ]
+ %cmp = icmp ult i64 %i.0, 2500
+ br i1 %cmp, label %for.body, label %for.end
+
+for.body: ; preds = %for.cond
+ %arrayidx = getelementptr inbounds [2500 x double], ptr %arr, i64 0, i64 %i.0
+ %0 = load double, ptr %arrayidx, align 8
+ %mul = fmul double %0, 2.000000e+00
+ store double %mul, ptr %arrayidx, align 8
+ br label %for.inc
+
+for.inc: ; preds = %for.body
+ %inc = add nuw nsw i64 %i.0, 1
+ br label %for.cond
+
+for.end: ; preds = %for.cond
+ ret void
+}
+
+define void @test_alloca_3d() {
+; CHECK-LABEL: 'test_alloca_3d'
+; CHECK-NEXT: Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%arr,+,4800}<nw><%for.i>,+,240}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT: ArrayDecl[10][20][30] 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 %mul, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%arr,+,4800}<nw><%for.i>,+,240}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT: ArrayDecl[10][20][30] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
+entry:
+ %arr = alloca [10 x [20 x [30 x double]]], align 8
+ br label %for.i
+
+for.i: ; preds = %for.i.inc, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+ %i.cmp = icmp ult i64 %i.0, 10
+ br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j: ; preds = %for.j.inc, %for.i
+ %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+ %j.cmp = icmp ult i64 %j.0, 20
+ br i1 %j.cmp, label %for.k, label %for.j.end
+
+for.k: ; preds = %for.k.inc, %for.j
+ %k.0 = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
+ %k.cmp = icmp ult i64 %k.0, 30
+ br i1 %k.cmp, label %for.body, label %for.k.end
+
+for.body: ; preds = %for.k
+ %arrayidx = getelementptr inbounds [10 x [20 x [30 x double]]], ptr %arr, i64 0, i64 %i.0, i64 %j.0, i64 %k.0
+ %0 = load double, ptr %arrayidx, align 8
+ %mul = fmul double %0, 2.000000e+00
+ store double %mul, ptr %arrayidx, align 8
+ br label %for.k.inc
+
+for.k.inc: ; preds = %for.body
+ %k.inc = add nuw nsw i64 %k.0, 1
+ br label %for.k
+
+for.k.end: ; preds = %for.k
+ br label %for.j.inc
+
+for.j.inc: ; preds = %for.k.end
+ %j.inc = add nuw nsw i64 %j.0, 1
+ br label %for.j
+
+for.j.end: ; preds = %for.j
+ br label %for.i.inc
+
+for.i.inc: ; preds = %for.j.end
+ %i.inc = add nuw nsw i64 %i.0, 1
+ br label %for.i
+
+for.i.end: ; preds = %for.i
+ ret void
+}
+
+; Global 3D array similar to what flang generates.
+ at global_3d_array = local_unnamed_addr global [54 x [54 x [54 x double]]] zeroinitializer
+
+define void @test_global_3d() {
+; CHECK-LABEL: 'test_global_3d'
+; CHECK-NEXT: Inst: %0 = load double, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}@global_3d_array,+,23328}<nw><%for.i>,+,432}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT: ArrayDecl[54][54][54] 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 %mul, ptr %arrayidx, align 8
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}@global_3d_array,+,23328}<nw><%for.i>,+,432}<nw><%for.j>,+,8}<nw><%for.k>
+; CHECK-NEXT: ArrayDecl[54][54][54] with elements of 8 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.k>]
+;
+entry:
+ br label %for.i
+
+for.i: ; preds = %for.i.inc, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+ %i.cmp = icmp ult i64 %i.0, 54
+ br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j: ; preds = %for.j.inc, %for.i
+ %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+ %j.cmp = icmp ult i64 %j.0, 54
+ br i1 %j.cmp, label %for.k, label %for.j.end
+
+for.k: ; preds = %for.k.inc, %for.j
+ %k.0 = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ]
+ %k.cmp = icmp ult i64 %k.0, 54
+ br i1 %k.cmp, label %for.body, label %for.k.end
+
+for.body: ; preds = %for.k
+ %arrayidx = getelementptr inbounds [54 x [54 x [54 x double]]], ptr @global_3d_array, i64 0, i64 %i.0, i64 %j.0, i64 %k.0
+ %0 = load double, ptr %arrayidx, align 8
+ %mul = fmul double %0, 3.000000e+00
+ store double %mul, ptr %arrayidx, align 8
+ br label %for.k.inc
+
+for.k.inc: ; preds = %for.body
+ %k.inc = add nuw nsw i64 %k.0, 1
+ br label %for.k
+
+for.k.end: ; preds = %for.k
+ br label %for.j.inc
+
+for.j.inc: ; preds = %for.k.end
+ %j.inc = add nuw nsw i64 %j.0, 1
+ br label %for.j
+
+for.j.end: ; preds = %for.j
+ br label %for.i.inc
+
+for.i.inc: ; preds = %for.j.end
+ %i.inc = add nuw nsw i64 %i.0, 1
+ br label %for.i
+
+for.i.end: ; preds = %for.i
+ ret void
+}
+
+define void @test_0() {
+; CHECK-LABEL: 'test_0'
+; CHECK-NEXT: Inst: %0 = load i32, ptr %arrayidx, align 4
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%matrix,+,200}<nw><%for.i>,+,4}<nw><%for.j>
+; CHECK-NEXT: ArrayDecl[100][50] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+; CHECK-EMPTY:
+; CHECK-NEXT: Inst: store i32 %add, ptr %arrayidx, align 4
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%matrix,+,200}<nw><%for.i>,+,4}<nw><%for.j>
+; CHECK-NEXT: ArrayDecl[100][50] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+;
+entry:
+ %matrix = alloca [100 x [50 x i32]], align 4
+ br label %for.i
+
+for.i: ; preds = %for.i.inc, %entry
+ %i.0 = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
+ %i.cmp = icmp ult i64 %i.0, 100
+ br i1 %i.cmp, label %for.j, label %for.i.end
+
+for.j: ; preds = %for.j.inc, %for.i
+ %j.0 = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ]
+ %j.cmp = icmp ult i64 %j.0, 50
+ br i1 %j.cmp, label %for.body, label %for.j.end
+
+for.body: ; preds = %for.j
+ %arrayidx = getelementptr inbounds [100 x [50 x i32]], ptr %matrix, i64 0, i64 %i.0, i64 %j.0
+ %0 = load i32, ptr %arrayidx, align 4
+ %add = add nsw i32 %0, 1
+ store i32 %add, ptr %arrayidx, align 4
+ br label %for.j.inc
+
+for.j.inc: ; preds = %for.body
+ %j.inc = add nuw nsw i64 %j.0, 1
+ br label %for.j
+
+for.j.end: ; preds = %for.j
+ br label %for.i.inc
+
+for.i.inc: ; preds = %for.j.end
+ %i.inc = add nuw nsw i64 %i.0, 1
+ br label %for.i
+
+for.i.end: ; preds = %for.i
+ ret void
+}
diff --git a/llvm/test/Analysis/Delinearization/array_info_delinearization.ll b/llvm/test/Analysis/Delinearization/array_info_delinearization.ll
new file mode 100644
index 0000000000000..7657f5153688e
--- /dev/null
+++ b/llvm/test/Analysis/Delinearization/array_info_delinearization.ll
@@ -0,0 +1,48 @@
+; 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"
+
+ at test_array_10x20 = global [10 x [20 x i32]] zeroinitializer
+
+; Function that accesses a 2D array with dimensions [10][20].
+define void @test_2d_array(i64 %i, i64 %j) {
+; CHECK-LABEL: 'test_2d_array'
+; CHECK-NEXT: Inst: %val = load i32, ptr %ptr, align 4
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}@test_array_10x20,+,80}<nw><%for.i>,+,4}<%for.j>
+; CHECK-NEXT: ArrayDecl[10][20] with elements of 4 bytes.
+; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
+;
+entry:
+ %arr = getelementptr inbounds [10 x [20 x i32]], ptr @test_array_10x20, i32 0, i32 0
+ br label %for.i
+
+for.i: ; preds = %for.j.end, %entry
+ %i.cur = phi i64 [ 0, %entry ], [ %i.next, %for.j.end ]
+ %i.cmp = icmp slt i64 %i.cur, 10
+ br i1 %i.cmp, label %for.j, label %exit
+
+for.j: ; preds = %for.j, %for.i
+ %j.cur = phi i64 [ 0, %for.i ], [ %j.next, %for.j ]
+
+ ; Compute linear access: arr[i][j] = arr + i*20 + j
+ %i.mul = mul i64 %i.cur, 20
+ %idx = add i64 %i.mul, %j.cur
+ %ptr = getelementptr inbounds i32, ptr %arr, i64 %idx
+
+ ; Load from the computed address
+ %val = load i32, ptr %ptr, align 4
+
+ %j.next = add i64 %j.cur, 1
+ %j.cmp = icmp slt i64 %j.next, 20
+ br i1 %j.cmp, label %for.j, label %for.j.end
+
+for.j.end: ; preds = %for.j
+ %i.next = add i64 %i.cur, 1
+ br label %for.i
+
+exit: ; preds = %for.i
+ ret void
+}
+
+attributes #0 = { nocallback nofree nosync nounwind willreturn inaccessiblememonly }
diff --git a/llvm/test/Analysis/Delinearization/byte_offset.ll b/llvm/test/Analysis/Delinearization/byte_offset.ll
index 675e3f36f39f7..15af2e9864aa8 100644
--- a/llvm/test/Analysis/Delinearization/byte_offset.ll
+++ b/llvm/test/Analysis/Delinearization/byte_offset.ll
@@ -13,7 +13,7 @@
define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store float 0.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: LinearAccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
+; CHECK-NEXT: LinearAccessFunction: ({%A,+,%i2}<%outer.loop> + %unknown)
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
index 30ac1b29a6ae3..3a7eabfef0cda 100644
--- a/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
+++ b/llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll
@@ -7,14 +7,12 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @mat_mul(ptr %C, ptr %A, ptr %B, i64 %N) #0 !kernel_arg_addr_space !2 !kernel_arg_access_qual !3 !kernel_arg_type !4 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
; CHECK-LABEL: 'mat_mul'
; CHECK-NEXT: Inst: %tmp = load float, ptr %arrayidx, align 4
-; CHECK-NEXT: LinearAccessFunction: {(4 * %N * %call),+,4}<%for.inc>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {((4 * %N * %call) + %A),+,4}<%for.inc>
; CHECK-NEXT: ArrayDecl[%N] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %tmp5 = load float, ptr %arrayidx4, align 4
-; CHECK-NEXT: LinearAccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
-; CHECK-NEXT: Base offset: %B
+; CHECK-NEXT: LinearAccessFunction: {((4 * %call1) + %B),+,(4 * %N)}<%for.inc>
; CHECK-NEXT: ArrayDecl[%N] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
;
diff --git a/llvm/test/Analysis/Delinearization/divide_by_one.ll b/llvm/test/Analysis/Delinearization/divide_by_one.ll
index 907b254097222..ea3a17dadba17 100644
--- a/llvm/test/Analysis/Delinearization/divide_by_one.ll
+++ b/llvm/test/Analysis/Delinearization/divide_by_one.ll
@@ -14,14 +14,12 @@ target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
define void @test(ptr nocapture %dst, i32 %stride, i32 %bs) {
; CHECK-LABEL: 'test'
; CHECK-NEXT: Inst: %0 = load i8, ptr %arrayidx, align 1
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK-NEXT: Base offset: %dst
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride) + %dst),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
; CHECK-NEXT: ArrayDecl[%stride] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i8 %0, ptr %arrayidx7, align 1
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(%stride * %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nsw><%for.body3>
-; CHECK-NEXT: Base offset: %dst
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}((%stride * %bs) + %dst),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
; CHECK-NEXT: ArrayDecl[%stride] with elements of 1 bytes.
; CHECK-NEXT: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
;
diff --git a/llvm/test/Analysis/Delinearization/fixed_size_array.ll b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
index 87ef40f07a501..1e09a57ca62e9 100644
--- a/llvm/test/Analysis/Delinearization/fixed_size_array.ll
+++ b/llvm/test/Analysis/Delinearization/fixed_size_array.ll
@@ -11,8 +11,7 @@
define void @a_i_j_k(ptr %a) {
; CHECK-LABEL: 'a_i_j_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -59,8 +58,7 @@ exit:
define void @a_i_nj_k(ptr %a) {
; CHECK-LABEL: 'a_i_nj_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}896,+,1024}<nuw><nsw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(896 + %a),+,1024}<nw><%for.i.header>,+,-128}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -114,14 +112,12 @@ exit:
define void @a_ijk_b_i2jk(ptr %a, ptr %b) {
; CHECK-LABEL: 'a_ijk_b_i2jk'
; CHECK-NEXT: Inst: store i32 1, ptr %a.idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %b
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%b,+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -176,8 +172,7 @@ exit:
define void @a_i_2j1_k(ptr %a) {
; CHECK-LABEL: 'a_i_2j1_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}128,+,1024}<nuw><nsw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(128 + %a),+,1024}<nw><%for.i.header>,+,256}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -229,7 +224,7 @@ exit:
define void @a_i_3j_k(ptr %a) {
; CHECK-LABEL: 'a_i_3j_k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,384}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
@@ -280,8 +275,7 @@ exit:
define void @a_i_j_3k(ptr %a) {
; CHECK-LABEL: 'a_i_j_3k'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1024}<nuw><nsw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,12}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -331,7 +325,7 @@ exit:
define void @a_i_j2k_i(ptr %a) {
; CHECK-LABEL: 'a_i_j2k_i'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1028}<%for.i.header>,+,256}<nw><%for.j.header>,+,128}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
@@ -382,8 +376,7 @@ exit:
define void @a_i_i_jk(ptr %a) {
; CHECK-LABEL: 'a_i_i_jk'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
-; CHECK-NEXT: Base offset: %a
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,1152}<%for.i.header>,+,4}<nw><%for.j.header>,+,4}<nw><%for.k>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -432,8 +425,7 @@ exit:
define void @a_i_jk_l(ptr %a) {
; CHECK-LABEL: 'a_i_jk_l'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{\{}}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: LinearAccessFunction: {{\{\{\{\{}}%a,+,1024}<nw><%for.i.header>,+,128}<nw><%for.j.header>,+,128}<nw><%for.k.header>,+,4}<nw><%for.l>
; CHECK-NEXT: ArrayDecl[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>]
;
@@ -492,7 +484,7 @@ exit:
define void @non_divisible_by_element_size(ptr %a) {
; CHECK-LABEL: 'non_divisible_by_element_size'
; CHECK-NEXT: Inst: store i32 1, ptr %idx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,256}<nuw><nsw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%a,+,256}<nw><%for.i.header>,+,32}<nw><%for.j.header>,+,1}<nw><%for.k>
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
index 2a7881e71c021..0b5aad73fbad5 100644
--- a/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
+++ b/llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll
@@ -29,115 +29,115 @@
define i32 @fn2() {
; CHECK-LABEL: 'fn2'
; CHECK-NEXT: Inst: store i32 %storemerge.i, ptr @a, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @a
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %9 = load i8, ptr %arrayidx.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %10 = load i8, ptr %arrayidx.1.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(1 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.1.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.1.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %11 = load i8, ptr %arrayidx.2.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(2 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.2.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.2.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %12 = load i8, ptr %arrayidx.3.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(3 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.3.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.3.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %13 = load i8, ptr %arrayidx.4.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(4 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.4.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.4.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %14 = load i8, ptr %arrayidx.5.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(5 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.5.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.5.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %15 = load i8, ptr %arrayidx.6.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(6 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.6.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.6.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %16 = load i8, ptr %arrayidx.7.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(7 + (%1 * %2)),+,1}<nw><%for.cond2thread-pre-split.i> + %.pr.i),+,8}<nw><%for.body4.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.7.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.7.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %21 = load i8, ptr %arrayidx.ur.i, align 1
-; CHECK-NEXT: LinearAccessFunction: (sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64)
+; CHECK-NEXT: LinearAccessFunction: ((sext i32 {({(%1 * %2),+,1}<nw><%for.cond2thread-pre-split.i> + %.ph),+,1}<nw><%for.body4.ur.i> to i64) + %3)
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %conv.ur.i, ptr @c, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @c
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store i32 %inc.ur.i, ptr @b, align 4
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: @b
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/himeno_1.ll b/llvm/test/Analysis/Delinearization/himeno_1.ll
index deb092c14a937..c8f105a786821 100644
--- a/llvm/test/Analysis/Delinearization/himeno_1.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_1.ll
@@ -32,8 +32,7 @@
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
; CHECK-LABEL: 'jacobi'
; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>) + %a.base),+,(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: ArrayDecl[(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>]
;
diff --git a/llvm/test/Analysis/Delinearization/himeno_2.ll b/llvm/test/Analysis/Delinearization/himeno_2.ll
index d1b0ac7883e3d..c41d1bf7bae0e 100644
--- a/llvm/test/Analysis/Delinearization/himeno_2.ll
+++ b/llvm/test/Analysis/Delinearization/himeno_2.ll
@@ -32,8 +32,7 @@
define void @jacobi(i32 %nn, ptr nocapture %a, ptr nocapture %p) nounwind uwtable {
; CHECK-LABEL: 'jacobi'
; CHECK-NEXT: Inst: store float 1.000000e+00, ptr %arrayidx, align 4
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))<nsw>) + %a.base),+,(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: ArrayDecl[(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>]
;
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 253b55ee8f62f..f76e607f4b1f6 100644
--- a/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
+++ b/llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll
@@ -12,8 +12,7 @@
define void @foo(i64 %n, i64 %m, i64 %b, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}(8 * %m * %b),+,(16 * %m)}<%for.i>,+,16}<%for.j>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}((8 * %m * %b) + %A),+,(16 * %m)}<%for.i>,+,16}<%for.j>
; CHECK-NEXT: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{%b,+,2}<nsw><%for.i>][{0,+,2}<nuw><%for.j>]
;
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 525e4b45cc055..7efbf49918797 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
@@ -12,8 +12,7 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}(56 + (8 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
; CHECK-NEXT: ArrayDecl[%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>]
;
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 1e28665164757..177639f8b5826 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
@@ -12,8 +12,7 @@
define void @foo(i64 %n, i64 %m, i64 %o, i64 %p, ptr nocapture %A) nounwind uwtable {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}(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-NEXT: ArrayDecl[%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>]
;
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 1dcb381640e94..b629996d4c93d 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
@@ -12,8 +12,7 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A, i64 %p, i64 %q, i64 %r) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}(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: LinearAccessFunction: {{\{\{\{}}((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
; CHECK-NEXT: ArrayDecl[%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>]
;
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
index 6079c0aec911d..6bad7834d1a12 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll
@@ -12,14 +12,12 @@
define void @foo(i64 %n, i64 %m, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: %val = load double, ptr %arrayidx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
; CHECK-NEXT: ArrayDecl[%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: LinearAccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
; CHECK-NEXT: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
;
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 8d6108fc6d662..df68e10680c04 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll
@@ -18,7 +18,7 @@
define void @foo(i64 %a, i64 %b) nounwind uwtable {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx10.us.us, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%vla.us,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us>
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
index 4efbb68ca1850..6fe3ce4646119 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll
@@ -12,8 +12,7 @@
define void @foo(i64 %n, i64 %m, i64 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}0,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k>
; CHECK-NEXT: ArrayDecl[%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>]
;
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 5bb1b46deccc0..52a0cc9ff1b8c 100644
--- a/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll
@@ -14,8 +14,7 @@ target triple = "x86_64-unknown-linux-gnu"
define void @foo(i32 %n, i32 %m, i32 %o, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %idx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{\{}}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: LinearAccessFunction: {{\{\{\{}}%A,+,(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: ArrayDecl[(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>]
;
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 f64e1680f6b94..646551f0c6162 100644
--- a/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
+++ b/llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll
@@ -15,14 +15,12 @@ target triple = "x86_64-unknown-linux-gnu"
define void @foo(i64 %n, i64 %m, ptr %A) {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,(8 * %m)}<%for.i>,+,8}<%for.j>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,(8 * %m)}<%for.i>,+,8}<%for.j>
; CHECK-NEXT: ArrayDecl[%m] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.i>][{0,+,1}<nuw><nsw><%for.j>]
; CHECK-EMPTY:
; CHECK-NEXT: Inst: store double 1.000000e+00, ptr %arrayidx1, align 8
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,8}<%for.i>,+,(8 * %n)}<%for.j>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,8}<%for.i>,+,(8 * %n)}<%for.j>
; CHECK-NEXT: ArrayDecl[%n] with elements of 8 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.j>][{0,+,1}<nuw><nsw><%for.i>]
;
diff --git a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
index 952338ea94497..820da9696e022 100644
--- a/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
+++ b/llvm/test/Analysis/Delinearization/parameter_addrec_product.ll
@@ -11,18 +11,16 @@ 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: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: %p
; CHECK-NEXT: failed to delinearize
; CHECK-EMPTY:
; CHECK-NEXT: Inst: %tmp11 = load float, ptr %tmp10, align 4
-; CHECK-NEXT: LinearAccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: ((4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw> + %A)
; CHECK-NEXT: ArrayDecl[%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: LinearAccessFunction: (4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: ((4 * (({0,+,1}<nuw><nsw><%bb2> * %pval)<nsw> + {0,+,1}<nuw><nsw><%bb4>)<nsw>)<nsw> + %A)
; CHECK-NEXT: ArrayDecl[%pval] with elements of 4 bytes.
; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%bb2>][{0,+,1}<nuw><nsw><%bb4>]
;
diff --git a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
index 9df1c85ee6e8d..f03253d272799 100644
--- a/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
+++ b/llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll
@@ -9,14 +9,12 @@
define void @foo(i32 %m, i32 %n, ptr nocapture %A) #0 {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Inst: %4 = load i8, ptr %arrayidx.us, align 1
-; CHECK-NEXT: LinearAccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,(sext i32 %n to i64)}<nw><%for.body3.lr.ph.us>,+,1}<nw><%for.body3.us>
; CHECK-NEXT: ArrayDecl[(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: LinearAccessFunction: {{\{\{}}0,+,(sext i32 %n to i64)}<nsw><%for.body3.lr.ph.us>,+,1}<nsw><%for.body3.us>
-; CHECK-NEXT: Base offset: %A
+; CHECK-NEXT: LinearAccessFunction: {{\{\{}}%A,+,(sext i32 %n to i64)}<nw><%for.body3.lr.ph.us>,+,1}<nw><%for.body3.us>
; CHECK-NEXT: ArrayDecl[(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>]
;
diff --git a/llvm/test/Analysis/Delinearization/type_mismatch.ll b/llvm/test/Analysis/Delinearization/type_mismatch.ll
index d13c22362a4fb..f67addf3089b3 100644
--- a/llvm/test/Analysis/Delinearization/type_mismatch.ll
+++ b/llvm/test/Analysis/Delinearization/type_mismatch.ll
@@ -12,7 +12,7 @@ target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"
define fastcc void @test(i1 %arg, ptr %x) {
; CHECK-LABEL: 'test'
; CHECK-NEXT: Inst: store i8 42, ptr %arrayidx.phi, align 1
-; CHECK-NEXT: LinearAccessFunction: 0
+; CHECK-NEXT: LinearAccessFunction: %arrayidx.phi
; CHECK-NEXT: failed to delinearize
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/Coupled.ll b/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
index 1d4513429a83c..230ad416aed40 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Coupled.ll
@@ -5,12 +5,13 @@
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-apple-macosx10.6.0"
+ at A.global = global [100 x [100 x i32]] zeroinitializer
;; for (long int i = 0; i < 50; i++) {
;; A[i][i] = i;
;; *B++ = A[i + 10][i + 9];
-define void @couple0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple0(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'couple0'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx1, align 4 --> Dst: store i32 %conv, ptr %arrayidx1, align 4
; CHECK-NEXT: da analyze - none!
@@ -26,6 +27,7 @@ define void @couple0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.body
@@ -495,16 +497,15 @@ for.end: ; preds = %for.body
;; for (long int i = 0; i <= 15; i++) {
-;; A[3*i - 18][18 - i] = i;
+;; A[3*i + 18][18 - i] = i;
;; *B++ = A[i][i];
-define void @couple11(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple11(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'couple11'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
-; CHECK-NEXT: da analyze - flow [0|<] splitable!
-; CHECK-NEXT: da analyze - split level = 1, iteration = 9!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
@@ -515,6 +516,7 @@ define void @couple11(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.body
@@ -523,7 +525,7 @@ for.body: ; preds = %entry, %for.body
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 18, %i.02
%mul = mul nsw i64 %i.02, 3
- %sub1 = add nsw i64 %mul, -18
+ %sub1 = add nsw i64 %mul, 18
%arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
store i32 %conv, ptr %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -540,16 +542,15 @@ for.end: ; preds = %for.body
;; for (long int i = 0; i <= 12; i++) {
-;; A[3*i - 18][22 - i] = i;
+;; A[3*i + 18][22 - i] = i;
;; *B++ = A[i][i];
-define void @couple12(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @couple12(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'couple12'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %conv, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
-; CHECK-NEXT: da analyze - flow [<] splitable!
-; CHECK-NEXT: da analyze - split level = 1, iteration = 11!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
@@ -560,6 +561,7 @@ define void @couple12(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x i32]], ptr @A.global, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.body
@@ -568,7 +570,7 @@ for.body: ; preds = %entry, %for.body
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
- %sub1 = add nsw i64 %mul, -18
+ %sub1 = add nsw i64 %mul, 18
%arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
store i32 %conv, ptr %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -585,7 +587,7 @@ for.end: ; preds = %for.body
;; for (long int i = 0; i < 12; i++) {
-;; A[3*i - 18][22 - i] = i;
+;; A[3*i + 18][22 - i] = i;
;; *B++ = A[i][i];
define void @couple13(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -612,7 +614,7 @@ for.body: ; preds = %entry, %for.body
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
- %sub1 = add nsw i64 %mul, -18
+ %sub1 = add nsw i64 %mul, 18
%arrayidx2 = getelementptr inbounds [100 x i32], ptr %A, i64 %sub1, i64 %sub
store i32 %conv, ptr %arrayidx2, align 4
%arrayidx4 = getelementptr inbounds [100 x i32], ptr %A, i64 %i.02, i64 %i.02
@@ -628,7 +630,7 @@ for.end: ; preds = %for.body
}
;; for (long int i = 0; i < 100; i++) {
-;; A[3*i - 18][18 - i][i] = i;
+;; A[3*i + 18][18 - i][i] = i;
;; *B++ = A[i][i][i];
define void @couple14(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -636,7 +638,7 @@ define void @couple14(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %conv, ptr %arrayidx3, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - flow [0|<]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
@@ -655,7 +657,7 @@ for.body: ; preds = %entry, %for.body
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 18, %i.02
%mul = mul nsw i64 %i.02, 3
- %sub1 = add nsw i64 %mul, -18
+ %sub1 = add nsw i64 %mul, 18
%arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
store i32 %conv, ptr %arrayidx3, align 4
%arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
@@ -672,7 +674,7 @@ for.end: ; preds = %for.body
;; for (long int i = 0; i < 100; i++) {
-;; A[3*i - 18][22 - i][i] = i;
+;; A[3*i + 18][22 - i][i] = i;
;; *B++ = A[i][i][i];
define void @couple15(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
@@ -699,7 +701,7 @@ for.body: ; preds = %entry, %for.body
%conv = trunc i64 %i.02 to i32
%sub = sub nsw i64 22, %i.02
%mul = mul nsw i64 %i.02, 3
- %sub1 = add nsw i64 %mul, -18
+ %sub1 = add nsw i64 %mul, 18
%arrayidx3 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %sub1, i64 %sub, i64 %i.02
store i32 %conv, ptr %arrayidx3, align 4
%arrayidx6 = getelementptr inbounds [100 x [100 x i32]], ptr %A, i64 %i.02, i64 %i.02, i64 %i.02
diff --git a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
index 8f94a455d3724..03193cb5359e2 100644
--- a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
@@ -139,7 +139,7 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3,
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < m; j++)
-;; for (int k = 0; k < o; k++)
+;; for (int k = 1; k < o; k++)
;; = A[i*m*o + j*o + k]
;; A[i*m*o + j*o + k - 1] =
define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
@@ -147,9 +147,9 @@ define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
-; CHECK-NEXT: da analyze - anti [* * *|<]!
+; CHECK-NEXT: da analyze - consistent anti [0 0 1]!
; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
-; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: da analyze - none!
;
entry:
%cmp49 = icmp sgt i32 %n, 0
@@ -178,7 +178,7 @@ for.body8.lr.ph: ; preds = %for.cond5.preheader
br label %for.body8
for.body8: ; preds = %for.body8, %for.body8.lr.ph
- %k.046 = phi i32 [ 0, %for.body8.lr.ph ], [ %inc, %for.body8 ]
+ %k.046 = phi i32 [ 1, %for.body8.lr.ph ], [ %inc, %for.body8 ]
%add11 = add nsw i32 %k.046, %add
%arrayidx = getelementptr inbounds i32, ptr %A, i32 %add11
%0 = load i32, ptr %arrayidx, align 4
@@ -275,7 +275,7 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3,
;; for (int j = 0; j < m; j++)
;; for (int k = 0; k < o; k++)
;; = A[i*m*o + j*o + k]
-;; A[i*m*o + j*o + k - o] =
+;; A[i*m*o + j*o + k + o] =
define void @t5(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-LABEL: 't5'
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4
@@ -317,7 +317,7 @@ for.body8: ; preds = %for.body8, %for.bod
%arrayidx = getelementptr inbounds i32, ptr %A, i32 %add11
%0 = load i32, ptr %arrayidx, align 4
%add12 = add nsw i32 %0, 1
- %add111 = sub nsw i32 %add11, %o
+ %add111 = add nsw i32 %add11, %o
%arrayidx2 = getelementptr inbounds i32, ptr %A, i32 %add111
store i32 %add12, ptr %arrayidx2, align 4
%inc = add nuw nsw i32 %k.046, 1
diff --git a/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll b/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
index bf2268b746a6f..5599c318534d8 100644
--- a/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/FlipFlopBaseAddress.ll
@@ -2,6 +2,8 @@
; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
; RUN: | FileCheck %s
+ at test_array_100x42x42 = global [100 x [42 x [42 x i32]]] zeroinitializer
+
; Check that dependence analysis correctly handles flip-flop of base addresses.
; Bug 41488 - https://github.com/llvm/llvm-project/issues/41488
@@ -219,12 +221,13 @@ exit:
; Same as the above case, there are loop-carried dependencies between the
; store.
-define void @non_invariant_baseptr_with_identical_obj2(ptr %A) {
+define void @non_invariant_baseptr_with_identical_obj2() {
; CHECK-LABEL: 'non_invariant_baseptr_with_identical_obj2'
; CHECK-NEXT: Src: store i32 1, ptr %idx, align 4 --> Dst: store i32 1, ptr %idx, align 4
; CHECK-NEXT: da analyze - confused!
;
entry:
+ %A = getelementptr inbounds [100 x [42 x [42 x i32]]], ptr @test_array_100x42x42, i32 0, i32 0
br label %loop.i.header
loop.i.header:
diff --git a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
index 1d8c51e475ae8..2707bee1567af 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
@@ -2,6 +2,8 @@
; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
; RUN: | FileCheck %s
+ at test_array_40x40 = global [40 x [40 x float]] zeroinitializer
+
; Test for a bug, which caused an assert when an invalid
; SCEVAddRecExpr is created in addToCoefficient.
@@ -16,7 +18,7 @@
; return res;
; }
-define float @foo(float %g, ptr %rr) nounwind {
+define float @foo(float %g) nounwind {
; CHECK-LABEL: 'foo'
; CHECK-NEXT: Src: %0 = load float, ptr %arrayidx4, align 4 --> Dst: %0 = load float, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - consistent input [S 0]!
@@ -26,6 +28,7 @@ define float @foo(float %g, ptr %rr) nounwind {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %rr = getelementptr inbounds [40 x [40 x float]], ptr @test_array_40x40, i32 0, i32 0
br label %for.cond1.preheader
for.cond1.preheader:
diff --git a/llvm/test/Analysis/DependenceAnalysis/PR51512.ll b/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
index 9bee38c6c00ef..2d1638d145ffe 100644
--- a/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/PR51512.ll
@@ -10,7 +10,7 @@ define void @foo() {
; CHECK-NEXT: Src: store i32 42, ptr %getelementptr, align 1 --> Dst: store i32 42, ptr %getelementptr, align 1
; CHECK-NEXT: da analyze - consistent output [0 S]!
; CHECK-NEXT: Src: store i32 42, ptr %getelementptr, align 1 --> Dst: store i32 0, ptr %getelementptr5, align 1
-; CHECK-NEXT: da analyze - output [0 *|<]!
+; CHECK-NEXT: da analyze - output [0 <=|<]!
; CHECK-NEXT: Src: store i32 0, ptr %getelementptr5, align 1 --> Dst: store i32 0, ptr %getelementptr5, align 1
; CHECK-NEXT: da analyze - none!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
index e67cae7d39a75..cda588609010f 100644
--- a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
@@ -7,6 +7,8 @@
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-apple-macosx10.6.0"
+ at test_array_100x100x100 = global [100 x [100 x [100 x i64]]] zeroinitializer
+
;; for (long int i = 0; i < n; i++) {
;; for (long int j = 0; j < n; j++) {
;; for (long int k = 0; k < n; k++) {
@@ -15,7 +17,7 @@ target triple = "x86_64-apple-macosx10.6.0"
;; for (long int k = 0; k < n; k++) {
;; *B++ = A[i + 3][j + 2][k + 1];
-define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
+define void @p2(i64 %n, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'p2'
; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %i.011, ptr %arrayidx8, align 8
; CHECK-NEXT: da analyze - none!
@@ -45,6 +47,7 @@ define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
; LIN-NEXT: da analyze - confused!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x [100 x i64]]], ptr @test_array_100x100x100, i32 0, i32 0
%cmp10 = icmp sgt i64 %n, 0
br i1 %cmp10, label %for.cond1.preheader.preheader, label %for.end26
diff --git a/llvm/test/Analysis/DependenceAnalysis/Separability.ll b/llvm/test/Analysis/DependenceAnalysis/Separability.ll
index 2ed9cca4d1fc0..173b969b37720 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Separability.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Separability.ll
@@ -5,6 +5,8 @@
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-apple-macosx10.6.0"
+ at test_array_100x100x100 = global [100 x [100 x [100 x i32]]] zeroinitializer
+ at test_array_100x100x100x100 = global [100 x [100 x [100 x [100 x i32]]]] zeroinitializer
;; for (long int i = 0; i < 50; i++)
;; for (long int j = 0; j < 50; j++)
@@ -13,7 +15,7 @@ target triple = "x86_64-apple-macosx10.6.0"
;; A[n][i][j + k] = i;
;; *B++ = A[10][i + 10][2*j - l];
-define void @sep0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep0(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'sep0'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx11, align 4 --> Dst: store i32 %conv, ptr %arrayidx11, align 4
; CHECK-NEXT: da analyze - output [0 * * S]!
@@ -29,6 +31,7 @@ define void @sep0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x [100 x i32]]], ptr @test_array_100x100x100, i32 0, i32 0
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc22
@@ -95,7 +98,7 @@ for.end24: ; preds = %for.inc22
;; A[i][i][j + k] = i;
;; *B++ = A[10][i + 10][2*j - l];
-define void @sep1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep1(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'sep1'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx11, align 4 --> Dst: store i32 %conv, ptr %arrayidx11, align 4
; CHECK-NEXT: da analyze - output [0 * * S]!
@@ -111,6 +114,7 @@ define void @sep1(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x [100 x i32]]], ptr @test_array_100x100x100, i32 0, i32 0
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc22
@@ -177,7 +181,7 @@ for.end24: ; preds = %for.inc22
;; A[i][i][i + k][l] = i;
;; *B++ = A[10][i + 10][j + k][l + 10];
-define void @sep2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep2(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'sep2'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx12, align 4 --> Dst: store i32 %conv, ptr %arrayidx12, align 4
; CHECK-NEXT: da analyze - consistent output [0 S 0 0]!
@@ -193,6 +197,7 @@ define void @sep2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x [100 x [100 x i32]]]], ptr @test_array_100x100x100x100, i32 0, i32 0
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc26
@@ -259,7 +264,7 @@ for.end28: ; preds = %for.inc26
;; A[i][i][i + k][l + k] = i;
;; *B++ = A[10][i + 10][j + k][l + 10];
-define void @sep3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
+define void @sep3(ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'sep3'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx13, align 4 --> Dst: store i32 %conv, ptr %arrayidx13, align 4
; CHECK-NEXT: da analyze - consistent output [0 S 0 0]!
@@ -275,6 +280,7 @@ define void @sep3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %A = getelementptr inbounds [100 x [100 x [100 x [100 x i32]]]], ptr @test_array_100x100x100x100, i32 0, i32 0
br label %for.cond1.preheader
for.cond1.preheader: ; preds = %entry, %for.inc27
diff --git a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
index 2638bb045de3d..6c1ead519885e 100644
--- a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll
@@ -1,5 +1,14 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
-; RUN: opt < %s -disable-output -passes="print<da>" 2>&1 | FileCheck %s
+; RUN: opt < %s -disable-output -passes="print<da>" -da-disable-delinearization-checks 2>&1 | FileCheck %s
+
+; FIXME: Remove -da-disable-delinearization-checks once SCEV's BTC gets better.
+; For the moment we are failing to bound simple SCEVs against constant number of iterations:
+; Check failed: !isKnownLessThan(S, Range)
+; + S: {0,+,1}<nuw><nsw><%for.body4>
+; + Range: 1024
+
+ at test_array_1024x2048 = global [1024 x [2048 x i32]] zeroinitializer
+ at test_array_1024x1024x1024x2048 = global [1024 x [1024 x [1024 x [1024 x [2048 x i32]]]]] zeroinitializer
; Note: exact results can be achieved even if
; "-da-disable-delinearization-checks" is not used
@@ -13,7 +22,7 @@
;; }
;;
;; Note that there is a getelementptr with index 0, make sure we can analyze this case.
-define void @t1(ptr %a) {
+define void @t1() {
; CHECK-LABEL: 't1'
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: %2 = load i32, ptr %arrayidx6, align 4
; CHECK-NEXT: da analyze - none!
@@ -23,6 +32,7 @@ define void @t1(ptr %a) {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %a = getelementptr inbounds [1024 x [2048 x i32]], ptr @test_array_1024x2048, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.inc11
@@ -53,7 +63,7 @@ for.end13: ; preds = %for.inc11
;; Similar to @t1 but includes a call with a "returned" arg, make sure we can analyze
;; this case.
-define void @t2(ptr %a) {
+define void @t2() {
; CHECK-LABEL: 't2'
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: %2 = load i32, ptr %arrayidx6, align 4
; CHECK-NEXT: da analyze - none!
@@ -69,6 +79,7 @@ define void @t2(ptr %a) {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %a = getelementptr inbounds [1024 x [2048 x i32]], ptr @test_array_1024x2048, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.inc11
@@ -110,7 +121,7 @@ declare ptr @func_with_returned_arg(ptr returned %arg)
;; a[i1][i2][i3][i4][i5] = a[i1+1][i2-2][i3][i4-3][i5+2];
;; }
-define void @t3(ptr %a) {
+define void @t3() {
; CHECK-LABEL: 't3'
; CHECK-NEXT: Src: %4 = load i32, ptr %arrayidx26, align 4 --> Dst: %4 = load i32, ptr %arrayidx26, align 4
; CHECK-NEXT: da analyze - none!
@@ -120,6 +131,7 @@ define void @t3(ptr %a) {
; CHECK-NEXT: da analyze - none!
;
entry:
+ %a = getelementptr inbounds [1024 x [1024 x [1024 x [2048 x i32]]]], ptr @test_array_1024x1024x1024x2048, i32 0, i32 0
br label %for.body
for.body: ; preds = %entry, %for.inc46
diff --git a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
index 3086224c58204..d68833a7f5712 100644
--- a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
+++ b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
@@ -1,9 +1,16 @@
; RUN: opt < %s -cache-line-size=64 -passes='print<loop-cache-cost>' -disable-output 2>&1 | FileCheck %s
-;; This test checks the effect of rounding cache cost to 1 when it is
+; Global arrays to replace array_info operand bundles
+ at test_array_A_2x3 = global [2 x [3 x i32]] zeroinitializer
+ at test_array_B_2 = global [2 x i32] zeroinitializer
+ at test_array_C_2 = global [2 x i32] zeroinitializer
+ at test_array_D_2 = global [2 x i32] zeroinitializer
+ at test_array_E_2 = global [2 x i32] zeroinitializer
+
+;; This test checks the effect of rounding cache cost to 1 when it is
;; evaluated to 0 because at least 1 cache line is accessed by the loopnest.
;; It does not make sense to output that zero cache lines are used.
-;; The cost of reference group for B[j], C[j], D[j] and E[j] were
+;; The cost of reference group for B[j], C[j], D[j] and E[j] were
;; calculted 0 before but now they are 1 which makes each loop cost more reasonable.
;
; void test(int n, int m, int o, int A[2][3], int B[2], int C[2], int D[2], int E[2]) {
@@ -19,9 +26,14 @@
; CHECK: Loop 'for.j' has cost = 18
; CHECK-NEXT: Loop 'for.i' has cost = 10
-define void @test(ptr %A, ptr %B, ptr %C, ptr %D, ptr %E) {
+define void @test() {
entry:
+ %A = getelementptr inbounds [2 x [3 x i32]], ptr @test_array_A_2x3, i32 0, i32 0
+ %B = getelementptr inbounds [2 x i32], ptr @test_array_B_2, i32 0, i32 0
+ %C = getelementptr inbounds [2 x i32], ptr @test_array_C_2, i32 0, i32 0
+ %D = getelementptr inbounds [2 x i32], ptr @test_array_D_2, i32 0, i32 0
+ %E = getelementptr inbounds [2 x i32], ptr @test_array_E_2, i32 0, i32 0
br label %for.i.preheader.split
for.i.preheader.split: ; preds = %for.i.preheader
diff --git a/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll b/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
index 16952a66aa78e..880f5d9d52405 100644
--- a/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
+++ b/llvm/test/Transforms/LoopInterchange/profitability-vectorization.ll
@@ -39,6 +39,7 @@
; PROFIT-VEC-NEXT: ...
define void @f() {
entry:
+
br label %for.i.header
for.i.header:
@@ -65,7 +66,7 @@ for.j.body:
%add.2 = fadd float %add.1, %d
%add.3 = fadd float %add.2, %e
%add.4 = fadd float %add.3, %f
- %a.1.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @A, i64 %j, i64 %i
+ %a.1.index = getelementptr nuw inbounds [256 x [256 x float]], ptr @A, i64 0, i64 %j, i64 %i
store float %add.4, ptr %a.1.index, align 4
%j.next = add nuw nsw i64 %j, 1
%cmp.j = icmp eq i64 %j.next, 256
diff --git a/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll b/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
index b95bbddf11d65..1e5baadfb0a34 100644
--- a/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
+++ b/llvm/test/Transforms/LoopUnrollAndJam/dependencies_multidims.ll
@@ -1,8 +1,6 @@
; RUN: opt -da-disable-delinearization-checks -passes=loop-unroll-and-jam -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
; RUN: opt -da-disable-delinearization-checks -aa-pipeline=basic-aa -passes='loop-unroll-and-jam' -allow-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-
; CHECK-LABEL: sub_sub_less
; CHECK: %j = phi
; CHECK-NOT: %j.1 = phi
diff --git a/polly/include/polly/ScopInfo.h b/polly/include/polly/ScopInfo.h
index f700144165d53..b9eddc1c38336 100644
--- a/polly/include/polly/ScopInfo.h
+++ b/polly/include/polly/ScopInfo.h
@@ -318,6 +318,16 @@ class ScopArrayInfo final {
/// Return the isl id for the base pointer.
isl::id getBasePtrId() const;
+ /// Mark this array as delinearized using array_info extraction.
+ void setUsedArrayInfoDelinearization(bool Used = true) {
+ UsedArrayInfoDelinearization = Used;
+ }
+
+ /// Check if this array was delinearized using array_info extraction.
+ bool usedArrayInfoDelinearization() const {
+ return UsedArrayInfoDelinearization;
+ }
+
/// Return what kind of memory this represents.
MemoryKind getKind() const { return Kind; }
@@ -425,6 +435,9 @@ class ScopArrayInfo final {
/// The scop this SAI object belongs to.
Scop &S;
+
+ /// True if this array was delinearized using array_info extraction.
+ bool UsedArrayInfoDelinearization = false;
};
/// Represent memory accesses in statements.
diff --git a/polly/lib/Analysis/ScopBuilder.cpp b/polly/lib/Analysis/ScopBuilder.cpp
index 67a4c43455809..d07090b222d3d 100644
--- a/polly/lib/Analysis/ScopBuilder.cpp
+++ b/polly/lib/Analysis/ScopBuilder.cpp
@@ -1449,34 +1449,15 @@ bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
Value *Address = Inst.getPointerOperand();
const SCEV *AccessFunction =
SE.getSCEVAtScope(Address, LI.getLoopFor(Inst->getParent()));
- const SCEVUnknown *BasePointer =
- dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
enum MemoryAccess::AccessType AccType =
isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
- if (auto *BitCast = dyn_cast<BitCastInst>(Address))
- Address = BitCast->getOperand(0);
-
- auto *GEP = dyn_cast<GetElementPtrInst>(Address);
- if (!GEP || DL.getTypeAllocSize(GEP->getResultElementType()) !=
- DL.getTypeAllocSize(ElementType))
- return false;
-
SmallVector<const SCEV *, 4> Subscripts;
- SmallVector<int, 4> Sizes;
- getIndexExpressionsFromGEP(SE, GEP, Subscripts, Sizes);
- auto *BasePtr = GEP->getOperand(0);
-
- if (auto *BasePtrCast = dyn_cast<BitCastInst>(BasePtr))
- BasePtr = BasePtrCast->getOperand(0);
-
- // Check for identical base pointers to ensure that we do not miss index
- // offsets that have been added before this GEP is applied.
- if (BasePtr != BasePointer->getValue())
+ SmallVector<const SCEV *, 4> Sizes;
+ if (!delinearizeUsingArrayInfo(SE, AccessFunction, Subscripts, Sizes,
+ SE.getElementSize(&*Inst)))
return false;
- std::vector<const SCEV *> SizesSCEV;
-
const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads();
Loop *SurroundingLoop = Stmt->getSurroundingLoop();
@@ -1491,17 +1472,39 @@ bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
return false;
}
- if (Sizes.empty())
- return false;
-
- SizesSCEV.push_back(nullptr);
+ // Remove the element size. This information is already provided by the
+ // ElementSize parameter.
+ Sizes.pop_back();
+ const SCEVUnknown *BasePointer =
+ dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
- for (auto V : Sizes)
- SizesSCEV.push_back(SE.getSCEV(
- ConstantInt::get(IntegerType::getInt64Ty(BasePtr->getContext()), V)));
+ // Get or create the ScopArrayInfo and mark it as using array_info
+ // delinearization.
+ LLVM_DEBUG(dbgs() << "buildAccessMultiDimFixed: BasePointer="
+ << *BasePointer->getValue() << "\n");
+ auto *SAI = scop->getOrCreateScopArrayInfo(
+ BasePointer->getValue(), ElementType, Sizes, MemoryKind::Array);
+ SAI->setUsedArrayInfoDelinearization(true);
+
+ LLVM_DEBUG({
+ dbgs() << "buildAccessMultiDimFixed for "
+ << BasePointer->getValue()->getName() << ": Subscripts=[";
+ for (unsigned i = 0; i < Subscripts.size(); i++) {
+ if (i > 0)
+ dbgs() << ", ";
+ dbgs() << *Subscripts[i];
+ }
+ dbgs() << "], Sizes=[";
+ for (unsigned i = 0; i < Sizes.size(); i++) {
+ if (i > 0)
+ dbgs() << ", ";
+ dbgs() << *Sizes[i];
+ }
+ dbgs() << "]\n";
+ });
addArrayAccess(Stmt, Inst, AccType, BasePointer->getValue(), ElementType,
- true, Subscripts, SizesSCEV, Val);
+ true, Subscripts, Sizes, Val);
return true;
}
@@ -2306,6 +2309,13 @@ void ScopBuilder::updateAccessDimensionality() {
if (Array->getNumberOfDimensions() != 1)
continue;
+
+ // Skip divisibility optimization for arrays delinearized using
+ // array_info, as they produce proper array indices rather than byte
+ // offsets.
+ if (Array->usedArrayInfoDelinearization())
+ continue;
+
unsigned DivisibleSize = Array->getElemSizeInBytes();
const SCEV *Subscript = Access->getSubscript(0);
while (!isDivisible(Subscript, DivisibleSize, SE))
@@ -2576,11 +2586,31 @@ bool checkCandidatePairAccesses(MemoryAccess *LoadMA, MemoryAccess *StoreMA,
}
if (Valid) {
- // Finally, check if they are no other instructions accessing this memory
+ // Finally, check if they are no other instructions accessing this memory.
+ // For multidimensional arrays with known bounds, be less strict about
+ // overlaps to preserve reduction detection for legitimate array reduction
+ // patterns.
isl::map AllAccsRel = LoadAccs.unite(StoreAccs);
AllAccsRel = AllAccsRel.intersect_domain(Domain);
isl::set AllAccs = AllAccsRel.range();
- Valid = !hasIntersectingAccesses(AllAccs, LoadMA, StoreMA, Domain, MemAccs);
+
+ bool hasOtherAccesses =
+ hasIntersectingAccesses(AllAccs, LoadMA, StoreMA, Domain, MemAccs);
+
+ // For arrays delinearized with array_info (multidimensional with known
+ // bounds), allow reductions even if there might be overlapping accesses
+ // from other reductions in the same statement, as these represent
+ // legitimate reduction patterns.
+ auto *SAI = LoadMA->getScopArrayInfo();
+ if (hasOtherAccesses && SAI->usedArrayInfoDelinearization() &&
+ SAI->getNumberOfDimensions() > 1) {
+ POLLY_DEBUG(dbgs() << " == Allowing potential overlap for "
+ "multidimensional array reduction\n");
+ Valid = true;
+ } else {
+ Valid = !hasOtherAccesses;
+ }
+
POLLY_DEBUG(dbgs() << " == The accessed memory is " << (Valid ? "not " : "")
<< "accessed by other instructions!\n");
}
diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index 8c6a2360a249b..92edf858e17c2 100644
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -447,9 +447,21 @@ void MemoryAccess::updateDimensionality() {
unsigned DimsArray = unsignedFromIslSize(ArraySpace.dim(isl::dim::set));
unsigned DimsAccess = unsignedFromIslSize(AccessSpace.dim(isl::dim::set));
- assert(DimsArray >= DimsAccess);
+
+ LLVM_DEBUG(dbgs() << "updateDimensionality: DimsArray=" << DimsArray
+ << ", DimsAccess=" << DimsAccess << " for array "
+ << SAI->getName() << "\n");
+
+ if (DimsArray < DimsAccess) {
+ LLVM_DEBUG(
+ dbgs() << "ERROR: DimsArray < DimsAccess - assertion would fail!\n");
+ return; // Graceful failure instead of assertion
+ }
unsigned DimsMissing = DimsArray - DimsAccess;
+ LLVM_DEBUG(dbgs() << "updateDimensionality: Computing DimsMissing="
+ << DimsMissing << "\n");
+
auto *BB = getStatement()->getEntryBlock();
auto &DL = BB->getModule()->getDataLayout();
unsigned ArrayElemSize = SAI->getElemSizeInBytes();
@@ -476,7 +488,10 @@ void MemoryAccess::updateDimensionality() {
// obvious again. If the base pointer was accessed with offsets not divisible
// by the accesses element size, we will have chosen a smaller ArrayElemSize
// that divides the offsets of all accesses to this base pointer.
- if (DimsAccess == 1) {
+ //
+ // Skip this division for arrays that used array_info delinearization,
+ // as they already produce proper array indices rather than byte offsets.
+ if (DimsAccess == 1 && !SAI->usedArrayInfoDelinearization()) {
isl::val V = isl::val(Ctx, ArrayElemSize);
AccessRelation = AccessRelation.floordiv_val(V);
}
@@ -498,9 +513,19 @@ void MemoryAccess::updateDimensionality() {
// An access ((float *)A)[i] to an array char *A is modeled as
// {[i] -> A[o] : 4 i <= o <= 4 i + 3
if (ElemBytes > ArrayElemSize) {
- assert(ElemBytes % ArrayElemSize == 0 &&
- "Loaded element size should be multiple of canonical element size");
- assert(DimsArray >= 1);
+ LLVM_DEBUG(dbgs() << "updateDimensionality: ElemBytes=" << ElemBytes
+ << " > ArrayElemSize=" << ArrayElemSize << "\n");
+
+ if (ElemBytes % ArrayElemSize != 0) {
+ LLVM_DEBUG(dbgs() << "ERROR: Loaded element size not multiple of "
+ "canonical element size!\n");
+ return; // Graceful failure instead of assertion
+ }
+
+ if (DimsArray < 1) {
+ LLVM_DEBUG(dbgs() << "ERROR: DimsArray < 1!\n");
+ return; // Graceful failure instead of assertion
+ }
isl::map Map = isl::map::from_domain_and_range(
isl::set::universe(ArraySpace), isl::set::universe(ArraySpace));
for (auto i : seq<unsigned>(0, DimsArray - 1))
@@ -525,6 +550,9 @@ void MemoryAccess::updateDimensionality() {
Map = Map.add_constraint(C);
AccessRelation = AccessRelation.apply_range(Map);
}
+
+ LLVM_DEBUG(dbgs() << "updateDimensionality: Completed successfully for array "
+ << SAI->getName() << "\n");
}
std::string
@@ -846,7 +874,11 @@ void MemoryAccess::buildAccessRelation(const ScopArrayInfo *SAI) {
isl::space Space = isl::space(Ctx, 0, Statement->getNumIterators(), 0);
AccessRelation = isl::map::universe(Space);
+ LLVM_DEBUG(dbgs() << "buildAccessRelation for " << BaseAddr->getName()
+ << ": Processing " << Subscripts.size() << " subscripts\n");
for (int i = 0, Size = Subscripts.size(); i < Size; ++i) {
+ LLVM_DEBUG(dbgs() << " Subscripts[" << i << "] = " << *Subscripts[i]
+ << "\n");
isl::pw_aff Affine = getPwAff(Subscripts[i]);
isl::map SubscriptMap = isl::map::from_pw_aff(Affine);
AccessRelation = AccessRelation.flat_range_product(SubscriptMap);
diff --git a/polly/test/CodeGen/MemAccess/create_arrays.ll b/polly/test/CodeGen/MemAccess/create_arrays.ll
index 40ae8d6efa95f..88ba0c0864204 100644
--- a/polly/test/CodeGen/MemAccess/create_arrays.ll
+++ b/polly/test/CodeGen/MemAccess/create_arrays.ll
@@ -8,16 +8,16 @@
;
;
; CHECK: Arrays {
-; CHECK: double MemRef_B[*][1024]; // Element size 8
+; CHECK: double MemRef_B[20][1024]; // Element size 8
; CHECK: double MemRef_beta; // Element size 8
-; CHECK: double MemRef_A[*][1056]; // Element size 8
+; CHECK: double MemRef_A[10][1056]; // Element size 8
; CHECK: double D[270336]; // Element size 8
; CHECK: double E[270336][200000]; // Element size 8
; CHECK: i64 F[270336]; // Element size 8
;
; CHECK:New access function '{ Stmt_bb12[i0, i1, i2] -> E[i2, i0] }' detected in JSCOP file
;
-; CODEGEN:define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+; CODEGEN:define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %arg7) #0 {
; CODEGEN:bb:
; CODEGEN: %beta.s2a = alloca double
; CODEGEN: %D = alloca [270336 x double]
@@ -25,11 +25,11 @@
; CODEGEN: %F = alloca [270336 x i64]
; CODEGEN: br label %bb8
;
-; CODEGEN: %beta.s2a.reload = load double, ptr %beta.s2a
-; CODEGEN: %polly.access.mul.E = mul nsw i64 %polly.indvar31, 200000
+; CODEGEN: %beta.s2a.reload = load double, ptr %beta.s2a, align 8
+; CODEGEN: %polly.access.mul.E = mul nsw i64 %polly.indvar10, 200000
; CODEGEN: %polly.access.add.E = add nsw i64 %polly.access.mul.E, %polly.indvar
; CODEGEN: {{%.*}} = load double, ptr %polly.access.E, align 8, !alias.scope !4, !noalias !7
-; CODEGEN: store double {{%.*}}, ptr %scevgep34, align 8, !alias.scope !12, !noalias !13
+; CODEGEN: store double {{%.*}}, ptr %scevgep13, align 8
;
; CODEGEN: !0 = distinct !{!0, !1}
; CODEGEN: !1 = !{!"llvm.loop.vectorize.enable", i32 0}
@@ -46,11 +46,11 @@
; CODEGEN: !12 = !{!9}
; CODEGEN: !13 = !{!8, !10, !5, !11}
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-; Function Attrs: nounwind uwtable
-define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+ at A = common global [10 x [1056 x double]] zeroinitializer
+ at B = common global [20 x [1024 x double]] zeroinitializer
+
+define internal void @create_arrays(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %arg7) {
bb:
br label %bb8
@@ -67,10 +67,10 @@ bb10: ; preds = %bb20, %bb9
bb12: ; preds = %bb12, %bb10
%tmp13 = phi i64 [ 0, %bb10 ], [ %tmp18, %bb12 ]
- %tmp14 = getelementptr inbounds [1024 x double], ptr %B, i64 %tmp, i64 %tmp13
+ %tmp14 = getelementptr inbounds [1024 x double], ptr @B, i64 %tmp, i64 %tmp13
%tmp15 = load double, ptr %tmp14, align 8
%tmp16 = fmul double %tmp15, %beta
- %tmp17 = getelementptr inbounds [1056 x double], ptr %A, i64 %tmp, i64 %tmp11
+ %tmp17 = getelementptr inbounds [1056 x double], ptr @A, i64 %tmp, i64 %tmp11
store double %tmp16, ptr %tmp17, align 8
%tmp18 = add nuw nsw i64 %tmp13, 1
%tmp19 = icmp ne i64 %tmp18, 1024
@@ -89,5 +89,3 @@ bb23: ; preds = %bb20
bb26: ; preds = %bb23
ret void
}
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/CodeGen/MemAccess/create_arrays_heap.ll b/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
index 1202d21998c94..94db0900bda4c 100644
--- a/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
+++ b/polly/test/CodeGen/MemAccess/create_arrays_heap.ll
@@ -5,7 +5,8 @@
; #define Nj 1056
; #define Nk 1024
;
-; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
+; double A[Ni][Nk], B[Ni][Nj];
+; void create_arrays_heap(double beta) {
; int i,j,k;
;
; for (i = 0; i < Ni; i++) {
@@ -19,9 +20,9 @@
;
; Check if the info from the JSON file has been analysed without errors.
; CHECK: Arrays {
-; CHECK: double MemRef_A[*][1024]; // Element size 8
+; CHECK: double MemRef_A[1056][1024]; // Element size 8
; CHECK: double MemRef_beta; // Element size 8
-; CHECK: double MemRef_B[*][1056]; // Element size 8
+; CHECK: double MemRef_B[1056][1056]; // Element size 8
; CHECK: double D[270336]; // Element size 8
; CHECK: double E[270336][200000]; // Element size 8
; CHECK: i64 F[270336]; // Element size 8
@@ -47,13 +48,11 @@
; CODEGEN: %polly.access.add.{{.*}} = add nsw i64 %polly.access.mul.{{.*}}, %
; CODEGEN: %polly.access.{{.*}} = getelementptr double, ptr %E, i64 %polly.access.add.{{.*}}
;
-; ModuleID = 'create_arrays_heap.ll'
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-; Function Attrs: nounwind uwtable
-define void @create_arrays_heap(double %beta, ptr nocapture readonly %A, ptr nocapture %B) local_unnamed_addr {
+ at A = common global [1056 x [1024 x double]] zeroinitializer
+ at B = common global [1056 x [1056 x double]] zeroinitializer
+
+define void @create_arrays_heap(double %beta) local_unnamed_addr {
entry:
br label %for.cond1.preheader
@@ -63,27 +62,27 @@ for.cond1.preheader: ; preds = %for.inc16, %entry
for.cond4.preheader: ; preds = %for.inc13, %for.cond1.preheader
%indvars.iv32 = phi i64 [ 0, %for.cond1.preheader ], [ %indvars.iv.next33, %for.inc13 ]
- %arrayidx12 = getelementptr inbounds [1056 x double], ptr %B, i64 %indvars.iv35, i64 %indvars.iv32
+ %arrayidx12 = getelementptr inbounds [1056 x double], ptr @B, i64 %indvars.iv35, i64 %indvars.iv32
br label %for.body6
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next.3, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv
%0 = load double, ptr %arrayidx8, align 8
%mul = fmul double %0, %beta
store double %mul, ptr %arrayidx12, align 8
%indvars.iv.next = or disjoint i64 %indvars.iv, 1
- %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next
+ %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next
%1 = load double, ptr %arrayidx8.1, align 8
%mul.1 = fmul double %1, %beta
store double %mul.1, ptr %arrayidx12, align 8
%indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
- %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.1
+ %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.1
%2 = load double, ptr %arrayidx8.2, align 8
%mul.2 = fmul double %2, %beta
store double %mul.2, ptr %arrayidx12, align 8
%indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
- %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.2
+ %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.2
%3 = load double, ptr %arrayidx8.3, align 8
%mul.3 = fmul double %3, %beta
store double %mul.3, ptr %arrayidx12, align 8
diff --git a/polly/test/CodeGen/OpenMP/matmul-parallel.ll b/polly/test/CodeGen/OpenMP/matmul-parallel.ll
index 43326b29f7ef1..9b3afc9b78655 100644
--- a/polly/test/CodeGen/OpenMP/matmul-parallel.ll
+++ b/polly/test/CodeGen/OpenMP/matmul-parallel.ll
@@ -3,12 +3,11 @@
; REQUIRES: asserts
; Parallelization of detected matrix-multiplication.
-; Currently, this is not supported. Due to Packed_A/Packed_B not private
-; per-thread the outer loops cannot be parallelized and a
-; '#pragma omp parallel for' on an inner loop may impose too much overhead.
+; The outer loop should be parallelized.
+; AST: // 1st level tiling - Tiles
+; AST-NEXT: #pragma omp parallel for
-target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc19.16.27034"
+; CODEGEN: polly.parallel.for
define i32 @foo(ptr nocapture readonly %A, ptr nocapture readonly %B, ptr nocapture %C) {
entry:
@@ -53,8 +52,3 @@ for.body8:
%exitcond = icmp eq i64 %indvars.iv.next, 1536
br i1 %exitcond, label %for.cond.cleanup7, label %for.body8
}
-
-
-; AST-NOT: parallel
-
-; CODEGEN-NOT: subfunc
diff --git a/polly/test/CodeGen/invariant-load-dimension.ll b/polly/test/CodeGen/invariant-load-dimension.ll
index 21e53055c56b0..ae74cb207d841 100644
--- a/polly/test/CodeGen/invariant-load-dimension.ll
+++ b/polly/test/CodeGen/invariant-load-dimension.ll
@@ -1,8 +1,6 @@
; RUN: opt %loadNPMPolly -polly-process-unprofitable -polly-invariant-load-hoisting '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadNPMPolly -S < %s -passes=polly-codegen -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
-
%S = type { i32, i32, [12 x %L] }
%L = type { i32, i32, double, i32, i32, i32, i32, i32 }
@@ -13,11 +11,11 @@ define void @test(ptr %cpi, i1 %b) {
; SCOPS-NEXT: [l2, l1] -> { Stmt_for_body_i[i0] -> MemRef_cpi[0, 0] };
; SCOPS-NEXT: Execution Context: [l2, l1] -> { : }
; SCOPS-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
-; SCOPS-NEXT: [l2, l1] -> { Stmt_for_body_lr_ph_i[] -> MemRef_cpi[0, 1] };
+; SCOPS-NEXT: [l2, l1] -> { Stmt_for_body_lr_ph_i[] -> MemRef_cpi[0, 0] };
; SCOPS-NEXT: Execution Context: [l2, l1] -> { : l2 > 0 }
; SCOPS-NEXT: }
; SCOPS: Arrays {
-; SCOPS-NEXT: i32 MemRef_cpi[*][(10 * %l1)]; // Element size 4
+; SCOPS-NEXT: i32 MemRef_cpi[*][(10 * (sext i32 %l1 to i64))<nsw>]; // Element size 4
; SCOPS-NEXT: }
; FIXME: Figure out how to actually generate code for this loop.
diff --git a/polly/test/DeLICM/load-in-cond-inf-loop.ll b/polly/test/DeLICM/load-in-cond-inf-loop.ll
index a78a4691bb0d5..9649f5583bab1 100644
--- a/polly/test/DeLICM/load-in-cond-inf-loop.ll
+++ b/polly/test/DeLICM/load-in-cond-inf-loop.ll
@@ -10,8 +10,6 @@
;
; Test case reduced from llvm.org/PR48445.
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-
@arr_18 = external dso_local local_unnamed_addr global [0 x i16], align 2
define void @func(i64 %b, ptr %c) {
@@ -60,11 +58,11 @@ for.cond.cleanup:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef_c[b] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT: [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef1[] };
+; CHECK-NEXT: [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef2[] };
; CHECK-NEXT: new: [b] -> { Stmt_for_body13[i0, i1, i2] -> MemRef_arr_18[i0] : i0 < b; Stmt_for_body13[0, i1, i2] -> MemRef_arr_18[0] : b < 0 };
; CHECK-NEXT: Stmt_for_cond_cleanup6
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT: [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef1[] };
+; CHECK-NEXT: [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef2[] };
; CHECK-NEXT: new: [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef_arr_18[i0] : i0 < b; Stmt_for_cond_cleanup6[0] -> MemRef_arr_18[0] : b < 0 };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [b] -> { Stmt_for_cond_cleanup6[i0] -> MemRef_arr_18[i0] };
diff --git a/polly/test/ForwardOpTree/atax.ll b/polly/test/ForwardOpTree/atax.ll
index 496e8315b068b..9f341cfbb6e6b 100644
--- a/polly/test/ForwardOpTree/atax.ll
+++ b/polly/test/ForwardOpTree/atax.ll
@@ -1,8 +1,8 @@
; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true '-passes=print<polly-optree>' -disable-output < %s | FileCheck %s -match-full-lines
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at A = common global [100 x [2100 x double]] zeroinitializer
-define internal fastcc void @kernel_atax(ptr nocapture readonly %A, ptr nocapture readonly %x, ptr nocapture %y, ptr nocapture %tmp) unnamed_addr #0 {
+define internal fastcc void @kernel_atax(ptr nocapture readonly %x, ptr nocapture %y, ptr nocapture %tmp) {
entry:
br label %entry.split
@@ -19,7 +19,7 @@ for.body3: ; preds = %for.inc40, %entry.s
for.body8: ; preds = %for.body8, %for.body3
%0 = phi double [ 0.000000e+00, %for.body3 ], [ %add, %for.body8 ]
%indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body8 ]
- %arrayidx14 = getelementptr inbounds [2100 x double], ptr %A, i64 %indvars.iv8, i64 %indvars.iv
+ %arrayidx14 = getelementptr inbounds [2100 x double], ptr @A, i64 %indvars.iv8, i64 %indvars.iv
%1 = load double, ptr %arrayidx14, align 8, !tbaa !6
%arrayidx16 = getelementptr inbounds double, ptr %x, i64 %indvars.iv
%2 = load double, ptr %arrayidx16, align 8, !tbaa !6
@@ -38,7 +38,7 @@ for.body24: ; preds = %for.body24.for.body
%indvars.iv5 = phi i64 [ 0, %for.end21 ], [ %indvars.iv.next6, %for.body24.for.body24_crit_edge ]
%arrayidx26 = getelementptr inbounds double, ptr %y, i64 %indvars.iv5
%4 = load double, ptr %arrayidx26, align 8, !tbaa !6
- %arrayidx30 = getelementptr inbounds [2100 x double], ptr %A, i64 %indvars.iv8, i64 %indvars.iv5
+ %arrayidx30 = getelementptr inbounds [2100 x double], ptr @A, i64 %indvars.iv8, i64 %indvars.iv5
%5 = load double, ptr %arrayidx30, align 8, !tbaa !6
%mul33 = fmul double %5, %3
%add34 = fadd double %4, %mul33
@@ -61,10 +61,7 @@ for.end42: ; preds = %for.inc40
}
; Function Attrs: argmemonly nounwind
-declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1) #1
-
-attributes #0 = { noinline norecurse nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
-attributes #1 = { argmemonly nounwind }
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1)
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
@@ -89,15 +86,15 @@ attributes #1 = { argmemonly nounwind }
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body3[i0] -> MemRef_tmp[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT: { Stmt_for_body3[i0] -> MemRef1__phi[] };
+; CHECK-NEXT: { Stmt_for_body3[i0] -> MemRef2__phi[] };
; CHECK-NEXT: Instructions {
; CHECK-NEXT: store double 0.000000e+00, ptr %arrayidx5, align 8, !tbaa !2
; CHECK-NEXT: }
; CHECK-NEXT: Stmt_for_body8
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT: { Stmt_for_body8[i0, i1] -> MemRef1__phi[] };
+; CHECK-NEXT: { Stmt_for_body8[i0, i1] -> MemRef2__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT: { Stmt_for_body8[i0, i1] -> MemRef1__phi[] };
+; CHECK-NEXT: { Stmt_for_body8[i0, i1] -> MemRef2__phi[] };
; CHECK-NEXT: new: { Stmt_for_body8[i0, i1] -> MemRef_tmp[i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body8[i0, i1] -> MemRef_A[i0, i1] };
diff --git a/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll b/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
index 6e13a5e413d76..0e07daf86e834 100644
--- a/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
+++ b/polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll
@@ -1,4 +1,4 @@
- ; RUN: not --crash opt %loadNPMPolly -passes=polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
+; RUN: not --crash opt %loadNPMPolly -passes=polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
;
; CHECK: Array has not a valid type.
;
@@ -11,11 +11,10 @@
;
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
+ at A = common global [1056 x [1056 x double]] zeroinitializer
+ at B = common global [1056 x [1024 x double]] zeroinitializer
-; Function Attrs: nounwind uwtable
-define internal void @ia4(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) #0 {
+define internal void @ia4(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %beta, ptr %A, ptr %B, ptr %arg7) {
bb:
br label %bb8
@@ -32,10 +31,10 @@ bb10: ; preds = %bb20, %bb9
bb12: ; preds = %bb12, %bb10
%tmp13 = phi i64 [ 0, %bb10 ], [ %tmp18, %bb12 ]
- %tmp14 = getelementptr inbounds [1024 x double], ptr %B, i64 %tmp, i64 %tmp13
+ %tmp14 = getelementptr inbounds [1024 x double], ptr @B, i64 %tmp, i64 %tmp13
%tmp15 = load double, ptr %tmp14, align 8
%tmp16 = fmul double %tmp15, %beta
- %tmp17 = getelementptr inbounds [1056 x double], ptr %A, i64 %tmp, i64 %tmp11
+ %tmp17 = getelementptr inbounds [1056 x double], ptr @A, i64 %tmp, i64 %tmp11
store double %tmp16, ptr %tmp17, align 8
%tmp18 = add nuw nsw i64 %tmp13, 1
%tmp19 = icmp ne i64 %tmp18, 1024
@@ -54,5 +53,3 @@ bb23: ; preds = %bb20
bb26: ; preds = %bb23
ret void
}
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll b/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
index 7f6578776e0bd..f4c99658ceda1 100644
--- a/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
+++ b/polly/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll
@@ -4,7 +4,8 @@
; #define Nj 1056
; #define Nk 1024
;
-; void ImportArray_Negative_size(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
+; double A[Ni][Nk], B[Ni][Nj];
+; void ImportArray_Negative_size(double beta) {
; int i,j,k;
;
; for (i = 0; i < Ni; i++) {
@@ -19,12 +20,11 @@
; Verify if the JSONImporter checks if the size of the new array is positive.
; CHECK: The size at index 0 is =< 0.
;
-; ModuleID = 'ImportArrays-Negative-size.ll'
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-; Function Attrs: nounwind uwtable
-define void @ImportArrays_Negative_Size(double %beta, ptr nocapture readonly %A, ptr nocapture %B) local_unnamed_addr {
+ at A = common global [1056 x [1024 x double]] zeroinitializer
+ at B = common global [1056 x [1056 x double]] zeroinitializer
+
+define void @ImportArrays_Negative_Size(double %beta) local_unnamed_addr {
entry:
br label %for.cond1.preheader
@@ -34,27 +34,27 @@ for.cond1.preheader: ; preds = %for.inc16, %entry
for.cond4.preheader: ; preds = %for.inc13, %for.cond1.preheader
%indvars.iv32 = phi i64 [ 0, %for.cond1.preheader ], [ %indvars.iv.next33, %for.inc13 ]
- %arrayidx12 = getelementptr inbounds [1056 x double], ptr %B, i64 %indvars.iv35, i64 %indvars.iv32
+ %arrayidx12 = getelementptr inbounds [1056 x double], ptr @B, i64 %indvars.iv35, i64 %indvars.iv32
br label %for.body6
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next.3, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv
%0 = load double, ptr %arrayidx8, align 8
%mul = fmul double %0, %beta
store double %mul, ptr %arrayidx12, align 8
%indvars.iv.next = or disjoint i64 %indvars.iv, 1
- %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next
+ %arrayidx8.1 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next
%1 = load double, ptr %arrayidx8.1, align 8
%mul.1 = fmul double %1, %beta
store double %mul.1, ptr %arrayidx12, align 8
%indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
- %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.1
+ %arrayidx8.2 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.1
%2 = load double, ptr %arrayidx8.2, align 8
%mul.2 = fmul double %2, %beta
store double %mul.2, ptr %arrayidx12, align 8
%indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
- %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv35, i64 %indvars.iv.next.2
+ %arrayidx8.3 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv35, i64 %indvars.iv.next.2
%3 = load double, ptr %arrayidx8.3, align 8
%mul.3 = fmul double %3, %beta
store double %mul.3, ptr %arrayidx12, align 8
diff --git a/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed b/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
index 066294b3d13ff..9e440e060aa83 100644
--- a/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
+++ b/polly/test/JSONExporter/ImportArrays/ia4___%bb9---%bb26.jscop.transformed
@@ -2,12 +2,12 @@
"arrays" : [
{
"name" : "MemRef_B",
- "sizes" : [ "*", "1024" ],
+ "sizes" : [ "1056", "1024" ],
"type" : "doble"
},
{
"name" : "MemRef_A",
- "sizes" : [ "*", "1056" ],
+ "sizes" : [ "1056", "1056" ],
"type" : "double"
},
{
diff --git a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
index 5e4ce8225a236..be3ead379e7a7 100644
--- a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
+++ b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll
@@ -1,7 +1,9 @@
; RUN: opt %loadNPMPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
; RUN: opt %loadNPMPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
-define void @func(i32 %n, ptr noalias nonnull %A, ptr noalias nonnull %B) {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @func(i32 %n) {
entry:
br label %outer.for1
@@ -16,7 +18,7 @@ outer.for1:
br i1 %j1.cmp, label %body1, label %exit1
body1:
- %arrayidx1 = getelementptr inbounds [1024 x double], ptr %A, i32 %k1, i32 %j1
+ %arrayidx1 = getelementptr inbounds [1024 x double], ptr @A, i32 %k1, i32 %j1
store double 21.0, ptr %arrayidx1
br label %inc1
@@ -45,7 +47,7 @@ outer.for2:
br i1 %j2.cmp, label %body2, label %exit2
body2:
- %arrayidx2 = getelementptr inbounds [1024 x double], ptr %A, i32 %k2, i32 %j2
+ %arrayidx2 = getelementptr inbounds [1024 x double], ptr @A, i32 %k2, i32 %j2
store double 42.0, ptr %arrayidx2
br label %inc2
diff --git a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
index a449a2fda9ba3..f4a95e7f7edcc 100644
--- a/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
+++ b/polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll
@@ -1,7 +1,9 @@
; RUN: opt %loadNPMPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
; RUN: opt %loadNPMPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 '-passes=print<polly-opt-isl>' -disable-output < %s | FileCheck %s
-define void @func(i32 %n, ptr noalias nonnull %A) {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @func(i32 %n) {
entry:
br label %outer.for
@@ -16,7 +18,7 @@ outer.for:
br i1 %j1.cmp, label %body1, label %exit1
body1:
- %arrayidx1 = getelementptr inbounds [1024 x double], ptr %A, i32 %k, i32 %j1
+ %arrayidx1 = getelementptr inbounds [1024 x double], ptr @A, i32 %k, i32 %j1
store double 21.0, ptr %arrayidx1
br label %inc1
@@ -33,7 +35,7 @@ outer.for:
br i1 %j2.cmp, label %body2, label %exit2
body2:
- %arrayidx2 = getelementptr inbounds [1024 x double], ptr %A, i32 %k, i32 %j2
+ %arrayidx2 = getelementptr inbounds [1024 x double], ptr @A, i32 %k, i32 %j2
store double 42.0, ptr %arrayidx2
br label %inc2
diff --git a/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll b/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
index 928ee858ae6d2..d0fd3202bc93a 100644
--- a/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
+++ b/polly/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll
@@ -169,9 +169,12 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
-define void @f(ptr %A, ptr %B, ptr %C) {
+ at A = common global [3000 x [3000 x i32]] zeroinitializer
+ at B = common global [3000 x [3000 x i32]] zeroinitializer
+ at C = common global [3000 x [3000 x i32]] zeroinitializer
+
+define void @f() {
entry:
br label %for.cond
@@ -189,7 +192,7 @@ for.cond1: ; preds = %for.inc21, %for.bod
br i1 %exitcond3, label %for.body3, label %for.end23
for.body3: ; preds = %for.cond1
- %arrayidx5 = getelementptr inbounds [3000 x i32], ptr %A, i64 %indvars.iv4, i64 %indvars.iv1
+ %arrayidx5 = getelementptr inbounds [3000 x i32], ptr @A, i64 %indvars.iv4, i64 %indvars.iv1
store i32 0, ptr %arrayidx5, align 4
br label %for.cond6
@@ -199,12 +202,12 @@ for.cond6: ; preds = %for.inc, %for.body3
br i1 %exitcond, label %for.body8, label %for.end
for.body8: ; preds = %for.cond6
- %arrayidx12 = getelementptr inbounds [3000 x i32], ptr %B, i64 %indvars.iv4, i64 %indvars.iv
+ %arrayidx12 = getelementptr inbounds [3000 x i32], ptr @B, i64 %indvars.iv4, i64 %indvars.iv
%tmp = load i32, ptr %arrayidx12, align 4
- %arrayidx16 = getelementptr inbounds [3000 x i32], ptr %C, i64 %indvars.iv, i64 %indvars.iv1
+ %arrayidx16 = getelementptr inbounds [3000 x i32], ptr @C, i64 %indvars.iv, i64 %indvars.iv1
%tmp7 = load i32, ptr %arrayidx16, align 4
%mul = mul nsw i32 %tmp, %tmp7
- %arrayidx20 = getelementptr inbounds [3000 x i32], ptr %A, i64 %indvars.iv4, i64 %indvars.iv1
+ %arrayidx20 = getelementptr inbounds [3000 x i32], ptr @A, i64 %indvars.iv4, i64 %indvars.iv1
%tmp8 = load i32, ptr %arrayidx20, align 4
%add = add nsw i32 %tmp8, %mul
store i32 %add, ptr %arrayidx20, align 4
diff --git a/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll b/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
index 3dd579ed736f7..5d284bf372a89 100644
--- a/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
+++ b/polly/test/ScheduleOptimizer/full_partial_tile_separation.ll
@@ -26,8 +26,11 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
-; Function Attrs: nounwind uwtable
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
%cmp.27 = icmp sgt i32 %ni, 0
br i1 %cmp.27, label %for.cond.1.preheader.lr.ph, label %for.end.22
@@ -53,12 +56,12 @@ for.body.6.lr.ph: ; preds = %for.cond.4.preheade
for.body.6: ; preds = %for.body.6.lr.ph, %for.body.6
%indvars.iv = phi i64 [ 0, %for.body.6.lr.ph ], [ %indvars.iv.next, %for.body.6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv33, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv33, i64 %indvars.iv
%0 = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv29
+ %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv29
%1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %0, %1
- %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv33, i64 %indvars.iv29
+ %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv33, i64 %indvars.iv29
%2 = load double, ptr %arrayidx16, align 8
%add = fadd double %2, %mul
store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed b/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
index 1b0e4de06c7d7..27ec159fc65a9 100644
--- a/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
+++ b/polly/test/ScheduleOptimizer/kernel_gemm___%for.body---%for.end24.jscop.transformed
@@ -1,23 +1,23 @@
{
"arrays" : [
- {
- "name" : "MemRef_C1",
- "sizes" : [ "*" ],
- "type" : "double"
- },
{
"name" : "MemRef_A",
- "sizes" : [ "*", "1024" ],
+ "sizes" : [ "1024", "1024" ],
"type" : "double"
},
{
"name" : "MemRef_B",
- "sizes" : [ "*", "1024" ],
+ "sizes" : [ "1024", "1024" ],
"type" : "double"
},
{
"name" : "MemRef_C",
- "sizes" : [ "*", "1024" ],
+ "sizes" : [ "1024", "1024" ],
+ "type" : "double"
+ },
+ {
+ "name" : "MemRef_C1",
+ "sizes" : [ "*" ],
"type" : "double"
}
],
diff --git a/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll b/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
index de1c815f92350..c3dccd5222f45 100644
--- a/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
+++ b/polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
@@ -83,10 +83,12 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+ at arg5 = common global [100 x [1056 x double]] zeroinitializer
+ at arg6 = common global [100 x [1023 x double]] zeroinitializer
+ at arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
bb:
br label %bb8
@@ -96,7 +98,7 @@ bb8: ; preds = %bb29, %bb
bb9: ; preds = %bb26, %bb8
%tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
- %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+ %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
%tmp12 = load double, ptr %tmp11, align 8
%tmp13 = fmul double %tmp12, %arg4
store double %tmp13, ptr %tmp11, align 8
@@ -104,10 +106,10 @@ bb9: ; preds = %bb26, %bb8
Copy_0: ; preds = %Copy_0, %bb9
%tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
- %tmp16 = getelementptr inbounds [1023 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+ %tmp16 = getelementptr inbounds [1023 x double], ptr @arg6, i64 %tmp, i64 %tmp15
%tmp17 = load double, ptr %tmp16, align 8
%tmp18 = fmul double %tmp17, %arg3
- %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+ %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
%tmp20 = load double, ptr %tmp19, align 8
%tmp21 = fmul double %tmp18, %tmp20
%tmp22 = load double, ptr %tmp11, align 8
@@ -130,5 +132,3 @@ bb29: ; preds = %bb26
bb32: ; preds = %bb29
ret void
}
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
index 6e9ade869ec6c..ab8ca27b0304b 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm.ll
@@ -43,11 +43,12 @@
; CHECK: The matrix multiplication pattern was detected
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
+ at A = common global [1600 x [2200 x double]] zeroinitializer
+ at B = common global [2200 x [1800 x double]] zeroinitializer
+ at tmp = common global [1600 x [1800 x double]] zeroinitializer
-; Function Attrs: norecurse nounwind uwtable
-define void @kernel_2mm(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta, ptr nocapture %tmp, ptr nocapture readonly %A, ptr nocapture readonly %B, ptr nocapture readnone %C, ptr nocapture readnone %D) local_unnamed_addr #0 {
+
+define void @kernel_2mm(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -60,17 +61,17 @@ for.body: ; preds = %for.inc25, %entry.s
for.body3: ; preds = %for.inc22, %for.body
%indvars.iv46 = phi i64 [ 0, %for.body ], [ %indvars.iv.next47, %for.inc22 ]
- %arrayidx5 = getelementptr inbounds [1800 x double], ptr %tmp, i64 %indvars.iv50, i64 %indvars.iv46
+ %arrayidx5 = getelementptr inbounds [1800 x double], ptr @tmp, i64 %indvars.iv50, i64 %indvars.iv46
store double 0.000000e+00, ptr %arrayidx5, align 8, !tbaa !2
br label %for.body8
for.body8: ; preds = %for.body8, %for.body3
%0 = phi double [ 0.000000e+00, %for.body3 ], [ %add, %for.body8 ]
%indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body8 ]
- %arrayidx12 = getelementptr inbounds [2200 x double], ptr %A, i64 %indvars.iv50, i64 %indvars.iv
+ %arrayidx12 = getelementptr inbounds [2200 x double], ptr @A, i64 %indvars.iv50, i64 %indvars.iv
%1 = load double, ptr %arrayidx12, align 8, !tbaa !2
%mul = fmul double %1, %alpha
- %arrayidx16 = getelementptr inbounds [1800 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv46
+ %arrayidx16 = getelementptr inbounds [1800 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv46
%2 = load double, ptr %arrayidx16, align 8, !tbaa !2
%mul17 = fmul double %mul, %2
%add = fadd double %0, %mul17
@@ -93,8 +94,6 @@ for.end27: ; preds = %for.inc25
ret void
}
-attributes #0 = { norecurse nounwind uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="none" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="haswell" "target-features"="+aes,+avx,+avx2,+bmi,+bmi2,+cmov,+cx16,+f16c,+fma,+fsgsbase,+fxsr,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+rdrnd,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt,-adx,-avx512bw,-avx512cd,-avx512dq,-avx512er,-avx512f,-avx512ifma,-avx512pf,-avx512vbmi,-avx512vl,-avx512vpopcntdq,-clflushopt,-clwb,-clzero,-fma4,-lwp,-mwaitx,-pku,-prefetchwt1,-prfchw,-rdseed,-rtm,-sgx,-sha,-sse4a,-tbm,-xop,-xsavec,-xsaves" "unsafe-fp-math"="false" "use-soft-float"="false" }
-
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
index 4ef0605a0ba75..291085f5feba1 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts-after-delicm_2.ll
@@ -34,11 +34,12 @@
; C[i][j][k][w] += A[i][l][j][q] * B[q][w][l][k];
;
; CHECK: The tensor contraction pattern was detected
-;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal fastcc void @kernel_tc(ptr nocapture %C, ptr nocapture readonly %A, ptr nocapture readonly %B) {
+ at A = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+ at B = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+ at C = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+
+define internal fastcc void @kernel_tc() {
entry:
br label %for.cond1.preheader
@@ -60,16 +61,16 @@ for.cond10.preheader: ; preds = %for.inc41, %for.con
for.cond13.preheader: ; preds = %for.inc38, %for.cond10.preheader
%indvars.iv7 = phi i64 [ 0, %for.cond10.preheader ], [ %indvars.iv.next8, %for.inc38 ]
- %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %C, i64 %indvars.iv19, i64 %indvars.iv16, i64 %indvars.iv13, i64 %indvars.iv7
+ %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @C, i64 %indvars.iv19, i64 %indvars.iv16, i64 %indvars.iv13, i64 %indvars.iv7
%.pre = load double, ptr %arrayidx37, align 8
br label %for.body15
for.body15: ; preds = %for.body15, %for.cond13.preheader
%i = phi double [ %.pre, %for.cond13.preheader ], [ %add, %for.body15 ]
%indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
- %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %A, i64 %indvars.iv19, i64 %indvars.iv10, i64 %indvars.iv16, i64 %indvars.iv
+ %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @A, i64 %indvars.iv19, i64 %indvars.iv10, i64 %indvars.iv16, i64 %indvars.iv
%i1 = load double, ptr %arrayidx21, align 8
- %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %B, i64 %indvars.iv, i64 %indvars.iv7, i64 %indvars.iv10, i64 %indvars.iv13
+ %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @B, i64 %indvars.iv, i64 %indvars.iv7, i64 %indvars.iv10, i64 %indvars.iv13
%i2 = load double, ptr %arrayidx29, align 8
%mul = fmul fast double %i2, %i1
%add = fadd fast double %i, %mul
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
index 09118e252233b..f7f0201739b18 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll
@@ -21,10 +21,12 @@
; PARALLEL-AST-NOT: #pragma known-parallel
; STATS: 1 polly-opt-isl - Number of matrix multiplication patterns detected and optimized
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+ at arg5 = common global [100 x [1056 x double]] zeroinitializer
+ at arg6 = common global [100 x [1024 x double]] zeroinitializer
+ at arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
bb:
br label %bb8
@@ -34,7 +36,7 @@ bb8: ; preds = %bb29, %bb
bb9: ; preds = %bb26, %bb8
%tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
- %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+ %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
%tmp12 = load double, ptr %tmp11, align 8
%tmp13 = fmul double %tmp12, %arg4
store double %tmp13, ptr %tmp11, align 8
@@ -42,10 +44,10 @@ bb9: ; preds = %bb26, %bb8
Copy_0: ; preds = %Copy_0, %bb9
%tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
- %tmp16 = getelementptr inbounds [1024 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+ %tmp16 = getelementptr inbounds [1024 x double], ptr @arg6, i64 %tmp, i64 %tmp15
%tmp17 = load double, ptr %tmp16, align 8
%tmp18 = fmul double %tmp17, %arg3
- %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+ %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
%tmp20 = load double, ptr %tmp19, align 8
%tmp21 = fmul double %tmp18, %tmp20
%tmp22 = load double, ptr %tmp11, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
index b771d1f87537e..b8199bbf48692 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_11.ll
@@ -20,10 +20,11 @@
; CHECK: The tensor contraction pattern was detected
; CHECK: The matrix multiplication pattern was detected
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %A, ptr %B, ptr %C) {
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %A) {
entry:
br label %entry.split
@@ -40,10 +41,10 @@ for.cond4.preheader: ; preds = %for.inc13, %for.con
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv32
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv32
%tmp = load double, ptr %arrayidx8, align 8
%mul = fmul double %tmp, %A
- %arrayidx12 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv35, i64 %indvars.iv32
+ %arrayidx12 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv35, i64 %indvars.iv32
%tmp1 = load double, ptr %arrayidx12, align 8
%add = fadd double %tmp1, %mul
store double %add, ptr %arrayidx12, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
index 0e4540eb7ba3c..c1e8f9871cd60 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
@@ -82,11 +82,12 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [3000 x [2000 x double]] zeroinitializer
+ at B = common global [3000 x [2000 x double]] zeroinitializer
+ at C = common global [3000 x [2000 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -103,12 +104,12 @@ for.body3: ; preds = %for.inc17, %for.bod
for.body6: ; preds = %for.body6, %for.body3
%indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [2000 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [2000 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
%tmp = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [2000 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+ %arrayidx12 = getelementptr inbounds [2000 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
%tmp1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %tmp, %tmp1
- %arrayidx16 = getelementptr inbounds [2000 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+ %arrayidx16 = getelementptr inbounds [2000 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
%tmp2 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp2, %mul
store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
index 9678ad83ff048..847f4dd3903e2 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_14.ll
@@ -12,11 +12,12 @@
; Check that we disable the Loop Vectorizer.
;
; CHECK: !{!"llvm.loop.vectorize.enable", i1 false}
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, ptr %A, ptr %B, ptr %C, ptr %C1) {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, ptr %C1) {
entry:
br label %entry.split
@@ -34,13 +35,13 @@ for.body3: ; preds = %for.inc19, %for.bod
for.body6: ; preds = %for.body6, %for.body3
%indvars.iv = phi i64 [ 0, %for.body3 ], [ %indvars.iv.next, %for.body6 ]
%tmp = load double, ptr %C1, align 8
- %arrayidx9 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv43, i64 %indvars.iv
+ %arrayidx9 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv43, i64 %indvars.iv
%tmp1 = load double, ptr %arrayidx9, align 8
- %arrayidx13 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv40
+ %arrayidx13 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv40
%tmp2 = load double, ptr %arrayidx13, align 8
%mul = fmul double %tmp1, %tmp2
%add = fadd double %tmp, %mul
- %arrayidx17 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+ %arrayidx17 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
%tmp3 = load double, ptr %arrayidx17, align 8
%add18 = fadd double %tmp3, %add
store double %add18, ptr %arrayidx17, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
index 9c99a090b69e7..74bc347271d41 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_16.ll
@@ -10,10 +10,12 @@
;
; CHECK: The tensor contraction pattern was detected
;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [1024 x [64 x [64 x double]]] zeroinitializer
+ at B = common global [64 x [1024 x [64 x double]]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
entry:
br label %for.cond1.preheader
@@ -31,12 +33,12 @@ for.cond7.preheader: ; preds = %for.inc24, %for.con
for.body9: ; preds = %for.body9, %for.cond7.preheader
%indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
- %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+ %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
%i = load double, ptr %arrayidx13, align 8
- %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr %B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
+ %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr @B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
%i1 = load double, ptr %arrayidx19, align 8
%mul = fmul fast double %i1, %i
- %arrayidx23 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+ %arrayidx23 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
%i2 = load double, ptr %arrayidx23, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
index 8e14035ce8629..db18ef773a520 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_17.ll
@@ -10,10 +10,12 @@
;
; CHECK: The tensor contraction pattern was detected
;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [32 x [32 x [1024 x double]]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [32 x [1024 x [32 x double]]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, double %alpha, double %beta) {
entry:
br label %for.cond1.preheader
@@ -31,12 +33,12 @@ for.cond7.preheader: ; preds = %for.inc24, %for.con
for.body9: ; preds = %for.body9, %for.cond7.preheader
%indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
- %arrayidx13 = getelementptr inbounds [32 x [1024 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+ %arrayidx13 = getelementptr inbounds [32 x [1024 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
%i = load double, ptr %arrayidx13, align 8
- %arrayidx17 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv40
+ %arrayidx17 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv40
%i1 = load double, ptr %arrayidx17, align 8
%mul = fmul fast double %i1, %i
- %arrayidx23 = getelementptr inbounds [1024 x [32 x double]], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40, i64 %indvars.iv37
+ %arrayidx23 = getelementptr inbounds [1024 x [32 x double]], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40, i64 %indvars.iv37
%i2 = load double, ptr %arrayidx23, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
index 4f562c306f96a..038b81702e614 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_18.ll
@@ -12,10 +12,13 @@
;
; CHECK: The tensor contraction pattern was detected
;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+ at B = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+ at C = common global [32 x [32 x [32 x [32 x double]]]] zeroinitializer
+
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nk, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
entry:
br label %for.cond1.preheader
@@ -41,12 +44,12 @@ for.cond13.preheader: ; preds = %for.inc38, %for.con
for.body15: ; preds = %for.body15, %for.cond13.preheader
%indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
- %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %A, i64 %indvars.iv71, i64 %indvars.iv62, i64 %indvars.iv68, i64 %indvars.iv
+ %arrayidx21 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @A, i64 %indvars.iv71, i64 %indvars.iv62, i64 %indvars.iv68, i64 %indvars.iv
%i = load double, ptr %arrayidx21, align 8
- %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %B, i64 %indvars.iv, i64 %indvars.iv59, i64 %indvars.iv62, i64 %indvars.iv65
+ %arrayidx29 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @B, i64 %indvars.iv, i64 %indvars.iv59, i64 %indvars.iv62, i64 %indvars.iv65
%i1 = load double, ptr %arrayidx29, align 8
%mul = fmul fast double %i1, %i
- %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr %C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59
+ %arrayidx37 = getelementptr inbounds [32 x [32 x [32 x double]]], ptr @C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59
%i2 = load double, ptr %arrayidx37, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx37, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
index 32ded897d4ff9..f47ea04e317e8 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_19.ll
@@ -12,10 +12,12 @@
;
; CHECK: The tensor contraction pattern was detected
;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(ptr %C, ptr %A, ptr %B) {
+ at A = common global [4 x [4 x [8 x [1024 x [8 x double]]]]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [8 x [8 x [4 x [1024 x [4 x double]]]]] zeroinitializer
+
+define internal void @kernel_tc() {
entry:
br label %for.cond1.preheader
@@ -41,12 +43,12 @@ for.cond13.preheader: ; preds = %for.inc38, %for.con
for.body15: ; preds = %for.body15, %for.cond13.preheader
%indvars.iv = phi i64 [ 0, %for.cond13.preheader ], [ %indvars.iv.next, %for.body15 ]
- %arrayidx23 = getelementptr inbounds [4 x [8 x [1024 x [8 x double]]]], ptr %A, i64 %indvars.iv, i64 %indvars.iv65, i64 %indvars.iv68, i64 %indvars.iv62, i64 %indvars.iv71
+ %arrayidx23 = getelementptr inbounds [4 x [8 x [1024 x [8 x double]]]], ptr @A, i64 %indvars.iv, i64 %indvars.iv65, i64 %indvars.iv68, i64 %indvars.iv62, i64 %indvars.iv71
%i = load double, ptr %arrayidx23, align 8
- %arrayidx27 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv62, i64 %indvars.iv59
+ %arrayidx27 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv62, i64 %indvars.iv59
%i1 = load double, ptr %arrayidx27, align 8
%mul = fmul fast double %i1, %i
- %arrayidx37 = getelementptr inbounds [8 x [4 x [1024 x [4 x double]]]], ptr %C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59, i64 %indvars.iv
+ %arrayidx37 = getelementptr inbounds [8 x [4 x [1024 x [4 x double]]]], ptr @C, i64 %indvars.iv71, i64 %indvars.iv68, i64 %indvars.iv65, i64 %indvars.iv59, i64 %indvars.iv
%i2 = load double, ptr %arrayidx37, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx37, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
index 155177bdfade0..2c4c434815901 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_20.ll
@@ -12,11 +12,12 @@
; C[i][j][k][w][q][x] += A[l][x][j][k] * B[w][q][l][i];
;
; CHECK: The tensor contraction pattern was detected
-;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(ptr %C, ptr %A, ptr %B) {
+ at A = common global [1024 x [8 x [16 x [8 x double]]]] zeroinitializer
+ at B = common global [8 x [8 x [1024 x [16 x double]]]] zeroinitializer
+ at C = common global [16 x [16 x [8 x [8 x [8 x [8 x double]]]]]] zeroinitializer
+
+define internal void @kernel_tc() {
entry:
br label %for.cond1.preheader
@@ -46,12 +47,12 @@ for.cond16.preheader: ; preds = %for.inc45, %for.con
for.body18: ; preds = %for.body18, %for.cond16.preheader
%indvars.iv = phi i64 [ 0, %for.cond16.preheader ], [ %indvars.iv.next, %for.body18 ]
- %arrayidx24 = getelementptr inbounds [8 x [16 x [8 x double]]], ptr %A, i64 %indvars.iv76, i64 %indvars.iv, i64 %indvars.iv82, i64 %indvars.iv79
+ %arrayidx24 = getelementptr inbounds [8 x [16 x [8 x double]]], ptr @A, i64 %indvars.iv76, i64 %indvars.iv, i64 %indvars.iv82, i64 %indvars.iv79
%i = load double, ptr %arrayidx24, align 8
- %arrayidx32 = getelementptr inbounds [8 x [1024 x [16 x double]]], ptr %B, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv76, i64 %indvars.iv85
+ %arrayidx32 = getelementptr inbounds [8 x [1024 x [16 x double]]], ptr @B, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv76, i64 %indvars.iv85
%i1 = load double, ptr %arrayidx32, align 8
%mul = fmul fast double %i1, %i
- %arrayidx44 = getelementptr inbounds [16 x [8 x [8 x [8 x [8 x double]]]]], ptr %C, i64 %indvars.iv85, i64 %indvars.iv82, i64 %indvars.iv79, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv
+ %arrayidx44 = getelementptr inbounds [16 x [8 x [8 x [8 x [8 x double]]]]], ptr @C, i64 %indvars.iv85, i64 %indvars.iv82, i64 %indvars.iv79, i64 %indvars.iv73, i64 %indvars.iv70, i64 %indvars.iv
%i2 = load double, ptr %arrayidx44, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx44, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
index bfe5c5249a3a8..40eb5e9d522c5 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_24.ll
@@ -11,10 +11,12 @@
;
; CHECK: The tensor contraction pattern was detected
;
-target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [1024 x [64 x [64 x double]]] zeroinitializer
+ at B = common global [64 x [1024 x [64 x double]]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_tc(i32 %ni, i32 %nj, i32 %nl, i32 %nq, i32 %nw, double %alpha, double %beta) {
entry:
br label %for.cond1.preheader
@@ -32,12 +34,12 @@ for.cond7.preheader: ; preds = %for.inc24, %for.con
for.body9: ; preds = %for.body9, %for.cond7.preheader
%indvars.iv = phi i64 [ 0, %for.cond7.preheader ], [ %indvars.iv.next, %for.body9 ]
- %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr %A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
+ %arrayidx13 = getelementptr inbounds [64 x [64 x double]], ptr @A, i64 %indvars.iv43, i64 %indvars.iv37, i64 %indvars.iv
%i = load double, ptr %arrayidx13, align 8
- %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr %B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
+ %arrayidx19 = getelementptr inbounds [1024 x [64 x double]], ptr @B, i64 %indvars.iv, i64 %indvars.iv40, i64 %indvars.iv37
%i1 = load double, ptr %arrayidx19, align 8
%mul = fmul fast double %i1, %i
- %arrayidx23 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv43, i64 %indvars.iv40
+ %arrayidx23 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv43, i64 %indvars.iv40
%i2 = load double, ptr %arrayidx23, align 8
%add = fadd fast double %i2, %mul
store double %add, ptr %arrayidx23, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
index 9844d377e609d..649a1fd6bc89b 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
@@ -140,11 +140,12 @@
; EXTRACTION-OF-MACRO-KERNEL-NEXT: }
; EXTRACTION-OF-MACRO-KERNEL-NEXT: }
; EXTRACTION-OF-MACRO-KERNEL-NEXT: }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %arg, i32 %arg1, i32 %arg2, double %arg3, double %arg4, ptr %arg5, ptr %arg6, ptr %arg7) #0 {
+ at arg5 = common global [100 x [1056 x double]] zeroinitializer
+ at arg6 = common global [100 x [1024 x double]] zeroinitializer
+ at arg7 = common global [100 x [1056 x double]] zeroinitializer
+
+define internal void @kernel_gemm(double %arg3, double %arg4) {
bb:
br label %bb8
@@ -154,7 +155,7 @@ bb8: ; preds = %bb29, %bb
bb9: ; preds = %bb26, %bb8
%tmp10 = phi i64 [ 0, %bb8 ], [ %tmp27, %bb26 ]
- %tmp11 = getelementptr inbounds [1056 x double], ptr %arg5, i64 %tmp, i64 %tmp10
+ %tmp11 = getelementptr inbounds [1056 x double], ptr @arg5, i64 %tmp, i64 %tmp10
%tmp12 = load double, ptr %tmp11, align 8
%tmp13 = fmul double %tmp12, %arg4
store double %tmp13, ptr %tmp11, align 8
@@ -162,10 +163,10 @@ bb9: ; preds = %bb26, %bb8
Copy_0: ; preds = %Copy_0, %bb9
%tmp15 = phi i64 [ 0, %bb9 ], [ %tmp24, %Copy_0 ]
- %tmp16 = getelementptr inbounds [1024 x double], ptr %arg6, i64 %tmp, i64 %tmp15
+ %tmp16 = getelementptr inbounds [1024 x double], ptr @arg6, i64 %tmp, i64 %tmp15
%tmp17 = load double, ptr %tmp16, align 8
%tmp18 = fmul double %tmp17, %arg3
- %tmp19 = getelementptr inbounds [1056 x double], ptr %arg7, i64 %tmp15, i64 %tmp10
+ %tmp19 = getelementptr inbounds [1056 x double], ptr @arg7, i64 %tmp15, i64 %tmp10
%tmp20 = load double, ptr %tmp19, align 8
%tmp21 = fmul double %tmp18, %tmp20
%tmp22 = load double, ptr %tmp11, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
index 250641d57bac5..d7aa4979ad02f 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
@@ -77,11 +77,12 @@
; PATTERN-MATCHING-OPTS-NEXT: }
; PATTERN-MATCHING-OPTS-NEXT: }
; PATTERN-MATCHING-OPTS-NEXT: }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -98,12 +99,12 @@ for.cond4.preheader: ; preds = %for.inc17, %for.con
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv38
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv38
%tmp = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv38, i64 %indvars.iv
+ %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv38, i64 %indvars.iv
%tmp1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %tmp, %tmp1
- %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv
+ %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv
%tmp2 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp2, %mul
store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
index ad2c195ba1e8e..3787f71d0af83 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
@@ -429,10 +429,12 @@
; AUTO-VECTORIZATION: 2 licm - Number of load insts hoisted or sunk
; AUTO-VECTORIZATION: 32 licm - Number of memory locations promoted to registers
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -461,12 +463,12 @@ for.body6.lr.ph: ; preds = %for.cond4.preheader
for.body6: ; preds = %for.body6, %for.body6.lr.ph
%indvars.iv = phi i64 [ 0, %for.body6.lr.ph ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x double], ptr %A, i64 %indvars.iv45, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x double], ptr @A, i64 %indvars.iv45, i64 %indvars.iv
%tmp = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv41
+ %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv41
%tmp1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %tmp, %tmp1
- %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv45, i64 %indvars.iv41
+ %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv45, i64 %indvars.iv41
%tmp2 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp2, %mul
store double %add, ptr %arrayidx16, align 8
@@ -499,5 +501,3 @@ for.cond.for.end22_crit_edge: ; preds = %for.inc20
for.end22: ; preds = %for.cond.for.end22_crit_edge, %entry.split
ret void
}
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
index 1d3cdbdbfdd85..ad8874b3c19df 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
@@ -124,11 +124,12 @@
; AUTO-VECTORIZATION: 146 licm - Number of instructions hoisted out of loop
; AUTO-VECTORIZATION: 1 licm - Number of load insts hoisted or sunk
; AUTO-VECTORIZATION: 32 licm - Number of memory locations promoted to registers
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+ at A = common global [1024 x [1020 x double]] zeroinitializer
+ at B = common global [1024 x [1020 x double]] zeroinitializer
+ at C = common global [1024 x [1020 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -145,12 +146,12 @@ for.cond4.preheader: ; preds = %for.inc17, %for.con
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1020 x double], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1020 x double], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
%tmp = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [1020 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+ %arrayidx12 = getelementptr inbounds [1020 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
%tmp1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %tmp, %tmp1
- %arrayidx16 = getelementptr inbounds [1020 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+ %arrayidx16 = getelementptr inbounds [1020 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
%tmp2 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp2, %mul
store double %add, ptr %arrayidx16, align 8
@@ -171,5 +172,3 @@ for.inc20: ; preds = %for.inc17
for.end22: ; preds = %for.inc20
ret void
}
-
-attributes #0 = { nounwind uwtable "target-cpu"="x86-64" "target-features"="+aes,+avx,+cmov,+cx16,+fxsr,+mmx,+pclmul,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt" }
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
index 59eaa4a0928e9..5e3f5697b4012 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
@@ -108,11 +108,12 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-; Function Attrs: noinline nounwind uwtable
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, float %alpha, float %beta, ptr %C, ptr %A, ptr %B) #0 {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, float %alpha, float %beta) {
entry:
br label %entry.split
@@ -129,12 +130,12 @@ for.cond4.preheader: ; preds = %for.inc17, %for.con
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x float], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x float], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
%tmp = load float, ptr %arrayidx8, align 4
- %arrayidx12 = getelementptr inbounds [1024 x float], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+ %arrayidx12 = getelementptr inbounds [1024 x float], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
%tmp1 = load float, ptr %arrayidx12, align 4
%mul = fmul float %tmp, %tmp1
- %arrayidx16 = getelementptr inbounds [1024 x float], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+ %arrayidx16 = getelementptr inbounds [1024 x float], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
%tmp2 = load float, ptr %arrayidx16, align 4
%add = fadd float %tmp2, %mul
store float %add, ptr %arrayidx16, align 4
diff --git a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
index 2544d502a2dc5..4e81c4def4248 100644
--- a/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
+++ b/polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
@@ -76,12 +76,12 @@
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
-;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
-; Function Attrs: noinline nounwind uwtable
-define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, ptr %C, ptr %A, ptr %B) #0 {
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
+
+define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta) {
entry:
br label %entry.split
@@ -98,13 +98,13 @@ for.cond4.preheader: ; preds = %for.inc17, %for.con
for.body6: ; preds = %for.body6, %for.cond4.preheader
%indvars.iv = phi i64 [ 0, %for.cond4.preheader ], [ %indvars.iv.next, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [1024 x float], ptr %A, i64 %indvars.iv41, i64 %indvars.iv
+ %arrayidx8 = getelementptr inbounds [1024 x float], ptr @A, i64 %indvars.iv41, i64 %indvars.iv
%tmp = load float, ptr %arrayidx8, align 4
%conv = fpext float %tmp to double
- %arrayidx12 = getelementptr inbounds [1024 x double], ptr %B, i64 %indvars.iv, i64 %indvars.iv38
+ %arrayidx12 = getelementptr inbounds [1024 x double], ptr @B, i64 %indvars.iv, i64 %indvars.iv38
%tmp1 = load double, ptr %arrayidx12, align 8
%mul = fmul double %conv, %tmp1
- %arrayidx16 = getelementptr inbounds [1024 x double], ptr %C, i64 %indvars.iv41, i64 %indvars.iv38
+ %arrayidx16 = getelementptr inbounds [1024 x double], ptr @C, i64 %indvars.iv41, i64 %indvars.iv38
%tmp2 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp2, %mul
store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll b/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
index 64285891a16c7..7c399ddeb0f87 100644
--- a/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
+++ b/polly/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll
@@ -12,11 +12,12 @@
; when the AccMap cannot be reduced to a single disjunct.
;
; CHECK: The matrix multiplication pattern was detected
-;
-; ModuleID = 'pattern_matching_based_opts_splitmap.ll'
-;
-; Function Attrs: noinline nounwind uwtable
-define void @pattern_matching_based_opts_splitmap(ptr noalias dereferenceable(32) %C, ptr noalias dereferenceable(12544) %A, ptr noalias dereferenceable(12544) %B) {
+
+ at A = common global [2 x [784 x double]] zeroinitializer
+ at B = common global [784 x [2 x double]] zeroinitializer
+ at C = common global [2 x [2 x double]] zeroinitializer
+
+define void @pattern_matching_based_opts_splitmap() {
entry:
br label %for.body
@@ -30,12 +31,12 @@ for.body3: ; preds = %for.body, %for.inc1
for.body6: ; preds = %for.body3, %for.body6
%k = phi i64 [ 0, %for.body3 ], [ %add17, %for.body6 ]
- %arrayidx8 = getelementptr inbounds [784 x double], ptr %A, i64 %i, i64 %k
+ %arrayidx8 = getelementptr inbounds [784 x double], ptr @A, i64 %i, i64 %k
%tmp6 = load double, ptr %arrayidx8, align 8
- %arrayidx12 = getelementptr inbounds [2 x double], ptr %B, i64 %k, i64 %j
+ %arrayidx12 = getelementptr inbounds [2 x double], ptr @B, i64 %k, i64 %j
%tmp10 = load double, ptr %arrayidx12, align 8
%mul = fmul double %tmp6, %tmp10
- %arrayidx16 = getelementptr inbounds [2 x double], ptr %C, i64 %i, i64 %j
+ %arrayidx16 = getelementptr inbounds [2 x double], ptr @C, i64 %i, i64 %j
%tmp14 = load double, ptr %arrayidx16, align 8
%add = fadd double %tmp14, %mul
store double %add, ptr %arrayidx16, align 8
diff --git a/polly/test/ScopInfo/assume_gep_bounds.ll b/polly/test/ScopInfo/assume_gep_bounds.ll
index bd14e3868d525..5a9047a58f7c8 100644
--- a/polly/test/ScopInfo/assume_gep_bounds.ll
+++ b/polly/test/ScopInfo/assume_gep_bounds.ll
@@ -1,7 +1,7 @@
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-; void foo(float A[][20][30], long n, long m, long p) {
+; float A[10][20][30];
+; void foo(long n, long m, long p) {
; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++)
; for (long k = 0; k < p; k++)
@@ -23,9 +23,9 @@
; CHECK-DAG: m <= 20
; CHECK: }
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at A = local_unnamed_addr global [10 x [20 x [30 x float]]] zeroinitializer
-define void @foo(ptr %A, i64 %n, i64 %m, i64 %p) {
+define void @foo(i64 %n, i64 %m, i64 %p) {
entry:
br label %for.cond
@@ -54,7 +54,7 @@ for.body6: ; preds = %for.cond4
%add = add nsw i64 %i.0, %j.0
%add7 = add nsw i64 %add, %k.0
%conv = sitofp i64 %add7 to float
- %arrayidx9 = getelementptr inbounds [20 x [30 x float]], ptr %A, i64 %i.0, i64 %j.0, i64 %k.0
+ %arrayidx9 = getelementptr inbounds [20 x [30 x float]], ptr @A, i64 %i.0, i64 %j.0, i64 %k.0
store float %conv, ptr %arrayidx9, align 4
br label %for.inc
diff --git a/polly/test/ScopInfo/assume_gep_bounds_2.ll b/polly/test/ScopInfo/assume_gep_bounds_2.ll
index 7a8c1870abe25..948727886ff88 100644
--- a/polly/test/ScopInfo/assume_gep_bounds_2.ll
+++ b/polly/test/ScopInfo/assume_gep_bounds_2.ll
@@ -1,8 +1,8 @@
; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 \
; RUN: -polly-precise-inbounds | FileCheck %s
;
-; void foo(float A[restrict][20], float B[restrict][20], long n, long m,
-; long p) {
+; float A[10][20], B[10][20];
+; void foo(long n, long m, long p) {
; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++)
; A[i][j] = i + j;
@@ -19,9 +19,10 @@
; CHECK: Assumed Context:
; CHECK-NEXT: [n, m, p] -> { : p <= 20 and (n <= 0 or (n > 0 and m <= 20)) }
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at A = common global [10 x [20 x float]] zeroinitializer
+ at B = common global [10 x [20 x float]] zeroinitializer
-define void @foo(ptr noalias %A, ptr noalias %B, i64 %n, i64 %m, i64 %p) {
+define void @foo(i64 %n, i64 %m, i64 %p) {
entry:
br label %for.cond
@@ -41,7 +42,7 @@ for.cond1: ; preds = %for.inc, %for.body
for.body3: ; preds = %for.cond1
%add = add nsw i64 %i.0, %j.0
%conv = sitofp i64 %add to float
- %arrayidx4 = getelementptr inbounds [20 x float], ptr %A, i64 %i.0, i64 %j.0
+ %arrayidx4 = getelementptr inbounds [20 x float], ptr @A, i64 %i.0, i64 %j.0
store float %conv, ptr %arrayidx4, align 4
br label %for.inc
@@ -75,7 +76,7 @@ for.cond14: ; preds = %for.inc22, %for.bod
for.body17: ; preds = %for.cond14
%add18 = add nsw i64 %i8.0, %j13.0
%conv19 = sitofp i64 %add18 to float
- %arrayidx21 = getelementptr inbounds [20 x float], ptr %B, i64 %i8.0, i64 %j13.0
+ %arrayidx21 = getelementptr inbounds [20 x float], ptr @B, i64 %i8.0, i64 %j13.0
store float %conv19, ptr %arrayidx21, align 4
br label %for.inc22
diff --git a/polly/test/ScopInfo/loop_affine_bound_0.ll b/polly/test/ScopInfo/loop_affine_bound_0.ll
index 918d4099740ce..e8c4e1ddaa024 100644
--- a/polly/test/ScopInfo/loop_affine_bound_0.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_0.ll
@@ -1,16 +1,16 @@
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-; void f(long a[][128], long N, long M) {
+; long a[10][128];
+; void f(long N, long M) {
; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = 0; i < (5*N + 2); ++i)
; a[j][i] = 0
; }
-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"
+ at a = local_unnamed_addr global [10 x [128 x i64]] zeroinitializer
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
entry:
%0 = shl i64 %N, 2 ; <i64> [#uses=2]
%1 = mul i64 %M, 7 ; <i64> [#uses=2]
@@ -21,7 +21,7 @@ entry:
bb1: ; preds = %bb2.preheader, %bb1
%i.06 = phi i64 [ 0, %bb2.preheader ], [ %5, %bb1 ] ; <i64> [#uses=2]
- %scevgep = getelementptr [128 x i64], ptr %a, i64 %i.06, i64 %10 ; <ptr> [#uses=1]
+ %scevgep = getelementptr [128 x i64], ptr @a, i64 %i.06, i64 %10 ; <ptr> [#uses=1]
store i64 0, ptr %scevgep, align 8
%5 = add nsw i64 %i.06, 1 ; <i64> [#uses=2]
%exitcond = icmp eq i64 %5, %8 ; <i1> [#uses=1]
diff --git a/polly/test/ScopInfo/loop_affine_bound_1.ll b/polly/test/ScopInfo/loop_affine_bound_1.ll
index 8f7a87f1c5ac4..0e5bf0e067a20 100644
--- a/polly/test/ScopInfo/loop_affine_bound_1.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_1.ll
@@ -1,16 +1,17 @@
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output< %s 2>&1 | FileCheck %s
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-;void f(long a[][128], long N, long M) {
+;
+; long a[10][128];
+; void f(long N, long M) {
; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = j; i < (5*N + 2); ++i)
; ...
;}
-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"
+ at a = local_unnamed_addr global [10 x [128 x i64]] zeroinitializer
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
entry:
%0 = shl i64 %N, 2 ; <i64> [#uses=2]
%1 = mul i64 %M, 7 ; <i64> [#uses=2]
@@ -21,7 +22,7 @@ entry:
bb1: ; preds = %bb2.preheader, %bb1
%indvar = phi i64 [ 0, %bb2.preheader ], [ %indvar.next, %bb1 ] ; <i64> [#uses=2]
- %scevgep = getelementptr [128 x i64], ptr %a, i64 %indvar, i64 %tmp10 ; <ptr> [#uses=1]
+ %scevgep = getelementptr [128 x i64], ptr @a, i64 %indvar, i64 %tmp10 ; <ptr> [#uses=1]
store i64 0, ptr %scevgep, align 8
%indvar.next = add i64 %indvar, 1 ; <i64> [#uses=2]
%exitcond = icmp sge i64 %indvar.next, %tmp9 ; <i1> [#uses=1]
@@ -61,5 +62,5 @@ return: ; preds = %bb3, %entry
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] : i0 <= 2 + 4N + 7M; Stmt_bb1[0, i1] -> [0, i1] : 7M <= -3 - 4N };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, 129i0] };
+; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i0 + i1, i0] };
; CHECK-NEXT: }
diff --git a/polly/test/ScopInfo/loop_affine_bound_2.ll b/polly/test/ScopInfo/loop_affine_bound_2.ll
index 2d9f997a0767f..8b1efc1372eac 100644
--- a/polly/test/ScopInfo/loop_affine_bound_2.ll
+++ b/polly/test/ScopInfo/loop_affine_bound_2.ll
@@ -1,16 +1,16 @@
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-
-; void f(long a[][128], long N, long M) {
+; long a[100][128];
+; void f(long N, long M) {
; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i)
; a[i][j] = 0;
; }
-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"
+ at a = local_unnamed_addr global [100 x [128 x i64]] zeroinitializer
-define void @f(ptr nocapture %a, i64 %N, i64 %M) nounwind {
+define void @f(i64 %N, i64 %M) nounwind {
entry:
%0 = shl i64 %N, 2
%1 = mul i64 %M, 7
@@ -46,7 +46,7 @@ bb: ; preds = %bb3, %bb.nph8
bb1: ; preds = %bb1, %bb
%indvar = phi i64 [ 0, %bb ], [ %indvar.next, %bb1 ]
%tmp16 = add i64 %indvar, %tmp15
- %scevgep = getelementptr [128 x i64], ptr %a, i64 %tmp16, i64 %tmp17
+ %scevgep = getelementptr [128 x i64], ptr @a, i64 %tmp16, i64 %tmp17
store i64 0, ptr %scevgep
%indvar.next = add i64 %indvar, 1
%exitcond = icmp eq i64 %indvar.next, %tmp13
@@ -72,5 +72,5 @@ return: ; preds = %bb3, %entry
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + i1, 897i0] };
+; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + 7i0 + i1, i0] };
; CHECK-NEXT: }
diff --git a/polly/test/ScopInfo/many-scalar-dependences.ll b/polly/test/ScopInfo/many-scalar-dependences.ll
index 5b003325ef0fb..0ec9eb547ed23 100644
--- a/polly/test/ScopInfo/many-scalar-dependences.ll
+++ b/polly/test/ScopInfo/many-scalar-dependences.ll
@@ -1,6 +1,6 @@
; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-;
-; void f(float a[100][100]) {
+; float a[100][100];
+; void f() {
; float x;
;
; for (int i = 0; i < 100; i++) {
@@ -147,7 +147,9 @@
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-define void @f(ptr %a) {
+ at a = common global [100 x [100 x float]] zeroinitializer
+
+define void @f() {
bb:
br label %bb5
@@ -184,7 +186,7 @@ bb11: ; preds = %bb10
bb12: ; preds = %bb11, %bb10
%x.3 = phi float [ 4.200000e+01, %bb11 ], [ %x.2, %bb10 ]
- %tmp13 = getelementptr inbounds [100 x float], ptr %a, i64 %indvars.iv2, i64 %indvars.iv
+ %tmp13 = getelementptr inbounds [100 x float], ptr @a, i64 %indvars.iv2, i64 %indvars.iv
%tmp14 = load float, ptr %tmp13, align 4
%tmp15 = fadd float %tmp14, %x.3
store float %tmp15, ptr %tmp13, align 4
diff --git a/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll b/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
index 4a1ee3b1af51d..a7dab38705131 100644
--- a/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
+++ b/polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll
@@ -1,8 +1,8 @@
; RUN: opt %loadNPMPolly '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
;
; #define N 400
-;
-; void first_higher_dimensional(float A[][N]) {
+; float A[N][N], B[N][N];
+; void first_higher_dimensional() {
; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++)
; A[i][j] += i + j;
@@ -14,7 +14,7 @@
; A[i][j] += i + j;
; }
-; void first_lower_dimensional(float A[][N], float B[][N]) {
+; void first_lower_dimensional() {
; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++)
; B[i][j] += i + j;
@@ -90,9 +90,10 @@
; CHECK-NEXT: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-NEXT: }
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at A = common global [400 x [400 x float]] zeroinitializer
+ at B = common global [400 x [400 x float]] zeroinitializer
-define void @first_higher_dimensional(ptr %A) {
+define void @first_higher_dimensional() {
bb:
br label %bb4
@@ -112,7 +113,7 @@ bb6: ; preds = %bb12, %bb5
bb7: ; preds = %bb6
%tmp = add nuw nsw i64 %i.0, %j.0
%tmp8 = sitofp i64 %tmp to float
- %tmp9 = getelementptr inbounds [400 x float], ptr %A, i64 %i.0, i64 %j.0
+ %tmp9 = getelementptr inbounds [400 x float], ptr @A, i64 %i.0, i64 %j.0
%tmp10 = load float, ptr %tmp9, align 4
%tmp11 = fadd float %tmp10, %tmp8
store float %tmp11, ptr %tmp9, align 4
@@ -130,11 +131,11 @@ bb15: ; preds = %bb14
br label %bb4
bb17: ; preds = %bb4
- %tmp18 = getelementptr inbounds [400 x float], ptr %A, i64 100, i64 100
+ %tmp18 = getelementptr inbounds [400 x float], ptr @A, i64 100, i64 100
%tmp19 = load float, ptr %tmp18, align 4
- %tmp21 = load float, ptr %A, align 4
+ %tmp21 = load float, ptr @A, align 4
%tmp22 = fadd float %tmp21, %tmp19
- store float %tmp22, ptr %A, align 4
+ store float %tmp22, ptr @A, align 4
br label %bb23
bb23: ; preds = %bb35, %bb17
@@ -153,7 +154,7 @@ bb25: ; preds = %bb32, %bb24
bb26: ; preds = %bb25
%tmp27 = add nuw nsw i64 %i1.0, %j2.0
%tmp28 = sitofp i64 %tmp27 to float
- %tmp29 = getelementptr inbounds [400 x float], ptr %A, i64 %i1.0, i64 %j2.0
+ %tmp29 = getelementptr inbounds [400 x float], ptr @A, i64 %i1.0, i64 %j2.0
%tmp30 = load float, ptr %tmp29, align 4
%tmp31 = fadd float %tmp30, %tmp28
store float %tmp31, ptr %tmp29, align 4
@@ -174,7 +175,7 @@ bb37: ; preds = %bb23
ret void
}
-define void @first_lower_dimensional(ptr %A, ptr %B) {
+define void @first_lower_dimensional() {
bb:
br label %bb4
@@ -194,7 +195,7 @@ bb6: ; preds = %bb12, %bb5
bb7: ; preds = %bb6
%tmp = add nuw nsw i64 %i.0, %j.0
%tmp8 = sitofp i64 %tmp to float
- %tmp9 = getelementptr inbounds [400 x float], ptr %B, i64 %i.0, i64 %j.0
+ %tmp9 = getelementptr inbounds [400 x float], ptr @B, i64 %i.0, i64 %j.0
%tmp10 = load float, ptr %tmp9, align 4
%tmp11 = fadd float %tmp10, %tmp8
store float %tmp11, ptr %tmp9, align 4
@@ -212,11 +213,11 @@ bb15: ; preds = %bb14
br label %bb4
bb17: ; preds = %bb4
- %tmp18 = getelementptr inbounds [400 x float], ptr %B, i64 100, i64 100
+ %tmp18 = getelementptr inbounds [400 x float], ptr @B, i64 100, i64 100
%tmp19 = load float, ptr %tmp18, align 4
- %tmp21 = load float, ptr %A, align 4
+ %tmp21 = load float, ptr @A, align 4
%tmp22 = fadd float %tmp21, %tmp19
- store float %tmp22, ptr %A, align 4
+ store float %tmp22, ptr @A, align 4
br label %bb23
bb23: ; preds = %bb35, %bb17
@@ -235,7 +236,7 @@ bb25: ; preds = %bb32, %bb24
bb26: ; preds = %bb25
%tmp27 = add nuw nsw i64 %i1.0, %j2.0
%tmp28 = sitofp i64 %tmp27 to float
- %tmp29 = getelementptr inbounds [400 x float], ptr %A, i64 %i1.0, i64 %j2.0
+ %tmp29 = getelementptr inbounds [400 x float], ptr @A, i64 %i1.0, i64 %j2.0
%tmp30 = load float, ptr %tmp29, align 4
%tmp31 = fadd float %tmp30, %tmp28
store float %tmp31, ptr %tmp29, align 4
diff --git a/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll b/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
index 9a6d8fbe12755..d445194907bc1 100644
--- a/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
+++ b/polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll
@@ -21,8 +21,8 @@
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body[i0] -> MemRef_A[1 + i0, 0] };
; CHECK-NEXT: }
-;
-; void f(int A[][2]) {
+; int A[100][2];
+; void f() {
; int(*B)[2] = &A[0][0];
; int(*C)[2] = &A[1][0];
; for (int i = 0; i < 100; i++) {
@@ -34,11 +34,12 @@
; Verify that the additional offset to A by accessing it through C is taken into
; account.
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-define void @f(ptr %A) {
+ at A = common global [100 x [2 x i32]] zeroinitializer, align 4
+
+define void @f() {
entry:
- %arrayidx3 = getelementptr inbounds [2 x i32], ptr %A, i64 1, i64 0
+ %arrayidx3 = getelementptr inbounds [2 x i32], ptr @A, i64 1, i64 0
br label %for.cond
for.cond: ; preds = %for.inc, %entry
@@ -47,7 +48,7 @@ for.cond: ; preds = %for.inc, %entry
br i1 %exitcond, label %for.body, label %for.end
for.body: ; preds = %for.cond
- %arrayidx5 = getelementptr inbounds [2 x i32], ptr %A, i64 %indvars.iv, i64 0
+ %arrayidx5 = getelementptr inbounds [2 x i32], ptr @A, i64 %indvars.iv, i64 0
%tmp1 = load i32, ptr %arrayidx5, align 4
%inc = add nsw i32 %tmp1, 1
store i32 %inc, ptr %arrayidx5, align 4
diff --git a/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll b/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
index 5778126ad8f17..bb4339a12d33d 100644
--- a/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
+++ b/polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll
@@ -9,14 +9,14 @@
; invalidated due to the zero size dimension.
; CHECK: Assumed Context:
-; CHECK-NEXT: { : false }
+; CHECK-NEXT: { : }
; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: { : false }
; CHECK: Arrays {
-; CHECK-NEXT: i8 MemRef_arg[*][0]; // Element size 1
+; CHECK-NEXT: i8 MemRef_arg[*]; // Element size 1
; CHECK-NEXT: }
; CHECK-NEXT: Arrays (Bounds as pw_affs) {
-; CHECK-NEXT: i8 MemRef_arg[*][ { [] -> [(0)] } ]; // Element size 1
+; CHECK-NEXT: i8 MemRef_arg[*]; // Element size 1
; CHECK-NEXT: }
; CHECK-NEXT: Alias Groups (0):
; CHECK-NEXT: n/a
@@ -27,16 +27,16 @@
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb2[] -> [] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: { Stmt_bb2[] -> MemRef_arg[0, 0] };
+; CHECK-NEXT: { Stmt_bb2[] -> MemRef_arg[0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: { Stmt_bb2[] -> MemRef_arg[o0, o1] : false };
+; CHECK-NEXT: { Stmt_bb2[] -> MemRef_arg[o0] : false };
; CHECK-NEXT: }
-target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
-
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1) #0
-define void @hoge([0 x [0 x i8]]* noalias %arg) {
+ at arg = common global [0 x [0 x i8]] zeroinitializer
+
+define void @hoge() {
bb:
br label %bb1
@@ -44,9 +44,9 @@ bb1: ; preds = %bb5, %bb
br i1 false, label %bb5, label %bb2
bb2: ; preds = %bb1
- %tmp = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* %arg, i64 0, i64 0, i64 0
+ %tmp = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* @arg, i64 0, i64 0, i64 0
store i8 32, i8* %tmp, align 1
- %tmp3 = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* %arg, i64 0, i64 0, i64 0
+ %tmp3 = getelementptr [0 x [0 x i8]], [0 x [0 x i8]]* @arg, i64 0, i64 0, i64 0
%tmp4 = getelementptr i8, i8* %tmp3, i64 1
tail call void @llvm.memset.p0i8.i64(i8* %tmp4, i8 32, i64 0, i32 1, i1 false)
br label %bb5
diff --git a/polly/test/ScopInfo/multidim_with_bitcast.ll b/polly/test/ScopInfo/multidim_with_bitcast.ll
index 0ab9c2d93ff46..7fbad537538c7 100644
--- a/polly/test/ScopInfo/multidim_with_bitcast.ll
+++ b/polly/test/ScopInfo/multidim_with_bitcast.ll
@@ -1,7 +1,5 @@
; RUN: opt %loadNPMPolly -polly-stmt-granularity=bb '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
; Verify that we can look through a bitcast when delinearizing multi-dimensional
; arrays.
@@ -9,7 +7,9 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
; CHECK: Stmt_bb17[i0] -> MemRef_B[i0, 100]
-define void @kernel(ptr %A, ptr %B, ptr %C, ptr %D) {
+ at B = local_unnamed_addr global [10 x [101 x float]] zeroinitializer
+
+define void @kernel(ptr %A, ptr %C, ptr %D) {
bb:
br label %bb4
@@ -29,14 +29,14 @@ bb6: ; preds = %bb16, %bb5
bb7: ; preds = %bb6
%tmp = getelementptr inbounds float, ptr %D, i64 %indvars.iv
%tmp8 = load float, ptr %tmp, align 4
- %tmp9 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 %indvars.iv
+ %tmp9 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 %indvars.iv
%tmp10 = load float, ptr %tmp9, align 4
%tmp11 = fmul float %tmp8, %tmp10
%tmp12 = getelementptr inbounds [101 x float], ptr %C, i64 %indvars.iv1, i64 %indvars.iv
store float %tmp11, ptr %tmp12, align 4
%tmp13 = getelementptr inbounds float, ptr %A, i64 %indvars.iv
%tmp141 = load i32, ptr %tmp13, align 4
- %tmp15 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 %indvars.iv
+ %tmp15 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 %indvars.iv
store i32 %tmp141, ptr %tmp15, align 4
br label %bb16
@@ -47,7 +47,7 @@ bb16: ; preds = %bb7
bb17: ; preds = %bb6
%tmp18 = trunc i64 %indvars.iv1 to i32
%tmp19 = sitofp i32 %tmp18 to float
- %tmp20 = getelementptr inbounds [101 x float], ptr %B, i64 %indvars.iv1, i64 100
+ %tmp20 = getelementptr inbounds [101 x float], ptr @B, i64 %indvars.iv1, i64 100
store float %tmp19, ptr %tmp20, align 4
br label %bb21
diff --git a/polly/test/ScopInfo/non-precise-inv-load-1.ll b/polly/test/ScopInfo/non-precise-inv-load-1.ll
index d55344b355f13..84d20e800ae96 100644
--- a/polly/test/ScopInfo/non-precise-inv-load-1.ll
+++ b/polly/test/ScopInfo/non-precise-inv-load-1.ll
@@ -20,7 +20,6 @@
; A[i] += I[(signed char)(c + (unsigned char)1)];
; }
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@GI = common global [256 x i32] zeroinitializer, align 16
diff --git a/polly/test/ScopInfo/process_added_dimensions.ll b/polly/test/ScopInfo/process_added_dimensions.ll
index 2d06f4b995976..19bef778d4099 100644
--- a/polly/test/ScopInfo/process_added_dimensions.ll
+++ b/polly/test/ScopInfo/process_added_dimensions.ll
@@ -13,21 +13,18 @@
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_for_cond40_preheader_4[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: { Stmt_for_cond40_preheader_4[i0] -> MemRef_call[5, 5, 0] };
+; CHECK-NEXT: { Stmt_for_cond40_preheader_4[i0] -> MemRef_call[2240] };
; CHECK-NEXT: Stmt_for_cond40_preheader_5
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_cond40_preheader_5[i0] : 0 <= i0 <= 1 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_for_cond40_preheader_5[i0] -> [i0, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT: { Stmt_for_cond40_preheader_5[i0] -> MemRef_call[5, 5, 0] };
+; CHECK-NEXT: { Stmt_for_cond40_preheader_5[i0] -> MemRef_call[2240] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_for_cond40_preheader_5[i0] -> MemRef__pre160[] };
; CHECK-NEXT: }
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
declare noalias ptr @malloc()
define i32 @main() {
diff --git a/polly/test/ScopInfo/remarks.ll b/polly/test/ScopInfo/remarks.ll
index 2c173a31c46e9..df27c7dcf9eda 100644
--- a/polly/test/ScopInfo/remarks.ll
+++ b/polly/test/ScopInfo/remarks.ll
@@ -15,8 +15,8 @@
; CHECK: remark: test/ScopInfo/remarks.c:22:16: SCoP ends here but was dismissed.
;
; #include <stdio.h>
-;
-; void valid(int *A, int *B, int N, int M, int C[100][100], int Debug) {
+; int C[100][100];
+; void valid(int *A, int *B, int N, int M, int Debug) {
; if (N + M == -1)
; C[0][0] = 0;
;
@@ -37,17 +37,17 @@
; A[0] = 0;
; }
;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@.str = private unnamed_addr constant [8 x i8] c"Printf!\00", align 1
+ at C = local_unnamed_addr global [100 x [100 x i32]] zeroinitializer
-define void @valid(ptr %A, ptr %B, i32 %N, i32 %M, ptr %C, i32 %Debug) #0 !dbg !4 {
+define void @valid(ptr %A, ptr %B, i32 %N, i32 %M, i32 %Debug) #0 !dbg !4 {
entry:
call void @llvm.dbg.value(metadata ptr %A, i64 0, metadata !23, metadata !24), !dbg !25
call void @llvm.dbg.value(metadata ptr %B, i64 0, metadata !26, metadata !24), !dbg !27
call void @llvm.dbg.value(metadata i32 %N, i64 0, metadata !28, metadata !24), !dbg !29
call void @llvm.dbg.value(metadata i32 %M, i64 0, metadata !30, metadata !24), !dbg !31
- call void @llvm.dbg.value(metadata ptr %C, i64 0, metadata !32, metadata !24), !dbg !33
+ call void @llvm.dbg.value(metadata ptr @C, i64 0, metadata !32, metadata !24), !dbg !33
call void @llvm.dbg.value(metadata i32 %Debug, i64 0, metadata !34, metadata !24), !dbg !35
br label %entry.split
@@ -57,7 +57,7 @@ entry.split:
br i1 %cmp, label %if.then, label %if.end, !dbg !39
if.then: ; preds = %entry
- store i32 0, ptr %C, align 4, !dbg !41
+ store i32 0, ptr @C, align 4, !dbg !41
br label %if.end, !dbg !40
if.end: ; preds = %if.then, %entry
@@ -89,7 +89,7 @@ for.body.5: ; preds = %for.cond.3
%arrayidx10 = getelementptr inbounds i32, ptr %B, i64 %tmp11, !dbg !64
%tmp12 = load i32, ptr %arrayidx10, align 4, !dbg !64
%add11 = add i32 %tmp10, %tmp12, !dbg !65
- %arrayidx15 = getelementptr inbounds [100 x i32], ptr %C, i64 %indvars.iv3, i64 %indvars.iv, !dbg !66
+ %arrayidx15 = getelementptr inbounds [100 x i32], ptr @C, i64 %indvars.iv3, i64 %indvars.iv, !dbg !66
%tmp13 = load i32, ptr %arrayidx15, align 4, !dbg !67
%add16 = add i32 %tmp13, %add11, !dbg !67
store i32 %add16, ptr %arrayidx15, align 4, !dbg !67
diff --git a/polly/test/ScopInfo/scalar_to_array.ll b/polly/test/ScopInfo/scalar_to_array.ll
index 3f61d0d723046..24ca5f7232185 100644
--- a/polly/test/ScopInfo/scalar_to_array.ll
+++ b/polly/test/ScopInfo/scalar_to_array.ll
@@ -1,9 +1,6 @@
; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadNPMPolly -aa-pipeline=basic-aa '-passes=print<polly-function-scops>' -disable-output < %s 2>&1 | FileCheck %s
-; ModuleID = 'scalar_to_array.ll'
-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"
-
@A = common global [1024 x float] zeroinitializer, align 8
; Terminating loops without side-effects will be optimized away, hence
diff --git a/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll b/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
index ba4801d9a0006..1393ec520bcb9 100644
--- a/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
+++ b/polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll
@@ -8,8 +8,6 @@
; should have been removed. We use -polly-delicm to trigger such an
; iteration of an already deleted MemoryAccess.
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
@ATH = external dso_local unnamed_addr constant [88 x float], align 16
define void @setup_tone_curves() {
@@ -84,7 +82,7 @@ for.inc.1: ; preds = %if.then.1, %if.else
; CHECK-NEXT: Stmt_if_else_1_last
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_min_1_1__phi[] };
-; CHECK-NEXT: new: [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_ath[i0] : p_0 <= 576460752303423487 };
+; CHECK-NEXT: new: [p_0] -> { Stmt_if_else_1_last[i0] -> MemRef_ath[i0]
; CHECK-NEXT: Stmt_for_inc_1
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0] -> { Stmt_for_inc_1[i0] -> MemRef_min_1_1__phi[] };
diff --git a/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll b/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
index 3e7883db48fcb..ab56da654c7a0 100644
--- a/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
+++ b/polly/test/ScopInfo/user_provided_non_dominating_assumptions.ll
@@ -5,8 +5,8 @@
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [i, N, M] -> { : N <= i or (N > i and N >= 0) }
; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, M] -> { : N <= i or (N > i and M <= 100) }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
-;
-; void f(int *restrict A, int *restrict B, int i, int N, int M, int C[100][100]) {
+; int C[100][100];
+; void f(int *restrict A, int *restrict B, int i, int N, int M) {
; for (; i < N; i++) {
; __builtin_assume(N >= 0);
; for (int j = 0; j != M; j++) {
@@ -52,8 +52,9 @@
; YAML: ...
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at C = local_unnamed_addr global [100 x [100 x i32]] zeroinitializer
-define void @f(ptr noalias %A, ptr noalias %B, i32 %i, i32 %N, i32 %M, ptr %C) {
+define void @f(ptr noalias %A, ptr noalias %B, i32 %i, i32 %N, i32 %M) {
entry:
%tmp = zext i32 %M to i64
%tmp6 = sext i32 %i to i64
@@ -85,7 +86,7 @@ for.body.4: ; preds = %for.cond.2
%arrayidx8 = getelementptr inbounds i32, ptr %B, i64 %tmp12
%tmp13 = load i32, ptr %arrayidx8, align 4
%add9 = add nsw i32 %tmp11, %tmp13
- %arrayidx13 = getelementptr inbounds [100 x i32], ptr %C, i64 %indvars.iv3, i64 %indvars.iv
+ %arrayidx13 = getelementptr inbounds [100 x i32], ptr @C, i64 %indvars.iv3, i64 %indvars.iv
%tmp14 = load i32, ptr %arrayidx13, align 4
%add14 = add nsw i32 %tmp14, %add9
store i32 %add14, ptr %arrayidx13, align 4
diff --git a/polly/test/Simplify/gemm.ll b/polly/test/Simplify/gemm.ll
index 5120de2db7677..3c8d576ae1894 100644
--- a/polly/test/Simplify/gemm.ll
+++ b/polly/test/Simplify/gemm.ll
@@ -24,10 +24,11 @@
; CHECK-NEXT: new: { Stmt_bb13[i0, i1, i2] -> MemRef_C[i0, i1] };
; CHECK-NEXT: }
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-linux-gnu"
+ at A = common global [1024 x [1024 x double]] zeroinitializer
+ at B = common global [1024 x [1024 x double]] zeroinitializer
+ at C = common global [1024 x [1024 x double]] zeroinitializer
-define void @gemm(ptr %A, ptr %B, ptr %C) {
+define void @gemm() {
bb:
br label %bb3
@@ -51,7 +52,7 @@ bb7: ; preds = %bb6
br label %bb25
bb8: ; preds = %bb6
- %tmp = getelementptr inbounds [1024 x float], ptr %C, i64 %i.0, i64 %j.0
+ %tmp = getelementptr inbounds [1024 x float], ptr @C, i64 %i.0, i64 %j.0
%tmp9 = load float, ptr %tmp, align 4, !tbaa !1
br label %bb10
@@ -69,9 +70,9 @@ bb12: ; preds = %bb10
br label %bb13
bb13: ; preds = %bb12
- %tmp14 = getelementptr inbounds [1024 x float], ptr %A, i64 %i.0, i64 %k.0
+ %tmp14 = getelementptr inbounds [1024 x float], ptr @A, i64 %i.0, i64 %k.0
%tmp15 = load float, ptr %tmp14, align 4, !tbaa !1
- %tmp16 = getelementptr inbounds [1024 x float], ptr %B, i64 %k.0, i64 %j.0
+ %tmp16 = getelementptr inbounds [1024 x float], ptr @B, i64 %k.0, i64 %j.0
%tmp17 = load float, ptr %tmp16, align 4, !tbaa !1
%tmp18 = fmul float %tmp15, %tmp17
%tmp19 = fadd float %tmp.0, %tmp18
@@ -79,7 +80,7 @@ bb13: ; preds = %bb12
br label %bb10
bb21: ; preds = %bb11
- %tmp22 = getelementptr inbounds [1024 x float], ptr %C, i64 %i.0, i64 %j.0
+ %tmp22 = getelementptr inbounds [1024 x float], ptr @C, i64 %i.0, i64 %j.0
store float %tmp.0.lcssa, ptr %tmp22, align 4, !tbaa !1
br label %bb23
diff --git a/polly/test/Simplify/pr33323.ll b/polly/test/Simplify/pr33323.ll
index 22921d5fba509..5104874d4cb47 100644
--- a/polly/test/Simplify/pr33323.ll
+++ b/polly/test/Simplify/pr33323.ll
@@ -5,9 +5,10 @@
; Do not remove the pair (store double %add119, read %add119) as redundant
; because the are in the wrong order.
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+ at data = common global [10 x [1000 x double]] zeroinitializer
+ at symmat = common global [10 x [1000 x double]] zeroinitializer
-define fastcc void @pr33323(ptr nocapture %data, ptr nocapture %symmat) {
+define fastcc void @pr33323() {
entry:
br label %for.body98
@@ -20,14 +21,14 @@ for.body98:
for.body105:
%indvars.iv = phi i64 [ 0, %for.body98 ], [ %indvars.iv.next, %for.body105 ]
- %arrayidx109 = getelementptr inbounds [1000 x double], ptr %data, i64 %indvars.iv, i64 0
+ %arrayidx109 = getelementptr inbounds [1000 x double], ptr @data, i64 %indvars.iv, i64 0
%add119 = fadd double undef, undef
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
%exitcond = icmp eq i64 %indvars.iv.next, 1000
br i1 %exitcond, label %for.end122, label %for.body105
for.end122:
- %arrayidx130 = getelementptr inbounds [1000 x double], ptr %symmat, i64 %indvars.iv13, i64 0
+ %arrayidx130 = getelementptr inbounds [1000 x double], ptr @symmat, i64 %indvars.iv13, i64 0
store double %add119, ptr %arrayidx130
%indvars.iv.next14 = add nuw nsw i64 %indvars.iv13, 1
%exitcond15 = icmp eq i64 %indvars.iv.next14, 1000
>From 1f39c61c768a43f16ff054250d164584b1581bd6 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Sat, 16 Aug 2025 08:49:03 -0500
Subject: [PATCH 4/4] [delinearize] do not rely on GEP for delinearization
This finishes removing the code of GEP delinearization.
Follow up patches will clean the interface, in particular Sizes array of ints
will be rewritten as an array of SCEVs to avoid unnecessary translations.
Another painful point to be addressed in subsequent patches is unifying the
delinearize() interface to avoid users directly hit in the internals of
delinearize. The many uses of delinearization internals makes changes to the
core delinearization algorithm hard to modify.
---
llvm/include/llvm/Analysis/Delinearization.h | 18 --
llvm/lib/Analysis/Delinearization.cpp | 180 +-----------------
.../DependenceAnalysis/DifferentOffsets.ll | 11 +-
.../interchange-cost-beneficial.ll | 4 +-
4 files changed, 15 insertions(+), 198 deletions(-)
diff --git a/llvm/include/llvm/Analysis/Delinearization.h b/llvm/include/llvm/Analysis/Delinearization.h
index 0dafac9102247..5499014242b00 100644
--- a/llvm/include/llvm/Analysis/Delinearization.h
+++ b/llvm/include/llvm/Analysis/Delinearization.h
@@ -139,29 +139,11 @@ bool findFixedSizeArrayDimensions(ScalarEvolution &SE, const SCEV *Expr,
/// Different from the normal delinearization, this function assumes that NO
/// terms exist in the \p Expr. In other words, it assumes that the all step
/// values are constant.
-///
-/// This function is intended to replace getIndexExpressionsFromGEP and
-/// tryDelinearizeFixedSizeImpl. They rely on the GEP source element type so
-/// that they will be removed in the future.
bool delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
SmallVectorImpl<const SCEV *> &Sizes,
const SCEV *ElementSize);
-/// Gathers the individual index expressions from a GEP instruction.
-///
-/// This function optimistically assumes the GEP references into a fixed size
-/// array. If this is actually true, this function returns a list of array
-/// subscript expressions in \p Subscripts and a list of integers describing
-/// the size of the individual array dimensions in \p Sizes. Both lists have
-/// either equal length or the size list is one element shorter in case there
-/// is no known size available for the outermost array dimension. Returns true
-/// if successful and false otherwise.
-bool getIndexExpressionsFromGEP(ScalarEvolution &SE,
- const GetElementPtrInst *GEP,
- SmallVectorImpl<const SCEV *> &Subscripts,
- SmallVectorImpl<int> &Sizes);
-
/// Compute access functions for each subscript in a delinearized array access.
void computeAccessFunctions(ScalarEvolution &SE, const SCEV *Expr,
SmallVectorImpl<const SCEV *> &Subscripts,
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 1d07d632fe787..f9d76ce9002a0 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -41,10 +41,6 @@ static cl::opt<bool> UseFixedSizeArrayHeuristic(
cl::desc("When printing analysis, use the heuristic for fixed-size arrays "
"if the default delinearizetion fails."));
-static cl::opt<bool> useGEPToDelinearize(
- "use-gep-to-delinearize", cl::init(true), cl::Hidden,
- cl::desc("validate both delinearization methods match."));
-
// Return true when S contains at least an undef value.
static inline bool containsUndefs(const SCEV *S) {
return SCEVExprContains(S, [](const SCEV *S) {
@@ -848,56 +844,6 @@ bool llvm::delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
return !Subscripts.empty();
}
-bool llvm::getIndexExpressionsFromGEP(ScalarEvolution &SE,
- const GetElementPtrInst *GEP,
- SmallVectorImpl<const SCEV *> &Subscripts,
- SmallVectorImpl<int> &Sizes) {
- assert(Subscripts.empty() && Sizes.empty() &&
- "Expected output lists to be empty on entry to this function.");
- assert(GEP && "getIndexExpressionsFromGEP called with a null GEP");
- LLVM_DEBUG(dbgs() << "\nGEP to delinearize: " << *GEP << "\n");
- Type *Ty = nullptr;
- bool DroppedFirstDim = false;
- for (unsigned i = 1; i < GEP->getNumOperands(); i++) {
- const SCEV *Expr = SE.getSCEV(GEP->getOperand(i));
- if (i == 1) {
- Ty = GEP->getSourceElementType();
- if (auto *Const = dyn_cast<SCEVConstant>(Expr))
- if (Const->getValue()->isZero()) {
- DroppedFirstDim = true;
- continue;
- }
- Subscripts.push_back(Expr);
- LLVM_DEBUG(dbgs() << "Subscripts push_back: " << *Expr << "\n");
- continue;
- }
-
- auto *ArrayTy = dyn_cast<ArrayType>(Ty);
- if (!ArrayTy) {
- LLVM_DEBUG(dbgs() << "GEP delinearize failed: " << *Ty
- << " is not an array type.\n");
- Subscripts.clear();
- Sizes.clear();
- return false;
- }
-
- Subscripts.push_back(Expr);
- LLVM_DEBUG(dbgs() << "Subscripts push_back: " << *Expr << "\n");
- if (!(DroppedFirstDim && i == 2))
- Sizes.push_back(ArrayTy->getNumElements());
-
- Ty = ArrayTy->getElementType();
- }
- LLVM_DEBUG({
- dbgs() << "Subscripts:\n";
- for (const SCEV *S : Subscripts)
- dbgs() << *S << "\n";
- dbgs() << "\n";
- });
-
- return !Subscripts.empty();
-}
-
bool llvm::tryDelinearizeFixedSizeImpl(
ScalarEvolution *SE, Instruction *Inst, const SCEV *AccessFn,
SmallVectorImpl<const SCEV *> &Subscripts, SmallVectorImpl<int> &Sizes) {
@@ -943,133 +889,15 @@ bool llvm::tryDelinearizeFixedSizeImpl(
// Array_info delinearization.
SmallVector<const SCEV *, 4> SCEVSizes;
const SCEV *ElementSize = SE->getElementSize(Inst);
- bool ArrayInfoSuccess = delinearizeUsingArrayInfo(
- *SE, AccessFn, ArrayInfoSubscripts, SCEVSizes, ElementSize);
+ if (!delinearizeUsingArrayInfo(*SE, AccessFn, Subscripts, SCEVSizes,
+ ElementSize))
+ return false;
// TODO: Remove the following code. Convert SCEV sizes to int sizes. This
// conversion is only needed as long as getIndexExpressionsFromGEP is still
// around. Remove this code and change the interface of
// tryDelinearizeFixedSizeImpl to take a SmallVectorImpl<const SCEV *> &Sizes.
- if (ArrayInfoSuccess)
- convertSCEVSizesToIntSizes(SCEVSizes, ArrayInfoSizes);
-
- // Validate consistency between methods.
- if (GEPSuccess && ArrayInfoSuccess) {
- // If both methods succeeded, validate they produce the same results.
- // Compare sizes arrays.
- if (GEPSizes.size() + 2 != ArrayInfoSizes.size()) {
- LLVM_DEBUG({
- dbgs() << "WARN: Size arrays have different lengths!\n";
- dbgs() << "GEP sizes count: " << GEPSizes.size() << "\n"
- << "ArrayInfo sizes count: " << ArrayInfoSizes.size() << "\n";
- });
- }
-
- for (size_t i = 0; i < GEPSizes.size(); ++i) {
- if (GEPSizes[i] != ArrayInfoSizes[i + 1]) {
- LLVM_DEBUG({
- dbgs() << "WARN: Size arrays differ at index " << i << "!\n";
- dbgs() << "GEP size[" << i << "]: " << GEPSizes[i] << "\n"
- << "ArrayInfo size[" << i + 1 << "]: " << ArrayInfoSizes[i + 1]
- << "\n";
- });
- }
- }
-
- // Compare subscripts arrays.
- if (GEPSubscripts.size() != ArrayInfoSubscripts.size()) {
- LLVM_DEBUG({
- dbgs() << "WARN: Subscript arrays have different lengths!\n";
- dbgs() << " GEP subscripts count: " << GEPSubscripts.size() << "\n"
- << " ArrayInfo subscripts count: " << ArrayInfoSubscripts.size()
- << "\n";
-
- dbgs() << " GEP subscripts:\n";
- for (size_t i = 0; i < GEPSubscripts.size(); ++i)
- dbgs() << " subscript[" << i << "]: " << *GEPSubscripts[i] << "\n";
-
- dbgs() << " ArrayInfo subscripts:\n";
- for (size_t i = 0; i < ArrayInfoSubscripts.size(); ++i)
- dbgs() << " subscript[" << i << "]: " << *ArrayInfoSubscripts[i]
- << "\n";
- });
- }
-
- for (size_t i = 0; i < GEPSubscripts.size(); ++i) {
- const SCEV *GEPS = GEPSubscripts[i];
- const SCEV *AIS = ArrayInfoSubscripts[i];
- // FIXME: there's no good way to compare two scevs: don't abort, warn.
- if (GEPS != AIS || !SE->getMinusSCEV(GEPS, AIS)->isZero()) {
- LLVM_DEBUG({
- dbgs() << "WARN: Subscript arrays differ at index " << i << "!\n";
- dbgs() << " GEP subscript[" << i << "]: " << *GEPSubscripts[i]
- << "\n"
- << " ArrayInfo subscript[" << i
- << "]: " << *ArrayInfoSubscripts[i] << "\n";
- });
- }
- }
-
- LLVM_DEBUG(dbgs() << "SUCCESS: Both delinearization methods produced "
- "identical results\n");
- } else if (GEPSuccess && !ArrayInfoSuccess) {
- LLVM_DEBUG({
- dbgs() << "WARNING: array_info failed and GEP analysis succeeded.\n";
- dbgs() << " Instruction: " << *Inst << "\n";
- dbgs() << " Using GEP analysis results despite array_info failure\n";
- });
- } else if (!GEPSuccess && ArrayInfoSuccess) {
- LLVM_DEBUG({
- dbgs() << "WARNING: GEP failed and array_info analysis succeeded.\n";
- dbgs() << " Instruction: " << *Inst << "\n";
- dbgs() << " Using array_info analysis results despite GEP failure\n";
- });
- } else if (!GEPSuccess && !ArrayInfoSuccess) {
- LLVM_DEBUG({
- dbgs() << "WARNING: both GEP and array_info analysis failed.\n";
- dbgs() << " Instruction: " << *Inst << "\n";
- });
- }
-
- // Choose which result to use.
- // Prefer array_info when available.
- if (ArrayInfoSuccess) {
- Subscripts = std::move(ArrayInfoSubscripts);
- Sizes = std::move(ArrayInfoSizes);
- return true;
- }
-
- // Both failed.
- if (!GEPSuccess)
- return false;
-
- // Return GEP-based delinearization.
- Subscripts = std::move(GEPSubscripts);
- Sizes = std::move(GEPSizes);
-
- // Check that the two size arrays are non-empty and equal in length and
- // value.
- // TODO: it would be better to let the caller to clear Subscripts, similar
- // to how we handle Sizes.
- if (Sizes.empty() || Subscripts.size() <= 1) {
- Subscripts.clear();
- return false;
- }
-
- // Check that for identical base pointers we do not miss index offsets
- // that have been added before this GEP is applied.
- Value *SrcBasePtr = SrcGEP->getOperand(0)->stripPointerCasts();
- const SCEVUnknown *SrcBase =
- dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
- if (!SrcBase || SrcBasePtr != SrcBase->getValue()) {
- Subscripts.clear();
- return false;
- }
-
- assert(Subscripts.size() == Sizes.size() + 1 &&
- "Expected equal number of entries in the list of size and "
- "subscript.");
-
+ convertSCEVSizesToIntSizes(SCEVSizes, Sizes);
return true;
}
diff --git a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
index d9ccea55dd478..668fd188385c2 100644
--- a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
@@ -149,11 +149,18 @@ define void @multidim_accesses(ptr %A) {
; CHECK-NEXT: Src: store i32 1, ptr %idx0, align 4 --> Dst: store i32 1, ptr %idx0, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 1, ptr %idx0, align 4 --> Dst: store i32 1, ptr %idx1, align 4
-; CHECK-NEXT: da analyze - consistent output [0 0 0|<]!
+; CHECK-NEXT: da analyze - output [<= * *|<]!
; CHECK-NEXT: Src: store i32 1, ptr %idx1, align 4 --> Dst: store i32 1, ptr %idx1, align 4
; CHECK-NEXT: da analyze - none!
;
-; FIXME: the dependence distance is not constant. Distance vector should be [* * *|<]!
+; NOTE: the dependence distance between the two stores at idx0 and idx1 is not constant.
+; The dependence direction vector should be "[<= * *|<]!"
+;
+; The memory accesses used to be GEP-delinearized leading to 32b and 64b stores
+; with the same subscript access functions to the same array A, leading the
+; dependence analysis to incorrect constant distance "[0 0 0|<]!" dependences.
+; The distance is not constant: 64b store's strides in memory is twice the 32b store.
+;
; for (i = 0; i < 256; i++)
; for (j = 0; j < 256; j++)
; for (k = 0; k < 256; k++) {
diff --git a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
index d68833a7f5712..9f88f3b529a6a 100644
--- a/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
+++ b/llvm/test/Analysis/LoopCacheAnalysis/interchange-cost-beneficial.ll
@@ -23,8 +23,8 @@
; E[j] = 1
; }
-; CHECK: Loop 'for.j' has cost = 18
-; CHECK-NEXT: Loop 'for.i' has cost = 10
+; CHECK: Loop 'for.j' has cost = 12
+; CHECK-NEXT: Loop 'for.i' has cost = 8
define void @test() {
More information about the llvm-commits
mailing list