[PATCH] Minor cleanup of const_and_copies stack

	* tree-ssa-scopedtables.c (const_and_copies::const_and_copies): Remove
	unnecessary constructor.  It's now trivial and implemented inside...
	* tree-ssa-scopedtables.h (const_and_copies): Implement trivial
	constructor.  Add comments to various methods.  Remove unused
	private fields.
	* tree-ssa-dom.c (pass_dominator::execute): Corresponding changes.
	* tree-vrp.c (identify_jump_threads): Likewise.
	* tree-ssa-threadedge.c (thread_through_normal_block): Fix minor
	indentation issues.
	(thread_across_edge): Similarly.
	(record_temporary_equivalences_from_stmts_at_dest): Remove unused
	arguments in constructor call.

From-SVN: r227493

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a3d8e6023274ddb286ab8c15249be4b873dd6393..a6f9f8f14acd4bacb7459190bda4bc3a4f09e215 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2015-09-04  Jeff Law  <law@redhat.com>
+
+       * tree-ssa-scopedtables.c (const_and_copies::const_and_copies): Remove
+       unnecessary constructor.  It's now trivial and implemented inside...
+       * tree-ssa-scopedtables.h (const_and_copies): Implement trivial
+       constructor.  Add comments to various methods.  Remove unused
+       private fields.
+       * tree-ssa-dom.c (pass_dominator::execute): Corresponding changes.
+       * tree-vrp.c (identify_jump_threads): Likewise.
+       * tree-ssa-threadedge.c (thread_through_normal_block): Fix minor
+       indentation issues.
+       (thread_across_edge): Similarly.
+       (record_temporary_equivalences_from_stmts_at_dest): Remove unused
+       arguments in constructor call.
+
 2015-09-04  Jonas Hahnfeld  <Hahnfeld@itc.rwth-aachen.de>
 
        * config/i386/intelmic-mkoffload.c (prepare_target_image): Fix if the

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index a26ae558b0e0a19e06d0a525b7d21700481c29a4..f0b19ffe1e4f163f8fd6b5bac2e2f4206669f73f 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1168,7 +1168,7 @@ pass_dominator::execute (function *fun)
   /* Create our hash tables.  */
   avail_exprs = new hash_table<expr_elt_hasher> (1024);
   avail_exprs_stack.create (20);
-  const_and_copies = new class const_and_copies (dump_file, dump_flags);
+  const_and_copies = new class const_and_copies ();
   need_eh_cleanup = BITMAP_ALLOC (NULL);
   need_noreturn_fixup.create (0);
 

diff --git a/gcc/tree-ssa-scopedtables.c b/gcc/tree-ssa-scopedtables.c
index 41bf88794481ff3c1ca308aa32f3af31275700e5..1fea69a7967b84577bfa5d9922c38df0b8aa353c 100644 (file)
--- a/gcc/tree-ssa-scopedtables.c
+++ b/gcc/tree-ssa-scopedtables.c
@@ -28,13 +28,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-ssa-scopedtables.h"
 #include "tree-ssa-threadedge.h"
 
-const_and_copies::const_and_copies (FILE *file, int flags)
-{
-  stack.create (20);
-  dump_file = file;
-  dump_flags = flags;
-}
-
 /* Pop entries off the stack until we hit the NULL marker.
    For each entry popped, use the SRC/DEST pair to restore
    SRC to its prior value.  */

diff --git a/gcc/tree-ssa-scopedtables.h b/gcc/tree-ssa-scopedtables.h
index bc30ee6758350b31a267c0b7aafd40723f25e31b..564c24d42899879419cfdd837433cabc92c79bd9 100644 (file)
--- a/gcc/tree-ssa-scopedtables.h
+++ b/gcc/tree-ssa-scopedtables.h
@@ -23,18 +23,31 @@ along with GCC; see the file COPYING3.  If not see
 class const_and_copies
 {
  public:
-  const_and_copies (FILE *, int);
+  const_and_copies (void) { stack.create (20); };
   ~const_and_copies (void) { stack.release (); }
+
+  /* Push the unwinding marker onto the stack.  */
   void push_marker (void) { stack.safe_push (NULL_TREE); }
+
+  /* Restore the const/copies table to its state whe the last marker
+     was pushed.  */
   void pop_to_marker (void);
+
+  /* Record a single const/copy pair that can be unwound.  */
   void record_const_or_copy (tree, tree);
+
+  /* Special entry point when we want to provide an explicit previous
+     value for the first argument.  Try to get rid of this in the future.  */
   void record_const_or_copy (tree, tree, tree);
+
+  /* When threading we need to invalidate certain equivalences after
+     following a loop backedge.  The entries we need to invalidate will
+     always be in this unwindable stack.  This entry point handles
+     finding and invalidating those entries.  */
   void invalidate (tree);
 
  private:
   vec<tree> stack;
-  FILE *dump_file;
-  int dump_flags;
 };
 
 #endif /* GCC_TREE_SSA_SCOPED_TABLES_H */

diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 451dc2e1c2e3d962f04a3f94650b944b6c4ea4ff..0ad24834feb678de80c5e1380fd88b822a001fda 100644 (file)
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -432,7 +432,8 @@ record_temporary_equivalences_from_stmts_at_dest (edge e,
       if (cached_lhs
          && (TREE_CODE (cached_lhs) == SSA_NAME
              || is_gimple_min_invariant (cached_lhs)))
-       const_and_copies->record_const_or_copy (gimple_get_lhs (stmt), cached_lhs);
+       const_and_copies->record_const_or_copy (gimple_get_lhs (stmt),
+                                               cached_lhs);
       else if (backedge_seen)
        const_and_copies->invalidate (gimple_get_lhs (stmt));
     }
@@ -1208,7 +1209,8 @@ thread_through_normal_block (edge e,
   /* Now walk each statement recording any context sensitive
      temporary equivalences we can detect.  */
   gimple stmt
-    = record_temporary_equivalences_from_stmts_at_dest (e, const_and_copies, simplify,
+    = record_temporary_equivalences_from_stmts_at_dest (e, const_and_copies,
+                                                       simplify,
                                                        *backedge_seen_p);
 
   /* There's two reasons STMT might be null, and distinguishing
@@ -1474,8 +1476,8 @@ thread_across_edge (gcond *dummy_cond,
        if (!found)
          found = thread_through_normal_block (path->last ()->e, dummy_cond,
                                               handle_dominating_asserts,
-                                              const_and_copies, simplify, path, visited,
-                                              &backedge_seen) > 0;
+                                              const_and_copies, simplify, path,
+                                              visited, &backedge_seen) > 0;
 
        /* If we were able to thread through a successor of E->dest, then
           record the jump threading opportunity.  */

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 21fbed0811520ab6bc33c9a406f4ad2bb1026573..d7615e104ed09e223d554916e6b2249f4cda45fc 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -10149,7 +10149,7 @@ identify_jump_threads (void)
 
   /* Allocate our unwinder stack to unwind any temporary equivalences
      that might be recorded.  */
-  equiv_stack = new const_and_copies (dump_file, dump_flags);
+  equiv_stack = new const_and_copies ();
 
   /* To avoid lots of silly node creation, we create a single
      conditional and just modify it in-place when attempting to