/* 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.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* 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 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'
#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include "errors.h"
#include "tree.h"
#include "c-common.h"
#include "flags.h"
#include "target.h"
/* local function prototypes */
-static void main_tree_if_conversion (void);
+static unsigned int main_tree_if_conversion (void);
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,
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, basic_block);
+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, basic_block, tree, tree,
block_stmt_iterator *);
static void clean_predicate_lists (struct loop *loop);
-static basic_block find_phi_replacement_condition (basic_block, tree *,
+static basic_block find_phi_replacement_condition (struct loop *loop,
+ basic_block, tree *,
block_stmt_iterator *);
static void replace_phi_with_cond_modify_expr (tree, tree, basic_block,
block_stmt_iterator *);
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;
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");
ifc_bbs = NULL;
}
free_dominance_info (CDI_POST_DOMINATORS);
- free_df ();
return false;
}
/* If current bb has only one successor, then consider it as an
unconditional goto. */
- if (EDGE_COUNT (bb->succs) == 1)
+ if (single_succ_p (bb))
{
- basic_block bb_n = EDGE_SUCC (bb, 0)->dest;
+ basic_block bb_n = single_succ (bb);
if (cond != NULL_TREE)
add_to_predicate_list (bb_n, cond);
cond = NULL_TREE;
clean_predicate_lists (loop);
free (ifc_bbs);
ifc_bbs = NULL;
- free_df ();
return true;
}
program. */
break;
- case GOTO_EXPR:
- /* Unconditional goto */
- add_to_predicate_list (bb_for_stmt (TREE_OPERAND (t, 1)), cond);
- bsi_remove (bsi);
- cond = NULL_TREE;
- break;
-
case COND_EXPR:
/* Update destination blocks' predicate list and remove this
condition expression. */
tree_if_convert_cond_expr (struct loop *loop, tree stmt, tree cond,
block_stmt_iterator *bsi)
{
- tree c, c2, new_cond;
+ tree c, c2;
edge true_edge, false_edge;
- new_cond = NULL_TREE;
gcc_assert (TREE_CODE (stmt) == COND_EXPR);
- c = TREE_OPERAND (stmt, 0);
-
- /* Create temp. for condition. */
- 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);
- }
+ c = COND_EXPR_COND (stmt);
extract_true_false_edges_from_block (bb_for_stmt (stmt),
&true_edge, &false_edge);
/* Add new condition into destination's predicate list. */
/* If 'c' is true then TRUE_EDGE is taken. */
- new_cond = add_to_dst_predicate_list (loop, true_edge->dest, cond,
- unshare_expr (c), bsi);
-
- 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);
- }
+ add_to_dst_predicate_list (loop, true_edge->dest, cond,
+ unshare_expr (c), bsi);
/* If 'c' is false then FALSE_EDGE is taken. */
c2 = invert_truthvalue (unshare_expr (c));
/* 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);
+ bsi_remove (bsi, true);
cond = NULL_TREE;
}
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))
{
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{
- int j;
- dataflow_t df = get_immediate_uses (phi);
- int num_uses = num_immediate_uses (df);
- for (j = 0; j < num_uses; j++)
+ imm_use_iterator imm_iter;
+ use_operand_p use_p;
+ FOR_EACH_IMM_USE_FAST (use_p, imm_iter, PHI_RESULT (phi))
{
- tree use = immediate_use (df, j);
- if (TREE_CODE (use) == PHI_NODE)
+ if (TREE_CODE (USE_STMT (use_p)) == PHI_NODE)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Difficult to handle this virtual phi.\n");
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
- - IT is LABEL_EXPR, GOTO_EXPR or COND_EXPR.
+/* Return true, iff STMT is if-convertible.
+ Statement is if-convertible if,
+ - It is if-convertible MODIFY_EXPR
+ - IT is LABEL_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;
- case GOTO_EXPR:
case COND_EXPR:
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.
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, basic_block exit_bb)
{
edge e;
edge_iterator ei;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "----------[%d]-------------\n", bb->index);
- if (exit_bb_seen)
+ if (exit_bb)
{
if (bb != loop->latch)
{
fprintf (dump_file, "non empty basic block after exit bb\n");
return false;
}
+ else if (bb == loop->latch
+ && bb != exit_bb
+ && !dominated_by_p (CDI_DOMINATORS, bb, exit_bb))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "latch is not dominated by exit_block\n");
+ return false;
+ }
}
/* Be less adventurous and handle only normal edges. */
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;
unsigned int i;
edge e;
edge_iterator ei;
- bool exit_bb_seen = false;
+ basic_block exit_bb = NULL;
/* Handle only inner most loop. */
if (!loop || loop->inner)
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_EACH_EDGE (e, ei, loop->header->succs)
- if ( e->flags & EDGE_LOOP_EXIT)
- return false;
-
- compute_immediate_uses (TDFA_USE_OPS|TDFA_USE_VOPS, NULL);
+ {
+ if (loop_exit_edge_p (loop, e))
+ return false;
+ }
calculate_dominance_info (CDI_DOMINATORS);
calculate_dominance_info (CDI_POST_DOMINATORS);
{
bb = ifc_bbs[i];
- if (!if_convertable_bb_p (loop, bb, exit_bb_seen))
+ if (!if_convertible_bb_p (loop, bb, exit_bb))
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 = PHI_CHAIN (phi))
- if (!if_convertable_phi_p (loop, bb, phi))
+ if (!if_convertible_phi_p (loop, bb, phi))
return false;
- if (bb_with_exit_edge_p (bb))
- exit_bb_seen = true;
+ if (bb_with_exit_edge_p (loop, bb))
+ exit_bb = bb;
}
/* OK. Did not find any potential issues so go ahead in if-convert
tree cond = bb->aux;
if (cond)
- cond = fold (build (TRUTH_OR_EXPR, boolean_type_node,
- unshare_expr (cond), new_cond));
+ cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
+ unshare_expr (cond), new_cond);
else
cond = new_cond;
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 = build2 (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
whose phi arguments are selected when cond is true. */
static basic_block
-find_phi_replacement_condition (basic_block bb, tree *cond,
+find_phi_replacement_condition (struct loop *loop,
+ basic_block bb, tree *cond,
block_stmt_iterator *bsi)
{
- edge e;
- basic_block p1 = NULL;
- basic_block p2 = NULL;
- basic_block true_bb = NULL;
+ basic_block first_bb = NULL;
+ basic_block second_bb = NULL;
tree tmp_cond;
- edge_iterator ei;
- FOR_EACH_EDGE (e, ei, bb->preds)
- {
- if (p1 == NULL)
- p1 = e->src;
- else
- {
- gcc_assert (!p2);
- p2 = e->src;
- }
- }
+ gcc_assert (EDGE_COUNT (bb->preds) == 2);
+ first_bb = (EDGE_PRED (bb, 0))->src;
+ second_bb = (EDGE_PRED (bb, 1))->src;
- /* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
- tmp_cond = p1->aux;
+ /* Use condition based on following criteria:
+ 1)
+ S1: x = !c ? a : b;
+
+ S2: x = c ? b : a;
+
+ S2 is preferred over S1. Make 'b' first_bb and use its condition.
+
+ 2) Do not make loop header first_bb.
+
+ 3)
+ S1: x = !(c == d)? a : b;
+
+ S21: t1 = c == d;
+ S22: x = t1 ? b : a;
+
+ S3: x = (c == d) ? b : a;
+
+ S3 is preferred over S1 and S2*, Make 'b' first_bb and use
+ its condition.
+
+ 4) If pred B is dominated by pred A then use pred B's condition.
+ See PR23115. */
+
+ /* Select condition that is not TRUTH_NOT_EXPR. */
+ tmp_cond = first_bb->aux;
if (TREE_CODE (tmp_cond) == TRUTH_NOT_EXPR)
{
- *cond = p2->aux;
- true_bb = p2;
+ basic_block tmp_bb;
+ tmp_bb = first_bb;
+ first_bb = second_bb;
+ second_bb = tmp_bb;
}
- else
+
+ /* Check if FIRST_BB is loop header or not and make sure that
+ FIRST_BB does not dominate SECOND_BB. */
+ if (first_bb == loop->header
+ || dominated_by_p (CDI_DOMINATORS, second_bb, first_bb))
{
- *cond = p1->aux;
- true_bb = p1;
+ tmp_cond = second_bb->aux;
+ if (TREE_CODE (tmp_cond) == TRUTH_NOT_EXPR)
+ {
+ /* Select non loop header condition but do not switch basic blocks. */
+ *cond = invert_truthvalue (unshare_expr (tmp_cond));
+ }
+ else
+ {
+ /* Select non loop header condition. */
+ first_bb = second_bb;
+ *cond = first_bb->aux;
+ }
}
+ else
+ /* FIRST_BB is not loop header */
+ *cond = first_bb->aux;
/* Create temp. for the condition. Vectorizer prefers to have gimple
value as condition. Various targets use different means to communicate
tree new_stmt;
new_stmt = ifc_temp_var (TREE_TYPE (*cond), unshare_expr (*cond));
- bsi_insert_after (bsi, new_stmt, BSI_SAME_STMT);
- bsi_next (bsi);
+ bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
*cond = TREE_OPERAND (new_stmt, 0);
}
gcc_assert (*cond);
- return true_bb;
+ return first_bb;
}
arg_1 = NULL_TREE;
/* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
- if (PHI_ARG_EDGE(phi, 1)->src == true_bb)
+ if (EDGE_PRED (bb, 1)->src == true_bb)
{
arg_0 = PHI_ARG_DEF (phi, 1);
arg_1 = PHI_ARG_DEF (phi, 0);
}
/* 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));
+ rhs = build3 (COND_EXPR, TREE_TYPE (PHI_RESULT (phi)),
+ unshare_expr (cond), unshare_expr (arg_0),
+ unshare_expr (arg_1));
/* Create new MODIFY expression using RHS. */
- new_stmt = build (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
- unshare_expr (PHI_RESULT (phi)), rhs);
+ new_stmt = build2 (MODIFY_EXPR, TREE_TYPE (PHI_RESULT (phi)),
+ unshare_expr (PHI_RESULT (phi)), rhs);
/* Make new statement definition of the original phi result. */
SSA_NAME_DEF_STMT (PHI_RESULT (phi)) = new_stmt;
- /* Set basic block and insert using iterator. */
- set_bb_for_stmt (new_stmt, bb);
-
- bsi_insert_after (bsi, new_stmt, BSI_SAME_STMT);
- bsi_next (bsi);
-
- modify_stmt (new_stmt);
+ /* Insert using iterator. */
+ bsi_insert_before (bsi, new_stmt, BSI_SAME_STMT);
+ update_stmt (new_stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
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)
- true_bb = find_phi_replacement_condition (bb, &cond, &bsi);
+ true_bb = find_phi_replacement_condition (loop, bb, &cond, &bsi);
while (phi)
{
- tree next = TREE_CHAIN (phi);
+ tree next = PHI_CHAIN (phi);
replace_phi_with_cond_modify_expr (phi, cond, true_bb, &bsi);
release_phi_node (phi);
phi = next;
}
- bb_ann (bb)->phi_nodes = NULL;
+ bb->phi_nodes = NULL;
}
return;
}
basic_block bb, exit_bb, merge_target_bb;
unsigned int orig_loop_num_nodes = loop->num_nodes;
unsigned int i;
+ unsigned int n_exits;
+ edge *exits;
+ exits = get_loop_exit_edges (loop, &n_exits);
+ free (exits);
/* Process phi nodes to prepare blocks for merge. */
process_phi_nodes (loop);
bb = ifc_bbs[i];
- 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_EACH_EDGE (e, ei, bb->succs)
- if (!(e->flags & EDGE_LOOP_EXIT))
- {
- redirect_edge_and_branch (e, loop->latch);
- set_immediate_dominator (CDI_DOMINATORS, loop->latch, bb);
- }
+ {
+ if (!loop_exit_edge_p (loop, e))
+ {
+ redirect_edge_and_branch (e, loop->latch);
+ set_immediate_dominator (CDI_DOMINATORS, loop->latch, bb);
+ }
+ }
}
continue;
}
continue;
/* It is time to remove this basic block. First remove edges. */
- 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_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); )
{
if (TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR)
- bsi_remove (&bsi);
+ bsi_remove (&bsi, true);
else
{
set_bb_for_stmt (bsi_stmt (bsi), merge_target_bb);
/* Create new temporary variable. */
var = create_tmp_var (type, name);
- add_referenced_tmp_var (var);
+ add_referenced_var (var);
/* Build new statement to assign EXP to new variable. */
- stmt = build (MODIFY_EXPR, type, var, exp);
+ stmt = build2 (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;
gcc_assert (loop->num_nodes);
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
- blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
- visited = BITMAP_XMALLOC ();
+ blocks = XCNEWVEC (basic_block, loop->num_nodes);
+ 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_EACH_EDGE (e, ei, bb->succs)
- if (e->flags & EDGE_LOOP_EXIT)
+ if (loop_exit_edge_p (loop, e))
{
exit_edge_found = true;
break;
/* Tree if-conversion pass management. */
-static void
+static unsigned int
main_tree_if_conversion (void)
{
unsigned i, loop_num;
struct loop *loop;
if (!current_loops)
- return;
+ return 0;
loop_num = current_loops->num;
for (i = 0; i < loop_num; i++)
tree_if_conversion (loop, true);
}
-
+ return 0;
}
static bool
struct tree_opt_pass pass_if_conversion =
{
- "ifcvt", /* name */
- gate_tree_if_conversion, /* gate */
- main_tree_if_conversion, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- 0, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- TODO_dump_func, /* todo_flags_start */
- TODO_dump_func
- | TODO_verify_ssa
- | TODO_verify_stmts
- | TODO_verify_flow, /* todo_flags_finish */
- 0 /* letter */
+ "ifcvt", /* name */
+ gate_tree_if_conversion, /* gate */
+ main_tree_if_conversion, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ 0, /* tv_id */
+ PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_dump_func | TODO_verify_loops | TODO_verify_stmts | TODO_verify_flow,
+ /* todo_flags_finish */
+ 0 /* letter */
};
OSDN Git Service
