From 5230ad61fd35d3006e7764c3152d28e2e68c288f Mon Sep 17 00:00:00 2001 From: Sebastian Pop Date: Tue, 12 Nov 2013 22:47:20 +0000 Subject: delinearization of arrays git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@194527 91177308-0d34-0410-b5e6-96231b3b80d8 --- test/Analysis/Delinearization/a.ll | 74 +++++++++++++++ test/Analysis/Delinearization/himeno_1.ll | 102 +++++++++++++++++++++ test/Analysis/Delinearization/himeno_2.ll | 102 +++++++++++++++++++++ test/Analysis/Delinearization/lit.local.cfg | 1 + .../multidim_ivs_and_integer_offsets_3d.ll | 68 ++++++++++++++ .../multidim_ivs_and_integer_offsets_nts_3d.ll | 72 +++++++++++++++ .../multidim_ivs_and_parameteric_offsets_3d.ll | 68 ++++++++++++++ .../Delinearization/multidim_only_ivs_2d.ll | 46 ++++++++++ .../Delinearization/multidim_only_ivs_2d_nested.ll | 78 ++++++++++++++++ .../Delinearization/multidim_only_ivs_3d.ll | 65 +++++++++++++ .../Delinearization/multidim_only_ivs_3d_cast.ll | 75 +++++++++++++++ 11 files changed, 751 insertions(+) create mode 100644 test/Analysis/Delinearization/a.ll create mode 100644 test/Analysis/Delinearization/himeno_1.ll create mode 100644 test/Analysis/Delinearization/himeno_2.ll create mode 100644 test/Analysis/Delinearization/lit.local.cfg create mode 100644 test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll create mode 100644 test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll create mode 100644 test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll create mode 100644 test/Analysis/Delinearization/multidim_only_ivs_2d.ll create mode 100644 test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll create mode 100644 test/Analysis/Delinearization/multidim_only_ivs_3d.ll create mode 100644 test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll (limited to 'test/Analysis') diff --git a/test/Analysis/Delinearization/a.ll b/test/Analysis/Delinearization/a.ll new file mode 100644 index 0000000..9308749 --- /dev/null +++ b/test/Analysis/Delinearization/a.ll @@ -0,0 +1,74 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s +; +; void foo(long n, long m, long o, int A[n][m][o]) { +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; for (long k = 0; k < o; k++) +; A[2*i+3][3*j-4][5*k+7] = 1; +; } + +; AddRec: {{{(28 + (4 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(i32) bytes. +; CHECK: ArrayRef[{3,+,2}<%for.i>][{-4,+,3}<%for.j>][{7,+,5}<%for.k>] + +; AddRec: {{(8 + ((4 + (12 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%o] with elements of sizeof(i32) bytes. +; CHECK: ArrayRef[{(1 + (3 * %m)),+,(2 * %m)}<%for.i>][{2,+,(3 * %o)}<%for.j>] + +; AddRec: {(8 + ((-8 + (24 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of 2 bytes. +; CHECK: ArrayRef[{((1 + ((-1 + (3 * %m)) * %o)) * sizeof(i32)),+,(%m * %o * sizeof(i32))}<%for.i>] + +; Function Attrs: nounwind uwtable +define void @foo(i64 %n, i64 %m, i64 %o, i32* nocapture %A) #0 { +entry: + %cmp32 = icmp sgt i64 %n, 0 + br i1 %cmp32, label %for.cond1.preheader.lr.ph, label %for.end17 + +for.cond1.preheader.lr.ph: ; preds = %entry + %cmp230 = icmp sgt i64 %m, 0 + %cmp528 = icmp sgt i64 %o, 0 + br i1 %cmp230, label %for.i, label %for.end17 + +for.inc15.us: ; preds = %for.inc12.us.us, %for.i + %inc16.us = add nsw i64 %i.033.us, 1 + %exitcond55 = icmp eq i64 %inc16.us, %n + br i1 %exitcond55, label %for.end17, label %for.i + +for.i: ; preds = %for.cond1.preheader.lr.ph, %for.inc15.us + %i.033.us = phi i64 [ %inc16.us, %for.inc15.us ], [ 0, %for.cond1.preheader.lr.ph ] + %mul8.us = shl i64 %i.033.us, 1 + %add9.us = add nsw i64 %mul8.us, 3 + %0 = mul i64 %add9.us, %m + %sub.us = add i64 %0, -4 + br i1 %cmp528, label %for.j, label %for.inc15.us + +for.inc12.us.us: ; preds = %for.k + %inc13.us.us = add nsw i64 %j.031.us.us, 1 + %exitcond54 = icmp eq i64 %inc13.us.us, %m + br i1 %exitcond54, label %for.inc15.us, label %for.j + +for.j: ; preds = %for.i, %for.inc12.us.us + %j.031.us.us = phi i64 [ %inc13.us.us, %for.inc12.us.us ], [ 0, %for.i ] + %mul7.us.us = mul nsw i64 %j.031.us.us, 3 + %tmp.us.us = add i64 %sub.us, %mul7.us.us + %tmp27.us.us = mul i64 %tmp.us.us, %o + br label %for.k + +for.k: ; preds = %for.k, %for.j + %k.029.us.us = phi i64 [ 0, %for.j ], [ %inc.us.us, %for.k ] + %mul.us.us = mul nsw i64 %k.029.us.us, 5 + %arrayidx.sum.us.us = add i64 %mul.us.us, 7 + %arrayidx10.sum.us.us = add i64 %arrayidx.sum.us.us, %tmp27.us.us + %arrayidx11.us.us = getelementptr inbounds i32* %A, i64 %arrayidx10.sum.us.us + store i32 1, i32* %arrayidx11.us.us, align 4 + %inc.us.us = add nsw i64 %k.029.us.us, 1 + %exitcond = icmp eq i64 %inc.us.us, %o + br i1 %exitcond, label %for.inc12.us.us, label %for.k + +for.end17: ; preds = %for.inc15.us, %for.cond1.preheader.lr.ph, %entry + ret void +} diff --git a/test/Analysis/Delinearization/himeno_1.ll b/test/Analysis/Delinearization/himeno_1.ll new file mode 100644 index 0000000..9458bd2 --- /dev/null +++ b/test/Analysis/Delinearization/himeno_1.ll @@ -0,0 +1,102 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; #define MR(mt,n,r,c,d) mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)] +; +; struct Mat { +; float* m; +; int mnums; +; int mrows; +; int mcols; +; int mdeps; +; }; +; +; typedef struct Mat Matrix; +; +; void jacobi(int nn, Matrix* a, Matrix* p) +; { +; long i, j, k, max,jmax,kmax; +; +; p_rows_sub = p->mrows - 1; +; p_cols_sub = p->mcols - 1; +; p_deps_sub = p->mdeps - 1; +; +; for(i = 1; i < p_rows_sub; i++) +; for(j = 1; j < p_cols_sub; j++) +; for(k = 1; k < p_deps_sub; k++) +; MR(a,0,i,j,k) = i + j + k; +; } + +; AddRec: {{{(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j>,+,4}<%for.k> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{1,+,1}<%for.i>][{1,+,1}<%for.j>][{1,+,1}<%for.k>] + +; AddRec: {{(-4 + (4 * (sext i32 (-1 + %p.deps) to i64)) + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.deps to i64)] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{(1 + (sext i32 %a.cols to i64)),+,(sext i32 %a.cols to i64)}<%for.i>][{(-1 + (sext i32 (-1 + %p.deps) to i64)),+,(sext i32 %a.deps to i64)}<%for.j>] + +; AddRec: {(-4 + (4 * (sext i32 (-1 + %p.deps) to i64)) + ((sext i32 %a.deps to i64) * (-4 + (4 * (sext i32 (-1 + %p.cols) to i64)) + (4 * (sext i32 %a.cols to i64)))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{(-1 + (sext i32 (-1 + %p.deps) to i64) + ((sext i32 %a.deps to i64) * (-1 + (sext i32 (-1 + %p.cols) to i64) + (sext i32 %a.cols to i64)))),+,((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>] + +%struct.Mat = type { float*, i32, i32, i32, i32 } + +define void @jacobi(i32 %nn, %struct.Mat* nocapture %a, %struct.Mat* nocapture %p) nounwind uwtable { +entry: + %p.rows.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 2 + %p.rows = load i32* %p.rows.ptr + %p.rows.sub = add i32 %p.rows, -1 + %p.rows.sext = sext i32 %p.rows.sub to i64 + %p.cols.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 3 + %p.cols = load i32* %p.cols.ptr + %p.cols.sub = add i32 %p.cols, -1 + %p.cols.sext = sext i32 %p.cols.sub to i64 + %p.deps.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 4 + %p.deps = load i32* %p.deps.ptr + %p.deps.sub = add i32 %p.deps, -1 + %p.deps.sext = sext i32 %p.deps.sub to i64 + %a.cols.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 3 + %a.cols = load i32* %a.cols.ptr + %a.deps.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 4 + %a.deps = load i32* %a.deps.ptr + %a.base.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 0 + %a.base = load float** %a.base.ptr, align 8 + br label %for.i + +for.i: ; preds = %for.i.inc, %entry + %i = phi i64 [ %i.inc, %for.i.inc ], [ 1, %entry ] + br label %for.j + +for.j: ; preds = %for.j.inc, %for.i + %j = phi i64 [ %j.inc, %for.j.inc ], [ 1, %for.i ] + %a.cols.sext = sext i32 %a.cols to i64 + %a.deps.sext = sext i32 %a.deps to i64 + br label %for.k + +for.k: ; preds = %for.k, %for.j + %k = phi i64 [ 1, %for.j ], [ %k.inc, %for.k ] + %tmp1 = mul nsw i64 %a.cols.sext, %i + %tmp2 = add i64 %tmp1, %j + %tmp3 = mul i64 %tmp2, %a.deps.sext + %tmp4 = add nsw i64 %k, %tmp3 + %arrayidx = getelementptr inbounds float* %a.base, i64 %tmp4 + store float 1.000000e+00, float* %arrayidx + %k.inc = add nsw i64 %k, 1 + %k.exitcond = icmp eq i64 %k.inc, %p.deps.sext + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: ; preds = %for.k + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %p.cols.sext + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: ; preds = %for.j.inc + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %p.rows.sext + br i1 %i.exitcond, label %end, label %for.i + +end: ; preds = %for.i.inc + ret void +} diff --git a/test/Analysis/Delinearization/himeno_2.ll b/test/Analysis/Delinearization/himeno_2.ll new file mode 100644 index 0000000..a290066 --- /dev/null +++ b/test/Analysis/Delinearization/himeno_2.ll @@ -0,0 +1,102 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; #define MR(mt,n,r,c,d) mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)] +; +; struct Mat { +; float* m; +; int mnums; +; int mrows; +; int mcols; +; int mdeps; +; }; +; +; typedef struct Mat Matrix; +; +; void jacobi(int nn, Matrix* a, Matrix* p) +; { +; long i, j, k, max,jmax,kmax; +; +; p_rows_sub = p->mrows - 1; +; p_cols_sub = p->mcols - 1; +; p_deps_sub = p->mdeps - 1; +; +; for(i = 1; i < p_rows_sub; i++) +; for(j = 1; j < p_cols_sub; j++) +; for(k = 1; k < p_deps_sub; k++) +; MR(a,0,i,j,k) = i + j + k; +; } + +; AddRec: {{{(4 + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j>,+,4}<%for.k> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.cols to i64)][(sext i32 %a.deps to i64)] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{1,+,1}<%for.i>][{1,+,1}<%for.j>][{1,+,1}<%for.k>] + +; AddRec: {{(-4 + (4 * (sext i32 (-1 + %p.deps) to i64)) + (4 * (sext i32 %a.deps to i64) * (1 + (sext i32 %a.cols to i64))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>,+,(4 * (sext i32 %a.deps to i64))}<%for.j> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize][(sext i32 %a.deps to i64)] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{(1 + (sext i32 %a.cols to i64)),+,(sext i32 %a.cols to i64)}<%for.i>][{(-1 + (sext i32 (-1 + %p.deps) to i64)),+,(sext i32 %a.deps to i64)}<%for.j>] + +; AddRec: {(-4 + (4 * (sext i32 (-1 + %p.deps) to i64)) + ((sext i32 %a.deps to i64) * (-4 + (4 * (sext i32 (-1 + %p.cols) to i64)) + (4 * (sext i32 %a.cols to i64)))) + %a.base),+,(4 * (sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i> +; CHECK: Base offset: %a.base +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(float) bytes. +; CHECK: ArrayRef[{(-1 + (sext i32 (-1 + %p.deps) to i64) + ((sext i32 %a.deps to i64) * (-1 + (sext i32 (-1 + %p.cols) to i64) + (sext i32 %a.cols to i64)))),+,((sext i32 %a.deps to i64) * (sext i32 %a.cols to i64))}<%for.i>] + +%struct.Mat = type { float*, i32, i32, i32, i32 } + +define void @jacobi(i32 %nn, %struct.Mat* nocapture %a, %struct.Mat* nocapture %p) nounwind uwtable { +entry: + %p.rows.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 2 + %p.rows = load i32* %p.rows.ptr + %p.rows.sub = add i32 %p.rows, -1 + %p.rows.sext = sext i32 %p.rows.sub to i64 + %p.cols.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 3 + %p.cols = load i32* %p.cols.ptr + %p.cols.sub = add i32 %p.cols, -1 + %p.cols.sext = sext i32 %p.cols.sub to i64 + %p.deps.ptr = getelementptr inbounds %struct.Mat* %p, i64 0, i32 4 + %p.deps = load i32* %p.deps.ptr + %p.deps.sub = add i32 %p.deps, -1 + %p.deps.sext = sext i32 %p.deps.sub to i64 + %a.cols.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 3 + %a.cols = load i32* %a.cols.ptr + %a.cols.sext = sext i32 %a.cols to i64 + %a.deps.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 4 + %a.deps = load i32* %a.deps.ptr + %a.deps.sext = sext i32 %a.deps to i64 + %a.base.ptr = getelementptr inbounds %struct.Mat* %a, i64 0, i32 0 + %a.base = load float** %a.base.ptr, align 8 + br label %for.i + +for.i: ; preds = %for.i.inc, %entry + %i = phi i64 [ %i.inc, %for.i.inc ], [ 1, %entry ] + br label %for.j + +for.j: ; preds = %for.j.inc, %for.i + %j = phi i64 [ %j.inc, %for.j.inc ], [ 1, %for.i ] + br label %for.k + +for.k: ; preds = %for.k, %for.j + %k = phi i64 [ 1, %for.j ], [ %k.inc, %for.k ] + %tmp1 = mul nsw i64 %a.cols.sext, %i + %tmp2 = add i64 %tmp1, %j + %tmp3 = mul i64 %tmp2, %a.deps.sext + %tmp4 = add nsw i64 %k, %tmp3 + %arrayidx = getelementptr inbounds float* %a.base, i64 %tmp4 + store float 1.000000e+00, float* %arrayidx + %k.inc = add nsw i64 %k, 1 + %k.exitcond = icmp eq i64 %k.inc, %p.deps.sext + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: ; preds = %for.k + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %p.cols.sext + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: ; preds = %for.j.inc + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %p.rows.sext + br i1 %i.exitcond, label %end, label %for.i + +end: ; preds = %for.i.inc + ret void +} diff --git a/test/Analysis/Delinearization/lit.local.cfg b/test/Analysis/Delinearization/lit.local.cfg new file mode 100644 index 0000000..19eebc0 --- /dev/null +++ b/test/Analysis/Delinearization/lit.local.cfg @@ -0,0 +1 @@ +config.suffixes = ['.ll', '.c', '.cpp'] diff --git a/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll b/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll new file mode 100644 index 0000000..82cab16 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll @@ -0,0 +1,68 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; void foo(long n, long m, long o, double A[n][m][o]) { +; +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; for (long k = 0; k < o; k++) +; A[i+3][j-4][k+7] = 1.0; +; } + +; AddRec: {{{(56 + (8 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{3,+,1}<%for.i>][{-4,+,1}<%for.j>][{7,+,1}<%for.k>] + +; AddRec: {{(48 + ((-24 + (24 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%o] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(-3 + (3 * %m)),+,%m}<%for.i>][{6,+,%o}<%for.j>] + +; AddRec: {(48 + ((-32 + (32 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(6 + ((-4 + (4 * %m)) * %o)),+,(%m * %o)}<%for.i>] + +define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { +entry: + br label %for.i + +for.i: + %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] + br label %for.j + +for.j: + %j = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ] + br label %for.k + +for.k: + %k = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ] + %offset0 = add nsw i64 %i, 3 + %subscript0 = mul i64 %offset0, %m + %offset1 = add nsw i64 %j, -4 + %subscript1 = add i64 %offset1, %subscript0 + %subscript2 = mul i64 %subscript1, %o + %offset2 = add nsw i64 %k, 7 + %subscript = add i64 %subscript2, %offset2 + %idx = getelementptr inbounds double* %A, i64 %subscript + store double 1.0, double* %idx + br label %for.k.inc + +for.k.inc: + %k.inc = add nsw i64 %k, 1 + %k.exitcond = icmp eq i64 %k.inc, %o + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %m + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %n + br i1 %i.exitcond, label %end, label %for.i + +end: + ret void +} diff --git a/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll b/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll new file mode 100644 index 0000000..a1e779f --- /dev/null +++ b/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll @@ -0,0 +1,72 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; void foo(long n, long m, long o, long p, double A[n][m][o+p]) { +; +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; for (long k = 0; k < o; k++) +; A[i+3][j-4][k+7] = 1.0; +; } + +; AddRec: {{{(56 + (8 * (-4 + (3 * %m)) * (%o + %p)) + %A),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>,+,(8 * (%o + %p))}<%for.body6.lr.ph.us.us>,+,8}<%for.body6.us.us> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m][(%o + %p)] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{3,+,1}<%for.cond4.preheader.lr.ph.us>][{-4,+,1}<%for.body6.lr.ph.us.us>][{7,+,1}<%for.body6.us.us>] + +; AddRec: {{(48 + (8 * %o) + (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> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][(%o + %p)] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(-4 + (3 * %m)),+,%m}<%for.cond4.preheader.lr.ph.us>][{(6 + %o),+,(%o + %p)}<%for.body6.lr.ph.us.us>] + +; AddRec: {(48 + (8 * %o) + ((-40 + (32 * %m)) * (%o + %p)) + %A),+,(8 * (%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(6 + ((-5 + (4 * %m)) * (%o + %p)) + %o),+,((%o + %p) * %m)}<%for.cond4.preheader.lr.ph.us>] + +define void @foo(i64 %n, i64 %m, i64 %o, i64 %p, double* nocapture %A) nounwind uwtable { +entry: + %add = add nsw i64 %p, %o + %cmp22 = icmp sgt i64 %n, 0 + br i1 %cmp22, label %for.cond1.preheader.lr.ph, label %for.end16 + +for.cond1.preheader.lr.ph: ; preds = %entry + %cmp220 = icmp sgt i64 %m, 0 + %cmp518 = icmp sgt i64 %o, 0 + br i1 %cmp220, label %for.cond4.preheader.lr.ph.us, label %for.end16 + +for.inc14.us: ; preds = %for.cond4.preheader.lr.ph.us, %for.inc11.us.us + %inc15.us = add nsw i64 %i.023.us, 1 + %exitcond43 = icmp eq i64 %inc15.us, %n + br i1 %exitcond43, label %for.end16, label %for.cond4.preheader.lr.ph.us + +for.cond4.preheader.lr.ph.us: ; preds = %for.inc14.us, %for.cond1.preheader.lr.ph + %i.023.us = phi i64 [ %inc15.us, %for.inc14.us ], [ 0, %for.cond1.preheader.lr.ph ] + %add8.us = add nsw i64 %i.023.us, 3 + %0 = mul i64 %add8.us, %m + %sub.us = add i64 %0, -4 + br i1 %cmp518, label %for.body6.lr.ph.us.us, label %for.inc14.us + +for.inc11.us.us: ; preds = %for.body6.us.us + %inc12.us.us = add nsw i64 %j.021.us.us, 1 + %exitcond42 = icmp eq i64 %inc12.us.us, %m + br i1 %exitcond42, label %for.inc14.us, label %for.body6.lr.ph.us.us + +for.body6.lr.ph.us.us: ; preds = %for.cond4.preheader.lr.ph.us, %for.inc11.us.us + %j.021.us.us = phi i64 [ %inc12.us.us, %for.inc11.us.us ], [ 0, %for.cond4.preheader.lr.ph.us ] + %tmp.us.us = add i64 %sub.us, %j.021.us.us + %tmp17.us.us = mul i64 %tmp.us.us, %add + br label %for.body6.us.us + +for.body6.us.us: ; preds = %for.body6.us.us, %for.body6.lr.ph.us.us + %k.019.us.us = phi i64 [ 0, %for.body6.lr.ph.us.us ], [ %inc.us.us, %for.body6.us.us ] + %arrayidx.sum.us.us = add i64 %k.019.us.us, 7 + %arrayidx9.sum.us.us = add i64 %arrayidx.sum.us.us, %tmp17.us.us + %arrayidx10.us.us = getelementptr inbounds double* %A, i64 %arrayidx9.sum.us.us + store double 1.000000e+00, double* %arrayidx10.us.us, align 8 + %inc.us.us = add nsw i64 %k.019.us.us, 1 + %exitcond = icmp eq i64 %inc.us.us, %o + br i1 %exitcond, label %for.inc11.us.us, label %for.body6.us.us + +for.end16: ; preds = %for.cond1.preheader.lr.ph, %for.inc14.us, %entry + ret void +} diff --git a/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll b/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll new file mode 100644 index 0000000..a52a4c9 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll @@ -0,0 +1,68 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) { +; +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; for (long k = 0; k < o; k++) +; A[i+p][j+q][k+r] = 1.0; +; } + +; AddRec: {{{((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{%p,+,1}<%for.i>][{%q,+,1}<%for.j>][{%r,+,1}<%for.k>] + +; AddRec: {{(-8 + (8 * ((((%m * %p) + %q) * %o) + %r)) + (8 * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%o] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(1 + (%m * %p) + %q),+,%m}<%for.i>][{(-1 + %r),+,%o}<%for.j>] + +; AddRec: {(-8 + (8 * ((((%m * %p) + %q) * %o) + %r)) + (8 * %m * %o) + %A),+,(8 * %m * %o)}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(-1 + ((((1 + %p) * %m) + %q) * %o) + %r),+,(%m * %o)}<%for.i>] + +define void @foo(i64 %n, i64 %m, i64 %o, double* %A, i64 %p, i64 %q, i64 %r) { +entry: + br label %for.i + +for.i: + %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] + br label %for.j + +for.j: + %j = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ] + br label %for.k + +for.k: + %k = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ] + %offset0 = add nsw i64 %i, %p + %subscript0 = mul i64 %offset0, %m + %offset1 = add nsw i64 %j, %q + %subscript1 = add i64 %offset1, %subscript0 + %subscript2 = mul i64 %subscript1, %o + %offset2 = add nsw i64 %k, %r + %subscript = add i64 %subscript2, %offset2 + %idx = getelementptr inbounds double* %A, i64 %subscript + store double 1.0, double* %idx + br label %for.k.inc + +for.k.inc: + %k.inc = add nsw i64 %k, 1 + %k.exitcond = icmp eq i64 %k.inc, %o + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %m + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %n + br i1 %i.exitcond, label %end, label %for.i + +end: + ret void +} diff --git a/test/Analysis/Delinearization/multidim_only_ivs_2d.ll b/test/Analysis/Delinearization/multidim_only_ivs_2d.ll new file mode 100644 index 0000000..d68a158 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_only_ivs_2d.ll @@ -0,0 +1,46 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; Derived from the following code: +; +; void foo(long n, long m, double A[n][m]) { +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; A[i][j] = 1.0; +; } + +; AddRec: {{%A,+,(8 * %m)}<%for.i>,+,8}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{0,+,1}<%for.i>][{0,+,1}<%for.j>] + +; AddRec: {(-8 + (8 * %m) + %A),+,(8 * %m)}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(-1 + %m),+,%m}<%for.i>] + +define void @foo(i64 %n, i64 %m, double* %A) { +entry: + br label %for.i + +for.i: + %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] + %tmp = mul nsw i64 %i, %m + br label %for.j + +for.j: + %j = phi i64 [ 0, %for.i ], [ %j.inc, %for.j ] + %vlaarrayidx.sum = add i64 %j, %tmp + %arrayidx = getelementptr inbounds double* %A, i64 %vlaarrayidx.sum + store double 1.0, double* %arrayidx + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %m + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %n + br i1 %i.exitcond, label %end, label %for.i + +end: + ret void +} diff --git a/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll b/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll new file mode 100644 index 0000000..7207420 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll @@ -0,0 +1,78 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; extern void bar(long n, long m, double A[n][m]); +; +; void foo(long a, long b) { +; for (long n = 1; n < a; ++n) +; for (long m = 1; m < b; ++m) { +; double A[n][m]; +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; A[i][j] = 1.0; +; bar(n, m, A); +; } +; } + +; AddRec: {{%vla.us,+,{8,+,8}<%for.cond7.preheader.lr.ph.split.us.us>}<%for.body9.lr.ph.us.us>,+,8}<%for.body9.us.us> +; CHECK: Base offset: %vla.us +; CHECK: ArrayDecl[UnknownSize][{1,+,1}<%for.cond7.preheader.lr.ph.split.us.us>] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{0,+,1}<%for.body9.lr.ph.us.us>][{0,+,1}<%for.body9.us.us>] + +define void @foo(i64 %a, i64 %b) nounwind uwtable { +entry: + %cmp43 = icmp sgt i64 %a, 1 + br i1 %cmp43, label %for.cond1.preheader.lr.ph, label %for.end19 + +for.cond1.preheader.lr.ph: ; preds = %entry + %cmp224 = icmp sgt i64 %b, 1 + br label %for.cond1.preheader + +for.cond1.preheader: ; preds = %for.inc17, %for.cond1.preheader.lr.ph + %indvars.iv51 = phi i64 [ 1, %for.cond1.preheader.lr.ph ], [ %indvars.iv.next52, %for.inc17 ] + br i1 %cmp224, label %for.cond7.preheader.lr.ph.split.us.us, label %for.inc17 + +for.end13.us: ; preds = %for.inc11.us.us + call void @bar(i64 %indvars.iv51, i64 %indvars.iv48, double* %vla.us) nounwind + call void @llvm.stackrestore(i8* %1) + %indvars.iv.next49 = add i64 %indvars.iv48, 1 + %exitcond54 = icmp eq i64 %indvars.iv.next49, %b + br i1 %exitcond54, label %for.inc17, label %for.cond7.preheader.lr.ph.split.us.us + +for.inc11.us.us: ; preds = %for.body9.us.us + %inc12.us.us = add nsw i64 %i.023.us.us, 1 + %exitcond53 = icmp eq i64 %inc12.us.us, %indvars.iv51 + br i1 %exitcond53, label %for.end13.us, label %for.body9.lr.ph.us.us + +for.body9.lr.ph.us.us: ; preds = %for.cond7.preheader.lr.ph.split.us.us, %for.inc11.us.us + %i.023.us.us = phi i64 [ 0, %for.cond7.preheader.lr.ph.split.us.us ], [ %inc12.us.us, %for.inc11.us.us ] + %0 = mul nsw i64 %i.023.us.us, %indvars.iv48 + br label %for.body9.us.us + +for.body9.us.us: ; preds = %for.body9.us.us, %for.body9.lr.ph.us.us + %j.021.us.us = phi i64 [ 0, %for.body9.lr.ph.us.us ], [ %inc.us.us, %for.body9.us.us ] + %arrayidx.sum.us.us = add i64 %j.021.us.us, %0 + %arrayidx10.us.us = getelementptr inbounds double* %vla.us, i64 %arrayidx.sum.us.us + store double 1.000000e+00, double* %arrayidx10.us.us, align 8 + %inc.us.us = add nsw i64 %j.021.us.us, 1 + %exitcond50 = icmp eq i64 %inc.us.us, %indvars.iv48 + br i1 %exitcond50, label %for.inc11.us.us, label %for.body9.us.us + +for.cond7.preheader.lr.ph.split.us.us: ; preds = %for.cond1.preheader, %for.end13.us + %indvars.iv48 = phi i64 [ %indvars.iv.next49, %for.end13.us ], [ 1, %for.cond1.preheader ] + %1 = call i8* @llvm.stacksave() + %2 = mul nuw i64 %indvars.iv48, %indvars.iv51 + %vla.us = alloca double, i64 %2, align 16 + br label %for.body9.lr.ph.us.us + +for.inc17: ; preds = %for.end13.us, %for.cond1.preheader + %indvars.iv.next52 = add i64 %indvars.iv51, 1 + %exitcond55 = icmp eq i64 %indvars.iv.next52, %a + br i1 %exitcond55, label %for.end19, label %for.cond1.preheader + +for.end19: ; preds = %for.inc17, %entry + ret void +} + +declare i8* @llvm.stacksave() nounwind +declare void @bar(i64, i64, double*) +declare void @llvm.stackrestore(i8*) nounwind diff --git a/test/Analysis/Delinearization/multidim_only_ivs_3d.ll b/test/Analysis/Delinearization/multidim_only_ivs_3d.ll new file mode 100644 index 0000000..24f9583 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_only_ivs_3d.ll @@ -0,0 +1,65 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s + +; void foo(long n, long m, long o, double A[n][m][o]) { +; +; for (long i = 0; i < n; i++) +; for (long j = 0; j < m; j++) +; for (long k = 0; k < o; k++) +; A[i][j][k] = 1.0; +; } + +; AddRec: {{{%A,+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j>,+,8}<%for.k> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{0,+,1}<%for.i>][{0,+,1}<%for.j>][{0,+,1}<%for.k>] + +; AddRec: {{(-8 + (8 * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(8 * %o)}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][(%m * %o)] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{0,+,1}<%for.i>][{(-1 + %o),+,%o}<%for.j>] + +; AddRec: {(-8 + (8 * %m * %o) + %A),+,(8 * %m * %o)}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of sizeof(double) bytes. +; CHECK: ArrayRef[{(-1 + (%m * %o)),+,(%m * %o)}<%for.i>] + +define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { +entry: + br label %for.i + +for.i: + %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] + br label %for.j + +for.j: + %j = phi i64 [ 0, %for.i ], [ %j.inc, %for.j.inc ] + br label %for.k + +for.k: + %k = phi i64 [ 0, %for.j ], [ %k.inc, %for.k.inc ] + %subscript0 = mul i64 %i, %m + %subscript1 = add i64 %j, %subscript0 + %subscript2 = mul i64 %subscript1, %o + %subscript = add i64 %subscript2, %k + %idx = getelementptr inbounds double* %A, i64 %subscript + store double 1.0, double* %idx + br label %for.k.inc + +for.k.inc: + %k.inc = add nsw i64 %k, 1 + %k.exitcond = icmp eq i64 %k.inc, %o + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: + %j.inc = add nsw i64 %j, 1 + %j.exitcond = icmp eq i64 %j.inc, %m + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: + %i.inc = add nsw i64 %i, 1 + %i.exitcond = icmp eq i64 %i.inc, %n + br i1 %i.exitcond, label %end, label %for.i + +end: + ret void +} diff --git a/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll b/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll new file mode 100644 index 0000000..e151610 --- /dev/null +++ b/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll @@ -0,0 +1,75 @@ +; RUN: opt < %s -analyze -delinearize | FileCheck %s +; void foo(int n, int m, int o, double A[n][m][o]) { +; +; for (int i = 0; i < n; i++) +; for (int j = 0; j < m; j++) +; for (int k = 0; k < o; k++) +; A[i][j][k] = 1.0; +; } + +; AddRec: {{{%A,+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))}<%for.j>,+,8}<%for.k> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][(zext i32 %m to i64)][(zext i32 %o to i64)] with elements of 8 bytes. +; CHECK: ArrayRef[{0,+,1}<%for.i>][{0,+,1}<%for.j>][{0,+,1}<%for.k>] + +; AddRec: {{((8 * (zext i32 (-1 + %o) to i64)) + %A),+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>,+,(8 * (zext i32 %o to i64))}<%for.j> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize][((zext i32 %m to i64) * (zext i32 %o to i64))] with elements of 8 bytes. +; CHECK: ArrayRef[{0,+,1}<%for.i>][{(zext i32 (-1 + %o) to i64),+,(zext i32 %o to i64)}<%for.j>] + +; AddRec: {((8 * (zext i32 (-1 + %o) to i64)) + (8 * (zext i32 (-1 + %m) to i64) * (zext i32 %o to i64)) + %A),+,(8 * (zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i> +; CHECK: Base offset: %A +; CHECK: ArrayDecl[UnknownSize] with elements of 8 bytes. +; CHECK: ArrayRef[{((zext i32 (-1 + %o) to i64) + ((zext i32 (-1 + %m) to i64) * (zext i32 %o to i64))),+,((zext i32 %m to i64) * (zext i32 %o to i64))}<%for.i>] + +target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +define void @foo(i32 %n, i32 %m, i32 %o, double* %A) { +entry: + %m_zext = zext i32 %m to i64 + %n_zext = zext i32 %o to i64 + br label %for.i + +for.i: + %i = phi i64 [ %i.inc, %for.i.inc ], [ 0, %entry ] + br label %for.j + +for.j: + %j = phi i64 [ %j.inc, %for.j.inc ], [ 0, %for.i ] + br label %for.k + +for.k: + %k = phi i64 [ %k.inc, %for.k.inc ], [ 0, %for.j ] + %tmp = mul i64 %i, %m_zext + %tmp1 = trunc i64 %j to i32 + %tmp2 = trunc i64 %i to i32 + %mul.us.us = mul nsw i32 %tmp1, %tmp2 + %tmp.us.us = add i64 %j, %tmp + %tmp17.us.us = mul i64 %tmp.us.us, %n_zext + %subscript = add i64 %tmp17.us.us, %k + %idx = getelementptr inbounds double* %A, i64 %subscript + store double 1.0, double* %idx + br label %for.k.inc + +for.k.inc: + %k.inc = add i64 %k, 1 + %k.inc.trunc = trunc i64 %k.inc to i32 + %k.exitcond = icmp eq i32 %k.inc.trunc, %o + br i1 %k.exitcond, label %for.j.inc, label %for.k + +for.j.inc: + %j.inc = add i64 %j, 1 + %j.inc.trunc = trunc i64 %j.inc to i32 + %j.exitcond = icmp eq i32 %j.inc.trunc, %m + br i1 %j.exitcond, label %for.i.inc, label %for.j + +for.i.inc: + %i.inc = add i64 %i, 1 + %i.inc.trunc = trunc i64 %i.inc to i32 + %i.exitcond = icmp eq i32 %i.inc.trunc, %n + br i1 %i.exitcond, label %end, label %for.i + +end: + ret void +} -- cgit v1.1