Tighten early exit in vect_analyze_data_ref_dependence (PR85586)

The problem in this PR was that we didn't consider aliases between
writes in the same strided group.  After tightening the early exit
we get the expected abs(step) >= 2 versioning check.

2018-05-02  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	PR tree-optimization/85586
	* tree-vect-data-refs.c (vect_analyze_data_ref_dependence): Only
	exit early for statements in the same group if the accesses are
	not strided.

gcc/testsuite/
	PR tree-optimization/85586
	* gcc.dg/vect/pr85586.c: New test.

From-SVN: r259822

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 65f76ab976b8d71c606da44d57475a248599974e..53fa68d9cbb171da28f5d53e2b31bad83db2b176 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2018-05-02  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       PR tree-optimization/85586
+       * tree-vect-data-refs.c (vect_analyze_data_ref_dependence): Only
+       exit early for statements in the same group if the accesses are
+       not strided.
+
 2018-05-02  Tom de Vries  <tom@codesourcery.com>
 
        PR lto/85451

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 465b079a366dd5ebe82efa10530b1c6a71c20579..9c93c81a3efa0e0f0fcb784fe0811cc9add903c6 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2018-05-02  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       PR tree-optimization/85586
+       * gcc.dg/vect/pr85586.c: New test.
+
 2018-05-01  Marc Glisse  <marc.glisse@inria.fr>
 
        PR tree-optimization/85143

diff --git a/gcc/testsuite/gcc.dg/vect/pr85586.c b/gcc/testsuite/gcc.dg/vect/pr85586.c
new file mode 100644 (file)
index 0000000..d6cc92d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr85586.c
@@ -0,0 +1,43 @@
+#define N 100
+
+void __attribute__ ((noipa))
+foo (int *out, int *in, int step)
+{
+  for (int i = 0; i < N; ++i)
+    {
+      out[0] = in[i];
+      out[1] = 2;
+      out += step;
+    }
+}
+
+int in[N];
+int out[N * 2];
+
+int
+main (void)
+{
+  for (int i = 0; i < N; ++i)
+    {
+      in[i] = i * (i + 1);
+      asm volatile ("" ::: "memory");
+    }
+
+  foo (out, in, 1);
+  for (int i = 0; i < N; ++i)
+    if (out[i] != in[i])
+      __builtin_abort ();
+  if (out[N] != 2)
+    __builtin_abort ();
+
+  foo (out + N - 1, in, -1);
+  if (out[0] != in[N - 1])
+    __builtin_abort ();
+  for (int i = 1; i <= N; ++i)
+    if (out[i] != 2)
+      __builtin_abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 1 "vect" { target vect_int } } } */

diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index df362b0e1c5cd9ec4709c93ce9848101c0ee07f1..9608b769cf2a6650ce24a36020e0d0feae3cf2fd 100644 (file)
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -305,9 +305,11 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr,
     return false;
 
   /* We do not have to consider dependences between accesses that belong
-     to the same group.  */
+     to the same group, unless the stride could be smaller than the
+     group size.  */
   if (GROUP_FIRST_ELEMENT (stmtinfo_a)
-      && GROUP_FIRST_ELEMENT (stmtinfo_a) == GROUP_FIRST_ELEMENT (stmtinfo_b))
+      && GROUP_FIRST_ELEMENT (stmtinfo_a) == GROUP_FIRST_ELEMENT (stmtinfo_b)
+      && !STMT_VINFO_STRIDED_P (stmtinfo_a))
     return false;
 
   /* Even if we have an anti-dependence then, as the vectorized loop covers at