This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[tree-ssa] New reference list iterator [patch]
- From: Diego Novillo <dnovillo at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Mon, 21 Oct 2002 14:36:36 -0400
- Subject: [tree-ssa] New reference list iterator [patch]
- Organization: Red Hat Canada
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. */