[PATCH] Another small cleanup to the const_and_copies stack

2015-09-11  Jeff Law  <law@redhat.com>

	PR tree-optimization/47679
	* tree-ssa-dom.c (struct cond_equivalence): Update comment.
	* tree-ssa-scopedtables.h (class const_and_copies): Prefix data
	member with m_.  Update inline member functions as necessary.  Add
	toplevel comment.
	* tree-ssa-scopedtables.c: Update const_and_copies's member
	functions to use m_ prefix to access the stack.

From-SVN: r227697

gcc/ChangeLog

+2015-09-11  Jeff Law  <law@redhat.com>
+
+	PR tree-optimization/47679
+	* tree-ssa-dom.c (struct cond_equivalence): Update comment.
+	* tree-ssa-scopedtables.h (class const_and_copies): Prefix data
+	member with m_.  Update inline member functions as necessary.  Add
+	toplevel comment.
+	* tree-ssa-scopedtables.c: Update const_and_copies's member
+	functions to use m_ prefix to access the stack.
+
 2015-09-11  Aditya Kumar  <aditya.k7@samsung.com>
 
         * graphite-optimize-isl.c (disable_tiling): Remove.

gcc/tree-ssa-dom.c

@@ -92,8 +92,7 @@ struct cond_equivalence
 };
 
 
-/* Structure for recording edge equivalences as well as any pending
-   edge redirections during the dominator optimizer.
+/* Structure for recording edge equivalences.
 
    Computing and storing the edge equivalences instead of creating
    them on-demand can save significant amounts of time, particularly
@@ -101,10 +100,7 @@ struct cond_equivalence
 
    These structures live for a single iteration of the dominator
    optimizer in the edge's AUX field.  At the end of an iteration we
-   free each of these structures and update the AUX field to point
-   to any requested redirection target (the code for updating the
-   CFG and SSA graph for edge redirection expects redirection edge
-   targets to be in the AUX field for each edge.  */
+   free each of these structures.  */
 
 struct edge_info
 {

gcc/tree-ssa-scopedtables.c

@@ -35,11 +35,11 @@ along with GCC; see the file COPYING3.  If not see
 void
 const_and_copies::pop_to_marker (void)
 {
-  while (stack.length () > 0)
+  while (m_stack.length () > 0)
     {
       tree prev_value, dest;
 
-      dest = stack.pop ();
+      dest = m_stack.pop ();
 
       /* A NULL value indicates we should stop unwinding, otherwise
 	 pop off the next entry as they're recorded in pairs.  */
@@ -55,7 +55,7 @@ const_and_copies::pop_to_marker (void)
 	  fprintf (dump_file, "\n");
 	}
 
-      prev_value = stack.pop ();
+      prev_value = m_stack.pop ();
       set_ssa_name_value (dest, prev_value);
     }
 }
@@ -90,9 +90,9 @@ const_and_copies::record_const_or_copy (tree x, tree y, tree prev_x)
     }
 
   set_ssa_name_value (x, y);
-  stack.reserve (2);
-  stack.quick_push (prev_x);
-  stack.quick_push (x);
+  m_stack.reserve (2);
+  m_stack.quick_push (prev_x);
+  m_stack.quick_push (x);
 }
 
 /* A new value has been assigned to LHS.  If necessary, invalidate any
@@ -114,16 +114,16 @@ const_and_copies::invalidate (tree lhs)
      then it's a "stop unwinding" marker.  Else the current marker is
      the SSA_NAME with an equivalence and the prior entry in the stack
      is what the current element is equivalent to.  */
-  for (int i = stack.length() - 1; i >= 0; i--)
+  for (int i = m_stack.length() - 1; i >= 0; i--)
     {
       /* Ignore the stop unwinding markers.  */
-      if ((stack)[i] == NULL)
+      if ((m_stack)[i] == NULL)
 	continue;
 
       /* We want to check the current value of stack[i] to see if
 	 it matches LHS.  If so, then invalidate.  */
-      if (SSA_NAME_VALUE ((stack)[i]) == lhs)
-	record_const_or_copy ((stack)[i], NULL_TREE);
+      if (SSA_NAME_VALUE ((m_stack)[i]) == lhs)
+	record_const_or_copy ((m_stack)[i], NULL_TREE);
 
       /* Remember, we're dealing with two elements in this case.  */
       i--;

gcc/tree-ssa-scopedtables.h

@@ -20,14 +20,20 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_TREE_SSA_SCOPED_TABLES_H
 #define GCC_TREE_SSA_SCOPED_TABLES_H
 
+/* This class defines an unwindable const/copy equivalence table
+   layered on top of SSA_NAME_VALUE/set_ssa_name_value.
+
+   Essentially it's just a stack of name,prev value pairs with a
+   special marker (NULL) to indicate unwind points.  */
+
 class const_and_copies
 {
  public:
-  const_and_copies (void) { stack.create (20); };
-  ~const_and_copies (void) { stack.release (); }
+  const_and_copies (void) { m_stack.create (20); };
+  ~const_and_copies (void) { m_stack.release (); }
 
   /* Push the unwinding marker onto the stack.  */
-  void push_marker (void) { stack.safe_push (NULL_TREE); }
+  void push_marker (void) { m_stack.safe_push (NULL_TREE); }
 
   /* Restore the const/copies table to its state when the last marker
      was pushed.  */
@@ -47,7 +53,7 @@ class const_and_copies
   void invalidate (tree);
 
  private:
-  vec<tree> stack;
+  vec<tree> m_stack;
 };
 
 #endif /* GCC_TREE_SSA_SCOPED_TABLES_H */