This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[tree-ssa] New reference list iterator [patch]


Adds an iterator object for reference lists.

Bootstrapped and tested x86.


Diego.



	* tree-flow-inline.h (rli_start): New function.
	(rli_start_rev): New function.
	(rli_start_at): New function.
	(rli_after_end): New function.
	(rli_step): New function.
	(rli_step_rev): New function.
	(rli_ref): New function.
	* tree-flow.h (struct ref_list_iterator): Declare.
	(FOR_REF_BETWEEN, FOR_EACH_REF, FOR_EACH_REF_REV): Replace with new
	rli_* iterator functions.  Update all users.

Index: tree-cfg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-cfg.c,v
retrieving revision 1.1.4.18
diff -d -u -p -r1.1.4.18 tree-cfg.c
--- tree-cfg.c	19 Oct 2002 19:48:04 -0000	1.1.4.18
+++ tree-cfg.c	21 Oct 2002 16:39:52 -0000
@@ -795,8 +795,7 @@ block_invalidates_loop (bb, loop)
      basic_block bb;
      struct loop *loop;
 {
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
   /* Valid loops cannot contain a return statement.  */
   if (TREE_CODE (last_stmt (bb)) == RETURN_EXPR)
@@ -811,8 +810,8 @@ block_invalidates_loop (bb, loop)
   /* If the node contains a non-pure function call, mark it invalid.  A
      non-pure function call is marked by the presence of a clobbering
      definition of GLOBAL_VAR.  */
-  FOR_EACH_REF (ref, tmp, bb_refs (bb))
-    if (ref_var (ref) == global_var && is_clobbering_def (ref))
+  for (i = rli_start (bb_refs (bb)); !rli_after_end (i); rli_step (&i))
+    if (ref_var (rli_ref (i)) == global_var && is_clobbering_def (rli_ref (i)))
       return true;
 
   return false;
Index: tree-dfa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-dfa.c,v
retrieving revision 1.1.4.34
diff -d -u -p -r1.1.4.34 tree-dfa.c
--- tree-dfa.c	20 Oct 2002 19:37:46 -0000	1.1.4.34
+++ tree-dfa.c	21 Oct 2002 16:39:52 -0000
@@ -580,37 +580,36 @@ add_ref_to_list_end (list, ref)
   list->last = node;
 }
 
+
 /* Add the contents of the list TOADD to the list LIST, at the beginning of
-   LIST. */ 
+   LIST.  */
+
 void 
 add_list_to_list_begin (list, toadd)
      ref_list list;
      ref_list toadd;
 {
-  struct ref_list_node *tmp;
-  tree_ref tempref;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (tempref, tmp, toadd)
-  {
-    add_ref_to_list_begin (list, tempref);
-  }
+  for (i = rli_start (toadd); !rli_after_end (i); rli_step (&i))
+    add_ref_to_list_begin (list, rli_ref (i));
 }
 
-/* Add the contents of the list TOADD to the list LIST, at the end of LIST. */
+
+/* Add the contents of the list TOADD to the list LIST, at the end of LIST.  */
+
 void
 add_list_to_list_end (list, toadd)
      ref_list list;
      ref_list toadd;
 {
-  struct ref_list_node *tmp;
-  tree_ref tempref;
-  
-  FOR_EACH_REF (tempref, tmp, toadd)
-  {
-    add_ref_to_list_end (list, tempref);
-  }
+  ref_list_iterator i;
+ 
+  for (i = rli_start (toadd); !rli_after_end (i); rli_step (&i))
+    add_ref_to_list_end (list, rli_ref (i));
 }
 
+
 /* Find the list container for reference REF in LIST.  */
 
 struct ref_list_node *
@@ -969,11 +968,11 @@ function_may_recurse_p ()
      function is not recursive.  */
   FOR_EACH_BB (bb)
     {
-      struct ref_list_node *tmp;
-      tree_ref ref;
+      ref_list_iterator i;
 
-      FOR_EACH_REF (ref, tmp, bb_refs (bb))
-	if (ref_var (ref) == global_var && is_clobbering_def (ref))
+      for (i = rli_start (bb_refs (bb)); !rli_after_end (i); rli_step (&i))
+	if (ref_var (rli_ref (i)) == global_var
+	    && is_clobbering_def (rli_ref (i)))
 	  return true;
     }
 
@@ -1109,14 +1108,10 @@ dump_ref_list (outf, prefix, reflist, in
      int indent;
      int details;
 {
-  struct ref_list_node *tmp;
-  tree_ref ref;
-
-  if (reflist == NULL)
-    return;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (ref, tmp, reflist)
-    dump_ref (outf, prefix, ref, indent, details);
+  for (i = rli_start (reflist); !rli_after_end (i); rli_step (&i))
+    dump_ref (outf, prefix, rli_ref (i), indent, details);
 }
 
 
@@ -1503,11 +1498,11 @@ count_tree_refs (dfa_stats_p, list)
      struct dfa_stats_d *dfa_stats_p;
      ref_list list;
 {
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (ref, tmp, list)
+  for (i = rli_start (list); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref ref = rli_ref (i);
       dfa_stats_p->num_tree_refs++;
 
       if (ref->vref.alias_imm_rdefs)
@@ -1554,10 +1549,9 @@ count_ref_list_nodes (dfa_stats_p, list)
      struct dfa_stats_d *dfa_stats_p;
      ref_list list;
 {
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (ref, tmp, list)
+  for (i = rli_start (list); !rli_after_end (i); rli_step (&i))
     dfa_stats_p->num_ref_list_nodes++;
 }
 
Index: tree-flow-inline.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-flow-inline.h,v
retrieving revision 1.1.2.6
diff -d -u -p -r1.1.2.6 tree-flow-inline.h
--- tree-flow-inline.h	19 Oct 2002 19:48:04 -0000	1.1.2.6
+++ tree-flow-inline.h	21 Oct 2002 16:39:52 -0000
@@ -752,4 +752,66 @@ is_pure_use (ref)
 	 && ref_type (ref) == V_USE;
 }
 
+/* Start a new forward iterator on the first element of LIST.  */
+static inline ref_list_iterator
+rli_start (list)
+     ref_list list;
+{
+  ref_list_iterator i;
+  i.node = (list) ? list->first : NULL;
+  return i;
+}
+
+/* Start a new reverse iterator on the last element of LIST.  */
+static inline ref_list_iterator
+rli_start_rev (list)
+     ref_list list;
+{
+  ref_list_iterator i;
+  i.node = (list) ? list->last : NULL;
+  return i;
+}
+
+/* Start a new reverse iterator on a specific list node N.  */
+static inline ref_list_iterator
+rli_start_at (n)
+     struct ref_list_node *n;
+{
+  ref_list_iterator i;
+  i.node = n;
+  return i;
+}
+
+/* Return TRUE if we reached the end of the list with iterator I.  */
+static inline bool
+rli_after_end (i)
+     ref_list_iterator i;
+{
+  return i.node == NULL;
+}
+
+/* Move iterator I to the next element in the list.  */
+static inline void
+rli_step (i)
+     ref_list_iterator *i;
+{
+  i->node = i->node->next;
+}
+
+/* Move iterator I to the previous element in the list.  */
+static inline void
+rli_step_rev (i)
+     ref_list_iterator *i;
+{
+  i->node = i->node->prev;
+}
+
+/* Return the reference at the current position of iterator I.  */
+static inline tree_ref
+rli_ref (i)
+     ref_list_iterator i;
+{
+  return i.node->ref;
+}
+
 #endif /* _TREE_FLOW_INLINE_H  */
Index: tree-flow.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-flow.h,v
retrieving revision 1.1.4.27
diff -d -u -p -r1.1.4.27 tree-flow.h
--- tree-flow.h	19 Oct 2002 19:48:04 -0000	1.1.4.27
+++ tree-flow.h	21 Oct 2002 16:39:52 -0000
@@ -101,19 +101,6 @@ struct ref_list_priv GTY(())
 typedef struct ref_list_priv *ref_list;
 
 
-/* Iterators for reference lists.  */
-#define FOR_REF_BETWEEN(REF, TMP, FROM, TO, DIR)		\
-  if (FROM) \
-  for (TMP = FROM, REF = TMP->ref;  TMP != TO; TMP = TMP->DIR, REF = (TMP ? TMP->ref : NULL))
-
-#define FOR_EACH_REF(REF, TMP, LIST)				\
-  if (LIST)							\
-  FOR_REF_BETWEEN (REF, TMP, LIST->first, LIST->last->next, next)
-
-#define FOR_EACH_REF_REV(REF, TMP, LIST)			\
-  if (LIST)							\
-  FOR_REF_BETWEEN (REF, TMP, LIST->last, LIST->first->prev, prev)
-
 /* Forward declare structures for the garbage collector GTY markers.  */
 #ifndef GCC_BASIC_BLOCK_H
 struct edge_def;
@@ -613,6 +600,19 @@ extern void gsi_insert_after (tree stmt,
 extern void gsi_delete (gimple_stmt_iterator, basic_block);
 extern void gsi_replace (tree stmt, gimple_stmt_iterator, basic_block);
 #endif
+
+/* Iterators for reference lists.  */
+typedef struct {
+  struct ref_list_node *node;
+} ref_list_iterator;
+
+static inline ref_list_iterator rli_start     PARAMS ((ref_list));
+static inline ref_list_iterator rli_start_rev PARAMS ((ref_list));
+static inline ref_list_iterator rli_start_at  PARAMS ((struct ref_list_node *));
+static inline bool rli_after_end	PARAMS ((ref_list_iterator));
+static inline void rli_step		PARAMS ((ref_list_iterator *));
+static inline void rli_step_rev		PARAMS ((ref_list_iterator *));
+static inline tree_ref rli_ref		PARAMS ((ref_list_iterator));
 
 
 /* Global declarations.  */
Index: tree-ssa-ccp.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-ccp.c,v
retrieving revision 1.1.2.24
diff -d -u -p -r1.1.2.24 tree-ssa-ccp.c
--- tree-ssa-ccp.c	19 Oct 2002 19:48:04 -0000	1.1.2.24
+++ tree-ssa-ccp.c	21 Oct 2002 16:39:52 -0000
@@ -195,8 +195,7 @@ simulate_block (block)
      basic_block block;
 {
   ref_list blockrefs;
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
   /* There is nothing to do for the exit block.  */
   if (block == EXIT_BLOCK_PTR)
@@ -212,11 +211,9 @@ simulate_block (block)
 
   /* Always simulate PHI nodes, even if we have simulated this block
      before.  Note that all PHI nodes are consecutive within a block.  */
-  FOR_EACH_REF (ref, tmp, blockrefs)
-    {
-      if (ref_type (ref) == V_PHI)
-	visit_phi_node (ref);
-    }
+  for (i = rli_start (blockrefs); !rli_after_end (i); rli_step (&i))
+    if (ref_type (rli_ref (i)) == V_PHI)
+      visit_phi_node (rli_ref (i));
 
 #if defined ENABLE_CHECKING
   if (block->index < 0 || block->index > last_basic_block)
@@ -232,11 +229,11 @@ simulate_block (block)
       /* Note that we have simulated this block.  */
       SET_BIT (executable_blocks, block->index);
 
-      FOR_EACH_REF (ref, tmp, blockrefs)
+      for (i = rli_start (blockrefs); !rli_after_end (i); rli_step (&i))
 	{
 	  /* Simulate each reference within the block.  */
-	  if (ref_type (ref) != V_PHI)
-	    visit_expression_for (ref);
+	  if (ref_type (rli_ref (i)) != V_PHI)
+	    visit_expression_for (rli_ref (i));
 	} 
 
       /* If we haven't looked at the next block, and it has a
@@ -256,15 +253,16 @@ static void
 simulate_def_use_chains (def)
      tree_ref def;
 {
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     dump_ref (dump_file, "\nSimulating def-use edges for definition: ",
 		 def, 0, 0);
 
-  FOR_EACH_REF (ref, tmp, imm_uses (def))
+  for (i = rli_start (imm_uses (def)); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref ref = rli_ref (i);
+
       /* Note that we only visit unmodified V_USE references.  We don't
 	 want to deal with any modifiers here.  */
       if (is_pure_use (ref)
@@ -309,14 +307,11 @@ optimize_unexecutable_edges (edges)
 	  if (edge->dest != EXIT_BLOCK_PTR)
 	    {
 	      ref_list blockrefs = bb_refs (edge->dest);
-	      tree_ref ref;
-	      struct ref_list_node *tmp;
+	      ref_list_iterator i;
 
-	      FOR_EACH_REF (ref, tmp, blockrefs)
-		{
-		  if (ref_type (ref) == V_PHI)
-		    tree_ssa_remove_phi_alternative (ref, edge->src);
-		}
+	      for (i = rli_start (blockrefs); !rli_after_end (i); rli_step (&i))
+		if (ref_type (rli_ref (i)) == V_PHI)
+		  tree_ssa_remove_phi_alternative (rli_ref (i), edge->src);
 	    }
 
 	  /* Since the edge was not executable, remove it from the CFG.  */
@@ -339,12 +334,12 @@ substitute_and_fold ()
   /* Substitute constants in every expression of every basic block.  */
   FOR_EACH_BB (bb)
     {
-      tree_ref ref;
-      struct ref_list_node *tmp;
       tree new_expr;
+      ref_list_iterator i;
 
-      FOR_EACH_REF (ref, tmp, bb_refs (bb))
+      for (i = rli_start (bb_refs (bb)); !rli_after_end (i); rli_step (&i))
 	{
+	  tree_ref ref = rli_ref (i);
 	  tree expr = ref_expr (ref);
 	  tree stmt = ref_stmt (ref);
 
@@ -856,12 +851,12 @@ initialize ()
   values = (value *) xmalloc (next_tree_ref_id * sizeof (value));
   for (i = 0; i < num_referenced_vars; i++)
     {
-      struct ref_list_node *tmp;
-      tree_ref r;
       tree var = referenced_var (i);
+      ref_list_iterator j;
 
-      FOR_EACH_REF (r, tmp, tree_refs (var))
+      for (j = rli_start (tree_refs (var)); !rli_after_end (j); rli_step (&j))
 	{
+	  tree_ref r = rli_ref (j);
 	  unsigned long id = ref_id (r);
 
 	  values[id].lattice_val = UNDEFINED;
@@ -1006,11 +1001,11 @@ replace_uses_in (expr)
      tree expr;
 {
   ref_list refs = tree_refs (expr);
-  struct ref_list_node *tmp;
-  tree_ref use;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (use, tmp, refs)
+  for (i = rli_start (refs); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref use = rli_ref (i);
       HOST_WIDE_INT rdef_id;
       tree_ref rdef;
 
@@ -1055,15 +1050,14 @@ restore_expr (expr)
      tree expr;
 {
   ref_list refs = tree_refs (expr);
-  struct ref_list_node *tmp;
-  tree_ref use;
+  ref_list_iterator i;
 
-  FOR_EACH_REF (use, tmp, refs)
+  for (i = rli_start (refs); !rli_after_end (i); rli_step (&i))
     {
       /* Only restore pure V_USE references (those are the only types
 	 of references changed by replace_uses_in.  */
-      if (is_pure_use (use))
-	restore_ref_operand (use);
+      if (is_pure_use (rli_ref (i)))
+	restore_ref_operand (rli_ref (i));
     }
 }
 
Index: tree-ssa-dce.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-dce.c,v
retrieving revision 1.1.2.8
diff -d -u -p -r1.1.2.8 tree-ssa-dce.c
--- tree-ssa-dce.c	19 Oct 2002 19:48:04 -0000	1.1.2.8
+++ tree-ssa-dce.c	21 Oct 2002 16:39:52 -0000
@@ -132,7 +132,6 @@ tree_ssa_eliminate_dead_code (fndecl)
 {
   basic_block bb;
   tree fnbody, t;
-  struct ref_list_node *tmp;
 
   stats.total = stats.removed = 0;
 
@@ -161,7 +160,6 @@ tree_ssa_eliminate_dead_code (fndecl)
   /* Find obviously useful instructions.  */
   FOR_EACH_BB (bb)
     {
-      tree_ref ref;
       ref_list blockrefs;
       gimple_stmt_iterator i;
 
@@ -170,6 +168,7 @@ tree_ssa_eliminate_dead_code (fndecl)
 	  
       for (i = gsi_start_bb (bb); !gsi_after_end (i); gsi_step (&i))
 	{
+	  ref_list_iterator j;
 	  t = gsi_stmt (i);
 
 	  if (TREE_CODE (t) == ASM_EXPR)
@@ -188,8 +187,9 @@ tree_ssa_eliminate_dead_code (fndecl)
 	  if (! blockrefs)
 	    continue;
 
-	  FOR_EACH_REF (ref, tmp, blockrefs)
+	  for (j = rli_start (blockrefs); !rli_after_end (j); rli_step (&j))
 	    {
+	      tree_ref ref = rli_ref (j);
 	      enum tree_ref_type type = ref_type (ref);
 
 	      if (type == V_DEF)
@@ -222,7 +222,7 @@ tree_ssa_eliminate_dead_code (fndecl)
     {
       tree i, j;
       basic_block b;
-      tree_ref r, rdef;
+      ref_list_iterator k;
 
       /* Take `i' from worklist.  */
       i = VARRAY_TOP_TREE (worklist);
@@ -232,14 +232,19 @@ tree_ssa_eliminate_dead_code (fndecl)
       b = bb_for_stmt (i);
 
       /* For each use by `i' .. */
-      FOR_EACH_REF (r, tmp, tree_refs (i))
+      for (k = rli_start (tree_refs (i)); !rli_after_end (k); rli_step (&k))
 	{
-	  struct ref_list_node *tmp2;
+	  ref_list_iterator l;
+	  tree_ref r = rli_ref (k);
+
 	  if (ref_type (r) != V_USE)
 	    continue;
 
-	  FOR_EACH_REF (rdef, tmp2, reaching_defs (r))
+	  l = rli_start (reaching_defs (r));
+	  for (; !rli_after_end (l); rli_step (&l))
 	    {
+	      tree_ref rdef = rli_ref (l);
+
 	      /* J = definition (T).  */
 	      j = ref_stmt (rdef);
 	      if (j && ! necessary_p (j))
Index: tree-ssa-pre.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-pre.c,v
retrieving revision 1.1.4.28
diff -d -u -p -r1.1.4.28 tree-ssa-pre.c
--- tree-ssa-pre.c	20 Oct 2002 19:33:07 -0000	1.1.4.28
+++ tree-ssa-pre.c	21 Oct 2002 16:39:53 -0000
@@ -259,8 +259,8 @@ static bool
 is_strred_cand (expr)
      tree expr;
 {
-  tree_ref ref, def, use;
-  struct ref_list_node *tmp;
+  tree_ref def, use;
+  ref_list_iterator i;
   
   STRIP_WFL (expr);
   /* Multiplications that def a variable they use can't be strength reduced.
@@ -270,15 +270,17 @@ is_strred_cand (expr)
     return false;
   
   def = use = NULL;
-  FOR_EACH_REF (ref, tmp, tree_refs (expr))
-    {
-      if (ref_type (ref) == V_DEF)	
-	  def = ref;
-    }
+  for (i = rli_start (tree_refs (expr)); !rli_after_end (i); rli_step (&i))
+    if (ref_type (rli_ref (i)) == V_DEF)	
+	def = rli_ref (i);
+
   if (!def)
     return true;
-  FOR_EACH_REF (ref, tmp, tree_refs (expr))
+
+  for (i = rli_start (tree_refs (expr)); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref ref = rli_ref (i);
+
       if (ref_type (ref) == V_USE)
 	{
 	  use = ref;
@@ -444,14 +446,12 @@ static inline tree_ref
 find_def_for_stmt (stmt)
      tree stmt;
 {
-  struct ref_list_node *tmp;
-  tree_ref ref;
+  ref_list_iterator i;
+
+  for (i = rli_start (tree_refs (stmt)); !rli_after_end (i); rli_step (&i))
+    if (ref_type (rli_ref (i)) == V_DEF)
+      return rli_ref (i);
 
-  FOR_EACH_REF (ref, tmp, tree_refs (stmt))
-    {
-      if (ref_type (ref) == V_DEF)
-        return ref;
-    }
   return NULL;
 }
 
@@ -475,12 +475,14 @@ maybe_find_rhs_use_for_var (def, var)
      tree_ref def;
      tree var;
 {
-  struct ref_list_node *tmp;
-  tree_ref ref;
+  ref_list_iterator i;
 
   /* Now look for the use of var in that expression. */
-  FOR_EACH_REF (ref, tmp, tree_refs (ref_expr (def)))
+  i = rli_start (tree_refs (ref_expr (def)));
+  for (; !rli_after_end (i); rli_step (&i))
     {
+      tree_ref ref = rli_ref (i);
+
       if (ref_type (ref) != V_USE
 	  || !is_simple_modify_expr (ref_expr (ref)))
         continue;
@@ -506,8 +508,7 @@ defs_y_dom_x (ei, y, x)
      most. */
   for (i =  0; i < 2; i++)
     {
-      tree_ref ref;
-      struct ref_list_node *tmp;
+      ref_list_iterator j;
       tree yexpr, refexpr;
       
       yexpr = ref_expr (y);
@@ -516,8 +517,12 @@ defs_y_dom_x (ei, y, x)
       
       if (!TREE_OPERAND (yexpr, i))
         continue;
-      FOR_EACH_REF (ref, tmp, tree_refs (ref_stmt (y)))
+
+      j = rli_start (tree_refs (ref_stmt (y)));
+      for (; !rli_after_end (j); rli_step (&j))
         {
+	  tree_ref ref = rli_ref (j);
+
           /* Find the ref for this operand. */
 	  if (ref_type (ref) != V_USE)
 	    continue;
@@ -560,18 +565,18 @@ defs_match_p (ei, t1, t2)
      tree t1;
      tree t2;
 {
-  tree_ref use1;
   tree_ref use2;
   tree origt2;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
   
   STRIP_WFL (t1);
   STRIP_WFL (t2);
   origt2 = t2;
   t2 = TREE_OPERAND (t2, 1);
   
-  FOR_EACH_REF (use1, tmp, tree_refs (t1))
+  for (i = rli_start (tree_refs (t1)); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref use1 = rli_ref (i);
       tree use1expr = ref_expr (use1);
       if (ref_type (use1) != V_USE
 	  || !is_simple_modify_expr (use1expr))
@@ -764,20 +769,22 @@ phi_opnd_from_res (ei, Z, j, b)
      basic_block b;
 {
   varray_type Q;
-  tree_ref v;
   size_t i = 0;
-  struct ref_list_node *tmp;
+  ref_list_iterator k;
 
   VARRAY_GENERIC_PTR_INIT (Q, 1, "Temp ops");
 
   /* b <- block containing phi that defines Z.
      Q <- copy of Z */
-  FOR_EACH_REF (v, tmp, tree_refs (ref_stmt (Z)))
-    VARRAY_PUSH_GENERIC_PTR (Q, v);
+  k = rli_start (tree_refs (ref_stmt (Z)));
+  for (; !rli_after_end (k); rli_step (&k))
+    VARRAY_PUSH_GENERIC_PTR (Q, rli_ref (k));
 
   /* For each variable v in Z */
-  FOR_EACH_REF (v, tmp, tree_refs (ref_stmt (Z)))
+  k = rli_start (tree_refs (ref_stmt (Z)));
+  for (; !rli_after_end (k); rli_step (&k))
     {
+      tree_ref v = rli_ref (k);
       if (ref_type (v) == V_USE)
 	if (ei->strred_cand)
 	  while  (is_injuring_def (ei, ref_expr (imm_reaching_def (v))))
@@ -885,14 +892,15 @@ rename_2 (ei, rename2_set)
 	      if (ref_type (X) == E_USE)
                 {
                   bool match = true;
-		  tree_ref op1;
-		  struct ref_list_node *tmp2;
+		  ref_list_iterator l;
 		  
 		  /* if (all corresponding variables in Y and X have
 		     the same SSA version) */
 		  k = 0;
-		  FOR_EACH_REF (op1, tmp2, tree_refs (ref_stmt (X)))
+		  l = rli_start (tree_refs (ref_stmt (X)));
+		  for (; !rli_after_end (l); rli_step (&l))
 		  {
+		    tree_ref op1 = rli_ref (l);
 		    tree_ref op2;
 		    if ((ref_type (op1) != V_USE))
 		      continue;
@@ -1476,8 +1484,6 @@ finalize_1 (ei, temp)
 		  tree *place;
 		  basic_block bb;
 		  tree endtree;
-		  struct ref_list_node *tmp;
-		  tree_ref tempref;
 
                   /* Insert definition of expr at end of BB containing X. */
 		  if (dump_file)
@@ -1536,12 +1542,13 @@ finalize_1 (ei, temp)
 		   create_ref is not correct.  We should keep statement and
 		   expression pointers here.  */
 		  find_refs_in_stmt (stmt, bb);
-		  FOR_EACH_REF (tempref, tmp, tree_refs (stmt))
-		  {
-		    if (ref_type (tempref) != V_USE)
-		      continue;
-		    find_reaching_def_of_var (tempref, bb, phi);  
-		  }
+		  i = rli_start (tree_refs (stmt));
+		  for (; !rli_after_end (i); rli_step (&i))
+		    {
+		      if (ref_type (rli_ref (i)) != V_USE)
+			continue;
+		      find_reaching_def_of_var (rli_ref (i), bb, phi);  
+		    }
 		  
 		  splay_tree_insert (new_stmt_map, 
 				     (splay_tree_key) expr,
@@ -1598,11 +1605,13 @@ expr_phi_insertion (dfs, ei)
 	  || (TREE_OPERAND (real, 1) 
 	      && is_simple_id (TREE_OPERAND (real, 1))))
         {
-          tree_ref ref;
-	  struct ref_list_node *tmp;
           int varcount = 0;
-	  FOR_EACH_REF (ref, tmp, tree_refs (VARRAY_TREE (ei->realstmts, i)))
+	  ref_list_iterator j;
+
+	  j = rli_start (tree_refs (VARRAY_TREE (ei->realstmts, i)));
+	  for (; !rli_after_end (j); rli_step (&j))
 	  {
+	    tree_ref ref = rli_ref (j);
 	    if (ei->strred_cand)
 	      while (ref_type (ref) == V_USE
 		     && ref_var (ref) == TREE_OPERAND (real, 0)
@@ -1965,7 +1974,6 @@ repair_injury (ei, use, temp, orig_euse)
   int i;
   tree expr, stmt;
   basic_block bb;
-  struct ref_list_node *tmp;
   ref_list toprocess = create_ref_list();
      
   for (i = 0; i < 2; i++)
@@ -1981,6 +1989,8 @@ repair_injury (ei, use, temp, orig_euse)
 
       if (ref_type (v) == V_DEF)
 	{
+	  ref_list_iterator j;
+
 	  /* If this isn't a def of *this* variable, ignore it, since it can't
 	   *possibly* injure it. */
 	  if (ref_var (find_def_for_stmt (ref_stmt (v))) 
@@ -2002,49 +2012,50 @@ repair_injury (ei, use, temp, orig_euse)
 	  /* The *first* reference will probably not have a reaching def we can
 	     set yet, since it'll come from a save that hasn't been done
 	     yet. */
-	  FOR_EACH_REF (v, tmp, toprocess)
-	  {	    
-	    if (htab_find (ei->repaired, ref_expr (v)) == NULL)
-	      {
+	  for (j = rli_start (toprocess); !rli_after_end (j); rli_step (&j))
+	    {
+	      v = rli_ref (j);
+	      if (htab_find (ei->repaired, ref_expr (v)) == NULL)
+		{
 #if DEBUGGING_STRRED
-		if (dump_file)
-		    {
-		      fprintf (dump_file, "Injuring def to repair is: ");
-		      print_generic_tree (dump_file, ref_expr (v));
-		      fprintf (dump_file, "\n");
-		    }
+		  if (dump_file)
+		      {
+			fprintf (dump_file, "Injuring def to repair is: ");
+			print_generic_tree (dump_file, ref_expr (v));
+			fprintf (dump_file, "\n");
+		      }
 #endif
-		  incr = calculate_increment (ei, ref_expr (v));
-		  expr = build_modify_expr (temp, NOP_EXPR, 
-					    fold (build (PLUS_EXPR, 
-							 TREE_TYPE (temp),
-							 temp, incr)));
-		  stmt = build (COMPOUND_EXPR, void_type_node, ref_stmt (v), expr);
-		  TREE_TYPE (stmt) = TREE_TYPE (expr);
-		  bb = ref_bb (use);
-		  replace_ref_stmt_with (v, stmt);
-		  *(htab_find_slot (ei->repaired, ref_expr (v), INSERT)) = ref_expr (v);
+		    incr = calculate_increment (ei, ref_expr (v));
+		    expr = build_modify_expr (temp, NOP_EXPR, 
+					      fold (build (PLUS_EXPR, 
+							  TREE_TYPE (temp),
+							  temp, incr)));
+		    stmt = build (COMPOUND_EXPR, void_type_node, ref_stmt (v), expr);
+		    TREE_TYPE (stmt) = TREE_TYPE (expr);
+		    bb = ref_bb (use);
+		    replace_ref_stmt_with (v, stmt);
+		    *(htab_find_slot (ei->repaired, ref_expr (v), INSERT)) = ref_expr (v);
 #if WAITING_FOR_DFA_UPDATE		  
-		  /* Update SSA for the repair.  
-		     1. Find the refs in the statement.
-		     2. Add the ref to the list of refs to find reaching defs
-		     for later (we don't necessarily have the eventual defs
-		     inserted yet). 
-		     3. Insert into new statement map the tuple (orig_euse,
-		     repair stmt).
-		  */
-		/* FIXME: Hack.  Passing the address of local trees to
-		   create_ref is not correct.  We should keep statement and
-		   expression pointers here.  */
-		  find_refs_in_stmt (stmt, bb);
-		  add_ref_to_list_begin (ei->injfixups, 
-					 find_def_for_stmt (stmt));
-		  splay_tree_insert (new_stmt_map, 
-				     (splay_tree_key) orig_euse,
-				     (splay_tree_value) stmt);
+		    /* Update SSA for the repair.  
+		      1. Find the refs in the statement.
+		      2. Add the ref to the list of refs to find reaching defs
+		      for later (we don't necessarily have the eventual defs
+		      inserted yet). 
+		      3. Insert into new statement map the tuple (orig_euse,
+		      repair stmt).
+		    */
+		  /* FIXME: Hack.  Passing the address of local trees to
+		    create_ref is not correct.  We should keep statement and
+		    expression pointers here.  */
+		    find_refs_in_stmt (stmt, bb);
+		    add_ref_to_list_begin (ei->injfixups, 
+					  find_def_for_stmt (stmt));
+		    splay_tree_insert (new_stmt_map, 
+				      (splay_tree_key) orig_euse,
+				      (splay_tree_value) stmt);
 #endif
-		}
-	  }
+		  }
+	    }
 	}
       else if (ref_type (imm_reaching_def (v)) == V_PHI)
 	{
@@ -2076,8 +2087,7 @@ find_reaching_def_of_var (var, stmtbb, p
      basic_block stmtbb;
      tree_ref phi;
 {
-  tree_ref tempref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
   struct ref_list_node *thisref;
   struct ref_list_node *fromhere;
 
@@ -2085,24 +2095,27 @@ find_reaching_def_of_var (var, stmtbb, p
     return NULL;
   
   if (phi)
-    FOR_EACH_REF (tempref, tmp, bb_refs (ref_bb (phi)))
-    {
-      if (ref_type (tempref) != V_PHI)
-	continue;
-      if (ref_var (tempref) == ref_var (var))
-	{
-	  int opnum;
-	  phi_node_arg realphiarg;
-	  
-	  opnum = opnum_of_phi (tempref, stmtbb->index);
-	  realphiarg = VARRAY_GENERIC_PTR (phi_args (tempref), opnum);
-	  
-	  set_imm_reaching_def (var, phi_arg_def (realphiarg));
-	  add_ref_to_list_end (imm_uses (phi_arg_def (realphiarg)), var);
-	  
-	  return 1;
-	}   
-    }
+    for (i = rli_start (bb_refs (ref_bb (phi)));
+	 !rli_after_end (i);
+	 rli_step (&i))
+      {
+	tree_ref tempref = rli_ref (i);
+	if (ref_type (tempref) != V_PHI)
+	  continue;
+	if (ref_var (tempref) == ref_var (var))
+	  {
+	    int opnum;
+	    phi_node_arg realphiarg;
+
+	    opnum = opnum_of_phi (tempref, stmtbb->index);
+	    realphiarg = VARRAY_GENERIC_PTR (phi_args (tempref), opnum);
+
+	    set_imm_reaching_def (var, phi_arg_def (realphiarg));
+	    add_ref_to_list_end (imm_uses (phi_arg_def (realphiarg)), var);
+
+	    return 1;
+	  }   
+      }
   
   /* If this is the bb of the var, we start looking *before* the var */
   fromhere = bb_refs (stmtbb)->last;
@@ -2113,27 +2126,28 @@ find_reaching_def_of_var (var, stmtbb, p
 	fromhere = thisref;
     }
 
-  FOR_REF_BETWEEN (tempref, tmp, fromhere, bb_refs (stmtbb)->first->prev, prev)
-  {
-    if ((ref_type (tempref) != V_DEF
-        && ref_type (tempref) != V_USE)
-	|| ref_expr (var) == ref_expr (tempref)) 
-      continue;
-    if (ref_var (tempref) == ref_var (var))
-      {
-	if (ref_type (tempref) == V_USE)
-	  {
-	    set_imm_reaching_def (var, imm_reaching_def (tempref));
-	    add_ref_to_list_end (imm_uses (imm_reaching_def (tempref)), var);
-	  }
-	else
-	  {
-	    set_imm_reaching_def (var, tempref);
-	    add_ref_to_list_end (imm_uses (tempref), var);
-	  }
-	return 1;
-      }
-  }
+  for (i = rli_start_at (fromhere); !rli_after_end (i); rli_step_rev (&i))
+    {
+      tree_ref tempref = rli_ref (i);
+      if ((ref_type (tempref) != V_DEF
+	    && ref_type (tempref) != V_USE)
+	  || ref_expr (var) == ref_expr (tempref)) 
+	continue;
+      if (ref_var (tempref) == ref_var (var))
+	{
+	  if (ref_type (tempref) == V_USE)
+	    {
+	      set_imm_reaching_def (var, imm_reaching_def (tempref));
+	      add_ref_to_list_end (imm_uses (imm_reaching_def (tempref)), var);
+	    }
+	  else
+	    {
+	      set_imm_reaching_def (var, tempref);
+	      add_ref_to_list_end (imm_uses (tempref), var);
+	    }
+	  return 1;
+	}
+    }
   return find_reaching_def_of_var (var,
 				   get_immediate_dominator (pre_idom, stmtbb),
 				   NULL);    
@@ -2151,8 +2165,7 @@ update_ssa_for_new_use (temp, newuse, de
      basic_block bb;
      
 {
-  tree_ref tempref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
   splay_tree_node reachingnode;
   tree_ref use_orig_ref;
   tree_ref olddefref, newdefref, newuseref;
@@ -2184,44 +2197,45 @@ update_ssa_for_new_use (temp, newuse, de
      the reaching def's immediate uses, etc.
   */
 
-  FOR_EACH_REF (tempref, tmp, tree_refs (newuse))
-  {
-    if (ref_type (tempref) == V_DEF)
-      {
-	use_orig_ref = tempref;
-	break;
-      }
-  }
+  for (i = rli_start (tree_refs (newuse)); !rli_after_end (i); rli_step (&i))
+    {
+      if (ref_type (rli_ref (i)) == V_DEF)
+	{
+	  use_orig_ref = rli_ref (i);
+	  break;
+	}
+    }
 #if WAITING_FOR_DFA_UPDATE
   olddefref = find_def_for_stmt (ref_stmt (use_orig_ref));
-  FOR_EACH_REF (tempref, tmp, tree_refs (ref_expr (use_orig_ref)))
-  {
-    remove_ref_from_list (tree_refs (ref_stmt (use_orig_ref)),
-			  tempref);
-    if (ref_type (tempref) == V_DEF)
-      {
-	add_list_to_list_end (immtoadd, imm_uses (tempref));
-	add_list_to_list_end (reachedtoadd, 
-			      reached_uses (tempref));
-      }
-    if (ref_type (tempref) != V_USE)
-      continue;
-    remove_tree_ref (ref_var (tempref), tempref);
-    remove_bb_ref (bb, tempref);
-    if (imm_reaching_def (tempref) != NULL)
-      {
-	tree_ref rdef = imm_reaching_def (tempref);
-	
-	remove_ref_from_list (imm_uses (rdef), tempref);
-	remove_ref_from_list (reached_uses (rdef), tempref);
-      }
-    add_ref_to_list_end (todelete, tempref);		
-  }
+  i = rli_start (tree_refs (ref_expr (use_orig_def)));
+  for (; !rli_after_end (i); rli_step (&i))
+    {
+      tree_ref tempref = rli_ref (i);
+      remove_ref_from_list (tree_refs (ref_stmt (use_orig_ref)),
+	  tempref);
+      if (ref_type (tempref) == V_DEF)
+	{
+	  add_list_to_list_end (immtoadd, imm_uses (tempref));
+	  add_list_to_list_end (reachedtoadd, 
+	      reached_uses (tempref));
+	}
+      if (ref_type (tempref) != V_USE)
+	continue;
+      remove_tree_ref (ref_var (tempref), tempref);
+      remove_bb_ref (bb, tempref);
+      if (imm_reaching_def (tempref) != NULL)
+	{
+	  tree_ref rdef = imm_reaching_def (tempref);
+
+	  remove_ref_from_list (imm_uses (rdef), tempref);
+	  remove_ref_from_list (reached_uses (rdef), tempref);
+	}
+      add_ref_to_list_end (todelete, tempref);		
+    }
   
-  FOR_EACH_REF (tempref, tmp, todelete)
-  {
-    remove_tree_ref (ref_expr (use_orig_ref), tempref);
-  }
+  for (i = rli_start (todelete); !rli_after_end (i); rli_step (&i))
+    remove_tree_ref (ref_expr (use_orig_ref), rli_ref (i));
+
   ref_expr (use_orig_ref)->common.ann = NULL;
 #endif
   useexpr = ref_expr (use_orig_ref);
@@ -2295,20 +2309,21 @@ update_phis_in_list (refs, old, new)
      tree_ref new;   
 {
   size_t i;
-  struct ref_list_node *tmp;
-  tree_ref tempref;
+  ref_list_iterator j;
   
-  FOR_EACH_REF (tempref, tmp, refs)
-  {
-    if (ref_type (tempref) != V_PHI)
-      continue;
-    
-    for (i = 0; i < VARRAY_ACTIVE_SIZE (phi_args (tempref)); i++)
-      {
-	if (phi_arg_def (phi_arg (tempref, i)) == old)
-	  phi_arg (tempref, i)->def = new;
-      }
-  }
+  for (j = rli_start (refs); !rli_after_end (j); rli_step (&j))
+    {
+      tree_ref tempref = rli_ref (j);
+
+      if (ref_type (tempref) != V_PHI)
+	continue;
+
+      for (i = 0; i < VARRAY_ACTIVE_SIZE (phi_args (tempref)); i++)
+	{
+	  if (phi_arg_def (phi_arg (tempref, i)) == old)
+	    phi_arg (tempref, i)->def = new;
+	}
+    }
 }
 
 /* Perform actual code motion.  */                        
@@ -2319,8 +2334,6 @@ code_motion (ei, temp)
 {
   fibheap_t exprs;
   tree_ref use;
-  struct ref_list_node *tmp;
-  tree_ref tempref;
   
   ei->injfixups = create_ref_list ();
   need_repair_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
@@ -2357,18 +2370,18 @@ code_motion (ei, temp)
 	      tree use_expr = ref_expr (use);
 	      tree_ref use_orig_ref = NULL;
 	      tree newexpr, newstmt;
-	      struct ref_list_node *tmp2;
-	      tree_ref a;
 	      size_t j;	      
+	      ref_list_iterator i;
 	      
-	      FOR_EACH_REF (tempref, tmp, tree_refs (use_expr))
-	      {
-		if (ref_type (tempref) == V_DEF)
-		  {
-		    use_orig_ref = tempref;
-		    break;
-		  }
-	      }
+	      i = rli_start (tree_refs (use_expr));
+	      for (; !rli_after_end (i); rli_step (&i))
+		{
+		  if (ref_type (rli_ref (i)) == V_DEF)
+		    {
+		      use_orig_ref = rli_ref (i);
+		      break;
+		    }
+		}
 	      if (!use_orig_ref)
 		abort ();
 	      if (dump_file)
@@ -2392,14 +2405,16 @@ code_motion (ei, temp)
 	      use->common.stmt_p = &TREE_OPERAND (newstmt, 1);
 	      use->common.expr_p = &TREE_OPERAND (newstmt, 1);
 	      /* REMOVE AFTER DFA UPDATE */
-	      FOR_EACH_REF (a, tmp2, tree_refs (use_stmt))
-	      {
-		if (ref_stmt (a) == newstmt)
-		  {
-		    a->common.stmt_p = &TREE_OPERAND (newstmt, 1);
-		    a->common.expr_p = &TREE_OPERAND (newstmt, 1);
-		  }
-	      }	      
+	      i = rli_start (tree_refs (use_stmt));
+	      for (; !rli_after_end (i); rli_step (&i))
+		{
+		  tree_ref a = rli_ref (i);
+		  if (ref_stmt (a) == newstmt)
+		    {
+		      a->common.stmt_p = &TREE_OPERAND (newstmt, 1);
+		      a->common.expr_p = &TREE_OPERAND (newstmt, 1);
+		    }
+		}	      
 	      /* END REMOVE AFTER DFA UPDATE */
 	      update_ssa_for_new_use (temp, ref_expr (use), use, use_bb);
 
@@ -2415,17 +2430,19 @@ code_motion (ei, temp)
 		 expression pointers here.  */
 	      find_refs_in_stmt (newstmt, use_bb);
 	      
-	      FOR_EACH_REF (tempref, tmp, tree_refs (newexpr))
-	      {
-		tree_ref olddef;
-		if (ref_type (tempref) != V_USE)
-		  continue;
-		
-		olddef = find_use_for_var (use_expr, ref_var (tempref));
-		olddef = imm_reaching_def (olddef);
-		
-		set_imm_reaching_def (tempref, olddef);
-	      }
+	      i = rli_start (tree_refs (newexpr));
+	      for (; !rli_after_end (i); rli_step (&i))
+		{
+		  tempref = rli_ref (i);
+		  tree_ref olddef;
+		  if (ref_type (tempref) != V_USE)
+		    continue;
+
+		  olddef = find_use_for_var (use_expr, ref_var (tempref));
+		  olddef = imm_reaching_def (olddef);
+
+		  set_imm_reaching_def (tempref, olddef);
+		}
 	      
 	      splay_tree_insert (new_stmt_map, 
 				 (splay_tree_key) ref_expr (use), 
@@ -2562,24 +2579,27 @@ code_motion (ei, temp)
     }
 #endif
 #if WAITING_FOR_DFA_UPDATE
-  FOR_EACH_REF (tempref, tmp, ei->injfixups)
+  for (i = rli_start (ei->injfixups); !rli_after_end (i); rli_step (&i))
   {
-    tree_ref tempref2;
-    struct ref_list_node *tmp2;
-    
-    FOR_EACH_REF (tempref2, tmp2, tree_refs (ref_expr (tempref)))
-    {
-      if (ref_type (tempref2) != V_USE)
-	continue;    
-      find_reaching_def_of_var (tempref2, ref_bb (tempref2), NULL);
+    ref_list_iterator j;
+    tempref = rli_ref (i);
+
+    j = rli_start (tree_refs (ref_expr (tempref)));
+    for (; !rli_after_end (j); rli_step (&j))
+      {
+	tree_ref tempref2 = rli_ref (j);
+
+	if (ref_type (tempref2) != V_USE)
+	  continue;    
+	find_reaching_def_of_var (tempref2, ref_bb (tempref2), NULL);
 #if DEBUGGING_SSA_UPDATE
-      if (dump_file)
-	{
-	  fprintf (dump_file, "Injury use and new reaching def:\n");
-	  dump_ref (dump_file, "", tempref2, 0, 1);
-	}
+	if (dump_file)
+	  {
+	    fprintf (dump_file, "Injury use and new reaching def:\n");
+	    dump_ref (dump_file, "", tempref2, 0, 1);
+	  }
 #endif
-    }
+      }
 #endif
   }
 
@@ -2752,12 +2772,12 @@ tree_perform_ssapre ()
   calculate_preorder ();
   FOR_EACH_BB (bb)
     {    
-      tree_ref ref;
-      struct ref_list_node *tmp;
+      ref_list_iterator i;
 
       htab_empty (seen);
-      FOR_EACH_REF (ref, tmp, bb_refs (bb))
+      for (i = rli_start (bb_refs (bb)); !rli_after_end (i); rli_step (&i))
 	{
+	  tree_ref ref = rli_ref (i);
 	  tree expr = ref_expr (ref);
 	  tree orig_expr = expr;
 	  tree stmt = ref_stmt (ref);
Index: tree-ssa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa.c,v
retrieving revision 1.1.4.24
diff -d -u -p -r1.1.4.24 tree-ssa.c
--- tree-ssa.c	19 Oct 2002 19:48:05 -0000	1.1.4.24
+++ tree-ssa.c	21 Oct 2002 16:39:53 -0000
@@ -345,14 +345,14 @@ search_fud_chains (bb, idom)
 {
   edge e;
   basic_block child_bb;
-  struct ref_list_node *tmp;
-  tree_ref ref;
+  ref_list_iterator i;
 
   /* Chain every V_USE reference in the block to its immediate reaching
      definition.  Update the current definition of a variable when V_DEF
      references are found.  */
-  FOR_EACH_REF (ref, tmp, bb_refs (bb))
+  for (i = rli_start (bb_refs (bb)); !rli_after_end (i); rli_step (&i))
     {
+      tree_ref ref = rli_ref (i);
       tree var = ref_var (ref);
 
       if (ref_type (ref) != V_DEF
@@ -392,23 +392,26 @@ search_fud_chains (bb, idom)
      is reaching the PHI node.  */
   for (e = bb->succ; e; e = e->succ_next)
     {
-      tree_ref phi;
+      ref_list_iterator i;
 
-      FOR_EACH_REF (phi, tmp, bb_refs (e->dest))
-	if (ref_type (phi) == V_PHI)
-	  {
-	    tree_ref currdef = currdef_for (ref_var (phi));
-	    if (currdef == NULL)
-	      currdef = create_default_def (ref_var (phi));
+      for (i = rli_start (bb_refs (e->dest)); !rli_after_end (i); rli_step (&i))
+	{
+	  tree_ref phi = rli_ref (i);
+	  if (ref_type (phi) == V_PHI)
+	    {
+	      tree_ref currdef = currdef_for (ref_var (phi));
+	      if (currdef == NULL)
+		currdef = create_default_def (ref_var (phi));
 
-	    /* Besides storing the incoming definition CURRDEF, we also
-	       store E, which is the edge that we are receiving CURRDEF
-	       from.  */
-	    add_phi_arg (phi, currdef, e);
+	      /* Besides storing the incoming definition CURRDEF, we also
+		store E, which is the edge that we are receiving CURRDEF
+		from.  */
+	      add_phi_arg (phi, currdef, e);
 
-	    /* Set a def-use edge between CURRDEF and this PHI node.  */
-	    add_ref_to_list_end (imm_uses (currdef), phi);
-	  }
+	      /* Set a def-use edge between CURRDEF and this PHI node.  */
+	      add_ref_to_list_end (imm_uses (currdef), phi);
+	    }
+	}
     }
 
 
@@ -420,19 +423,23 @@ search_fud_chains (bb, idom)
 
   /* Restore the current reaching definition for each variable referenced
      in the block (in reverse order).  */
-  FOR_EACH_REF_REV (ref, tmp, bb_refs (bb))
-    if (ref_type (ref) == V_DEF || ref_type (ref) == V_PHI)
-      {
-	size_t i;
-	unsigned long id = ref_id (ref);
-	tree var = ref_var (ref);
+  for (i = rli_start_rev (bb_refs (bb)); !rli_after_end (i); rli_step_rev (&i))
+    {
+      tree_ref ref = rli_ref (i);
 
-	set_currdef_for (var, save_chain[id]);
+      if (ref_type (ref) == V_DEF || ref_type (ref) == V_PHI)
+	{
+	  size_t i;
+	  unsigned long id = ref_id (ref);
+	  tree var = ref_var (ref);
 
-	/* Also restore CURRDEF for every alias of REF's variable.  */
-	for (i = 0; i < num_may_alias (var); i++)
-	  set_currdef_for (may_alias (var, i), save_chain[id]);
-      }
+	  set_currdef_for (var, save_chain[id]);
+
+	  /* Also restore CURRDEF for every alias of REF's variable.  */
+	  for (i = 0; i < num_may_alias (var); i++)
+	    set_currdef_for (may_alias (var, i), save_chain[id]);
+	}
+    }
 }
 
 
@@ -451,11 +458,11 @@ tree_compute_rdefs ()
   for (i = 0; i < num_referenced_vars; i++)
     {
       tree var = referenced_var (i);
-      tree_ref r;
-      struct ref_list_node *tmp;
+      ref_list_iterator j;
 
-      FOR_EACH_REF (r, tmp, tree_refs (var))
+      for (j = rli_start (tree_refs (var)); !rli_after_end (j); rli_step (&j))
 	{
+	  tree_ref r = rli_ref (j);
 	  if (ref_type (r) == V_USE)
 	    empty_ref_list (reaching_defs (r));
 	  else if (ref_type (r) == V_DEF || ref_type (r) == V_PHI)
@@ -475,12 +482,14 @@ tree_compute_rdefs ()
   for (i = 0; i < num_referenced_vars; i++)
     {
       tree var = referenced_var (i);
-      tree_ref u;
-      struct ref_list_node *tmp;
+      ref_list_iterator j;
 
-      FOR_EACH_REF (u, tmp, tree_refs (var))
-	if (ref_type (u) == V_USE)
-	  follow_chain (imm_reaching_def (u), u);
+      for (j = rli_start (tree_refs (var)); !rli_after_end (j); rli_step (&j))
+	{
+	  tree_ref u = rli_ref (j);
+	  if (ref_type (u) == V_USE)
+	    follow_chain (imm_reaching_def (u), u);
+	}
     }
 
   free (marked);
@@ -508,8 +517,7 @@ analyze_rdefs ()
   for (i = 0; i < num_referenced_vars; i++)
     {
       tree var = referenced_var (i);
-      struct ref_list_node *tmp;
-      tree_ref use;
+      ref_list_iterator j;
 
       /* Uninitialized warning messages are only given for local variables
 	 with auto declarations.  */
@@ -522,11 +530,11 @@ analyze_rdefs ()
       /* For each use of VAR, if the use is reached by VAR's default
 	 definition, then the variable may have been used uninitialized in
 	 the function.  */
-      FOR_EACH_REF (use, tmp, tree_refs (var))
+      for (j = rli_start (tree_refs (var)); !rli_after_end (j); rli_step (&j))
 	{
+	  tree_ref use = rli_ref (j);
 	  int found_default;
-	  tree_ref def;
-	  struct ref_list_node *tmp2;
+	  ref_list_iterator k;
 
 	  if (ref_type (use) != V_USE)
 	    continue;
@@ -534,11 +542,10 @@ analyze_rdefs ()
 	  /* Check all the reaching definitions looking for the default
 	     definition.  */
 	  found_default = 0;
-	  FOR_EACH_REF (def, tmp2, reaching_defs (use))
-	    {
-	      if (is_default_def (def))
-		found_default = 1;
-	    }
+	  k = rli_start (reaching_defs (use));
+	  for (; !rli_after_end (k); rli_step (&k))
+	    if (is_default_def (rli_ref (k)))
+	      found_default = 1;
 
 	  /* If we found a default definition for VAR, then the reference may
 	     be accessing an uninitialized variable.  If the default def is the
@@ -679,13 +686,13 @@ dump_reaching_defs (file)
   for (i = 0; i < num_referenced_vars; i++)
     {
       tree var = referenced_var (i);
-      struct ref_list_node *tmp;
-      tree_ref u;
+      ref_list_iterator j;
 
       dump_variable (file, var);
 
-      FOR_EACH_REF (u, tmp, tree_refs (var))
+      for (j = rli_start (tree_refs (var)); !rli_after_end (j); rli_step (&j))
 	{
+	  tree_ref u = rli_ref (j);
 	  if (ref_type (u) == V_USE)
 	    {
 	      dump_ref (file, "", u, 4, 0);
@@ -747,8 +754,7 @@ insert_phi_nodes_for (var, dfs)
      tree var;
      sbitmap *dfs;
 {
-  tree_ref ref;
-  struct ref_list_node *tmp;
+  ref_list_iterator i;
 
 #if defined ENABLE_CHECKING
   /* Variables in referenced_vars must have at least 1 reference.  */
@@ -758,16 +764,17 @@ insert_phi_nodes_for (var, dfs)
 
   /* Add to the worklist all the basic blocks that have definitions of
      VAR.  */
-  FOR_EACH_REF (ref, tmp, tree_refs (var))
-  {
-    basic_block bb = ref_bb (ref);
+  for (i = rli_start (tree_refs (var)); !rli_after_end (i); rli_step (&i))
+    {
+      tree_ref ref = rli_ref (i);
+      basic_block bb = ref_bb (ref);
 
-    if (ref_type (ref) == V_DEF)
-      {
-	VARRAY_PUSH_BB (work_stack, bb);
-	VARRAY_TREE (in_work, bb->index) = var;
-      }
-  }
+      if (ref_type (ref) == V_DEF)
+	{
+	  VARRAY_PUSH_BB (work_stack, bb);
+	  VARRAY_TREE (in_work, bb->index) = var;
+	}
+    }
 
   /* Insert PHI nodes at the dominance frontier of all the basic blocks
      in the worklist.  */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]