Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-/* This pass implements tree level if-conversion transformation of loops.
+/* This pass implements tree level if-conversion transformation of loops.
Initial goal is to help vectorizer vectorize loops with conditions.
A short description of if-conversion:
o Decide if a loop is if-convertable 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 propogate condition into destination basic blcoks'
+ and propagate condition into destination basic blocks'
predicate list.
o Replace modify expression with conditional modify expression
using current basic block's condition.
# i_23 = PHI <0(0), i_18(10)>;
<L0>:;
j_15 = A[i_23];
-
+
<L3>:;
iftmp.2_4 = j_15 > 41 ? 42 : 0;
A[i_23] = iftmp.2_4;
i_18 = i_23 + 1;
if (i_18 <= 15) goto <L19>; else goto <L18>;
-
+
<L19>:;
goto <bb 1> (<L0>);
/* local function prototypes */
static void main_tree_if_conversion (void);
-static tree tree_if_convert_stmt (struct loop *loop, tree, tree,
+static tree tree_if_convert_stmt (struct loop *loop, tree, tree,
block_stmt_iterator *);
-static void tree_if_convert_cond_expr (struct loop *, tree, tree,
+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 tree add_to_dst_predicate_list (struct loop * loop, tree, 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 *);
/* Main entry point.
Apply if-conversion to the LOOP. Return true if successful otherwise return
- false. If false is returned then loop remains unchanged.
+ false. If false is returned then loop remains unchanged.
FOR_VECTORIZER is a boolean flag. It indicates whether if-conversion is used
for vectorizer or not. If it is used for vectorizer, additional checks are
- used. (Vectorization checks are not yet imlemented). */
+ used. (Vectorization checks are not yet implemented). */
bool
tree_if_conversion (struct loop *loop, bool for_vectorizer)
}
cond = NULL_TREE;
-
+
/* Do actual work now. */
- for (i = 0; i < loop->num_nodes; i++)
+ for (i = 0; i < loop->num_nodes; i++)
{
bb = ifc_bbs [i];
cond = bb->aux;
/* Process all statements in this basic block.
- Remove conditional expresion, if any, and annotate
+ Remove conditional expression, if any, and annotate
destination basic block(s) appropriately. */
for (itr = bsi_start (bb); !bsi_end_p (itr); /* empty */)
{
bsi_next (&itr);
}
- /* If current bb has only one successor, then consider it as an
+ /* If current bb has only one successor, then consider it as an
unconditional goto. */
- if (bb->succ && !bb->succ->succ_next)
+ if (EDGE_COUNT (bb->succs) == 1)
{
- basic_block bb_n = bb->succ->dest;
+ basic_block bb_n = EDGE_SUCC (bb, 0)->dest;
if (cond != NULL_TREE)
add_to_predicate_list (bb_n, cond);
cond = NULL_TREE;
return true;
}
-/* if-convert stmt T which is part of LOOP.
- If T is a MODIFY_EXPR than it is converted into conditional modify
- expression using COND. For conditional expressions, add condition in the
- destination basic block's predicate list and remove conditional
- expression itself. BSI is the iterator used to traverse statements of
+/* if-convert stmt T which is part of LOOP.
+ If T is a MODIFY_EXPR than it is converted into conditional modify
+ expression using COND. For conditional expressions, add condition in the
+ destination basic block's predicate list and remove conditional
+ expression itself. BSI is the iterator used to traverse statements of
loop. It is used here when it is required to delete current statement. */
static tree
-tree_if_convert_stmt (struct loop * loop, tree t, tree cond,
+tree_if_convert_stmt (struct loop * loop, tree t, tree cond,
block_stmt_iterator *bsi)
{
if (dump_file && (dump_flags & TDF_DETAILS))
/* This modify_expr is killing previous value of LHS. Appropriate value will
be selected by PHI node based on condition. It is possible that before
this transformation, PHI nodes was selecting default value and now it will
- use this new value. This is OK because it does not change validity the
+ use this new value. This is OK because it does not change validity the
program. */
break;
/* Update destination blocks' predicate list and remove this
condition expression. */
tree_if_convert_cond_expr (loop, t, cond, bsi);
- cond = NULL_TREE;
- break;
-
- default:
- abort ();
+ cond = NULL_TREE;
break;
+
+ default:
+ gcc_unreachable ();
}
return cond;
}
/* STMT is COND_EXPR. Update two destination's predicate list.
Remove COND_EXPR, if it is not the loop exit condition. Otherwise
- update loop exit condition appropriatly. BSI is the iterator
+ update loop exit condition appropriately. BSI is the iterator
used to traverse statement list. STMT is part of loop LOOP. */
static void
-tree_if_convert_cond_expr (struct loop *loop, tree stmt, tree 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;
-#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);
-
+
/* 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));
bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
c = TREE_OPERAND (new_stmt, 0);
}
-
+
/* 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);
-
+ new_cond = add_to_dst_predicate_list (loop, then_clause, cond,
+ unshare_expr (c), bsi);
+
if (else_clause)
{
+ tree c2;
+ if (!is_gimple_reg(c) && is_gimple_condexpr (c))
+ {
+ 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 else_clause is reached. */
- tree c2 = build1 (TRUTH_NOT_EXPR,
- boolean_type_node,
- unshare_expr (c));
+ c2 = invert_truthvalue (unshare_expr (c));
add_to_dst_predicate_list (loop, else_clause, cond, c2, bsi);
}
- /* Now this conditional statement is redundent. Remove it.
+ /* 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)))
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
and it belongs to basic block BB.
- PHI is not if-convertable
+ PHI is not if-convertable
- if it has more than 2 arguments.
- Virtual PHI is immediately used in another PHI node. */
fprintf (dump_file, "-------------------------\n");
print_generic_stmt (dump_file, phi, TDF_SLIM);
}
-
+
if (bb != loop->header && PHI_NUM_ARGS (phi) != 2)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "More than two phi node args.\n");
return false;
}
-
+
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{
int j;
return true;
}
-/* Return true, if M_EXPR is if-convertable.
+/* Return true, if M_EXPR is if-convertable.
MODIFY_EXPR is not if-convertable if,
- It is not movable.
- It could trap.
fprintf (dump_file, "-------------------------\n");
print_generic_stmt (dump_file, m_expr, TDF_SLIM);
}
-
+
/* Be conservative and do not handle immovable expressions. */
if (movement_possibility (m_expr) == MOVE_IMPOSSIBLE)
{
}
/* See if it needs speculative loading or not. */
- if (bb != loop->header
+ if (bb != loop->header
&& tree_could_trap_p (TREE_OPERAND (m_expr, 1)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
return true;
}
-/* Return true, iff STMT is if-convertable.
+/* Return true, iff STMT is if-convertable.
Statement is if-convertable if,
- - It is if-converatable MODIFY_EXPR
- - IT is LABEL_EXPR, GOTO_EXPR or COND_EXPR.
+ - It is if-convertable MODIFY_EXPR
+ - IT is LABEL_EXPR, GOTO_EXPR or COND_EXPR.
STMT is inside block BB, which is inside loop LOOP. */
static bool
{
case LABEL_EXPR:
break;
-
+
case MODIFY_EXPR:
-
+
if (!if_convertable_modify_expr_p (loop, bb, stmt))
return false;
break;
-
+
case GOTO_EXPR:
case COND_EXPR:
break;
-
+
default:
/* Don't know what to do with 'em so don't do anything. */
if (dump_file && (dump_flags & TDF_DETAILS))
return true;
}
-/* Return true, iff BB is if-convertable.
+/* Return true, iff BB is if-convertable.
Note: This routine does _not_ check basic block statements and phis.
- Basic block is not if-converatable if,
- - Basic block is non-empty and it is after exit block (in BFS order).
+ Basic block is not if-convertable 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.
+ - 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
+static bool
if_convertable_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);
-
+
if (exit_bb_seen)
{
if (bb != loop->latch)
return false;
}
}
-
- /* Be less adveturous and handle only normal edges. */
- for (e = bb->succ; e; e = e->succ_next)
- if (e->flags &
+
+ /* Be less adventurous and handle only normal edges. */
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ if (e->flags &
(EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_ABNORMAL | EDGE_IRREDUCIBLE_LOOP))
{
if (dump_file && (dump_flags & TDF_DETAILS))
return true;
}
-/* Return true, iff LOOP is if-convertable.
+/* Return true, iff LOOP is if-convertable.
LOOP is if-convertable 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
- more info.
+ - Loop header is not the exit edge.
+ - If its basic blocks and phi nodes are if convertable. See above for
+ more info.
FOR_VECTORIZER enables vectorizer specific checks. For example, support
for vector conditions, data dependency checks etc.. (Not implemented yet). */
block_stmt_iterator itr;
unsigned int i;
edge e;
+ edge_iterator ei;
bool exit_bb_seen = false;
/* Handle only inner most loop. */
fprintf (dump_file, "not inner most loop\n");
return false;
}
-
+
flow_loop_scan (loop, LOOP_ALL);
/* If only one block, no need for if-conversion. */
if (loop->num_nodes <= 2)
{
if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "less thant 2 basic blocks\n");
+ fprintf (dump_file, "less than 2 basic blocks\n");
return false;
}
-
+
/* More than one loop exit is too much to handle. */
if (loop->num_exits > 1)
{
/* 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)
+ FOR_EACH_EDGE (e, ei, loop->header->succs)
if ( e->flags & EDGE_LOOP_EXIT)
return false;
free_dominance_info (CDI_POST_DOMINATORS);
return false;
}
-
+
for (i = 0; i < loop->num_nodes; i++)
{
bb = ifc_bbs[i];
add_to_predicate_list (basic_block bb, tree new_cond)
{
tree cond = bb->aux;
-
+
if (cond)
cond = fold (build (TRUTH_OR_EXPR, boolean_type_node,
unshare_expr (cond), new_cond));
existing condition. */
static tree
-add_to_dst_predicate_list (struct loop * loop, tree dst,
+add_to_dst_predicate_list (struct loop * loop, tree dst,
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
+ gcc_assert (TREE_CODE (dst) == GOTO_EXPR);
bb = label_to_block (TREE_OPERAND (dst, 0));
if (!flow_bb_inside_loop_p (loop, bb))
return NULL_TREE;
}
/* 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. Vectorizier prefers to have gimple
- value as condition. Various targets use different means to communicate
- condition in vector compare operation. Using gimple value allows compiler
+
+ /* Create temp. for the condition. Vectorizer prefers to have gimple
+ value as condition. Various targets use different means to communicate
+ condition in vector compare operation. Using gimple value allows compiler
to emit vector compare and select RTL without exposing compare's result. */
if (!is_gimple_reg (*cond) && !is_gimple_condexpr (*cond))
{
*cond = TREE_OPERAND (new_stmt, 0);
}
-#ifdef ENABLE_CHECKING
- if (*cond == NULL_TREE)
- abort ();
-#endif
+ gcc_assert (*cond);
- return switch_args;
+ return true_bb;
}
-/* Replace PHI node with conditional modify expr using COND.
- This routine does not handle PHI nodes with more than two arguments.
+/* Replace PHI node with conditional modify expr using COND.
+ This routine does not handle PHI nodes with more than two arguments.
For example,
S1: A = PHI <x1(1), x2(5)
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);
new_stmt = NULL_TREE;
arg_0 = NULL_TREE;
arg_1 = NULL_TREE;
-
+
/* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
- if (switch_args)
+ if (PHI_ARG_EDGE(phi, 1)->src == true_bb)
{
arg_0 = PHI_ARG_DEF (phi, 1);
arg_1 = PHI_ARG_DEF (phi, 0);
arg_1 = PHI_ARG_DEF (phi, 1);
}
- /* Build new RHS using selected condtion and arguments. */
+ /* Build new RHS using selected condition and arguments. */
rhs = build (COND_EXPR, TREE_TYPE (PHI_RESULT (phi)),
unshare_expr (cond), unshare_expr (arg_0),
unshare_expr (arg_1));
- /* Create new MODIFY expresstion using RHS. */
+ /* Create new MODIFY expression using RHS. */
new_stmt = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
unshare_expr (PHI_RESULT (phi)), rhs);
}
}
-/* Process phi nodes for the given LOOP. Replace phi nodes with cond
+/* Process phi nodes for the given LOOP. Replace phi nodes with cond
modify expr. */
static void
{
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);
/* 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);
+ replace_phi_with_cond_modify_expr (phi, cond, true_bb, &bsi);
release_phi_node (phi);
phi = next;
}
return;
}
-/* Combine all basic block from the given LOOP into one or two super
- basic block. Replace PHI nodes with conditional modify expression. */
+/* Combine all basic block from the given LOOP into one or two super
+ basic block. Replace PHI nodes with conditional modify expression. */
static void
combine_blocks (struct loop *loop)
bb = ifc_bbs[i];
- if (bb == loop->latch)
- continue;
-
if (!exit_bb && bb_with_exit_edge_p (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);
if (exit_bb != loop->latch)
{
/* Redirect non-exit edge to loop->latch. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (!(e->flags & EDGE_LOOP_EXIT))
{
redirect_edge_and_branch (e, loop->latch);
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->succs) > 0)
+ ssa_remove_edge (EDGE_SUCC (bb, 0));
+ while (EDGE_COUNT (bb->preds) > 0)
+ ssa_remove_edge (EDGE_PRED (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_DOMINATORS, bb);
if (dom_computed[CDI_POST_DOMINATORS])
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
+/* Make new temp variable of type TYPE. Add MODIFY_EXPR to assign EXP
to the new variable. */
static tree
var = create_tmp_var (type, name);
add_referenced_tmp_var (var);
- /* Build new statement to assigne EXP to new variable. */
+ /* Build new statement to assign EXP to new variable. */
stmt = build (MODIFY_EXPR, type, var, exp);
-
+
/* Get SSA name for the new variable and set make new statement
its definition statment. */
new_name = make_ssa_name (var, 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;
-
+
return true;
}
additional constraint. Select block in BFS block, if all
pred are already selected. */
-static basic_block *
+static basic_block *
get_loop_body_in_if_conv_order (const struct loop *loop)
{
basic_block *blocks, *blocks_in_bfs_order;
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 ();
while (index < loop->num_nodes)
{
bb = blocks_in_bfs_order [index];
-
+
if (bb->flags & BB_IRREDUCIBLE_LOOP)
{
free (blocks_in_bfs_order);
bb_with_exit_edge_p (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)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (e->flags & EDGE_LOOP_EXIT)
- exit_edge_found = true;
+ {
+ exit_edge_found = true;
+ break;
+ }
return exit_edge_found;
}
static bool
gate_tree_if_conversion (void)
{
- return true;
+ return flag_tree_vectorize != 0;
}
struct tree_opt_pass pass_if_conversion =
0, /* properties_provided */
0, /* properties_destroyed */
TODO_dump_func, /* todo_flags_start */
- TODO_dump_func
+ TODO_dump_func
| TODO_verify_ssa
- | TODO_verify_stmts
- | TODO_verify_flow /* todo_flags_finish */
+ | TODO_verify_stmts
+ | TODO_verify_flow, /* todo_flags_finish */
+ 0 /* letter */
};
-
OSDN Git Service
