FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
+ edge_iterator ei;
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
{
struct edge_info *inf = EDGE_INFO (e);
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
- for (e = bb->succ; e; e = e->succ_next)
+ edge_iterator ei;
+
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
num_edges++;
}
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
+ edge_iterator ei;
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!EDGE_INFO (e)->ignore)
BB_INFO (bb)->succ_count++;
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
if (!EDGE_INFO (e)->ignore)
BB_INFO (bb)->pred_count++;
}
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
- for (e = bb->succ; e; e = e->succ_next)
+ edge_iterator ei;
+
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
{
num_edges++;
if (bi->succ_count == 0)
{
edge e;
+ edge_iterator ei;
gcov_type total = 0;
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
total += e->count;
bb->count = total;
bi->count_valid = 1;
else if (bi->pred_count == 0)
{
edge e;
+ edge_iterator ei;
gcov_type total = 0;
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
total += e->count;
bb->count = total;
bi->count_valid = 1;
if (bi->succ_count == 1)
{
edge e;
+ edge_iterator ei;
gcov_type total = 0;
/* One of the counts will be invalid, but it is zero,
so adding it in also doesn't hurt. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
total += e->count;
/* Seedgeh for the invalid edge, and set its count. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
break;
if (bi->pred_count == 1)
{
edge e;
+ edge_iterator ei;
gcov_type total = 0;
/* One of the counts will be invalid, but it is zero,
so adding it in also doesn't hurt. */
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
total += e->count;
/* Search for the invalid edge, and set its count. */
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
if (!EDGE_INFO (e)->count_valid && !EDGE_INFO (e)->ignore)
break;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
+ edge_iterator ei;
rtx note;
if (bb->count < 0)
bb->index, (int)bb->count);
bb->count = 0;
}
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
{
/* Function may return twice in the cased the called function is
setjmp or calls fork, but we can't represent this by extra
}
if (bb->count)
{
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
e->probability = (e->count * REG_BR_PROB_BASE + bb->count / 2) / bb->count;
if (bb->index >= 0
&& block_ends_with_condjump_p (bb)
- && bb->succ->succ_next)
+ && EDGE_COUNT (bb->succs) >= 2)
{
int prob;
edge e;
/* Find the branch edge. It is possible that we do have fake
edges here. */
- for (e = bb->succ; e->flags & (EDGE_FAKE | EDGE_FALLTHRU);
- e = e->succ_next)
- continue; /* Loop body has been intentionally left blank. */
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (!(e->flags & (EDGE_FAKE | EDGE_FALLTHRU)))
+ break;
prob = e->probability;
index = prob * 20 / REG_BR_PROB_BASE;
tree based profile guessing put into code. */
else if (profile_status == PROFILE_ABSENT
&& !ir_type ()
- && bb->succ && bb->succ->succ_next
+ && EDGE_COUNT (bb->succs) > 1
&& (note = find_reg_note (BB_END (bb), REG_BR_PROB, 0)))
{
int prob = INTVAL (XEXP (note, 0));
{
int total = 0;
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
total ++;
if (total)
{
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
e->probability = REG_BR_PROB_BASE / total;
else
}
else
{
- for (e = bb->succ; e; e = e->succ_next)
- total ++;
- for (e = bb->succ; e; e = e->succ_next)
+ total += EDGE_COUNT (bb->succs);
+ FOR_EACH_EDGE (e, ei, bb->succs)
e->probability = REG_BR_PROB_BASE / total;
}
if (bb->index >= 0
&& block_ends_with_condjump_p (bb)
- && bb->succ->succ_next)
+ && EDGE_COUNT (bb->succs) >= 2)
num_branches++, num_never_executed;
}
}
int need_exit_edge = 0, need_entry_edge = 0;
int have_exit_edge = 0, have_entry_edge = 0;
edge e;
+ edge_iterator ei;
/* Functions returning multiple times are not handled by extra edges.
Instead we simply allow negative counts on edges from exit to the
with the extra edges because that would result in flowgraph that
needs to have fake edges outside the spanning tree. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
{
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->dest != EXIT_BLOCK_PTR)
if (e->dest == EXIT_BLOCK_PTR)
have_exit_edge = 1;
}
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
{
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->src != ENTRY_BLOCK_PTR)
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
{
edge e;
+ edge_iterator ei;
offset = gcov_write_tag (GCOV_TAG_ARCS);
gcov_write_unsigned (BB_TO_GCOV_INDEX (bb));
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
{
struct edge_info *i = EDGE_INFO (e);
if (!i->ignore)
/* Notice GOTO expressions we eliminated while constructing the
CFG. */
- if (bb->succ && !bb->succ->succ_next && bb->succ->goto_locus)
+ if (EDGE_COUNT (bb->succs) == 1 && EDGE_SUCC (bb, 0)->goto_locus)
{
/* ??? source_locus type is marked deprecated in input.h. */
- source_locus curr_location = bb->succ->goto_locus;
+ source_locus curr_location = EDGE_SUCC (bb, 0)->goto_locus;
/* ??? The FILE/LINE API is inconsistent for these cases. */
#ifdef USE_MAPPED_LOCATION
output_location (LOCATION_FILE (curr_location),