tree-optimization/97307 - improve sinking of loads

This improves the heuristics finding a sink location for loads that does
not cross any store.

2020-10-07  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/97307
	* tree-ssa-sink.c (statement_sink_location): Change heuristic
	for not skipping stores to look for virtual definitions
	rather than uses.

	* gcc.dg/tree-ssa/ssa-sink-17.c: New testcase.
	* gcc.dg/vect/pr65947-3.c: XFAIL.

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-17.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-17.c
new file mode 100644 (file)
index 0000000..cf2e2a0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-sink-17.c
@@ -0,0 +1,15 @@
+/* PR tree-optimization/97307  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-sink-details" } */
+
+int pure_f(int a, int b) __attribute__((pure));
+int my_f(int a, int b)
+{
+  int x = pure_f(a, b);
+  if (a > 0)
+    return x;
+  return a;
+}
+
+/* We should sink the call to pure_f to the if block.  */
+/* { dg-final { scan-tree-dump "Sinking # VUSE" "sink" } } */

diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-3.c b/gcc/testsuite/gcc.dg/vect/pr65947-3.c
index 6b4077e1a62b255f7658acb71573efcbd068cf17..8a2608cf0f15055da5d5187f2bf27dd1df45e183 100644 (file)
--- a/gcc/testsuite/gcc.dg/vect/pr65947-3.c
+++ b/gcc/testsuite/gcc.dg/vect/pr65947-3.c
@@ -51,6 +51,9 @@ main (void)
   return 0;
 }
 
-/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" } } */
+/* XFAILed because of the fix for PR97307 which sinks the load of a[i], preventing
+   if-conversion to happen.  */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail *-*-* } } } */
+/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 1 "vect" } } */
 /* { dg-final { scan-tree-dump-times "optimizing condition reduction with FOLD_EXTRACT_LAST" 2 "vect" { target vect_fold_extract_last } } } */
 /* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */

diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 4cc5195f2f8f0cde078822c07d4c74e002844b3e..ba8e5577e9c38a1145e458ee7b00bbfe58979af9 100644 (file)
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -369,10 +369,9 @@ statement_sink_location (gimple *stmt, basic_block frombb,
        return false;
 
       /* If this is a load then do not sink past any stores.
-        ???  This is overly simple but cheap.  We basically look
-        for an existing load with the same VUSE in the path to one
-        of the sink candidate blocks and we adjust commondom to the
-        nearest to commondom.  */
+        Look for virtual definitions in the path from frombb to the sink
+        location computed from the real uses and if found, adjust
+        that it a common dominator.  */
       if (gimple_vuse (stmt))
        {
          /* Do not sink loads from hard registers.  */
@@ -383,29 +382,33 @@ statement_sink_location (gimple *stmt, basic_block frombb,
 
          imm_use_iterator imm_iter;
          use_operand_p use_p;
-         basic_block found = NULL;
          FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_vuse (stmt))
            {
              gimple *use_stmt = USE_STMT (use_p);
              basic_block bb = gimple_bb (use_stmt);
-             /* For PHI nodes the block we know sth about
-                is the incoming block with the use.  */
+             /* For PHI nodes the block we know sth about is the incoming block
+                with the use.  */
              if (gimple_code (use_stmt) == GIMPLE_PHI)
-               bb = EDGE_PRED (bb, PHI_ARG_INDEX_FROM_USE (use_p))->src;
-             /* Any dominator of commondom would be ok with
-                adjusting commondom to that block.  */
-             bb = nearest_common_dominator (CDI_DOMINATORS, bb, commondom);
-             if (!found)
-               found = bb;
-             else if (dominated_by_p (CDI_DOMINATORS, bb, found))
-               found = bb;
-             /* If we can't improve, stop.  */
-             if (found == commondom)
-               break;
+               {
+                 /* In case the PHI node post-dominates the current insert location
+                    we can disregard it.  */
+                 if (commondom != bb
+                     && dominated_by_p (CDI_POST_DOMINATORS, commondom, bb))
+                   continue;
+                 bb = EDGE_PRED (bb, PHI_ARG_INDEX_FROM_USE (use_p))->src;
+               }
+             else if (!gimple_vdef (use_stmt))
+               continue;
+             /* If the use is not dominated by the path entry it is not on
+                the path.  */
+             if (!dominated_by_p (CDI_DOMINATORS, bb, frombb))
+               continue;
+             /* There is no easy way to disregard defs not on the path from
+                frombb to commondom so just consider them all.  */
+             commondom = nearest_common_dominator (CDI_DOMINATORS, bb, commondom);
+             if (commondom == frombb)
+               return false;
            }
-         commondom = found;
-         if (commondom == frombb)
-           return false;
        }
 
       /* Our common dominator has to be dominated by frombb in order to be a