Tweak BB analysis for dr_analyze_innermost

dr_analyze_innermost had a "struct loop *nest" parameter that acted
like a boolean.  This was added in r179161, with the idea that a
null nest selected BB-level analysis rather than loop analysis.

The handling seemed strange though.  If the DR was part of a loop,
we still tried to express the base and offset values as IVs, potentially
giving a nonzero step.  If that failed for any reason, we'd revert to
using the original base and offset, just as we would if we hadn't asked
for an IV in the first place.

It seems more natural to use the !in_loop handling whenever nest is null
and always set the step to zero.  This actually enables one more SLP
opportunity in bb-slp-pr65935.c.

I checked out r179161 and tried the patch there.  The test case added
in that revision still passes, so I don't think there was any particular
need to check simple_iv.

2017-06-28  Richard Sandiford  <richard.sandiford@linaro.org>

gcc/
	* tree-data-ref.c (dr_analyze_innermost): Replace the "nest"
	parameter with a "loop" parameter and use it instead of the
	loop containing DR_STMT.  Don't check simple_iv when doing
	BB analysis.  Describe the two analysis modes in the comment.

gcc/testsuite/
	* gcc.dg/vect/bb-slp-pr65935.c: Expect SLP to be used in main
	as well.

From-SVN: r249896

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c95a82fd351b7de5eb1d08e8f64d91761c02ad6a..08657e0accf0f31343b4eb282e530fc43b97f640 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2017-07-03  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       * tree-data-ref.c (dr_analyze_innermost): Replace the "nest"
+       parameter with a "loop" parameter and use it instead of the
+       loop containing DR_STMT.  Don't check simple_iv when doing
+       BB analysis.  Describe the two analysis modes in the comment.
+
 2017-07-03  Tom de Vries  <tom@codesourcery.com>
 
        PR tree-optimization/69468

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index c52c7a838148856922a83f422c031473fb9a0da8..f5d2f8be78973bb60770cc8b69aa3ace42429bcc 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2017-07-03  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       * gcc.dg/vect/bb-slp-pr65935.c: Expect SLP to be used in main
+       as well.
+
 2017-07-03  Tom de Vries  <tom@codesourcery.com>
 
        PR tree-optimization/69468

diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c b/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
index a6c75c7c77f9fa9f625c169d7adeb8bee636f078..0e4f1a71b6b55d8570b26acac6685600332f45d6 100644 (file)
--- a/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
+++ b/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
@@ -57,4 +57,6 @@ int main()
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "basic block vectorized" 1 "slp1" } } */
+/* We should also be able to use 2-lane SLP to initialize the real and
+   imaginary components in the first loop of main.  */
+/* { dg-final { scan-tree-dump-times "basic block vectorized" 2 "slp1" } } */

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index ba473021534b7d65acff96237c515fcab877fa76..0fcefdc43b1d0b3907540f245ccb6de756fcafe6 100644 (file)
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -749,15 +749,29 @@ canonicalize_base_object_address (tree addr)
   return build_fold_addr_expr (TREE_OPERAND (addr, 0));
 }
 
-/* Analyzes the behavior of the memory reference DR in the innermost loop or
-   basic block that contains it.  Returns true if analysis succeed or false
-   otherwise.  */
+/* Analyze the behavior of memory reference DR.  There are two modes:
+
+   - BB analysis.  In this case we simply split the address into base,
+     init and offset components, without reference to any containing loop.
+     The resulting base and offset are general expressions and they can
+     vary arbitrarily from one iteration of the containing loop to the next.
+     The step is always zero.
+
+   - loop analysis.  In this case we analyze the reference both wrt LOOP
+     and on the basis that the reference occurs (is "used") in LOOP;
+     see the comment above analyze_scalar_evolution_in_loop for more
+     information about this distinction.  The base, init, offset and
+     step fields are all invariant in LOOP.
+
+   Perform BB analysis if LOOP is null, or if LOOP is the function's
+   dummy outermost loop.  In other cases perform loop analysis.
+
+   Return true if the analysis succeeded and store the results in DR if so.
+   BB analysis can only fail for bitfield or reversed-storage accesses.  */
 
 bool
-dr_analyze_innermost (struct data_reference *dr, struct loop *nest)
+dr_analyze_innermost (struct data_reference *dr, struct loop *loop)
 {
-  gimple *stmt = DR_STMT (dr);
-  struct loop *loop = loop_containing_stmt (stmt);
   tree ref = DR_REF (dr);
   HOST_WIDE_INT pbitsize, pbitpos;
   tree base, poffset;
@@ -806,22 +820,11 @@ dr_analyze_innermost (struct data_reference *dr, struct loop *nest)
 
   if (in_loop)
     {
-      if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv,
-                      nest ? true : false))
+      if (!simple_iv (loop, loop, base, &base_iv, true))
         {
-          if (nest)
-            {
-              if (dump_file && (dump_flags & TDF_DETAILS))
-                fprintf (dump_file, "failed: evolution of base is not"
-                                    " affine.\n");
-              return false;
-            }
-          else
-            {
-              base_iv.base = base;
-              base_iv.step = ssize_int (0);
-              base_iv.no_overflow = true;
-            }
+         if (dump_file && (dump_flags & TDF_DETAILS))
+           fprintf (dump_file, "failed: evolution of base is not affine.\n");
+         return false;
         }
     }
   else
@@ -843,22 +846,11 @@ dr_analyze_innermost (struct data_reference *dr, struct loop *nest)
           offset_iv.base = poffset;
           offset_iv.step = ssize_int (0);
         }
-      else if (!simple_iv (loop, loop_containing_stmt (stmt),
-                           poffset, &offset_iv,
-                          nest ? true : false))
+      else if (!simple_iv (loop, loop, poffset, &offset_iv, true))
         {
-          if (nest)
-            {
-              if (dump_file && (dump_flags & TDF_DETAILS))
-                fprintf (dump_file, "failed: evolution of offset is not"
-                                    " affine.\n");
-              return false;
-            }
-          else
-            {
-              offset_iv.base = poffset;
-              offset_iv.step = ssize_int (0);
-            }
+         if (dump_file && (dump_flags & TDF_DETAILS))
+           fprintf (dump_file, "failed: evolution of offset is not affine.\n");
+         return false;
         }
     }
 
@@ -1077,7 +1069,7 @@ create_data_ref (loop_p nest, loop_p loop, tree memref, gimple *stmt,
   DR_REF (dr) = memref;
   DR_IS_READ (dr) = is_read;
 
-  dr_analyze_innermost (dr, nest);
+  dr_analyze_innermost (dr, nest != NULL ? loop : NULL);
   dr_analyze_indices (dr, nest, loop);
   dr_analyze_alias (dr);