[PATCH] const_and_copies is no longer file scoped

        PR tree-optimization/47679
	* tree-ssa-dom.c (const_and_copies): No longer file scoped.  Move
	it here ...
	(dom_opt_dom_walker): New private member holding the const_and_copies
	object.  Update constructor.
	(pass_dominator::execute): Corresponding changes to declaration
	and initialization of const_and_copies.  Update constructor call
	for the dom_opt_dom_walker object.
	(record_temporary_equivalences): Accept const_and_copies argument
	pass it down to children as needed.
	(record_equality): Likewise.
	(record_equivalences_from_incoming_edge): Likewise.
	(cprop_into_successor_phis, optimize_stmt): Likewise.
	(eliminate_redundant_computations): Likewise.
	(dom_opt_dom_walker::thread_across_edge): Update access to
	const_and_copies object and pass it to children as needed.
	(dom_opt_dom_walker::before_dom_children): Similarly.
	(dom_opt_dom_walker::after_dom_children): Similarly.

From-SVN: r227922

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d46088083c373565d5a8065f89429571966f7f10..475497713f421729eec5a2e2c90d09746e1e7449 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,24 @@
 2015-09-18  Jeff Law  <law@redhat.com>
 
+       PR tree-optimization/47679
+       * tree-ssa-dom.c (const_and_copies): No longer file scoped.  Move
+       it here ...
+       (dom_opt_dom_walker): New private member holding the const_and_copies
+       object.  Update constructor.
+       (pass_dominator::execute): Corresponding changes to declaration
+       and initialization of const_and_copies.  Update constructor call
+       for the dom_opt_dom_walker object.
+       (record_temporary_equivalences): Accept const_and_copies argument
+       pass it down to children as needed.
+       (record_equality): Likewise.
+       (record_equivalences_from_incoming_edge): Likewise.
+       (cprop_into_successor_phis, optimize_stmt): Likewise.
+       (eliminate_redundant_computations): Likewise.
+       (dom_opt_dom_walker::thread_across_edge): Update access to
+       const_and_copies object and pass it to children as needed.
+       (dom_opt_dom_walker::before_dom_children): Similarly.
+       (dom_opt_dom_walker::after_dom_children): Similarly.
+
        PR tree-optimization/47679
        * tree-ssa-dom.c (avail_exprs): No longer file scoped.  Bury
        it into the avail_exprs_stack class.

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index bf5e8a116ab16d87e2c8b4dda40ab8b7d8972198..fd2566c72dcfb3266e287bdc1bdb33801d032407 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -79,7 +79,6 @@ struct edge_info
 };
 
 /* Unwindable equivalences, both const/copy and expression varieties.  */
-static const_and_copies *const_and_copies;
 static avail_exprs_stack *avail_exprs_stack;
 
 /* Track whether or not we have changed the control flow graph.  */
@@ -103,13 +102,16 @@ struct opt_stats_d
 static struct opt_stats_d opt_stats;
 
 /* Local functions.  */
-static void optimize_stmt (basic_block, gimple_stmt_iterator);
+static void optimize_stmt (basic_block, gimple_stmt_iterator,
+                          class const_and_copies *);
 static tree lookup_avail_expr (gimple, bool);
 static void record_cond (cond_equivalence *);
-static void record_equality (tree, tree);
+static void record_equality (tree, tree, class const_and_copies *);
 static void record_equivalences_from_phis (basic_block);
-static void record_equivalences_from_incoming_edge (basic_block);
-static void eliminate_redundant_computations (gimple_stmt_iterator *);
+static void record_equivalences_from_incoming_edge (basic_block,
+                                                   class const_and_copies *);
+static void eliminate_redundant_computations (gimple_stmt_iterator *,
+                                             class const_and_copies *);
 static void record_equivalences_from_stmt (gimple, int);
 static edge single_incoming_edge_ignoring_loop_edges (basic_block);
 static void dump_dominator_optimization_stats (FILE *file,
@@ -487,8 +489,11 @@ record_edge_info (basic_block bb)
 class dom_opt_dom_walker : public dom_walker
 {
 public:
-  dom_opt_dom_walker (cdi_direction direction)
-    : dom_walker (direction), m_dummy_cond (NULL) {}
+  dom_opt_dom_walker (cdi_direction direction,
+                     class const_and_copies *const_and_copies)
+    : dom_walker (direction),
+      m_const_and_copies (const_and_copies),
+      m_dummy_cond (NULL) {}
 
   virtual void before_dom_children (basic_block);
   virtual void after_dom_children (basic_block);
@@ -496,6 +501,9 @@ public:
 private:
   void thread_across_edge (edge);
 
+  /* Unwindable equivalences, both const/copy and expression varieties.  */
+  class const_and_copies *m_const_and_copies;
+
   gcond *m_dummy_cond;
 };
 
@@ -543,7 +551,7 @@ pass_dominator::execute (function *fun)
   hash_table<expr_elt_hasher> *avail_exprs
     = new hash_table<expr_elt_hasher> (1024);
   avail_exprs_stack = new class avail_exprs_stack (avail_exprs);
-  const_and_copies = new class const_and_copies ();
+  class const_and_copies *const_and_copies = new class const_and_copies ();
   need_eh_cleanup = BITMAP_ALLOC (NULL);
   need_noreturn_fixup.create (0);
 
@@ -581,7 +589,8 @@ pass_dominator::execute (function *fun)
     record_edge_info (bb);
 
   /* Recursively walk the dominator tree optimizing statements.  */
-  dom_opt_dom_walker (CDI_DOMINATORS).walk (fun->cfg->x_entry_block_ptr);
+  dom_opt_dom_walker walker (CDI_DOMINATORS, const_and_copies);
+  walker.walk (fun->cfg->x_entry_block_ptr);
 
   {
     gimple_stmt_iterator gsi;
@@ -764,7 +773,8 @@ dom_valueize (tree t)
 
    Callers are responsible for managing the unwinding markers.  */
 static void
-record_temporary_equivalences (edge e)
+record_temporary_equivalences (edge e,
+                              class const_and_copies *const_and_copies)
 {
   int i;
   struct edge_info *edge_info = (struct edge_info *) e->aux;
@@ -779,7 +789,7 @@ record_temporary_equivalences (edge e)
 
       /* If we have a simple NAME = VALUE equivalence, record it.  */
       if (lhs)
-       record_equality (lhs, rhs);
+       record_equality (lhs, rhs, const_and_copies);
 
       /* If LHS is an SSA_NAME and RHS is a constant integer and LHS was
         set via a widening type conversion, then we may be able to record
@@ -808,7 +818,7 @@ record_temporary_equivalences (edge e)
                  && int_fits_type_p (rhs, TREE_TYPE (old_rhs)))
                {
                  tree newval = fold_convert (TREE_TYPE (old_rhs), rhs);
-                 record_equality (old_rhs, newval);
+                 record_equality (old_rhs, newval, const_and_copies);
                }
            }
        }
@@ -843,7 +853,7 @@ record_temporary_equivalences (edge e)
                  if (res
                      && (TREE_CODE (res) == SSA_NAME
                          || is_gimple_min_invariant (res)))
-                   record_equality (lhs2, res);
+                   record_equality (lhs2, res, const_and_copies);
                }
            }
        }
@@ -871,15 +881,15 @@ dom_opt_dom_walker::thread_across_edge (edge e)
   /* Push a marker on both stacks so we can unwind the tables back to their
      current state.  */
   avail_exprs_stack->push_marker ();
-  const_and_copies->push_marker ();
+  m_const_and_copies->push_marker ();
 
   /* Traversing E may result in equivalences we can utilize.  */
-  record_temporary_equivalences (e);
+  record_temporary_equivalences (e, m_const_and_copies);
 
   /* With all the edge equivalences in the tables, go ahead and attempt
      to thread through E->dest.  */
   ::thread_across_edge (m_dummy_cond, e, false,
-                       const_and_copies, avail_exprs_stack,
+                       m_const_and_copies, avail_exprs_stack,
                        simplify_stmt_for_jump_threading);
 
   /* And restore the various tables to their state before
@@ -983,7 +993,8 @@ single_incoming_edge_ignoring_loop_edges (basic_block bb)
    has more than one incoming edge, then no equivalence is created.  */
 
 static void
-record_equivalences_from_incoming_edge (basic_block bb)
+record_equivalences_from_incoming_edge (basic_block bb,
+    class const_and_copies *const_and_copies)
 {
   edge e;
   basic_block parent;
@@ -998,7 +1009,7 @@ record_equivalences_from_incoming_edge (basic_block bb)
   /* If we had a single incoming edge from our parent block, then enter
      any data associated with the edge into our tables.  */
   if (e && e->src == parent)
-    record_temporary_equivalences (e);
+    record_temporary_equivalences (e, const_and_copies);
 }
 
 /* Dump statistics for the hash table HTAB.  */
@@ -1083,7 +1094,7 @@ loop_depth_of_name (tree x)
    This constrains the cases in which we may treat this as assignment.  */
 
 static void
-record_equality (tree x, tree y)
+record_equality (tree x, tree y, class const_and_copies *const_and_copies)
 {
   tree prev_x = NULL, prev_y = NULL;
 
@@ -1183,14 +1194,12 @@ simple_iv_increment_p (gimple stmt)
   return false;
 }
 
-/* CONST_AND_COPIES is a table which maps an SSA_NAME to the current
-   known value for that SSA_NAME (or NULL if no value is known).
-
-   Propagate values from CONST_AND_COPIES into the PHI nodes of the
+/* Propagate know values from SSA_NAME_VALUE into the PHI nodes of the
    successors of BB.  */
 
 static void
-cprop_into_successor_phis (basic_block bb)
+cprop_into_successor_phis (basic_block bb,
+                          class const_and_copies *const_and_copies)
 {
   edge e;
   edge_iterator ei;
@@ -1272,9 +1281,9 @@ dom_opt_dom_walker::before_dom_children (basic_block bb)
   /* Push a marker on the stacks of local information so that we know how
      far to unwind when we finalize this block.  */
   avail_exprs_stack->push_marker ();
-  const_and_copies->push_marker ();
+  m_const_and_copies->push_marker ();
 
-  record_equivalences_from_incoming_edge (bb);
+  record_equivalences_from_incoming_edge (bb, m_const_and_copies);
 
   /* PHI nodes can create equivalences too.  */
   record_equivalences_from_phis (bb);
@@ -1284,15 +1293,15 @@ dom_opt_dom_walker::before_dom_children (basic_block bb)
      marker and unwind right afterwards.  */
   avail_exprs_stack->push_marker ();
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    eliminate_redundant_computations (&gsi);
+    eliminate_redundant_computations (&gsi, m_const_and_copies);
   avail_exprs_stack->pop_to_marker ();
 
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    optimize_stmt (bb, gsi);
+    optimize_stmt (bb, gsi, m_const_and_copies);
 
   /* Now prepare to process dominated blocks.  */
   record_edge_info (bb);
-  cprop_into_successor_phis (bb);
+  cprop_into_successor_phis (bb, m_const_and_copies);
 }
 
 /* We have finished processing the dominator children of BB, perform
@@ -1337,7 +1346,7 @@ dom_opt_dom_walker::after_dom_children (basic_block bb)
 
   /* These remove expressions local to BB from the tables.  */
   avail_exprs_stack->pop_to_marker ();
-  const_and_copies->pop_to_marker ();
+  m_const_and_copies->pop_to_marker ();
 }
 
 /* Search for redundant computations in STMT.  If any are found, then
@@ -1347,7 +1356,8 @@ dom_opt_dom_walker::after_dom_children (basic_block bb)
    table.  */
 
 static void
-eliminate_redundant_computations (gimple_stmt_iterator* gsi)
+eliminate_redundant_computations (gimple_stmt_iterator* gsi,
+                                 class const_and_copies *const_and_copies)
 {
   tree expr_type;
   tree cached_lhs;
@@ -1655,7 +1665,8 @@ cprop_into_stmt (gimple stmt)
       the variable in the LHS in the CONST_AND_COPIES table.  */
 
 static void
-optimize_stmt (basic_block bb, gimple_stmt_iterator si)
+optimize_stmt (basic_block bb, gimple_stmt_iterator si,
+              class const_and_copies *const_and_copies)
 {
   gimple stmt, old_stmt;
   bool may_optimize_p;
@@ -1745,7 +1756,7 @@ optimize_stmt (basic_block bb, gimple_stmt_iterator si)
        }
 
       update_stmt_if_modified (stmt);
-      eliminate_redundant_computations (&si);
+      eliminate_redundant_computations (&si, const_and_copies);
       stmt = gsi_stmt (si);
 
       /* Perform simple redundant store elimination.  */