diff options
Diffstat (limited to 'gcc/cfganal.c')
-rw-r--r-- | gcc/cfganal.c | 169 |
1 files changed, 87 insertions, 82 deletions
diff --git a/gcc/cfganal.c b/gcc/cfganal.c index 01f5f7d..30aa5c4 100644 --- a/gcc/cfganal.c +++ b/gcc/cfganal.c @@ -85,7 +85,7 @@ forwarder_block_p (basic_block bb) rtx insn; if (bb == EXIT_BLOCK_PTR || bb == ENTRY_BLOCK_PTR - || !bb->succ || bb->succ->succ_next) + || EDGE_COUNT (bb->succs) != 1) return false; for (insn = BB_HEAD (bb); insn != BB_END (bb); insn = NEXT_INSN (insn)) @@ -105,15 +105,16 @@ can_fallthru (basic_block src, basic_block target) rtx insn = BB_END (src); rtx insn2; edge e; + edge_iterator ei; if (target == EXIT_BLOCK_PTR) return true; if (src->next_bb != target) return 0; - for (e = src->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, src->succs) if (e->dest == EXIT_BLOCK_PTR && e->flags & EDGE_FALLTHRU) - return 0; + return 0; insn2 = BB_HEAD (target); if (insn2 && !active_insn_p (insn2)) @@ -130,13 +131,14 @@ bool could_fall_through (basic_block src, basic_block target) { edge e; + edge_iterator ei; if (target == EXIT_BLOCK_PTR) return true; - for (e = src->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, src->succs) if (e->dest == EXIT_BLOCK_PTR && e->flags & EDGE_FALLTHRU) - return 0; + return 0; return true; } @@ -153,7 +155,7 @@ could_fall_through (basic_block src, basic_block target) bool mark_dfs_back_edges (void) { - edge *stack; + edge_iterator *stack; int *pre; int *post; int sp; @@ -167,7 +169,7 @@ mark_dfs_back_edges (void) post = xcalloc (last_basic_block, sizeof (int)); /* Allocate stack for back-tracking up CFG. */ - stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge)); + stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge_iterator)); sp = 0; /* Allocate bitmap to track nodes that have been visited. */ @@ -177,19 +179,19 @@ mark_dfs_back_edges (void) sbitmap_zero (visited); /* Push the first edge on to the stack. */ - stack[sp++] = ENTRY_BLOCK_PTR->succ; + stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs); while (sp) { - edge e; + edge_iterator ei; basic_block src; basic_block dest; /* Look at the edge on the top of the stack. */ - e = stack[sp - 1]; - src = e->src; - dest = e->dest; - e->flags &= ~EDGE_DFS_BACK; + ei = stack[sp - 1]; + src = ei_edge (ei)->src; + dest = ei_edge (ei)->dest; + ei_edge (ei)->flags &= ~EDGE_DFS_BACK; /* Check if the edge destination has been visited yet. */ if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index)) @@ -198,11 +200,11 @@ mark_dfs_back_edges (void) SET_BIT (visited, dest->index); pre[dest->index] = prenum++; - if (dest->succ) + if (EDGE_COUNT (dest->succs) > 0) { /* Since the DEST node has been visited for the first time, check its successors. */ - stack[sp++] = dest->succ; + stack[sp++] = ei_start (dest->succs); } else post[dest->index] = postnum++; @@ -212,13 +214,13 @@ mark_dfs_back_edges (void) if (dest != EXIT_BLOCK_PTR && src != ENTRY_BLOCK_PTR && pre[src->index] >= pre[dest->index] && post[dest->index] == 0) - e->flags |= EDGE_DFS_BACK, found = true; + ei_edge (ei)->flags |= EDGE_DFS_BACK, found = true; - if (! e->succ_next && src != ENTRY_BLOCK_PTR) + if (ei_one_before_end_p (ei) && src != ENTRY_BLOCK_PTR) post[src->index] = postnum++; - if (e->succ_next) - stack[sp - 1] = e->succ_next; + if (!ei_one_before_end_p (ei)) + ei_next (&stack[sp - 1]); else sp--; } @@ -242,8 +244,9 @@ set_edge_can_fallthru_flag (void) FOR_EACH_BB (bb) { edge e; + edge_iterator ei; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { e->flags &= ~EDGE_CAN_FALLTHRU; @@ -254,15 +257,15 @@ set_edge_can_fallthru_flag (void) /* If the BB ends with an invertible condjump all (2) edges are CAN_FALLTHRU edges. */ - if (!bb->succ || !bb->succ->succ_next || bb->succ->succ_next->succ_next) + if (EDGE_COUNT (bb->succs) != 2) continue; if (!any_condjump_p (BB_END (bb))) continue; if (!invert_jump (BB_END (bb), JUMP_LABEL (BB_END (bb)), 0)) continue; invert_jump (BB_END (bb), JUMP_LABEL (BB_END (bb)), 0); - bb->succ->flags |= EDGE_CAN_FALLTHRU; - bb->succ->succ_next->flags |= EDGE_CAN_FALLTHRU; + EDGE_SUCC (bb, 0)->flags |= EDGE_CAN_FALLTHRU; + EDGE_SUCC (bb, 1)->flags |= EDGE_CAN_FALLTHRU; } } @@ -274,6 +277,7 @@ void find_unreachable_blocks (void) { edge e; + edge_iterator ei; basic_block *tos, *worklist, bb; tos = worklist = xmalloc (sizeof (basic_block) * n_basic_blocks); @@ -287,7 +291,7 @@ find_unreachable_blocks (void) be only one. It isn't inconceivable that we might one day directly support Fortran alternate entry points. */ - for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) { *tos++ = e->dest; @@ -301,7 +305,7 @@ find_unreachable_blocks (void) { basic_block b = *--tos; - for (e = b->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, b->succs) if (!(e->dest->flags & BB_REACHABLE)) { *tos++ = e->dest; @@ -333,6 +337,7 @@ create_edge_list (void) int num_edges; int block_count; basic_block bb; + edge_iterator ei; block_count = n_basic_blocks + 2; /* Include the entry and exit blocks. */ @@ -342,8 +347,7 @@ create_edge_list (void) edges on each basic block. */ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb) { - for (e = bb->succ; e; e = e->succ_next) - num_edges++; + num_edges += EDGE_COUNT (bb->succs); } elist = xmalloc (sizeof (struct edge_list)); @@ -355,7 +359,7 @@ create_edge_list (void) /* Follow successors of blocks, and register these edges. */ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb) - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) elist->index_to_edge[num_edges++] = e; return elist; @@ -408,10 +412,11 @@ verify_edge_list (FILE *f, struct edge_list *elist) int pred, succ, index; edge e; basic_block bb, p, s; + edge_iterator ei; FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb) { - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { pred = e->src->index; succ = e->dest->index; @@ -439,14 +444,14 @@ verify_edge_list (FILE *f, struct edge_list *elist) { int found_edge = 0; - for (e = p->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, p->succs) if (e->dest == s) { found_edge = 1; break; } - for (e = s->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, s->preds) if (e->src == p) { found_edge = 1; @@ -471,8 +476,9 @@ edge find_edge (basic_block pred, basic_block succ) { edge e; + edge_iterator ei; - for (e = pred->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, pred->succs) if (e->dest == succ) return e; @@ -537,14 +543,14 @@ static void remove_fake_predecessors (basic_block bb) { edge e; + edge_iterator ei; - for (e = bb->pred; e;) + for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) { - edge tmp = e; - - e = e->pred_next; - if ((tmp->flags & EDGE_FAKE) == EDGE_FAKE) - remove_edge (tmp); + if ((e->flags & EDGE_FAKE) == EDGE_FAKE) + remove_edge (e); + else + ei_next (&ei); } } @@ -580,7 +586,7 @@ add_noreturn_fake_exit_edges (void) basic_block bb; FOR_EACH_BB (bb) - if (bb->succ == NULL) + if (EDGE_COUNT (bb->succs) == 0) make_single_succ_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE); } @@ -626,13 +632,13 @@ connect_infinite_loops_to_exit (void) void flow_reverse_top_sort_order_compute (int *rts_order) { - edge *stack; + edge_iterator *stack; int sp; int postnum = 0; sbitmap visited; /* Allocate stack for back-tracking up CFG. */ - stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge)); + stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge_iterator)); sp = 0; /* Allocate bitmap to track nodes that have been visited. */ @@ -642,18 +648,18 @@ flow_reverse_top_sort_order_compute (int *rts_order) sbitmap_zero (visited); /* Push the first edge on to the stack. */ - stack[sp++] = ENTRY_BLOCK_PTR->succ; + stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs); while (sp) { - edge e; + edge_iterator ei; basic_block src; basic_block dest; /* Look at the edge on the top of the stack. */ - e = stack[sp - 1]; - src = e->src; - dest = e->dest; + ei = stack[sp - 1]; + src = ei_edge (ei)->src; + dest = ei_edge (ei)->dest; /* Check if the edge destination has been visited yet. */ if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index)) @@ -661,20 +667,20 @@ flow_reverse_top_sort_order_compute (int *rts_order) /* Mark that we have visited the destination. */ SET_BIT (visited, dest->index); - if (dest->succ) + if (EDGE_COUNT (dest->succs) > 0) /* Since the DEST node has been visited for the first time, check its successors. */ - stack[sp++] = dest->succ; + stack[sp++] = ei_start (dest->succs); else rts_order[postnum++] = dest->index; } else { - if (! e->succ_next && src != ENTRY_BLOCK_PTR) + if (ei_one_before_end_p (ei) && src != ENTRY_BLOCK_PTR) rts_order[postnum++] = src->index; - if (e->succ_next) - stack[sp - 1] = e->succ_next; + if (!ei_one_before_end_p (ei)) + ei_next (&stack[sp - 1]); else sp--; } @@ -694,14 +700,14 @@ flow_reverse_top_sort_order_compute (int *rts_order) int flow_depth_first_order_compute (int *dfs_order, int *rc_order) { - edge *stack; + edge_iterator *stack; int sp; int dfsnum = 0; int rcnum = n_basic_blocks - 1; sbitmap visited; /* Allocate stack for back-tracking up CFG. */ - stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge)); + stack = xmalloc ((n_basic_blocks + 1) * sizeof (edge_iterator)); sp = 0; /* Allocate bitmap to track nodes that have been visited. */ @@ -711,18 +717,18 @@ flow_depth_first_order_compute (int *dfs_order, int *rc_order) sbitmap_zero (visited); /* Push the first edge on to the stack. */ - stack[sp++] = ENTRY_BLOCK_PTR->succ; + stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs); while (sp) { - edge e; + edge_iterator ei; basic_block src; basic_block dest; /* Look at the edge on the top of the stack. */ - e = stack[sp - 1]; - src = e->src; - dest = e->dest; + ei = stack[sp - 1]; + src = ei_edge (ei)->src; + dest = ei_edge (ei)->dest; /* Check if the edge destination has been visited yet. */ if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index)) @@ -735,10 +741,10 @@ flow_depth_first_order_compute (int *dfs_order, int *rc_order) dfsnum++; - if (dest->succ) + if (EDGE_COUNT (dest->succs) > 0) /* Since the DEST node has been visited for the first time, check its successors. */ - stack[sp++] = dest->succ; + stack[sp++] = ei_start (dest->succs); else if (rc_order) /* There are no successors for the DEST node so assign its reverse completion number. */ @@ -746,14 +752,14 @@ flow_depth_first_order_compute (int *dfs_order, int *rc_order) } else { - if (! e->succ_next && src != ENTRY_BLOCK_PTR + if (ei_one_before_end_p (ei) && src != ENTRY_BLOCK_PTR && rc_order) /* There are no more successors for the SRC node so assign its reverse completion number. */ rc_order[rcnum--] = src->index; - if (e->succ_next) - stack[sp - 1] = e->succ_next; + if (!ei_one_before_end_p (ei)) + ei_next (&stack[sp - 1]); else sp--; } @@ -789,8 +795,7 @@ struct dfst_node void flow_preorder_transversal_compute (int *pot_order) { - edge e; - edge *stack; + edge_iterator *stack, ei; int i; int max_successors; int sp; @@ -808,10 +813,7 @@ flow_preorder_transversal_compute (int *pot_order) FOR_EACH_BB (bb) { - max_successors = 0; - for (e = bb->succ; e; e = e->succ_next) - max_successors++; - + max_successors = EDGE_COUNT (bb->succs); dfst[bb->index].node = (max_successors ? xcalloc (max_successors, sizeof (struct dfst_node *)) : NULL); @@ -824,7 +826,7 @@ flow_preorder_transversal_compute (int *pot_order) sbitmap_zero (visited); /* Push the first edge on to the stack. */ - stack[sp++] = ENTRY_BLOCK_PTR->succ; + stack[sp++] = ei_start (ENTRY_BLOCK_PTR->succs); while (sp) { @@ -832,9 +834,9 @@ flow_preorder_transversal_compute (int *pot_order) basic_block dest; /* Look at the edge on the top of the stack. */ - e = stack[sp - 1]; - src = e->src; - dest = e->dest; + ei = stack[sp - 1]; + src = ei_edge (ei)->src; + dest = ei_edge (ei)->dest; /* Check if the edge destination has been visited yet. */ if (dest != EXIT_BLOCK_PTR && ! TEST_BIT (visited, dest->index)) @@ -850,14 +852,14 @@ flow_preorder_transversal_compute (int *pot_order) dfst[dest->index].up = &dfst[src->index]; } - if (dest->succ) + if (EDGE_COUNT (dest->succs) > 0) /* Since the DEST node has been visited for the first time, check its successors. */ - stack[sp++] = dest->succ; + stack[sp++] = ei_start (dest->succs); } - else if (e->succ_next) - stack[sp - 1] = e->succ_next; + else if (! ei_one_before_end_p (ei)) + ei_next (&stack[sp - 1]); else sp--; } @@ -960,13 +962,14 @@ flow_dfs_compute_reverse_execute (depth_first_search_ds data) { basic_block bb; edge e; + edge_iterator ei; while (data->sp > 0) { bb = data->stack[--data->sp]; /* Perform depth-first search on adjacent vertices. */ - for (e = bb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) if (!TEST_BIT (data->visited_blocks, e->src->index - (INVALID_BLOCK + 1))) flow_dfs_compute_reverse_add_bb (data, e->src); @@ -1007,10 +1010,11 @@ dfs_enumerate_from (basic_block bb, int reverse, while (sp) { edge e; + edge_iterator ei; lbb = st[--sp]; if (reverse) { - for (e = lbb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, lbb->preds) if (!(e->src->flags & BB_VISITED) && predicate (e->src, data)) { gcc_assert (tv != rslt_max); @@ -1020,7 +1024,7 @@ dfs_enumerate_from (basic_block bb, int reverse, } else { - for (e = lbb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, lbb->succs) if (!(e->dest->flags & BB_VISITED) && predicate (e->dest, data)) { gcc_assert (tv != rslt_max); @@ -1056,6 +1060,7 @@ static void compute_dominance_frontiers_1 (bitmap *frontiers, basic_block bb, sbitmap done) { edge e; + edge_iterator ei; basic_block c; SET_BIT (done, bb->index); @@ -1072,7 +1077,7 @@ compute_dominance_frontiers_1 (bitmap *frontiers, basic_block bb, sbitmap done) } /* Find blocks conforming to rule (1) above. */ - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { if (e->dest == EXIT_BLOCK_PTR) continue; @@ -1106,7 +1111,7 @@ compute_dominance_frontiers (bitmap *frontiers) sbitmap_zero (done); - compute_dominance_frontiers_1 (frontiers, ENTRY_BLOCK_PTR->succ->dest, done); + compute_dominance_frontiers_1 (frontiers, EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest, done); sbitmap_free (done); |