X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-loop-manip.c;h=f6e2e9c937f358e412a63a571e3f6a5fdb3b2240;hb=9e229ec708d7e1c812330cd2eb941b6c4f50bb9c;hp=1ff6254c0b1a36ae83d16aa97a1ed14a7fd05786;hpb=d88fd237e17f1ffbcb915692ea6ef65763838f80;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c index 1ff6254c0b1..f6e2e9c937f 100644 --- a/gcc/tree-ssa-loop-manip.c +++ b/gcc/tree-ssa-loop-manip.c @@ -1,18 +1,19 @@ /* High-level loop manipulation functions. - Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc. - + Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 + Free Software Foundation, Inc. + This file is part of GCC. - + GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. - + GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ @@ -22,12 +23,9 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "tm.h" #include "tree.h" -#include "rtl.h" #include "tm_p.h" -#include "hard-reg-set.h" #include "basic-block.h" #include "output.h" -#include "diagnostic.h" #include "tree-flow.h" #include "tree-dump.h" #include "timevar.h" @@ -37,22 +35,25 @@ along with GCC; see the file COPYING3. If not see #include "tree-scalar-evolution.h" #include "params.h" #include "tree-inline.h" +#include "langhooks.h" /* Creates an induction variable with value BASE + STEP * iteration in LOOP. 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). INCR_POS and + 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). */ void create_iv (tree base, tree step, tree var, struct loop *loop, - block_stmt_iterator *incr_pos, bool after, + gimple_stmt_iterator *incr_pos, bool after, tree *var_before, tree *var_after) { - tree stmt, initial, step1, stmts; + gimple stmt; + tree initial, step1; + gimple_seq stmts; tree vb, va; enum tree_code incr_op = PLUS_EXPR; edge pe = loop_preheader_edge (loop); @@ -63,10 +64,10 @@ create_iv (tree base, tree step, tree var, struct loop *loop, add_referenced_var (var); } - vb = make_ssa_name (var, NULL_TREE); + vb = make_ssa_name (var, NULL); if (var_before) *var_before = vb; - va = make_ssa_name (var, NULL_TREE); + va = make_ssa_name (var, NULL); if (var_after) *var_after = va; @@ -97,34 +98,33 @@ create_iv (tree base, tree step, tree var, struct loop *loop, } if (POINTER_TYPE_P (TREE_TYPE (base))) { - step = fold_convert (sizetype, step); + if (TREE_CODE (base) == ADDR_EXPR) + mark_addressable (TREE_OPERAND (base, 0)); + step = convert_to_ptrofftype (step); if (incr_op == MINUS_EXPR) - step = fold_build1 (NEGATE_EXPR, sizetype, step); + step = fold_build1 (NEGATE_EXPR, TREE_TYPE (step), step); incr_op = POINTER_PLUS_EXPR; } /* 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, NULL_TREE); if (stmts) - bsi_insert_on_edge_immediate (pe, stmts); + gsi_insert_seq_on_edge_immediate (pe, stmts); - stmt = build_gimple_modify_stmt (va, - build2 (incr_op, TREE_TYPE (base), - vb, step)); - SSA_NAME_DEF_STMT (va) = stmt; + stmt = gimple_build_assign_with_ops (incr_op, va, vb, step); if (after) - bsi_insert_after (incr_pos, stmt, BSI_NEW_STMT); + gsi_insert_after (incr_pos, stmt, GSI_NEW_STMT); else - bsi_insert_before (incr_pos, stmt, BSI_NEW_STMT); + gsi_insert_before (incr_pos, stmt, GSI_NEW_STMT); initial = force_gimple_operand (base, &stmts, true, var); if (stmts) - bsi_insert_on_edge_immediate (pe, stmts); + gsi_insert_seq_on_edge_immediate (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), UNKNOWN_LOCATION); + add_phi_arg (stmt, va, loop_latch_edge (loop), UNKNOWN_LOCATION); } /* Add exit phis for the USE on EXIT. */ @@ -132,8 +132,8 @@ create_iv (tree base, tree step, tree var, struct loop *loop, static void add_exit_phis_edge (basic_block exit, tree use) { - tree phi, def_stmt = SSA_NAME_DEF_STMT (use); - basic_block def_bb = bb_for_stmt (def_stmt); + gimple phi, def_stmt = SSA_NAME_DEF_STMT (use); + basic_block def_bb = gimple_bb (def_stmt); struct loop *def_loop; edge e; edge_iterator ei; @@ -151,9 +151,10 @@ 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)); + create_new_def_for (gimple_phi_result (phi), phi, + gimple_phi_result_ptr (phi)); FOR_EACH_EDGE (e, ei, exit->preds) - add_phi_arg (phi, use, e); + add_phi_arg (phi, use, e, UNKNOWN_LOCATION); } /* Add exit phis for VAR that is used in LIVEIN. @@ -164,7 +165,7 @@ add_exit_phis_var (tree var, bitmap livein, bitmap exits) { bitmap def; unsigned index; - basic_block def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (var)); + basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (var)); bitmap_iterator bi; if (is_gimple_reg (var)) @@ -243,7 +244,7 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks, return; ver = SSA_NAME_VERSION (use); - def_bb = bb_for_stmt (SSA_NAME_DEF_STMT (use)); + def_bb = gimple_bb (SSA_NAME_DEF_STMT (use)); if (!def_bb) return; def_loop = def_bb->loop_father; @@ -270,11 +271,14 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks, NEED_PHIS. */ static void -find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks, bitmap need_phis) +find_uses_to_rename_stmt (gimple stmt, bitmap *use_blocks, bitmap need_phis) { ssa_op_iter iter; tree var; - basic_block bb = bb_for_stmt (stmt); + basic_block bb = gimple_bb (stmt); + + if (is_gimple_debug (stmt)) + return; FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES) find_uses_to_rename_use (bb, var, use_blocks, need_phis); @@ -288,20 +292,19 @@ find_uses_to_rename_stmt (tree stmt, bitmap *use_blocks, bitmap need_phis) static void find_uses_to_rename_bb (basic_block bb, bitmap *use_blocks, bitmap need_phis) { - block_stmt_iterator bsi; + gimple_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), + for (bsi = gsi_start_phis (e->dest); !gsi_end_p (bsi); gsi_next (&bsi)) + find_uses_to_rename_use (bb, PHI_ARG_DEF_FROM_EDGE (gsi_stmt (bsi), 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); + + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + find_uses_to_rename_stmt (gsi_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. If CHANGED_BBS is not NULL, @@ -355,7 +358,7 @@ find_uses_to_rename (bitmap changed_bbs, bitmap *use_blocks, bitmap need_phis) 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. - + If CHANGED_BBS is not NULL, we look for uses outside loops only in the basic blocks in this set. @@ -407,14 +410,14 @@ rewrite_into_loop_closed_ssa (bitmap changed_bbs, unsigned update_flag) static void check_loop_closed_ssa_use (basic_block bb, tree use) { - tree def; + gimple def; basic_block def_bb; - + if (TREE_CODE (use) != SSA_NAME || !is_gimple_reg (use)) return; def = SSA_NAME_DEF_STMT (use); - def_bb = bb_for_stmt (def); + def_bb = gimple_bb (def); gcc_assert (!def_bb || flow_bb_inside_loop_p (def_bb->loop_father, bb)); } @@ -422,40 +425,53 @@ check_loop_closed_ssa_use (basic_block bb, tree use) /* Checks invariants of loop closed ssa form in statement STMT in BB. */ static void -check_loop_closed_ssa_stmt (basic_block bb, tree stmt) +check_loop_closed_ssa_stmt (basic_block bb, gimple stmt) { ssa_op_iter iter; tree var; + if (is_gimple_debug (stmt)) + return; + FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_USES) check_loop_closed_ssa_use (bb, var); } -/* Checks that invariants of the loop closed ssa form are preserved. */ +/* Checks that invariants of the loop closed ssa form are preserved. + Call verify_ssa when VERIFY_SSA_P is true. */ -void -verify_loop_closed_ssa (void) +DEBUG_FUNCTION void +verify_loop_closed_ssa (bool verify_ssa_p) { basic_block bb; - block_stmt_iterator bsi; - tree phi; - unsigned i; + gimple_stmt_iterator bsi; + gimple phi; + edge e; + edge_iterator ei; if (number_of_loops () <= 1) return; - verify_ssa (false); + if (verify_ssa_p) + verify_ssa (false); + + timevar_push (TV_VERIFY_LOOP_CLOSED); FOR_EACH_BB (bb) { - 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)); + for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + { + phi = gsi_stmt (bsi); + FOR_EACH_EDGE (e, ei, bb->preds) + check_loop_closed_ssa_use (e->src, + PHI_ARG_DEF_FROM_EDGE (phi, e)); + } - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - check_loop_closed_ssa_stmt (bb, bsi_stmt (bsi)); + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + check_loop_closed_ssa_stmt (bb, gsi_stmt (bsi)); } + + timevar_pop (TV_VERIFY_LOOP_CLOSED); } /* Split loop exit edge EXIT. The things are a bit complicated by a need to @@ -466,12 +482,17 @@ split_loop_exit_edge (edge exit) { basic_block dest = exit->dest; basic_block bb = split_edge (exit); - tree phi, new_phi, new_name, name; + gimple phi, new_phi; + tree new_name, name; use_operand_p op_p; + gimple_stmt_iterator psi; + source_location locus; - for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi)) + for (psi = gsi_start_phis (dest); !gsi_end_p (psi); gsi_next (&psi)) { + phi = gsi_stmt (psi); op_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, single_succ_edge (bb)); + locus = gimple_phi_arg_location_from_edge (phi, single_succ_edge (bb)); name = USE_FROM_PTR (op_p); @@ -485,7 +506,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, locus); SET_USE (op_p, new_name); } @@ -507,7 +528,7 @@ ip_end_pos (struct loop *loop) basic_block ip_normal_pos (struct loop *loop) { - tree last; + gimple last; basic_block bb; edge exit; @@ -517,7 +538,7 @@ ip_normal_pos (struct loop *loop) bb = single_pred (loop->latch); last = last_stmt (bb); if (!last - || TREE_CODE (last) != COND_EXPR) + || gimple_code (last) != GIMPLE_COND) return NULL; exit = EDGE_SUCC (bb, 0); @@ -536,21 +557,21 @@ ip_normal_pos (struct loop *loop) the increment should be inserted after *BSI. */ void -standard_iv_increment_position (struct loop *loop, block_stmt_iterator *bsi, +standard_iv_increment_position (struct loop *loop, gimple_stmt_iterator *bsi, bool *insert_after) { basic_block bb = ip_normal_pos (loop), latch = ip_end_pos (loop); - tree last = last_stmt (latch); + gimple last = last_stmt (latch); if (!bb - || (last && TREE_CODE (last) != LABEL_EXPR)) + || (last && gimple_code (last) != GIMPLE_LABEL)) { - *bsi = bsi_last (latch); + *bsi = gsi_last_bb (latch); *insert_after = true; } else { - *bsi = bsi_last (bb); + *bsi = gsi_last_bb (bb); *insert_after = false; } } @@ -584,7 +605,7 @@ copy_phi_node_args (unsigned first_new_block) after the loop has been duplicated. */ bool -tree_duplicate_loop_to_header_edge (struct loop *loop, edge e, +gimple_duplicate_loop_to_header_edge (struct loop *loop, edge e, unsigned int ndupl, sbitmap wont_exit, edge orig, VEC (edge, heap) **to_remove, int flags) @@ -598,7 +619,7 @@ tree_duplicate_loop_to_header_edge (struct loop *loop, edge e, #ifdef ENABLE_CHECKING if (loops_state_satisfies_p (LOOP_CLOSED_SSA)) - verify_loop_closed_ssa (); + verify_loop_closed_ssa (true); #endif first_new_block = last_basic_block; @@ -673,7 +694,7 @@ determine_exit_conditions (struct loop *loop, struct tree_niter_desc *desc, tree *exit_base, tree *exit_step, enum tree_code *exit_cmp, tree *exit_bound) { - tree stmts; + gimple_seq stmts; tree base = desc->control.base; tree step = desc->control.step; tree bound = desc->bound; @@ -684,7 +705,7 @@ determine_exit_conditions (struct loop *loop, struct tree_niter_desc *desc, enum tree_code cmp = desc->cmp; tree cond = boolean_true_node, assum; - /* For pointers, do the arithmetics in the type of step (sizetype). */ + /* For pointers, do the arithmetics in the type of step. */ base = fold_convert (type, base); bound = fold_convert (type, bound); @@ -748,7 +769,7 @@ determine_exit_conditions (struct loop *loop, struct tree_niter_desc *desc, cond = force_gimple_operand (unshare_expr (cond), &stmts, false, NULL_TREE); if (stmts) - bsi_insert_on_edge_immediate (loop_preheader_edge (loop), stmts); + gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts); /* cond now may be a gimple comparison, which would be OK, but also any other gimple rhs (say a && b). In this case we need to force it to operand. */ @@ -756,16 +777,16 @@ determine_exit_conditions (struct loop *loop, struct tree_niter_desc *desc, { cond = force_gimple_operand (cond, &stmts, true, NULL_TREE); if (stmts) - bsi_insert_on_edge_immediate (loop_preheader_edge (loop), stmts); + gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts); } *enter_cond = cond; base = force_gimple_operand (unshare_expr (base), &stmts, true, NULL_TREE); if (stmts) - bsi_insert_on_edge_immediate (loop_preheader_edge (loop), stmts); + gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts); bound = force_gimple_operand (unshare_expr (bound), &stmts, true, NULL_TREE); if (stmts) - bsi_insert_on_edge_immediate (loop_preheader_edge (loop), stmts); + gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts); *exit_base = base; *exit_step = bigstep; @@ -801,7 +822,7 @@ scale_dominated_blocks_in_loop (struct loop *loop, basic_block bb, If N is number of iterations of the loop and MAY_BE_ZERO is the condition under that loop exits in the first iteration even if N != 0, - + while (1) { x = phi (init, next); @@ -814,7 +835,7 @@ scale_dominated_blocks_in_loop (struct loop *loop, basic_block bb, becomes (with possibly the exit conditions formulated a bit differently, avoiding the need to create a new iv): - + if (MAY_BE_ZERO || N < FACTOR) goto rest; @@ -830,7 +851,7 @@ scale_dominated_blocks_in_loop (struct loop *loop, basic_block bb, pre; post; N -= FACTOR; - + } while (N >= FACTOR); rest: @@ -845,7 +866,7 @@ scale_dominated_blocks_in_loop (struct loop *loop, basic_block bb, break; post; } - + Before the loop is unrolled, TRANSFORM is called for it (only for the unrolled loop, but not for its versioned copy). DATA is passed to TRANSFORM. */ @@ -859,15 +880,18 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, transform_callback transform, void *data) { - tree exit_if, ctr_before, ctr_after; + gimple exit_if; + tree ctr_before, ctr_after; tree enter_main_cond, exit_base, exit_step, exit_bound; enum tree_code exit_cmp; - tree phi_old_loop, phi_new_loop, phi_rest, init, next, new_init, var; + gimple phi_old_loop, phi_new_loop, phi_rest; + gimple_stmt_iterator psi_old_loop, psi_new_loop; + tree init, next, new_init, var; struct loop *new_loop; basic_block rest, exit_bb; edge old_entry, new_entry, old_latch, precond_edge, new_exit; edge new_nonexit, e; - block_stmt_iterator bsi; + gimple_stmt_iterator bsi; use_operand_p op; bool ok; unsigned est_niter, prob_entry, scale_unrolled, scale_rest, freq_e, freq_h; @@ -937,11 +961,12 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, REG_BR_PROB_BASE, REG_BR_PROB_BASE - exit->probability); - bsi = bsi_last (exit_bb); - exit_if = build3 (COND_EXPR, void_type_node, boolean_true_node, - NULL_TREE, NULL_TREE); + bsi = gsi_last_bb (exit_bb); + exit_if = gimple_build_cond (EQ_EXPR, integer_zero_node, + integer_zero_node, + NULL_TREE, NULL_TREE); - bsi_insert_after (&bsi, exit_if, BSI_NEW_STMT); + gsi_insert_after (&bsi, exit_if, GSI_NEW_STMT); new_exit = make_edge (exit_bb, rest, EDGE_FALSE_VALUE | irr); rescan_loop_exit (new_exit, true, false); @@ -962,12 +987,14 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, old_entry = loop_preheader_edge (loop); new_entry = loop_preheader_edge (new_loop); old_latch = loop_latch_edge (loop); - for (phi_old_loop = phi_nodes (loop->header), - phi_new_loop = phi_nodes (new_loop->header); - phi_old_loop; - phi_old_loop = PHI_CHAIN (phi_old_loop), - phi_new_loop = PHI_CHAIN (phi_new_loop)) + for (psi_old_loop = gsi_start_phis (loop->header), + psi_new_loop = gsi_start_phis (new_loop->header); + !gsi_end_p (psi_old_loop); + gsi_next (&psi_old_loop), gsi_next (&psi_new_loop)) { + phi_old_loop = gsi_stmt (psi_old_loop); + phi_new_loop = gsi_stmt (psi_new_loop); + init = PHI_ARG_DEF_FROM_EDGE (phi_old_loop, old_entry); op = PHI_ARG_DEF_PTR_FROM_EDGE (phi_new_loop, new_entry); gcc_assert (operand_equal_for_phi_arg_p (init, USE_FROM_PTR (op))); @@ -976,22 +1003,31 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, /* Prefer using original variable as a base for the new ssa name. This is necessary for virtual ops, and useful in order to avoid losing debug info for real ops. */ - if (TREE_CODE (next) == SSA_NAME) + if (TREE_CODE (next) == SSA_NAME + && useless_type_conversion_p (TREE_TYPE (next), + TREE_TYPE (init))) var = SSA_NAME_VAR (next); - else if (TREE_CODE (init) == SSA_NAME) + else if (TREE_CODE (init) == SSA_NAME + && useless_type_conversion_p (TREE_TYPE (init), + TREE_TYPE (next))) var = SSA_NAME_VAR (init); + else if (useless_type_conversion_p (TREE_TYPE (next), TREE_TYPE (init))) + { + var = create_tmp_var (TREE_TYPE (next), "unrinittmp"); + add_referenced_var (var); + } else { var = create_tmp_var (TREE_TYPE (init), "unrinittmp"); add_referenced_var (var); } - new_init = make_ssa_name (var, NULL_TREE); + new_init = make_ssa_name (var, NULL); phi_rest = create_phi_node (new_init, rest); SSA_NAME_DEF_STMT (new_init) = phi_rest; - add_phi_arg (phi_rest, init, precond_edge); - add_phi_arg (phi_rest, next, new_exit); + add_phi_arg (phi_rest, init, precond_edge, UNKNOWN_LOCATION); + add_phi_arg (phi_rest, next, new_exit, UNKNOWN_LOCATION); SET_USE (op, new_init); } @@ -1007,13 +1043,13 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, sbitmap_ones (wont_exit); RESET_BIT (wont_exit, factor - 1); - ok = tree_duplicate_loop_to_header_edge + ok = gimple_duplicate_loop_to_header_edge (loop, loop_latch_edge (loop), factor - 1, wont_exit, new_exit, &to_remove, DLTHE_FLAG_UPDATE_FREQ); free (wont_exit); gcc_assert (ok); - for (i = 0; VEC_iterate (edge, to_remove, i, e); i++) + FOR_EACH_VEC_ELT (edge, to_remove, i, e) { ok = remove_path (e); gcc_assert (ok); @@ -1049,19 +1085,20 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor, /* Finally create the new counter for number of iterations and add the new exit instruction. */ - bsi = bsi_last (exit_bb); - exit_if = bsi_stmt (bsi); + bsi = gsi_last_nondebug_bb (exit_bb); + exit_if = gsi_stmt (bsi); create_iv (exit_base, exit_step, NULL_TREE, loop, &bsi, false, &ctr_before, &ctr_after); - COND_EXPR_COND (exit_if) = build2 (exit_cmp, boolean_type_node, ctr_after, - exit_bound); + gimple_cond_set_code (exit_if, exit_cmp); + gimple_cond_set_lhs (exit_if, ctr_after); + gimple_cond_set_rhs (exit_if, exit_bound); update_stmt (exit_if); #ifdef ENABLE_CHECKING verify_flow_info (); verify_dominators (CDI_DOMINATORS); verify_loop_structure (); - verify_loop_closed_ssa (); + verify_loop_closed_ssa (true); #endif } @@ -1076,3 +1113,155 @@ tree_unroll_loop (struct loop *loop, unsigned factor, tree_transform_and_unroll_loop (loop, factor, exit, desc, NULL, NULL); } + +/* Rewrite the phi node at position PSI in function of the main + induction variable MAIN_IV and insert the generated code at GSI. */ + +static void +rewrite_phi_with_iv (loop_p loop, + gimple_stmt_iterator *psi, + gimple_stmt_iterator *gsi, + tree main_iv) +{ + affine_iv iv; + gimple stmt, phi = gsi_stmt (*psi); + tree atype, mtype, val, res = PHI_RESULT (phi); + + if (!is_gimple_reg (res) || res == main_iv) + { + gsi_next (psi); + return; + } + + if (!simple_iv (loop, loop, res, &iv, true)) + { + gsi_next (psi); + return; + } + + remove_phi_node (psi, false); + + atype = TREE_TYPE (res); + mtype = POINTER_TYPE_P (atype) ? sizetype : atype; + val = fold_build2 (MULT_EXPR, mtype, unshare_expr (iv.step), + fold_convert (mtype, main_iv)); + val = fold_build2 (POINTER_TYPE_P (atype) + ? POINTER_PLUS_EXPR : PLUS_EXPR, + atype, unshare_expr (iv.base), val); + val = force_gimple_operand_gsi (gsi, val, false, NULL_TREE, true, + GSI_SAME_STMT); + stmt = gimple_build_assign (res, val); + gsi_insert_before (gsi, stmt, GSI_SAME_STMT); + SSA_NAME_DEF_STMT (res) = stmt; +} + +/* Rewrite all the phi nodes of LOOP in function of the main induction + variable MAIN_IV. */ + +static void +rewrite_all_phi_nodes_with_iv (loop_p loop, tree main_iv) +{ + unsigned i; + basic_block *bbs = get_loop_body_in_dom_order (loop); + gimple_stmt_iterator psi; + + for (i = 0; i < loop->num_nodes; i++) + { + basic_block bb = bbs[i]; + gimple_stmt_iterator gsi = gsi_after_labels (bb); + + if (bb->loop_father != loop) + continue; + + for (psi = gsi_start_phis (bb); !gsi_end_p (psi); ) + rewrite_phi_with_iv (loop, &psi, &gsi, main_iv); + } + + free (bbs); +} + +/* Bases all the induction variables in LOOP on a single induction + variable (unsigned with base 0 and step 1), whose final value is + compared with *NIT. When the IV type precision has to be larger + than *NIT type precision, *NIT is converted to the larger type, the + conversion code is inserted before the loop, and *NIT is updated to + the new definition. When BUMP_IN_LATCH is true, the induction + variable is incremented in the loop latch, otherwise it is + incremented in the loop header. Return the induction variable that + was created. */ + +tree +canonicalize_loop_ivs (struct loop *loop, tree *nit, bool bump_in_latch) +{ + unsigned precision = TYPE_PRECISION (TREE_TYPE (*nit)); + unsigned original_precision = precision; + tree type, var_before; + gimple_stmt_iterator gsi, psi; + gimple stmt; + edge exit = single_dom_exit (loop); + gimple_seq stmts; + enum machine_mode mode; + bool unsigned_p = false; + + for (psi = gsi_start_phis (loop->header); + !gsi_end_p (psi); gsi_next (&psi)) + { + gimple phi = gsi_stmt (psi); + tree res = PHI_RESULT (phi); + bool uns; + + type = TREE_TYPE (res); + if (!is_gimple_reg (res) + || (!INTEGRAL_TYPE_P (type) + && !POINTER_TYPE_P (type)) + || TYPE_PRECISION (type) < precision) + continue; + + uns = POINTER_TYPE_P (type) | TYPE_UNSIGNED (type); + + if (TYPE_PRECISION (type) > precision) + unsigned_p = uns; + else + unsigned_p |= uns; + + precision = TYPE_PRECISION (type); + } + + mode = smallest_mode_for_size (precision, MODE_INT); + precision = GET_MODE_PRECISION (mode); + type = build_nonstandard_integer_type (precision, unsigned_p); + + if (original_precision != precision) + { + *nit = fold_convert (type, *nit); + *nit = force_gimple_operand (*nit, &stmts, true, NULL_TREE); + if (stmts) + gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts); + } + + if (bump_in_latch) + gsi = gsi_last_bb (loop->latch); + else + gsi = gsi_last_nondebug_bb (loop->header); + create_iv (build_int_cst_type (type, 0), build_int_cst (type, 1), NULL_TREE, + loop, &gsi, bump_in_latch, &var_before, NULL); + + rewrite_all_phi_nodes_with_iv (loop, var_before); + + stmt = last_stmt (exit->src); + /* Make the loop exit if the control condition is not satisfied. */ + if (exit->flags & EDGE_TRUE_VALUE) + { + edge te, fe; + + extract_true_false_edges_from_block (exit->src, &te, &fe); + te->flags = EDGE_FALSE_VALUE; + fe->flags = EDGE_TRUE_VALUE; + } + gimple_cond_set_code (stmt, LT_EXPR); + gimple_cond_set_lhs (stmt, var_before); + gimple_cond_set_rhs (stmt, *nit); + update_stmt (stmt); + + return var_before; +}