/* If-conversion for vectorizer.
- Copyright (C) 2004 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005 Free Software Foundation, Inc.
Contributed by Devang Patel <dpatel@apple.com>
This file is part of GCC.
A short description of if-conversion:
- o Decide if a loop is if-convertable or not.
+ o Decide if a loop is if-convertible or not.
o Walk all loop basic blocks in breadth first order (BFS order).
o Remove conditional statements (at the end of basic block)
and propagate condition into destination basic blocks'
block_stmt_iterator *);
static void tree_if_convert_cond_expr (struct loop *, tree, tree,
block_stmt_iterator *);
-static bool if_convertable_phi_p (struct loop *, basic_block, tree);
-static bool if_convertable_modify_expr_p (struct loop *, basic_block, tree);
-static bool if_convertable_stmt_p (struct loop *, basic_block, tree);
-static bool if_convertable_bb_p (struct loop *, basic_block, bool);
-static bool if_convertable_loop_p (struct loop *, bool);
+static bool if_convertible_phi_p (struct loop *, basic_block, tree);
+static bool if_convertible_modify_expr_p (struct loop *, basic_block, tree);
+static bool if_convertible_stmt_p (struct loop *, basic_block, tree);
+static bool if_convertible_bb_p (struct loop *, basic_block, bool);
+static bool if_convertible_loop_p (struct loop *, bool);
static void add_to_predicate_list (basic_block, tree);
-static tree add_to_dst_predicate_list (struct loop * loop, tree, tree, tree,
+static tree add_to_dst_predicate_list (struct loop * loop, basic_block, tree, tree,
block_stmt_iterator *);
static void clean_predicate_lists (struct loop *loop);
-static bool find_phi_replacement_condition (basic_block, tree *,
- block_stmt_iterator *);
-static void replace_phi_with_cond_modify_expr (tree, tree, bool,
+static basic_block find_phi_replacement_condition (basic_block, tree *,
+ block_stmt_iterator *);
+static void replace_phi_with_cond_modify_expr (tree, tree, basic_block,
block_stmt_iterator *);
static void process_phi_nodes (struct loop *);
static void combine_blocks (struct loop *);
static tree ifc_temp_var (tree, tree);
static bool pred_blocks_visited_p (basic_block, bitmap *);
static basic_block * get_loop_body_in_if_conv_order (const struct loop *loop);
-static bool bb_with_exit_edge_p (basic_block);
+static bool bb_with_exit_edge_p (struct loop *, basic_block);
/* List of basic blocks in if-conversion-suitable order. */
static basic_block *ifc_bbs;
for vectorizer or not. If it is used for vectorizer, additional checks are
used. (Vectorization checks are not yet implemented). */
-bool
+static bool
tree_if_conversion (struct loop *loop, bool for_vectorizer)
{
basic_block bb;
ifc_bbs = NULL;
/* if-conversion is not appropriate for all loops. First, check if loop is
- if-convertable or not. */
- if (!if_convertable_loop_p (loop, for_vectorizer))
+ if-convertible or not. */
+ if (!if_convertible_loop_p (loop, for_vectorizer))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,"-------------------------\n");
/* If current bb has only one successor, then consider it as an
unconditional goto. */
- if (bb->succ && !bb->succ->succ_next)
+ if (single_succ_p (bb))
{
- basic_block bb_n = bb->succ->dest;
+ basic_block bb_n = single_succ (bb);
if (cond != NULL_TREE)
add_to_predicate_list (bb_n, cond);
cond = NULL_TREE;
break;
default:
- abort ();
- break;
+ gcc_unreachable ();
}
return cond;
}
tree_if_convert_cond_expr (struct loop *loop, tree stmt, tree cond,
block_stmt_iterator *bsi)
{
- tree then_clause, else_clause, c, new_cond;
- new_cond = NULL_TREE;
+ tree c, c2;
+ edge true_edge, false_edge;
-#ifdef ENABLE_CHECKING
- if (TREE_CODE (stmt) != COND_EXPR)
- abort ();
-#endif
+ gcc_assert (TREE_CODE (stmt) == COND_EXPR);
- c = TREE_OPERAND (stmt, 0);
- then_clause = TREE_OPERAND (stmt, 1);
- else_clause = TREE_OPERAND (stmt, 2);
+ c = COND_EXPR_COND (stmt);
/* Create temp. for condition. */
- if (!is_gimple_reg (c))
+ if (!is_gimple_condexpr (c))
{
tree new_stmt;
new_stmt = ifc_temp_var (TREE_TYPE (c), unshare_expr (c));
c = TREE_OPERAND (new_stmt, 0);
}
+ extract_true_false_edges_from_block (bb_for_stmt (stmt),
+ &true_edge, &false_edge);
+
/* Add new condition into destination's predicate list. */
- if (then_clause)
- /* if 'c' is true then then_clause is reached. */
- new_cond = add_to_dst_predicate_list (loop, then_clause, cond, c, bsi);
- if (else_clause)
+ /* If 'c' is true then TRUE_EDGE is taken. */
+ add_to_dst_predicate_list (loop, true_edge->dest, cond,
+ unshare_expr (c), bsi);
+
+ if (!is_gimple_reg(c) && is_gimple_condexpr (c))
{
- /* if 'c' is false then else_clause is reached. */
- tree c2 = build1 (TRUTH_NOT_EXPR,
- boolean_type_node,
- unshare_expr (c));
- add_to_dst_predicate_list (loop, else_clause, cond, c2, bsi);
+ tree new_stmt;
+ new_stmt = ifc_temp_var (TREE_TYPE (c), unshare_expr (c));
+ bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
+ c = TREE_OPERAND (new_stmt, 0);
}
+ /* If 'c' is false then FALSE_EDGE is taken. */
+ c2 = invert_truthvalue (unshare_expr (c));
+ add_to_dst_predicate_list (loop, false_edge->dest, cond, c2, bsi);
+
/* Now this conditional statement is redundant. Remove it.
But, do not remove exit condition! Update exit condition
using new condition. */
- if (!bb_with_exit_edge_p (bb_for_stmt (stmt)))
+ if (!bb_with_exit_edge_p (loop, bb_for_stmt (stmt)))
{
bsi_remove (bsi);
cond = NULL_TREE;
}
- else if (new_cond != NULL_TREE)
- {
- TREE_OPERAND (stmt, 0) = new_cond;
- modify_stmt (stmt);
- }
return;
}
-/* Return true, iff PHI is if-convertable. PHI is part of loop LOOP
+/* Return true, iff PHI is if-convertible. PHI is part of loop LOOP
and it belongs to basic block BB.
- PHI is not if-convertable
+ PHI is not if-convertible
- if it has more than 2 arguments.
- Virtual PHI is immediately used in another PHI node. */
static bool
-if_convertable_phi_p (struct loop *loop, basic_block bb, tree phi)
+if_convertible_phi_p (struct loop *loop, basic_block bb, tree phi)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
return true;
}
-/* Return true, if M_EXPR is if-convertable.
- MODIFY_EXPR is not if-convertable if,
+/* Return true, if M_EXPR is if-convertible.
+ MODIFY_EXPR is not if-convertible if,
- It is not movable.
- It could trap.
- LHS is not var decl.
*/
static bool
-if_convertable_modify_expr_p (struct loop *loop, basic_block bb, tree m_expr)
+if_convertible_modify_expr_p (struct loop *loop, basic_block bb, tree m_expr)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
if (TREE_CODE (TREE_OPERAND (m_expr, 0)) != SSA_NAME
&& bb != loop->header
- && !bb_with_exit_edge_p (bb))
+ && !bb_with_exit_edge_p (loop, bb))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
return true;
}
-/* Return true, iff STMT is if-convertable.
- Statement is if-convertable if,
- - It is if-convertable MODIFY_EXPR
+/* Return true, iff STMT is if-convertible.
+ Statement is if-convertible if,
+ - It is if-convertible MODIFY_EXPR
- IT is LABEL_EXPR, GOTO_EXPR or COND_EXPR.
STMT is inside block BB, which is inside loop LOOP. */
static bool
-if_convertable_stmt_p (struct loop *loop, basic_block bb, tree stmt)
+if_convertible_stmt_p (struct loop *loop, basic_block bb, tree stmt)
{
switch (TREE_CODE (stmt))
{
case MODIFY_EXPR:
- if (!if_convertable_modify_expr_p (loop, bb, stmt))
+ if (!if_convertible_modify_expr_p (loop, bb, stmt))
return false;
break;
return true;
}
-/* Return true, iff BB is if-convertable.
+/* Return true, iff BB is if-convertible.
Note: This routine does _not_ check basic block statements and phis.
- Basic block is not if-convertable if,
+ Basic block is not if-convertible if,
- Basic block is non-empty and it is after exit block (in BFS order).
- Basic block is after exit block but before latch.
- Basic block edge(s) is not normal.
EXIT_BB_SEEN is true if basic block with exit edge is already seen.
- BB is inside loop LOOP. */
+ BB is inside loop LOOP. */
static bool
-if_convertable_bb_p (struct loop *loop, basic_block bb, bool exit_bb_seen)
+if_convertible_bb_p (struct loop *loop, basic_block bb, bool exit_bb_seen)
{
edge e;
+ edge_iterator ei;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "----------[%d]-------------\n", bb->index);
}
/* Be less adventurous and handle only normal edges. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (e->flags &
(EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_ABNORMAL | EDGE_IRREDUCIBLE_LOOP))
{
return true;
}
-/* Return true, iff LOOP is if-convertable.
- LOOP is if-convertable if,
+/* Return true, iff LOOP is if-convertible.
+ LOOP is if-convertible if,
- It is innermost.
- It has two or more basic blocks.
- It has only one exit.
- Loop header is not the exit edge.
- - If its basic blocks and phi nodes are if convertable. See above for
+ - If its basic blocks and phi nodes are if convertible. See above for
more info.
FOR_VECTORIZER enables vectorizer specific checks. For example, support
for vector conditions, data dependency checks etc.. (Not implemented yet). */
static bool
-if_convertable_loop_p (struct loop *loop, bool for_vectorizer ATTRIBUTE_UNUSED)
+if_convertible_loop_p (struct loop *loop, bool for_vectorizer ATTRIBUTE_UNUSED)
{
tree phi;
basic_block bb;
block_stmt_iterator itr;
unsigned int i;
edge e;
+ edge_iterator ei;
bool exit_bb_seen = false;
/* Handle only inner most loop. */
return false;
}
- flow_loop_scan (loop, LOOP_ALL);
-
/* If only one block, no need for if-conversion. */
if (loop->num_nodes <= 2)
{
}
/* More than one loop exit is too much to handle. */
- if (loop->num_exits > 1)
+ if (!loop->single_exit)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "multiple exits\n");
/* If one of the loop header's edge is exit edge then do not apply
if-conversion. */
- for (e = loop->header->succ; e; e = e->succ_next)
- if ( e->flags & EDGE_LOOP_EXIT)
- return false;
+ FOR_EACH_EDGE (e, ei, loop->header->succs)
+ {
+ if (loop_exit_edge_p (loop, e))
+ return false;
+ }
compute_immediate_uses (TDFA_USE_OPS|TDFA_USE_VOPS, NULL);
{
bb = ifc_bbs[i];
- if (!if_convertable_bb_p (loop, bb, exit_bb_seen))
+ if (!if_convertible_bb_p (loop, bb, exit_bb_seen))
return false;
/* Check statements. */
for (itr = bsi_start (bb); !bsi_end_p (itr); bsi_next (&itr))
- if (!if_convertable_stmt_p (loop, bb, bsi_stmt (itr)))
+ if (!if_convertible_stmt_p (loop, bb, bsi_stmt (itr)))
return false;
/* ??? Check data dependency for vectorizer. */
/* What about phi nodes ? */
- for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
- if (!if_convertable_phi_p (loop, bb, phi))
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ if (!if_convertible_phi_p (loop, bb, phi))
return false;
- if (bb_with_exit_edge_p (bb))
+ if (bb_with_exit_edge_p (loop, bb))
exit_bb_seen = true;
}
bb->aux = cond;
}
-/* Add condition COND into DST's predicate list. PREV_COND is
+/* Add condition COND into BB's predicate list. PREV_COND is
existing condition. */
static tree
-add_to_dst_predicate_list (struct loop * loop, tree dst,
+add_to_dst_predicate_list (struct loop * loop, basic_block bb,
tree prev_cond, tree cond,
block_stmt_iterator *bsi)
{
- basic_block bb;
tree new_cond = NULL_TREE;
-#ifdef ENABLE_CHECKING
- if (TREE_CODE (dst) != GOTO_EXPR)
- abort ();
-#endif
- bb = label_to_block (TREE_OPERAND (dst, 0));
if (!flow_bb_inside_loop_p (loop, bb))
return NULL_TREE;
new_cond = unshare_expr (cond);
else
{
- tree tmp_stmt;
+ tree tmp;
+ tree tmp_stmt = NULL_TREE;
+ tree tmp_stmts1 = NULL_TREE;
+ tree tmp_stmts2 = NULL_TREE;
+ prev_cond = force_gimple_operand (unshare_expr (prev_cond),
+ &tmp_stmts1, true, NULL);
+ if (tmp_stmts1)
+ bsi_insert_before (bsi, tmp_stmts1, BSI_SAME_STMT);
+
+ cond = force_gimple_operand (unshare_expr (cond),
+ &tmp_stmts2, true, NULL);
+ if (tmp_stmts2)
+ bsi_insert_before (bsi, tmp_stmts2, BSI_SAME_STMT);
+
/* new_cond == prev_cond AND cond */
- tree tmp = build (TRUTH_AND_EXPR, boolean_type_node,
- unshare_expr (prev_cond), cond);
+ tmp = build (TRUTH_AND_EXPR, boolean_type_node,
+ unshare_expr (prev_cond), cond);
tmp_stmt = ifc_temp_var (boolean_type_node, tmp);
bsi_insert_before (bsi, tmp_stmt, BSI_SAME_STMT);
new_cond = TREE_OPERAND (tmp_stmt, 0);
static void
clean_predicate_lists (struct loop *loop)
{
+ basic_block *bb;
unsigned int i;
-
+ bb = get_loop_body (loop);
for (i = 0; i < loop->num_nodes; i++)
- ifc_bbs[i]->aux = NULL;
+ bb[i]->aux = NULL;
+
+ free (bb);
}
/* Basic block BB has two predecessors. Using predecessor's aux field, set
- appropriate condition COND for the PHI node replacement. Return true if
- phi arguments are condition is selected from second predecessor. */
+ appropriate condition COND for the PHI node replacement. Return true block
+ whose phi arguments are selected when cond is true. */
-static bool
+static basic_block
find_phi_replacement_condition (basic_block bb, tree *cond,
block_stmt_iterator *bsi)
{
edge e;
basic_block p1 = NULL;
basic_block p2 = NULL;
- bool switch_args = false;
+ basic_block true_bb = NULL;
tree tmp_cond;
+ edge_iterator ei;
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
{
if (p1 == NULL)
- p1 = e->src;
- else if (p2 == NULL)
- p2 = e->src;
- else
- /* More than two predecessors. This is not expected. */
- abort ();
+ p1 = e->src;
+ else
+ {
+ gcc_assert (!p2);
+ p2 = e->src;
+ }
}
/* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
if (TREE_CODE (tmp_cond) == TRUTH_NOT_EXPR)
{
*cond = p2->aux;
- switch_args = true;
+ true_bb = p2;
}
else
{
*cond = p1->aux;
- switch_args = false;
+ true_bb = p1;
}
/* Create temp. for the condition. Vectorizer prefers to have gimple
*cond = TREE_OPERAND (new_stmt, 0);
}
-#ifdef ENABLE_CHECKING
- if (*cond == NULL_TREE)
- abort ();
-#endif
+ gcc_assert (*cond);
- return switch_args;
+ return true_bb;
}
is converted into,
S2: A = cond ? x1 : x2;
S2 is inserted at the top of basic block's statement list.
- PHI arguments are switched if SWITCH_ARGS is true.
+ When COND is true, phi arg from TRUE_BB is selected.
*/
static void
-replace_phi_with_cond_modify_expr (tree phi, tree cond, bool switch_args,
+replace_phi_with_cond_modify_expr (tree phi, tree cond, basic_block true_bb,
block_stmt_iterator *bsi)
{
tree new_stmt;
tree rhs;
tree arg_0, arg_1;
-#ifdef ENABLE_CHECKING
- if (TREE_CODE (phi) != PHI_NODE)
- abort ();
-
+ gcc_assert (TREE_CODE (phi) == PHI_NODE);
+
/* If this is not filtered earlier, then now it is too late. */
- if (PHI_NUM_ARGS (phi) != 2)
- abort ();
-#endif
+ gcc_assert (PHI_NUM_ARGS (phi) == 2);
/* Find basic block and initialize iterator. */
bb = bb_for_stmt (phi);
arg_1 = NULL_TREE;
/* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
- if (switch_args)
+ if (EDGE_PRED (bb, 1)->src == true_bb)
{
arg_0 = PHI_ARG_DEF (phi, 1);
arg_1 = PHI_ARG_DEF (phi, 0);
{
tree phi, cond;
block_stmt_iterator bsi;
- bool switch_args = false;
+ basic_block true_bb = NULL;
bb = ifc_bbs[i];
- if (bb == loop->header || bb == loop->latch)
+ if (bb == loop->header)
continue;
phi = phi_nodes (bb);
- bsi = bsi_start (bb);
+ bsi = bsi_after_labels (bb);
/* BB has two predecessors. Using predecessor's aux field, set
appropriate condition for the PHI node replacement. */
if (phi)
- switch_args = find_phi_replacement_condition (bb, &cond, &bsi);
+ true_bb = find_phi_replacement_condition (bb, &cond, &bsi);
while (phi)
{
- tree next = TREE_CHAIN (phi);
- replace_phi_with_cond_modify_expr (phi, cond, switch_args, &bsi);
+ tree next = PHI_CHAIN (phi);
+ replace_phi_with_cond_modify_expr (phi, cond, true_bb, &bsi);
release_phi_node (phi);
phi = next;
}
}
/* Combine all basic block from the given LOOP into one or two super
- basic block. Replace PHI nodes with conditional modify expression. */
+ basic block. Replace PHI nodes with conditional modify expression. */
static void
combine_blocks (struct loop *loop)
basic_block bb, exit_bb, merge_target_bb;
unsigned int orig_loop_num_nodes = loop->num_nodes;
unsigned int i;
+ unsigned int n_exits;
+ get_loop_exit_edges (loop, &n_exits);
/* Process phi nodes to prepare blocks for merge. */
process_phi_nodes (loop);
bb = ifc_bbs[i];
- if (bb == loop->latch)
- continue;
-
- if (!exit_bb && bb_with_exit_edge_p (bb))
+ if (!exit_bb && bb_with_exit_edge_p (loop, bb))
exit_bb = bb;
if (bb == exit_bb)
{
- edge new_e;
+ edge_iterator ei;
/* Connect this node with loop header. */
- new_e = make_edge (ifc_bbs[0], bb, EDGE_FALLTHRU);
+ make_edge (ifc_bbs[0], bb, EDGE_FALLTHRU);
set_immediate_dominator (CDI_DOMINATORS, bb, ifc_bbs[0]);
if (exit_bb != loop->latch)
{
/* Redirect non-exit edge to loop->latch. */
- for (e = bb->succ; e; e = e->succ_next)
- if (!(e->flags & EDGE_LOOP_EXIT))
- {
- redirect_edge_and_branch (e, loop->latch);
- set_immediate_dominator (CDI_DOMINATORS, loop->latch, bb);
- }
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ if (!loop_exit_edge_p (loop, e))
+ {
+ redirect_edge_and_branch (e, loop->latch);
+ set_immediate_dominator (CDI_DOMINATORS, loop->latch, bb);
+ }
+ }
}
continue;
}
+ if (bb == loop->latch && empty_block_p (bb))
+ continue;
+
/* It is time to remove this basic block. First remove edges. */
- while (bb->succ != NULL)
- ssa_remove_edge (bb->succ);
- while (bb->pred != NULL)
- ssa_remove_edge (bb->pred);
+ while (EDGE_COUNT (bb->preds) > 0)
+ remove_edge (EDGE_PRED (bb, 0));
+
+ /* This is loop latch and loop does not have exit then do not
+ delete this basic block. Just remove its PREDS and reconnect
+ loop->header and loop->latch blocks. */
+ if (bb == loop->latch && n_exits == 0)
+ {
+ make_edge (loop->header, loop->latch, EDGE_FALLTHRU);
+ set_immediate_dominator (CDI_DOMINATORS, loop->latch, loop->header);
+ continue;
+ }
+
+ while (EDGE_COUNT (bb->succs) > 0)
+ remove_edge (EDGE_SUCC (bb, 0));
/* Remove labels and make stmts member of loop->header. */
for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
/* Remove basic block. */
+ if (bb == loop->latch)
+ loop->latch = merge_target_bb;
remove_bb_from_loops (bb);
expunge_block (bb);
}
+
+ /* Now if possible, merge loop header and block with exit edge.
+ This reduces number of basic blocks to 2. Auto vectorizer addresses
+ loops with two nodes only. FIXME: Use cleanup_tree_cfg(). */
+ if (exit_bb
+ && loop->header != loop->latch
+ && exit_bb != loop->latch
+ && empty_block_p (loop->latch))
+ {
+ if (can_merge_blocks_p (loop->header, exit_bb))
+ {
+ remove_bb_from_loops (exit_bb);
+ merge_blocks (loop->header, exit_bb);
+ }
+ }
}
/* Make new temp variable of type TYPE. Add MODIFY_EXPR to assign EXP
stmt = build (MODIFY_EXPR, type, var, exp);
/* Get SSA name for the new variable and set make new statement
- its definition statment. */
+ its definition statement. */
new_name = make_ssa_name (var, stmt);
TREE_OPERAND (stmt, 0) = new_name;
SSA_NAME_DEF_STMT (new_name) = stmt;
pred_blocks_visited_p (basic_block bb, bitmap *visited)
{
edge e;
- for (e = bb->pred; e; e = e->pred_next)
+ edge_iterator ei;
+ FOR_EACH_EDGE (e, ei, bb->preds)
if (!bitmap_bit_p (*visited, e->src->index))
return false;
unsigned int index = 0;
unsigned int visited_count = 0;
- if (!loop->num_nodes)
- abort ();
-
- if (loop->latch == EXIT_BLOCK_PTR)
- abort ();
+ gcc_assert (loop->num_nodes);
+ gcc_assert (loop->latch != EXIT_BLOCK_PTR);
blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
- visited = BITMAP_XMALLOC ();
+ visited = BITMAP_ALLOC (NULL);
blocks_in_bfs_order = get_loop_body_in_bfs_order (loop);
}
}
free (blocks_in_bfs_order);
- BITMAP_XFREE (visited);
+ BITMAP_FREE (visited);
return blocks;
}
-/* Return true if one of the basic block BB edge is loop exit. */
+/* Return true if one of the basic block BB edge is exit of LOOP. */
static bool
-bb_with_exit_edge_p (basic_block bb)
+bb_with_exit_edge_p (struct loop *loop, basic_block bb)
{
edge e;
+ edge_iterator ei;
bool exit_edge_found = false;
- for (e = bb->succ; e && !exit_edge_found ; e = e->succ_next)
- if (e->flags & EDGE_LOOP_EXIT)
- exit_edge_found = true;
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (loop_exit_edge_p (loop, e))
+ {
+ exit_edge_found = true;
+ break;
+ }
return exit_edge_found;
}
TODO_dump_func
| TODO_verify_ssa
| TODO_verify_stmts
- | TODO_verify_flow /* todo_flags_finish */
+ | TODO_verify_flow, /* todo_flags_finish */
+ 0 /* letter */
};
OSDN Git Service
