X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-loop-manip.c;h=50989710dc474deb4a4a3560720f97b3292b2736;hb=c69ba4690b07c368688b11a6d1bec08886df58fb;hp=1f949a43041b5f11c9c33e043f5dca8d55f8d875;hpb=1bd13ef117738b816e270e9fd9e3d475d92eb4f3;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c index 1f949a43041..50989710dc4 100644 --- a/gcc/tree-ssa-loop-manip.c +++ b/gcc/tree-ssa-loop-manip.c @@ -1,5 +1,5 @@ /* High-level loop manipulation functions. - Copyright (C) 2004 Free Software Foundation, Inc. + Copyright (C) 2004, 2005 Free Software Foundation, Inc. This file is part of GCC. @@ -41,7 +41,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA It is expected that neither BASE nor STEP are shared with other expressions (unless the sharing rules allow this). Use VAR as a base var_decl for it (if NULL, a new temporary will be created). The increment will occur at - INCR_POS (after it if AFTER is true, before it otherwise). The ssa versions + INCR_POS (after it if AFTER is true, before it otherwise). INCR_POS and + AFTER can be computed using standard_iv_increment_position. The ssa versions of the variable before and after increment will be stored in VAR_BEFORE and VAR_AFTER (unless they are NULL). */ @@ -53,6 +54,7 @@ create_iv (tree base, tree step, tree var, struct loop *loop, tree stmt, initial, step1, stmts; tree vb, va; enum tree_code incr_op = PLUS_EXPR; + edge pe = loop_preheader_edge (loop); if (!var) { @@ -91,6 +93,12 @@ create_iv (tree base, tree step, tree var, struct loop *loop, } } + /* Gimplify the step if necessary. We put the computations in front of the + loop (i.e. the step should be loop invariant). */ + step = force_gimple_operand (step, &stmts, true, var); + if (stmts) + bsi_insert_on_edge_immediate_loop (pe, stmts); + stmt = build2 (MODIFY_EXPR, void_type_node, va, build2 (incr_op, TREE_TYPE (base), vb, step)); @@ -102,16 +110,12 @@ create_iv (tree base, tree step, tree var, struct loop *loop, initial = force_gimple_operand (base, &stmts, true, var); if (stmts) - { - edge pe = loop_preheader_edge (loop); - - bsi_insert_on_edge_immediate_loop (pe, stmts); - } + bsi_insert_on_edge_immediate_loop (pe, stmts); stmt = create_phi_node (vb, loop->header); SSA_NAME_DEF_STMT (vb) = stmt; - add_phi_arg (&stmt, initial, loop_preheader_edge (loop)); - add_phi_arg (&stmt, va, loop_latch_edge (loop)); + add_phi_arg (stmt, initial, loop_preheader_edge (loop)); + add_phi_arg (stmt, va, loop_latch_edge (loop)); } /* Add exit phis for the USE on EXIT. */ @@ -138,11 +142,9 @@ add_exit_phis_edge (basic_block exit, tree use) return; phi = create_phi_node (use, exit); - + create_new_def_for (PHI_RESULT (phi), phi, PHI_RESULT_PTR (phi)); FOR_EACH_EDGE (e, ei, exit->preds) - add_phi_arg (&phi, use, e); - - SSA_NAME_DEF_STMT (use) = def_stmt; + add_phi_arg (phi, use, e); } /* Add exit phis for VAR that is used in LIVEIN. @@ -152,16 +154,19 @@ static void add_exit_phis_var (tree var, bitmap livein, bitmap exits) { bitmap def; - int index; + unsigned index; basic_block def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (var)); bitmap_iterator bi; - bitmap_clear_bit (livein, def_bb->index); + if (is_gimple_reg (var)) + bitmap_clear_bit (livein, def_bb->index); + else + bitmap_set_bit (livein, def_bb->index); - def = BITMAP_XMALLOC (); + def = BITMAP_ALLOC (NULL); bitmap_set_bit (def, def_bb->index); compute_global_livein (livein, def); - BITMAP_XFREE (def); + BITMAP_FREE (def); EXECUTE_IF_AND_IN_BITMAP (exits, livein, 0, index, bi) { @@ -190,7 +195,7 @@ add_exit_phis (bitmap names_to_rename, bitmap *use_blocks, bitmap loop_exits) static bitmap get_loops_exits (void) { - bitmap exits = BITMAP_XMALLOC (); + bitmap exits = BITMAP_ALLOC (NULL); basic_block bb; edge e; edge_iterator ei; @@ -211,10 +216,11 @@ get_loops_exits (void) /* For USE in BB, if it is used outside of the loop it is defined in, mark it for rewrite. Record basic block BB where it is used - to USE_BLOCKS. */ + to USE_BLOCKS. Record the ssa name index to NEED_PHIS bitmap. */ static void -find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks) +find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks, + bitmap need_phis) { unsigned ver; basic_block def_bb; @@ -223,6 +229,10 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks) if (TREE_CODE (use) != SSA_NAME) return; + /* We don't need to keep virtual operands in loop-closed form. */ + if (!is_gimple_reg (use)) + return; + ver = SSA_NAME_VERSION (use); def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (use)); if (!def_bb) @@ -234,51 +244,75 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks) return; if (!use_blocks[ver]) - use_blocks[ver] = BITMAP_XMALLOC (); + use_blocks[ver] = BITMAP_ALLOC (NULL); bitmap_set_bit (use_blocks[ver], bb->index); - if (!flow_bb_inside_loop_p (def_loop, bb)) - mark_for_rewrite (use); + bitmap_set_bit (need_phis, ver); } /* For uses in STMT, mark names that are used outside of the loop they are defined to rewrite. Record the set of blocks in that the ssa - names are defined to USE_BLOCKS. */ + names are defined to USE_BLOCKS and the ssa names themselves to + NEED_PHIS. */ static void -find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks) +find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks, bitmap need_phis) { ssa_op_iter iter; tree var; basic_block bb = bb_for_stmt (stmt); - get_stmt_operands (stmt); - FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS) - find_uses_to_rename_use (bb, var, use_blocks); + find_uses_to_rename_use (bb, var, use_blocks, need_phis); } +/* Marks names that are used in BB and outside of the loop they are + defined in for rewrite. Records the set of blocks in that the ssa + names are defined to USE_BLOCKS. Record the SSA names that will + need exit PHIs in NEED_PHIS. */ + +static void +find_uses_to_rename_bb (basic_block bb, bitmap *use_blocks, bitmap need_phis) +{ + block_stmt_iterator bsi; + edge e; + edge_iterator ei; + tree phi; + + FOR_EACH_EDGE (e, ei, bb->succs) + for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi)) + find_uses_to_rename_use (bb, PHI_ARG_DEF_FROM_EDGE (phi, e), + use_blocks, need_phis); + + for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) + find_uses_to_rename_stmt (bsi_stmt (bsi), use_blocks, need_phis); +} + /* Marks names that are used outside of the loop they are defined in for rewrite. Records the set of blocks in that the ssa - names are defined to USE_BLOCKS. */ + names are defined to USE_BLOCKS. If CHANGED_BBS is not NULL, + scan only blocks in this set. */ static void -find_uses_to_rename (bitmap *use_blocks) +find_uses_to_rename (bitmap changed_bbs, bitmap *use_blocks, bitmap need_phis) { basic_block bb; - block_stmt_iterator bsi; - tree phi; - unsigned i; + unsigned index; + bitmap_iterator bi; - FOR_EACH_BB (bb) + if (changed_bbs && !bitmap_empty_p (changed_bbs)) { - for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi)) - for (i = 0; i < (unsigned) PHI_NUM_ARGS (phi); i++) - find_uses_to_rename_use (PHI_ARG_EDGE (phi, i)->src, - PHI_ARG_DEF (phi, i), use_blocks); - - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - find_uses_to_rename_stmt (bsi_stmt (bsi), use_blocks); + EXECUTE_IF_SET_IN_BITMAP (changed_bbs, 0, index, bi) + { + find_uses_to_rename_bb (BASIC_BLOCK (index), use_blocks, need_phis); + } + } + else + { + FOR_EACH_BB (bb) + { + find_uses_to_rename_bb (bb, use_blocks, need_phis); + } } } @@ -306,36 +340,45 @@ find_uses_to_rename (bitmap *use_blocks) Looking from the outer loop with the normal SSA form, the first use of k is not well-behaved, while the second one is an induction variable with - base 99 and step 1. */ + base 99 and step 1. + + If CHANGED_BBS is not NULL, we look for uses outside loops only in + the basic blocks in this set. + + UPDATE_FLAG is used in the call to update_ssa. See + TODO_update_ssa* for documentation. */ void -rewrite_into_loop_closed_ssa (void) +rewrite_into_loop_closed_ssa (bitmap changed_bbs, unsigned update_flag) { bitmap loop_exits = get_loops_exits (); bitmap *use_blocks; - unsigned i; - bitmap names_to_rename; + unsigned i, old_num_ssa_names; + bitmap names_to_rename = BITMAP_ALLOC (NULL); - gcc_assert (!any_marked_for_rewrite_p ()); + /* If the pass has caused the SSA form to be out-of-date, update it + now. */ + update_ssa (update_flag); - use_blocks = xcalloc (num_ssa_names, sizeof (bitmap)); + old_num_ssa_names = num_ssa_names; + use_blocks = xcalloc (old_num_ssa_names, sizeof (bitmap)); /* Find the uses outside loops. */ - find_uses_to_rename (use_blocks); + find_uses_to_rename (changed_bbs, use_blocks, names_to_rename); - /* Add the phi nodes on exits of the loops for the names we need to + /* Add the PHI nodes on exits of the loops for the names we need to rewrite. */ - names_to_rename = marked_ssa_names (); add_exit_phis (names_to_rename, use_blocks, loop_exits); - for (i = 0; i < num_ssa_names; i++) - BITMAP_XFREE (use_blocks[i]); + for (i = 0; i < old_num_ssa_names; i++) + BITMAP_FREE (use_blocks[i]); free (use_blocks); - BITMAP_XFREE (loop_exits); - BITMAP_XFREE (names_to_rename); + BITMAP_FREE (loop_exits); + BITMAP_FREE (names_to_rename); - /* Do the rewriting. */ - rewrite_ssa_into_ssa (); + /* Fix up all the names found to be used outside their original + loops. */ + update_ssa (TODO_update_ssa); } /* Check invariants of the loop closed ssa form for the USE in BB. */ @@ -346,7 +389,7 @@ check_loop_closed_ssa_use (basic_block bb, tree use) tree def; basic_block def_bb; - if (TREE_CODE (use) != SSA_NAME) + if (TREE_CODE (use) != SSA_NAME || !is_gimple_reg (use)) return; def = SSA_NAME_DEF_STMT (use); @@ -363,9 +406,7 @@ check_loop_closed_ssa_stmt (basic_block bb, tree stmt) ssa_op_iter iter; tree var; - get_stmt_operands (stmt); - - FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES) + FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES | SSA_OP_ALL_KILLS) check_loop_closed_ssa_use (bb, var); } @@ -379,11 +420,14 @@ verify_loop_closed_ssa (void) tree phi; unsigned i; - verify_ssa (); + if (current_loops == NULL) + return; + + verify_ssa (false); FOR_EACH_BB (bb) { - for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi)) + for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) for (i = 0; i < (unsigned) PHI_NUM_ARGS (phi); i++) check_loop_closed_ssa_use (PHI_ARG_EDGE (phi, i)->src, PHI_ARG_DEF (phi, i)); @@ -404,9 +448,9 @@ split_loop_exit_edge (edge exit) tree phi, new_phi, new_name, name; use_operand_p op_p; - for (phi = phi_nodes (dest); phi; phi = TREE_CHAIN (phi)) + for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi)) { - op_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, EDGE_SUCC (bb, 0)); + op_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, single_succ_edge (bb)); name = USE_FROM_PTR (op_p); @@ -420,7 +464,7 @@ split_loop_exit_edge (edge exit) new_name = duplicate_ssa_name (name, NULL); new_phi = create_phi_node (new_name, bb); SSA_NAME_DEF_STMT (new_name) = new_phi; - add_phi_arg (&new_phi, name, exit); + add_phi_arg (new_phi, name, exit); SET_USE (op_p, new_name); } } @@ -470,10 +514,10 @@ ip_normal_pos (struct loop *loop) basic_block bb; edge exit; - if (EDGE_COUNT (loop->latch->preds) > 1) + if (!single_pred_p (loop->latch)) return NULL; - bb = EDGE_PRED (loop->latch, 0)->src; + bb = single_pred (loop->latch); last = last_stmt (bb); if (TREE_CODE (last) != COND_EXPR) return NULL; @@ -522,62 +566,24 @@ copy_phi_node_args (unsigned first_new_block) unsigned i; for (i = first_new_block; i < (unsigned) last_basic_block; i++) - BASIC_BLOCK (i)->rbi->duplicated = 1; + BASIC_BLOCK (i)->flags |= BB_DUPLICATED; for (i = first_new_block; i < (unsigned) last_basic_block; i++) add_phi_args_after_copy_bb (BASIC_BLOCK (i)); for (i = first_new_block; i < (unsigned) last_basic_block; i++) - BASIC_BLOCK (i)->rbi->duplicated = 0; -} - -/* Renames variables in the area copied by tree_duplicate_loop_to_header_edge. - FIRST_NEW_BLOCK is the first block in the copied area. DEFINITIONS is - a bitmap of all ssa names defined inside the loop. */ - -static void -rename_variables (unsigned first_new_block, bitmap definitions) -{ - unsigned i, copy_number = 0; - basic_block bb; - htab_t ssa_name_map = NULL; - - for (i = first_new_block; i < (unsigned) last_basic_block; i++) - { - bb = BASIC_BLOCK (i); - - /* We assume that first come all blocks from the first copy, then all - blocks from the second copy, etc. */ - if (copy_number != (unsigned) bb->rbi->copy_number) - { - allocate_ssa_names (definitions, &ssa_name_map); - copy_number = bb->rbi->copy_number; - } - - rewrite_to_new_ssa_names_bb (bb, ssa_name_map); - } - - htab_delete (ssa_name_map); + BASIC_BLOCK (i)->flags &= ~BB_DUPLICATED; } -/* Sets SSA_NAME_DEF_STMT for results of all phi nodes in BB. */ -static void -set_phi_def_stmts (basic_block bb) -{ - tree phi; - - for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi)) - SSA_NAME_DEF_STMT (PHI_RESULT (phi)) = phi; -} +/* The same as cfgloopmanip.c:duplicate_loop_to_header_edge, but also + updates the PHI nodes at start of the copied region. In order to + achieve this, only loops whose exits all lead to the same location + are handled. -/* The same ad cfgloopmanip.c:duplicate_loop_to_header_edge, but also updates - ssa. In order to achieve this, only loops whose exits all lead to the same - location are handled. - - FIXME: we create some degenerate phi nodes that could be avoided by copy - propagating them instead. Unfortunately this is not completely - straightforward due to problems with constant folding. */ + Notice that we do not completely update the SSA web after + duplication. The caller is responsible for calling update_ssa + after the loop has been duplicated. */ bool tree_duplicate_loop_to_header_edge (struct loop *loop, edge e, @@ -587,10 +593,6 @@ tree_duplicate_loop_to_header_edge (struct loop *loop, edge e, unsigned int *n_to_remove, int flags) { unsigned first_new_block; - basic_block bb; - unsigned i; - tree phi, arg, map, def; - bitmap definitions; if (!(loops->state & LOOPS_HAVE_SIMPLE_LATCHES)) return false; @@ -601,257 +603,18 @@ tree_duplicate_loop_to_header_edge (struct loop *loop, edge e, verify_loop_closed_ssa (); #endif - gcc_assert (!any_marked_for_rewrite_p ()); - first_new_block = last_basic_block; if (!duplicate_loop_to_header_edge (loop, e, loops, ndupl, wont_exit, orig, to_remove, n_to_remove, flags)) return false; /* Readd the removed phi args for e. */ - map = PENDING_STMT (e); - PENDING_STMT (e) = NULL; - - for (phi = phi_nodes (e->dest), arg = map; - phi; - phi = TREE_CHAIN (phi), arg = TREE_CHAIN (arg)) - { - def = TREE_VALUE (arg); - add_phi_arg (&phi, def, e); - } - gcc_assert (arg == NULL); + flush_pending_stmts (e); /* Copy the phi node arguments. */ copy_phi_node_args (first_new_block); - /* Rename the variables. */ - definitions = marked_ssa_names (); - rename_variables (first_new_block, definitions); - unmark_all_for_rewrite (); - BITMAP_XFREE (definitions); - - /* For some time we have the identical ssa names as results in multiple phi - nodes. When phi node is resized, it sets SSA_NAME_DEF_STMT of its result - to the new copy. This means that we cannot easily ensure that the ssa - names defined in those phis are pointing to the right one -- so just - recompute SSA_NAME_DEF_STMT for them. */ - - for (i = first_new_block; i < (unsigned) last_basic_block; i++) - { - bb = BASIC_BLOCK (i); - set_phi_def_stmts (bb); - if (bb->rbi->copy_number == 1) - set_phi_def_stmts (bb->rbi->original); - } - scev_reset (); -#ifdef ENABLE_CHECKING - verify_loop_closed_ssa (); -#endif return true; } - -/*--------------------------------------------------------------------------- - Loop versioning - ---------------------------------------------------------------------------*/ - -/* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy - of 'first'. Both of them are dominated by 'new_head' basic block. When - 'new_head' was created by 'second's incoming edge it received phi arguments - on the edge by split_edge(). Later, additional edge 'e' was created to - connect 'new_head' and 'first'. Now this routine adds phi args on this - additional edge 'e' that new_head to second edge received as part of edge - splitting. -*/ - -static void -lv_adjust_loop_header_phi (basic_block first, basic_block second, - basic_block new_head, edge e) -{ - tree phi1, phi2; - - /* Browse all 'second' basic block phi nodes and add phi args to - edge 'e' for 'first' head. PHI args are always in correct order. */ - - for (phi2 = phi_nodes (second), phi1 = phi_nodes (first); - phi2 && phi1; - phi2 = TREE_CHAIN (phi2), phi1 = TREE_CHAIN (phi1)) - { - int i; - for (i = 0; i < PHI_NUM_ARGS (phi2); i++) - { - if (PHI_ARG_EDGE (phi2, i)->src == new_head) - { - tree def = PHI_ARG_DEF (phi2, i); - add_phi_arg (&phi1, def, e); - } - } - } -} - -/* Adjust entry edge for lv. - - e is a incoming edge. - - --- edge e ---- > [second_head] - - Split it and insert new conditional expression and adjust edges. - - --- edge e ---> [cond expr] ---> [first_head] - | - +---------> [second_head] - -*/ - -static basic_block -lv_adjust_loop_entry_edge (basic_block first_head, - basic_block second_head, - edge e, - tree cond_expr) -{ - block_stmt_iterator bsi; - basic_block new_head = NULL; - tree goto1 = NULL_TREE; - tree goto2 = NULL_TREE; - tree new_cond_expr = NULL_TREE; - edge e0, e1; - - gcc_assert (e->dest == second_head); - - /* Split edge 'e'. This will create a new basic block, where we can - insert conditional expr. */ - new_head = split_edge (e); - - /* Build new conditional expr */ - goto1 = build1 (GOTO_EXPR, void_type_node, tree_block_label (first_head)); - goto2 = build1 (GOTO_EXPR, void_type_node, tree_block_label (second_head)); - new_cond_expr = build3 (COND_EXPR, void_type_node, cond_expr, goto1, goto2); - - /* Add new cond. in new head. */ - bsi = bsi_start (new_head); - bsi_insert_after (&bsi, new_cond_expr, BSI_NEW_STMT); - - /* Adjust edges appropriately to connect new head with first head - as well as second head. */ - e0 = EDGE_SUCC (new_head, 0); - e0->flags &= ~EDGE_FALLTHRU; - e0->flags |= EDGE_FALSE_VALUE; - e1 = make_edge (new_head, first_head, EDGE_TRUE_VALUE); - set_immediate_dominator (CDI_DOMINATORS, first_head, new_head); - set_immediate_dominator (CDI_DOMINATORS, second_head, new_head); - - /* Adjust loop header phi nodes. */ - lv_adjust_loop_header_phi (first_head, second_head, new_head, e1); - - return new_head; -} - -/* Add phi args using PENDINT_STMT list. */ - -static void -lv_update_pending_stmts (edge e) -{ - basic_block dest; - tree phi, arg, def; - - if (!PENDING_STMT (e)) - return; - - dest = e->dest; - - for (phi = phi_nodes (dest), arg = PENDING_STMT (e); - phi; - phi = TREE_CHAIN (phi), arg = TREE_CHAIN (arg)) - { - def = TREE_VALUE (arg); - add_phi_arg (&phi, def, e); - } - - PENDING_STMT (e) = NULL; -} - - -/* Main entry point for Loop Versioning transformation. - -This transformation given a condition and a loop, creates --if (condition) { loop_copy1 } else { loop_copy2 }, -where loop_copy1 is the loop transformed in one way, and loop_copy2 -is the loop transformed in another way (or unchanged). 'condition' -may be a run time test for things that were not resolved by static -analysis (overlapping ranges (anti-aliasing), alignment, etc.). */ - -struct loop * -tree_ssa_loop_version (struct loops *loops, struct loop * loop, - tree cond_expr, basic_block *condition_bb) -{ - edge entry, latch_edge, exit, true_edge, false_edge; - basic_block first_head, second_head; - int irred_flag; - struct loop *nloop; - - /* CHECKME: Loop versioning does not handle nested loop at this point. */ - if (loop->inner) - return NULL; - - /* Record entry and latch edges for the loop */ - entry = loop_preheader_edge (loop); - - /* Note down head of loop as first_head. */ - first_head = entry->dest; - - /* Duplicate loop. */ - irred_flag = entry->flags & EDGE_IRREDUCIBLE_LOOP; - entry->flags &= ~EDGE_IRREDUCIBLE_LOOP; - if (!tree_duplicate_loop_to_header_edge (loop, entry, loops, 1, - NULL, NULL, NULL, NULL, 0)) - { - entry->flags |= irred_flag; - return NULL; - } - - /* After duplication entry edge now points to new loop head block. - Note down new head as second_head. */ - second_head = entry->dest; - - /* Split loop entry edge and insert new block with cond expr. */ - *condition_bb = lv_adjust_loop_entry_edge (first_head, second_head, entry, - cond_expr); - - latch_edge = EDGE_SUCC (loop->latch->rbi->copy, 0); - - extract_true_false_edges_from_block (*condition_bb, &true_edge, &false_edge); - nloop = loopify (loops, - latch_edge, - EDGE_PRED (loop->header->rbi->copy, 0), - *condition_bb, true_edge, false_edge, - false /* Do not redirect all edges. */); - - exit = loop->single_exit; - if (exit) - nloop->single_exit = find_edge (exit->src->rbi->copy, exit->dest); - - /* loopify redirected latch_edge. Update its PENDING_STMTS. */ - lv_update_pending_stmts (latch_edge); - - /* loopify redirected condition_bb's succ edge. Update its PENDING_STMTS. */ - extract_true_false_edges_from_block (*condition_bb, &true_edge, &false_edge); - lv_update_pending_stmts (false_edge); - - /* Adjust irreducible flag. */ - if (irred_flag) - { - (*condition_bb)->flags |= BB_IRREDUCIBLE_LOOP; - loop_preheader_edge (loop)->flags |= EDGE_IRREDUCIBLE_LOOP; - loop_preheader_edge (nloop)->flags |= EDGE_IRREDUCIBLE_LOOP; - EDGE_PRED ((*condition_bb), 0)->flags |= EDGE_IRREDUCIBLE_LOOP; - } - - /* At this point condition_bb is loop predheader with two successors, - first_head and second_head. Make sure that loop predheader has only - one successor. */ - loop_split_edge_with (loop_preheader_edge (loop), NULL); - loop_split_edge_with (loop_preheader_edge (nloop), NULL); - - return nloop; -}