summaryrefslogtreecommitdiff
path: root/gcc/testsuite
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/testsuite')
-rw-r--r--gcc/testsuite/ChangeLog16
-rw-r--r--gcc/testsuite/g++.dg/vect/pr21218.cc18
-rw-r--r--gcc/testsuite/g++.dg/vect/vect.exp2
-rw-r--r--gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c13
-rw-r--r--gcc/testsuite/gcc.dg/vect/pr20122.c20
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-100.c80
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-101.c49
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-102.c55
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-103.c57
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-104.c66
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-105.c66
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-115.c75
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-116.c28
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-43.c26
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect-91.c14
-rw-r--r--gcc/testsuite/gcc.dg/vect/vect.exp2
-rw-r--r--gcc/testsuite/gfortran.dg/vect/pr19049.f9024
-rw-r--r--gcc/testsuite/gfortran.dg/vect/vect-4.f9010
-rw-r--r--gcc/testsuite/gfortran.dg/vect/vect.exp2
19 files changed, 587 insertions, 36 deletions
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index a5d540ca5cb..4656f1b6b62 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,19 @@
+2005-07-25 Ira Rosen <irar@il.ibm.com>
+
+ * gcc.dg/vect/vect.exp: Change verbosity level to 4.
+ * gfortran.dg/vect/vect.exp, g++.dg/vect/vect.exp: Likewise.
+ * gcc.dg/vect/pr20122.c: Add vectorizable version of the loop.
+ * gcc.dg/vect/vect-100.c: New test.
+ * gcc.dg/vect/vect-101.c, gcc.dg/vect/vect-102.c,
+ gcc.dg/vect/vect-103.c, gcc.dg/vect/vect-104.c,
+ gcc.dg/vect/vect-105.c, gcc.dg/vect/vect-115.c: Likewise.
+ * gcc.dg/vect/vect-116.c: Renamed (from vect-100.c).
+ * gcc.dg/vect/vect-43.c: Add vectorizable version of the loop.
+ * gcc.dg/vect/vect-91.c: Now 3 loops are vectorizable.
+ * gfortran.dg/vect/vect-4.f90: Now vectorizable.
+ * gfortran.dg/vect/pr19049.f90: New testcase.
+ * g++.dg/vect/pr21218.cc, gcc.dg/tree-ssa/ltrans-8.c: Likewise.
+
2005-07-25 Jakub Jelinek <jakub@redhat.com>
* gcc.c-torture/execute/20050713-1.c: New test.
diff --git a/gcc/testsuite/g++.dg/vect/pr21218.cc b/gcc/testsuite/g++.dg/vect/pr21218.cc
new file mode 100644
index 00000000000..73331d22702
--- /dev/null
+++ b/gcc/testsuite/g++.dg/vect/pr21218.cc
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+
+struct A
+{
+ double d[2];
+ double foo(int i) { return d[i]; }
+};
+
+struct B : public A {};
+
+void bar(B& b)
+{
+ for (int i=0; i<2; ++i)
+ b.d[i] = b.foo(i);
+}
+
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/g++.dg/vect/vect.exp b/gcc/testsuite/g++.dg/vect/vect.exp
index 1a084d0e1ae..f3631016673 100644
--- a/gcc/testsuite/g++.dg/vect/vect.exp
+++ b/gcc/testsuite/g++.dg/vect/vect.exp
@@ -40,7 +40,7 @@ set DEFAULT_VECTCFLAGS ""
# These flags are used for all targets.
lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" \
- "-ftree-vectorizer-verbose=3" "-fdump-tree-vect-stats"
+ "-ftree-vectorizer-verbose=4" "-fdump-tree-vect-stats"
# Skip these tests for targets that do not support generating vector
# code. Set additional target-dependent vector flags, which can be
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
new file mode 100644
index 00000000000..80c9c0180d7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ltrans-8.c
@@ -0,0 +1,13 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-loop-linear -fdump-tree-ltrans-all" } */
+double foo(double *a)
+{
+ int i,j;
+ double r = 0.0;
+ for (i=0; i<8; ++i)
+ for (j=0; j<8; ++j)
+ r += a[j*8+i];
+ return r;
+}
+
+/* { dg-final { scan-tree-dump-times "transformed loop" 1 "ltrans"} } */
diff --git a/gcc/testsuite/gcc.dg/vect/pr20122.c b/gcc/testsuite/gcc.dg/vect/pr20122.c
index 7fef9887fb2..a713e5e1fa8 100644
--- a/gcc/testsuite/gcc.dg/vect/pr20122.c
+++ b/gcc/testsuite/gcc.dg/vect/pr20122.c
@@ -7,8 +7,10 @@ typedef short ashort __attribute__ ((__aligned__(16)));
ashort Kernshort[24];
static void VecBug(ashort Kernel[8][24]) __attribute__((noinline));
static void VecBug(ashort Kernel[8][24]);
+static void VecBug2(ashort Kernel[8][24]) __attribute__((noinline));
+static void VecBug2(ashort Kernel[8][24]);
-/* Doesn't occur of only inner-loop. */
+/* Not vectorizable: Kernel may alias Kernshort - a global array. */
static void VecBug(ashort Kernel[8][24])
{
int k,i;
@@ -17,6 +19,21 @@ static void VecBug(ashort Kernel[8][24])
Kernshort[i] = Kernel[k][i];
}
+/* Vectorizable: Kernshort2 is local. */
+static void VecBug2(ashort Kernel[8][24])
+{
+ int k,i;
+ ashort Kernshort2[24];
+ for (k = 0; k<8; k++)
+ for (i = 0; i<24; i++)
+ Kernshort2[i] = Kernel[k][i];
+
+ for (k = 0; k<8; k++)
+ for (i = 0; i<24; i++)
+ if (Kernshort2[i] != Kernel[k][i])
+ abort ();
+}
+
int main (int argc, char **argv)
{
check_vect ();
@@ -29,6 +46,7 @@ int main (int argc, char **argv)
Kernel[k][i] = 0;
VecBug(Kernel);
+ VecBug2(Kernel);
return 0;
}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-100.c b/gcc/testsuite/gcc.dg/vect/vect-100.c
index 3b803fc71b6..c1b9e401897 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-100.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-100.c
@@ -1,28 +1,78 @@
-/* Assuming we can vectorize char multiplication, here's an execute test. */
+/* { dg-require-effective-target vect_int } */
+#include <stdlib.h>
#include <stdarg.h>
#include "tree-vect.h"
-extern void abort (void);
-void foo()
+#define N 9
+
+struct extraction
{
- static unsigned char A[256], B[256], C[256];
+ int a[N];
+ int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,0};
+
+int main1 () {
int i;
+ struct extraction *p;
+
+ p = (struct extraction *) malloc (sizeof (struct extraction));
- for (i = 0; i < 256; ++i)
- A[i] = B[i] = i;
+ /* Not vectorizable: p may alias a and/or b, since they are globals. */
+ for (i = 0; i < N; i++)
+ {
+ p->a[i] = a[i];
+ p->b[i] = b[i];
+ }
- for (i = 0; i < 256; ++i)
- C[i] = A[i] * B[i];
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->a[i] != a[i] || p->b[i] != b[i])
+ abort();
+ }
- for (i = 0; i < 256; ++i)
- if (C[i] != (unsigned char)(i * i))
- abort ();
+ return 0;
}
-int main()
-{
- check_vect ();
- foo();
+int main2 () {
+ int i;
+ int c[N] = {1,2,3,4,5,6,7,8,9};
+ int d[N] = {2,3,4,5,6,7,8,9,0};
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ /* Vectorizable: c and d are local arrays. */
+ for (i = 0; i < N; i++)
+ {
+ p->a[i] = c[i];
+ p->b[i] = d[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->a[i] != c[i] || p->b[i] != d[i])
+ abort();
+ }
+
return 0;
}
+
+int main (void)
+{
+ check_vect ();
+
+ main1 ();
+ main2 ();
+
+ return 0;
+}
+
+/* Requires versioning. */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-101.c b/gcc/testsuite/gcc.dg/vect/vect-101.c
new file mode 100644
index 00000000000..e195a58af5f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-101.c
@@ -0,0 +1,49 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+ int a[N];
+ int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,0};
+
+int main1 (int x, int y) {
+ int i;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ /* Not vectorizable: different unknown offset. */
+ for (i = 0; i < N; i++)
+ {
+ *((int *)p + x + i) = a[i];
+ *((int *)p + y + i) = b[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->a[i] != a[i] || p->b[i] != b[i])
+ abort();
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "can't determine dependence" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-102.c b/gcc/testsuite/gcc.dg/vect/vect-102.c
new file mode 100644
index 00000000000..af3261d01f8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-102.c
@@ -0,0 +1,55 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+ int a[N];
+ int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {2,3,4,5,6,7,8,9,9};
+
+int main1 (int x, int y) {
+ int i;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ for (i = 0; i < N; i++)
+ {
+ p->a[i] = a[i];
+ if (x == 135)
+ abort (); /* to avoid vectorization */
+ }
+
+ /* Not vectorizable: distance 1. */
+ for (i = 0; i < N - 1; i++)
+ {
+ *((int *)p + x + i) = *((int *)p + x + i + 1);
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->a[i] != b[i])
+ abort();
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-103.c b/gcc/testsuite/gcc.dg/vect/vect-103.c
new file mode 100644
index 00000000000..effa97e15ed
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-103.c
@@ -0,0 +1,57 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 9
+
+struct extraction
+{
+ int a[N];
+ int b[N];
+};
+
+static int a[N] = {1,2,3,4,5,6,7,8,9};
+static int b[N] = {17,24,7,0,2,3,4,31,82};
+static int c[N] = {9,17,24,7,0,2,3,4,31};
+
+int main1 (int x, int y) {
+ int i;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ for (i = 0; i < N; i++)
+ {
+ p->a[i] = a[i];
+ p->b[i] = b[i];
+ if (x == 135)
+ abort (); /* to avoid vectorization */
+ }
+
+ /* Vectorizable: distance > VF. */
+ for (i = 0; i < N; i++)
+ {
+ *((int *)p + x + i) = *((int *)p + x + i + 8);
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (p->a[i] != c[i])
+ abort();
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (0, N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "dependence distance modulo vf == 0" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-104.c b/gcc/testsuite/gcc.dg/vect/vect-104.c
new file mode 100644
index 00000000000..6d16da6b32e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-104.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 3
+
+struct extraction
+{
+ int a[N][N];
+ int b[N][N];
+};
+
+static int a[N][N] = {{1,2,3},{4,5,6},{7,8,9}};
+static int b[N][N] = {{17,24,7},{0,2,3},{4,31,82}};
+static int c[N][N] = {{1,2,3},{4,6,8},{8,9,9}};
+
+int main1 (int x) {
+ int i,j;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ p->a[i][j] = a[i][j];
+ p->b[i][j] = b[i][j];
+ if (x == 135)
+ abort (); /* to avoid vectorization */
+ }
+ }
+
+ /* Not vectorizable: distance = 1. */
+ for (i = 1; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ *((int *)p + x + i + j) = *((int *)p + x + i + j + 1);
+ }
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ if (p->a[i][j] != c[i][j])
+ abort();
+ }
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-105.c b/gcc/testsuite/gcc.dg/vect/vect-105.c
new file mode 100644
index 00000000000..c8f8e5b6813
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-105.c
@@ -0,0 +1,66 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 4
+
+struct extraction
+{
+ int a[N][N];
+ int b[N][N];
+};
+
+static int a[N][N] = {{1,2,3,11},{4,5,6,12},{7,8,9,13},{34,45,67,83}};
+static int b[N][N] = {{17,28,15,23},{0,2,3,24},{4,31,82,25},{29,31,432,256}};
+static int c[N][N] = {{1,2,3,11},{4,9,13,34},{45,67,83,13},{34,45,67,83}};
+
+int main1 (int x) {
+ int i,j;
+ struct extraction *p;
+ p = (struct extraction *) malloc (sizeof (struct extraction));
+
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ p->a[i][j] = a[i][j];
+ p->b[i][j] = b[i][j];
+ if (x == 135)
+ abort (); /* to avoid vectorization */
+ }
+ }
+
+ /* Vectorizable: distance > number of iterations. */
+ for (i = 1; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ *((int *)p + x + i + j) = *((int *)p + x + i + j + 5);
+ }
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ for (j = 0; j < N; j++)
+ {
+ if (p->a[i][j] != c[i][j])
+ abort();
+ }
+ }
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 (N);
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
+/* { dg-final { scan-tree-dump-times "possible dependence between data-refs" 0 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-115.c b/gcc/testsuite/gcc.dg/vect/vect-115.c
new file mode 100644
index 00000000000..fe055fb0def
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-115.c
@@ -0,0 +1,75 @@
+/* { dg-require-effective-target vect_int } */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+#define N 16
+
+struct s{
+ int b[N];
+ int c[N];
+ int m;
+};
+
+struct t{
+ struct s strc_s;
+ int m;
+};
+
+struct test1{
+ struct t strc_t;
+ struct t *ptr_t;
+ int k;
+ int l;
+};
+
+int main1 ()
+{
+ int i;
+ struct test1 tmp1;
+ int a[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ struct t tmp2;
+
+ tmp1.ptr_t = &tmp2;
+
+ /* DR bases comparison: record and array. */
+ for (i = 0; i < N; i++)
+ {
+ tmp1.strc_t.strc_s.b[i] = a[i];
+ }
+
+ /* Check results. */
+ for (i = 0; i < N; i++)
+ {
+ if (tmp1.strc_t.strc_s.b[i] != a[i])
+ abort();
+ }
+
+ /* DR bases comparison: record containing ptr and array. */
+ for (i = 0; i < N; i++)
+ {
+ tmp1.ptr_t->strc_s.c[i] = a[i];
+ }
+
+ /* Check results. */
+ for (i = 0; i < N; i++)
+ {
+ if (tmp1.ptr_t->strc_s.c[i] != a[i])
+ abort();
+ }
+
+
+ return 0;
+}
+
+int main (void)
+{
+ check_vect ();
+
+ return main1 ();
+}
+
+/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
+/* { dg-final { cleanup-tree-dump "vect" } } */
+
+
diff --git a/gcc/testsuite/gcc.dg/vect/vect-116.c b/gcc/testsuite/gcc.dg/vect/vect-116.c
new file mode 100644
index 00000000000..3b803fc71b6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/vect-116.c
@@ -0,0 +1,28 @@
+/* Assuming we can vectorize char multiplication, here's an execute test. */
+
+#include <stdarg.h>
+#include "tree-vect.h"
+
+extern void abort (void);
+void foo()
+{
+ static unsigned char A[256], B[256], C[256];
+ int i;
+
+ for (i = 0; i < 256; ++i)
+ A[i] = B[i] = i;
+
+ for (i = 0; i < 256; ++i)
+ C[i] = A[i] * B[i];
+
+ for (i = 0; i < 256; ++i)
+ if (C[i] != (unsigned char)(i * i))
+ abort ();
+}
+
+int main()
+{
+ check_vect ();
+ foo();
+ return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-43.c b/gcc/testsuite/gcc.dg/vect/vect-43.c
index 6cea83206f9..12db333b39b 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-43.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-43.c
@@ -29,7 +29,7 @@ main1 (afloat * pa)
afloat pb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
afloat pc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
-
+ /* Not vectorizable: pa may alias pb and/or pc, since their addresses escape. */
for (i = 0; i < N; i++)
{
pa[i] = pb[i] * pc[i];
@@ -40,6 +40,29 @@ main1 (afloat * pa)
return 0;
}
+int
+main2 (afloat * pa)
+{
+ int i;
+ afloat pb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45,48,51,54,57};
+ afloat pc[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+
+ /* Vectorizable: pb and pc addresses do not escape. */
+ for (i = 0; i < N; i++)
+ {
+ pa[i] = pb[i] * pc[i];
+ }
+
+ /* check results: */
+ for (i = 0; i < N; i++)
+ {
+ if (pa[i] != (pb[i] * pc[i]))
+ abort ();
+ }
+
+ return 0;
+}
+
int main (void)
{
int i;
@@ -50,6 +73,7 @@ int main (void)
check_vect ();
main1 (a);
+ main2 (a);
return 0;
}
diff --git a/gcc/testsuite/gcc.dg/vect/vect-91.c b/gcc/testsuite/gcc.dg/vect/vect-91.c
index 96099f4fe0b..d72bd4c8cf0 100644
--- a/gcc/testsuite/gcc.dg/vect/vect-91.c
+++ b/gcc/testsuite/gcc.dg/vect/vect-91.c
@@ -11,10 +11,7 @@ extern int a[N];
/* The alignment of 'pa' is unknown.
Yet we do know that both the read access and write access have
the same alignment. Peeling to align one of the accesses will
- align the other.
-
- Not vectorized yet due to problems in dataref analysis that
- are fixed in autovect-branch but not yet in mainline. */
+ align the other. */
int
main1 (int * pa)
@@ -60,11 +57,8 @@ main3 ()
return 0;
}
-/* Currently only the loops in main2 and main3 get vectorized. After the merge
- of the datarefs-analysis cleanups from autovect-branch to mainline, the loop
- in main1 will also be vectorized. */
-/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 2 "vect" { xfail vect_no_int_add } } } */
+/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 3 "vect" } } */
/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
-/* { dg-final { scan-tree-dump-times "accesses have the same alignment." 2 "vect" } } */
-/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 2 "vect" } } */
+/* { dg-final { scan-tree-dump-times "accesses have the same alignment." 3 "vect" } } */
+/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 3 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
diff --git a/gcc/testsuite/gcc.dg/vect/vect.exp b/gcc/testsuite/gcc.dg/vect/vect.exp
index 8c53541003d..07b7e946f80 100644
--- a/gcc/testsuite/gcc.dg/vect/vect.exp
+++ b/gcc/testsuite/gcc.dg/vect/vect.exp
@@ -24,7 +24,7 @@ set DEFAULT_VECTCFLAGS ""
# These flags are used for all targets.
lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" \
- "-ftree-vectorizer-verbose=3" "-fdump-tree-vect-stats"
+ "-ftree-vectorizer-verbose=4" "-fdump-tree-vect-stats"
# If the target system supports vector instructions, the default action
# for a test is 'run', otherwise it's 'compile'. Save current default.
diff --git a/gcc/testsuite/gfortran.dg/vect/pr19049.f90 b/gcc/testsuite/gfortran.dg/vect/pr19049.f90
new file mode 100644
index 00000000000..6c8030cce30
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/vect/pr19049.f90
@@ -0,0 +1,24 @@
+! { dg-do compile }
+! { dg-require-effective-target vect_float }
+
+subroutine s111 (ntimes,ld,n,ctime,dtime,a,b,c,d,e,aa,bb,cc)
+! linear dependence testing
+! no dependence - vectorizable
+! but not consecutive access
+
+ integer ntimes, ld, n, i, nl
+ real a(n), b(n), c(n), d(n), e(n), aa(ld,n), bb(ld,n), cc(ld,n)
+ real t1, t2, second, chksum, ctime, dtime, cs1d
+ do 1 nl = 1,2*ntimes
+ do 10 i = 2,n,2
+ a(i) = a(i-1) + b(i)
+ 10 continue
+ call dummy(ld,n,a,b,c,d,e,aa,bb,cc,1.)
+ 1 continue
+ return
+ end
+
+! { dg-final { scan-tree-dump-times "vectorized 1 loops" 0 "vect" } }
+! { dg-final { scan-tree-dump-times "complicated access pattern" 1 "vect" } }
+! { dg-final { cleanup-tree-dump "vect" } }
+
diff --git a/gcc/testsuite/gfortran.dg/vect/vect-4.f90 b/gcc/testsuite/gfortran.dg/vect/vect-4.f90
index e83c05c5e50..74f4e97678e 100644
--- a/gcc/testsuite/gfortran.dg/vect/vect-4.f90
+++ b/gcc/testsuite/gfortran.dg/vect/vect-4.f90
@@ -9,10 +9,8 @@ DIMENSION X(64), Y(64)
Y = Y + A * X
END
-! fail to vectorize due to aliasing problems in dataref analysis that are
-! solved in autvect-branch but not yet in mainline.
-! { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } }
-! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" { xfail *-*-* } } }
-! { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" { xfail *-*-* } } }
-! { dg-final { scan-tree-dump-times "accesses have the same alignment." 1 "vect" { xfail *-*-* } } }
+! { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } }
+! { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 1 "vect" } }
+! { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 1 "vect" } }
+! { dg-final { scan-tree-dump-times "accesses have the same alignment." 1 "vect" } }
! { dg-final { cleanup-tree-dump "vect" } }
diff --git a/gcc/testsuite/gfortran.dg/vect/vect.exp b/gcc/testsuite/gfortran.dg/vect/vect.exp
index dfaaeb9b5dc..7f1ec2d7ce1 100644
--- a/gcc/testsuite/gfortran.dg/vect/vect.exp
+++ b/gcc/testsuite/gfortran.dg/vect/vect.exp
@@ -25,7 +25,7 @@ set DEFAULT_VECTCFLAGS ""
# These flags are used for all targets.
lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" \
- "-ftree-vectorizer-verbose=3" "-fdump-tree-vect-stats"
+ "-ftree-vectorizer-verbose=4" "-fdump-tree-vect-stats"
# If the target system supports vector instructions, the default action
# for a test is 'run', otherwise it's 'compile'. Save current default.
View Lorry Controller Status