Minor cleanup of const_and_copies stack

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a3d8e60..a6f9f8f 100644
--- 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 a26ae55..f0b19ff 100644
--- 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 41bf887..1fea69a 100644
--- 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 bc30ee6..564c24d 100644
--- 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 451dc2e..0ad2483 100644
--- 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 21fbed0..d7615e1 100644
--- 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