aboutsummaryrefslogtreecommitdiff
path: root/gcc/cfghooks.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/cfghooks.c')
-rw-r--r--gcc/cfghooks.c91
1 files changed, 52 insertions, 39 deletions
diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c
index 970dcbe..b3fde68 100644
--- a/gcc/cfghooks.c
+++ b/gcc/cfghooks.c
@@ -106,6 +106,7 @@ verify_flow_info (void)
{
int n_fallthru = 0;
edge e;
+ edge_iterator ei;
if (bb->count < 0)
{
@@ -119,7 +120,7 @@ verify_flow_info (void)
bb->index, bb->frequency);
err = 1;
}
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
{
if (last_visited [e->dest->index + 2] == bb)
{
@@ -165,7 +166,7 @@ verify_flow_info (void)
err = 1;
}
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->dest != bb)
{
@@ -184,11 +185,12 @@ verify_flow_info (void)
/* Complete edge checksumming for ENTRY and EXIT. */
{
edge e;
+ edge_iterator ei;
- for (e = ENTRY_BLOCK_PTR->succ; e ; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
edge_checksum[e->dest->index + 2] += (size_t) e;
- for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
edge_checksum[e->dest->index + 2] -= (size_t) e;
}
@@ -221,6 +223,7 @@ void
dump_bb (basic_block bb, FILE *outf, int indent)
{
edge e;
+ edge_iterator ei;
char *s_indent;
s_indent = alloca ((size_t) indent + 1);
@@ -245,12 +248,12 @@ dump_bb (basic_block bb, FILE *outf, int indent)
putc ('\n', outf);
fprintf (outf, ";;%s pred: ", s_indent);
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
dump_edge_info (outf, e, 0);
putc ('\n', outf);
fprintf (outf, ";;%s succ: ", s_indent);
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
dump_edge_info (outf, e, 1);
putc ('\n', outf);
@@ -360,13 +363,13 @@ delete_basic_block (basic_block bb)
/* Remove the edges into and out of this block. Note that there may
indeed be edges in, if we are removing an unreachable loop. */
- while (bb->pred != NULL)
- remove_edge (bb->pred);
- while (bb->succ != NULL)
- remove_edge (bb->succ);
+ while (EDGE_COUNT (bb->preds) != 0)
+ remove_edge (EDGE_PRED (bb, 0));
+ while (EDGE_COUNT (bb->succs) != 0)
+ remove_edge (EDGE_SUCC (bb, 0));
- bb->pred = NULL;
- bb->succ = NULL;
+ VEC_truncate (edge, bb->preds, 0);
+ VEC_truncate (edge, bb->succs, 0);
if (dom_computed[CDI_DOMINATORS])
delete_from_dominance_info (CDI_DOMINATORS, bb);
@@ -393,11 +396,11 @@ split_edge (edge e)
ret = cfg_hooks->split_edge (e);
ret->count = count;
ret->frequency = freq;
- ret->succ->probability = REG_BR_PROB_BASE;
- ret->succ->count = count;
+ EDGE_SUCC (ret, 0)->probability = REG_BR_PROB_BASE;
+ EDGE_SUCC (ret, 0)->count = count;
if (dom_computed[CDI_DOMINATORS])
- set_immediate_dominator (CDI_DOMINATORS, ret, ret->pred->src);
+ set_immediate_dominator (CDI_DOMINATORS, ret, EDGE_PRED (ret, 0)->src);
if (dom_computed[CDI_DOMINATORS] >= DOM_NO_FAST_QUERY)
{
@@ -410,21 +413,22 @@ split_edge (edge e)
ret, provided that all other predecessors of e->dest are
dominated by e->dest. */
- if (get_immediate_dominator (CDI_DOMINATORS, ret->succ->dest)
- == ret->pred->src)
+ if (get_immediate_dominator (CDI_DOMINATORS, EDGE_SUCC (ret, 0)->dest)
+ == EDGE_PRED (ret, 0)->src)
{
- for (f = ret->succ->dest->pred; f; f = f->pred_next)
+ edge_iterator ei;
+ FOR_EACH_EDGE (f, ei, EDGE_SUCC (ret, 0)->dest->preds)
{
- if (f == ret->succ)
+ if (f == EDGE_SUCC (ret, 0))
continue;
if (!dominated_by_p (CDI_DOMINATORS, f->src,
- ret->succ->dest))
+ EDGE_SUCC (ret, 0)->dest))
break;
}
if (!f)
- set_immediate_dominator (CDI_DOMINATORS, ret->succ->dest, ret);
+ set_immediate_dominator (CDI_DOMINATORS, EDGE_SUCC (ret, 0)->dest, ret);
}
};
@@ -500,6 +504,7 @@ void
merge_blocks (basic_block a, basic_block b)
{
edge e;
+ edge_iterator ei;
if (!cfg_hooks->merge_blocks)
internal_error ("%s does not support merge_blocks.", cfg_hooks->name);
@@ -510,17 +515,18 @@ merge_blocks (basic_block a, basic_block b)
partway though the merge of blocks for conditional_execution we'll
be merging a TEST block with THEN and ELSE successors. Free the
whole lot of them and hope the caller knows what they're doing. */
- while (a->succ)
- remove_edge (a->succ);
+
+ while (EDGE_COUNT (a->succs) != 0)
+ remove_edge (EDGE_SUCC (a, 0));
/* Adjust the edges out of B for the new owner. */
- for (e = b->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, b->succs)
e->src = a;
- a->succ = b->succ;
+ a->succs = b->succs;
a->flags |= b->flags;
/* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
- b->pred = b->succ = NULL;
+ b->preds = b->succs = NULL;
a->global_live_at_end = b->global_live_at_end;
if (dom_computed[CDI_DOMINATORS])
@@ -542,7 +548,8 @@ edge
make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
void (*new_bb_cbk) (basic_block))
{
- edge e, next_e, fallthru;
+ edge e, fallthru;
+ edge_iterator ei;
basic_block dummy, jump;
if (!cfg_hooks->make_forwarder_block)
@@ -554,11 +561,13 @@ make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
bb = fallthru->dest;
/* Redirect back edges we want to keep. */
- for (e = dummy->pred; e; e = next_e)
+ for (ei = ei_start (dummy->preds); (e = ei_safe_edge (ei)); )
{
- next_e = e->pred_next;
if (redirect_edge_p (e))
- continue;
+ {
+ ei_next (&ei);
+ continue;
+ }
dummy->frequency -= EDGE_FREQUENCY (e);
dummy->count -= e->count;
@@ -630,12 +639,14 @@ tidy_fallthru_edges (void)
merge the flags for the duplicate edges. So we do not want to
check that the edge is not a FALLTHRU edge. */
- if ((s = b->succ) != NULL
- && ! (s->flags & EDGE_COMPLEX)
- && s->succ_next == NULL
- && s->dest == c
- && !find_reg_note (BB_END (b), REG_CROSSING_JUMP, NULL_RTX))
- tidy_fallthru_edge (s);
+ if (EDGE_COUNT (b->succs) == 1)
+ {
+ s = EDGE_SUCC (b, 0);
+ if (! (s->flags & EDGE_COMPLEX)
+ && s->dest == c
+ && !find_reg_note (BB_END (b), REG_CROSSING_JUMP, NULL_RTX))
+ tidy_fallthru_edge (s);
+ }
}
}
@@ -645,6 +656,7 @@ bool
can_duplicate_block_p (basic_block bb)
{
edge e;
+ edge_iterator ei;
if (!cfg_hooks->can_duplicate_block_p)
internal_error ("%s does not support can_duplicate_block_p.",
@@ -655,7 +667,7 @@ can_duplicate_block_p (basic_block bb)
/* Duplicating fallthru block to exit would require adding a jump
and splitting the real last BB. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (e->dest == EXIT_BLOCK_PTR && e->flags & EDGE_FALLTHRU)
return false;
@@ -671,6 +683,7 @@ duplicate_block (basic_block bb, edge e)
edge s, n;
basic_block new_bb;
gcov_type new_count = e ? e->count : 0;
+ edge_iterator ei;
if (!cfg_hooks->duplicate_block)
internal_error ("%s does not support duplicate_block.",
@@ -678,7 +691,7 @@ duplicate_block (basic_block bb, edge e)
if (bb->count < new_count)
new_count = bb->count;
- gcc_assert (bb->pred);
+ gcc_assert (EDGE_COUNT (bb->preds) > 0);
#ifdef ENABLE_CHECKING
gcc_assert (can_duplicate_block_p (bb));
#endif
@@ -687,7 +700,7 @@ duplicate_block (basic_block bb, edge e)
new_bb->loop_depth = bb->loop_depth;
new_bb->flags = bb->flags;
- for (s = bb->succ; s; s = s->succ_next)
+ FOR_EACH_EDGE (s, ei, bb->succs)
{
/* Since we are creating edges from a new block to successors
of another block (which therefore are known to be disjoint), there
generated by cgit v1.1 at 2024-10-07 13:07:59 +0000