[PATCH 1/2] Allow folding all statements.

This patch allows users of the substitute_and_fold_engine to
enable folding all statements.  It is now enabled for VRP which
is needed for the match.pd pattern in patch 2/2.

The loop versioning pass was missing one case when
deconstructing addresses that would only be triggered after
this patch for me:
It could handle addition and subsequent convert/nop but not
a convert/nop directly.  This would cause the hash to be
calculated differently and, in turn, cause the pass to miss
a versioning opportunity.  Fixed this by adding the missing
case.

--

gcc/ChangeLog:

2019-08-26  Robin Dapp  <rdapp@linux.ibm.com>

        * gimple-loop-versioning.cc (loop_versioning::record_address_fragment):
        Add nop_convert case.
        * tree-ssa-propagate.c (substitute_and_fold_dom_walker::before_dom_children):
        Fold all statements if requested.
        * tree-ssa-propagate.h (class substitute_and_fold_engine):
        Allow to fold all statements.
        * tree-vrp.c (class vrp_folder):
        Let substitute_and_fold_engine fold all statements.

From-SVN: r274923

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 705c993bc158eb230529f4f7fdca95adffadb651..f5acb32756baf47ac9f37f3e50eb22fca6973aad 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2019-08-26  Robin Dapp  <rdapp@linux.ibm.com>
+
+       * gimple-loop-versioning.cc (loop_versioning::record_address_fragment):
+       Add nop_convert case.
+       * tree-ssa-propagate.c (substitute_and_fold_dom_walker::before_dom_children):
+       Fold all statements if requested.
+       * tree-ssa-propagate.h (class substitute_and_fold_engine):
+       Allow to fold all statements.
+       * tree-vrp.c (class vrp_folder):
+       Let substitute_and_fold_engine fold all statements.
+
 2019-08-26  Richard Biener  <rguenther@suse.de>
 
        PR tree-optimization/91526

diff --git a/gcc/gimple-loop-versioning.cc b/gcc/gimple-loop-versioning.cc
index 8fa194884909458a579cc1cbcfb312e7f08f713b..35344b7b44827bf6eca7a4a5c9c946ff58046958 100644 (file)
--- a/gcc/gimple-loop-versioning.cc
+++ b/gcc/gimple-loop-versioning.cc
@@ -1266,6 +1266,12 @@ loop_versioning::record_address_fragment (gimple *stmt,
                  continue;
                }
            }
+         if (CONVERT_EXPR_CODE_P (code))
+           {
+             tree op1 = gimple_assign_rhs1 (assign);
+             address->terms[i].expr = strip_casts (op1);
+             continue;
+           }
        }
       i += 1;
     }

diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index 0862f83e9a19f1318996e58e05e9981be713e5aa..7172ef8b4e68ad06cf7799bcd1d7cba3830acf83 100644 (file)
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -814,7 +814,6 @@ ssa_propagation_engine::ssa_propagate (void)
   ssa_prop_fini ();
 }
 
-
 /* Return true if STMT is of the form 'mem_ref = RHS', where 'mem_ref'
    is a non-volatile pointer dereference, a structure reference or a
    reference to a single _DECL.  Ignore volatile memory references
@@ -1071,6 +1070,14 @@ substitute_and_fold_dom_walker::before_dom_children (basic_block bb)
          stmt = gsi_stmt (i);
          gimple_set_modified (stmt, true);
        }
+      /* Also fold if we want to fold all statements.  */
+      else if (substitute_and_fold_engine->fold_all_stmts
+         && fold_stmt (&i, follow_single_use_edges))
+       {
+         did_replace = true;
+         stmt = gsi_stmt (i);
+         gimple_set_modified (stmt, true);
+       }
 
       /* Some statements may be simplified using propagator
         specific information.  Do this before propagating

diff --git a/gcc/tree-ssa-propagate.h b/gcc/tree-ssa-propagate.h
index 81b635e0787e6022a51ed4f307917951a6f63b0b..f79c2ffadf3ca65f29d88fff6cb2d62c5ca69774 100644 (file)
--- a/gcc/tree-ssa-propagate.h
+++ b/gcc/tree-ssa-propagate.h
@@ -100,6 +100,8 @@ class ssa_propagation_engine
 class substitute_and_fold_engine
 {
  public:
+  substitute_and_fold_engine (bool fold_all_stmts = false)
+    : fold_all_stmts (fold_all_stmts) { }
   virtual ~substitute_and_fold_engine (void) { }
   virtual bool fold_stmt (gimple_stmt_iterator *) { return false; }
   virtual tree get_value (tree) { return NULL_TREE; }
@@ -107,6 +109,10 @@ class substitute_and_fold_engine
   bool substitute_and_fold (basic_block = NULL);
   bool replace_uses_in (gimple *);
   bool replace_phi_args_in (gphi *);
+
+  /* Users like VRP can set this when they want to perform
+     folding for every propagation.  */
+  bool fold_all_stmts;
 };
 
 #endif /* _TREE_SSA_PROPAGATE_H  */

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 8067f8560cd1854af7c9efc89e41586b97394532..4145bcc83a9da4ff7ecd90db480427cd017a8739 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -6415,6 +6415,7 @@ vrp_prop::visit_phi (gphi *phi)
 class vrp_folder : public substitute_and_fold_engine
 {
  public:
+  vrp_folder () : substitute_and_fold_engine (/* Fold all stmts.  */ true) {  }
   tree get_value (tree) FINAL OVERRIDE;
   bool fold_stmt (gimple_stmt_iterator *) FINAL OVERRIDE;
   bool fold_predicate_in (gimple_stmt_iterator *);