X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-loop-unswitch.c;h=5b9ba90469c3e4385dc830da481488db83051c18;hb=0378889e03cb5daa8dbca43966085838a7ae5b1c;hp=d0625c52ec955486c067c3dd0bd476ff3a49c195;hpb=c4d867e016d15d83fd56246c31074f7694cbf9e8;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssa-loop-unswitch.c b/gcc/tree-ssa-loop-unswitch.c index d0625c52ec9..5b9ba90469c 100644 --- a/gcc/tree-ssa-loop-unswitch.c +++ b/gcc/tree-ssa-loop-unswitch.c @@ -1,22 +1,21 @@ /* Loop unswitching. - Copyright (C) 2004, 2005 Free Software Foundation, Inc. - + Copyright (C) 2004, 2005, 2007, 2008 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 2, or (at your option) any +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 COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" @@ -33,9 +32,9 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "tree-dump.h" #include "timevar.h" #include "cfgloop.h" -#include "domwalk.h" #include "params.h" #include "tree-pass.h" +#include "tree-inline.h" /* This file implements the loop unswitching, i.e. transformation of loops like @@ -73,38 +72,28 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA tree-ssa-loop-im.c ensures that all the suitable conditions are in this shape. */ -static struct loop *tree_unswitch_loop (struct loops *, struct loop *, basic_block, - tree); -static bool tree_unswitch_single_loop (struct loops *, struct loop *, int); +static struct loop *tree_unswitch_loop (struct loop *, basic_block, tree); +static bool tree_unswitch_single_loop (struct loop *, int); static tree tree_may_unswitch_on (basic_block, struct loop *); -/* Main entry point. Perform loop unswitching on all suitable LOOPS. */ +/* Main entry point. Perform loop unswitching on all suitable loops. */ -void -tree_ssa_unswitch_loops (struct loops *loops) +unsigned int +tree_ssa_unswitch_loops (void) { - int i, num; + loop_iterator li; struct loop *loop; bool changed = false; /* Go through inner loops (only original ones). */ - num = loops->num; - - for (i = 1; i < num; i++) + FOR_EACH_LOOP (li, loop, LI_ONLY_INNERMOST) { - /* Removed loop? */ - loop = loops->parray[i]; - if (!loop) - continue; - - if (loop->inner) - continue; - - changed |= tree_unswitch_single_loop (loops, loop, 0); + changed |= tree_unswitch_single_loop (loop, 0); } if (changed) - cleanup_tree_cfg_loop (); + return TODO_cleanup_cfg; + return 0; } /* Checks whether we can unswitch LOOP on condition at end of BB -- one of its @@ -113,26 +102,29 @@ tree_ssa_unswitch_loops (struct loops *loops) static tree tree_may_unswitch_on (basic_block bb, struct loop *loop) { - tree stmt, def, cond, use; + gimple stmt, def; + tree cond, use; basic_block def_bb; ssa_op_iter iter; /* BB must end in a simple conditional jump. */ stmt = last_stmt (bb); - if (!stmt || TREE_CODE (stmt) != COND_EXPR) + if (!stmt || gimple_code (stmt) != GIMPLE_COND) return NULL_TREE; /* Condition must be invariant. */ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE) { def = SSA_NAME_DEF_STMT (use); - def_bb = bb_for_stmt (def); + def_bb = gimple_bb (def); if (def_bb && flow_bb_inside_loop_p (loop, def_bb)) return NULL_TREE; } - cond = COND_EXPR_COND (stmt); + cond = build2 (gimple_cond_code (stmt), boolean_type_node, + gimple_cond_lhs (stmt), gimple_cond_rhs (stmt)); + /* To keep the things simple, we do not directly remove the conditions, but just replace tests with 0/1. Prevent the infinite loop where we would unswitch again on such a condition. */ @@ -150,14 +142,18 @@ static tree simplify_using_entry_checks (struct loop *loop, tree cond) { edge e = loop_preheader_edge (loop); - tree stmt; + gimple stmt; while (1) { stmt = last_stmt (e->src); if (stmt - && TREE_CODE (stmt) == COND_EXPR - && operand_equal_p (COND_EXPR_COND (stmt), cond, 0)) + && gimple_code (stmt) == GIMPLE_COND + && gimple_cond_code (stmt) == TREE_CODE (cond) + && operand_equal_p (gimple_cond_lhs (stmt), + TREE_OPERAND (cond, 0), 0) + && operand_equal_p (gimple_cond_rhs (stmt), + TREE_OPERAND (cond, 1), 0)) return (e->flags & EDGE_TRUE_VALUE ? boolean_true_node : boolean_false_node); @@ -176,12 +172,13 @@ simplify_using_entry_checks (struct loop *loop, tree cond) grow exponentially. */ static bool -tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) +tree_unswitch_single_loop (struct loop *loop, int num) { basic_block *bbs; struct loop *nloop; unsigned i; - tree cond = NULL_TREE, stmt; + tree cond = NULL_TREE; + gimple stmt; bool changed = false; /* Do not unswitch too much. */ @@ -200,8 +197,16 @@ tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) return false; } + /* Do not unswitch in cold regions. */ + if (optimize_loop_for_size_p (loop)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, ";; Not unswitching cold loops\n"); + return false; + } + /* The loop should not be too large, to limit code growth. */ - if (tree_num_loop_insns (loop) + if (tree_num_loop_insns (loop, &eni_size_weights) > (unsigned) PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS)) { if (dump_file && (dump_flags & TDF_DETAILS)) @@ -211,7 +216,7 @@ tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) i = 0; bbs = get_loop_body (loop); - + while (1) { /* Find a bb to unswitch on. */ @@ -230,13 +235,13 @@ tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) if (integer_nonzerop (cond)) { /* Remove false path. */ - COND_EXPR_COND (stmt) = boolean_true_node; + gimple_cond_set_condition_from_tree (stmt, boolean_true_node); changed = true; } else if (integer_zerop (cond)) { /* Remove true path. */ - COND_EXPR_COND (stmt) = boolean_false_node; + gimple_cond_set_condition_from_tree (stmt, boolean_false_node); changed = true; } else @@ -251,17 +256,22 @@ tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) initialize_original_copy_tables (); /* Unswitch the loop on this condition. */ - nloop = tree_unswitch_loop (loops, loop, bbs[i], cond); + nloop = tree_unswitch_loop (loop, bbs[i], cond); if (!nloop) - return changed; + { + free_original_copy_tables (); + free (bbs); + return changed; + } /* Update the SSA form after unswitching. */ update_ssa (TODO_update_ssa); free_original_copy_tables (); /* Invoke itself on modified loops. */ - tree_unswitch_single_loop (loops, nloop, num + 1); - tree_unswitch_single_loop (loops, loop, num + 1); + tree_unswitch_single_loop (nloop, num + 1); + tree_unswitch_single_loop (loop, num + 1); + free (bbs); return true; } @@ -271,16 +281,20 @@ tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num) if impossible, new loop otherwise. */ static struct loop * -tree_unswitch_loop (struct loops *loops, struct loop *loop, +tree_unswitch_loop (struct loop *loop, basic_block unswitch_on, tree cond) { - basic_block condition_bb; + unsigned prob_true; + edge edge_true, edge_false; /* Some sanity checking. */ gcc_assert (flow_bb_inside_loop_p (loop, unswitch_on)); gcc_assert (EDGE_COUNT (unswitch_on->succs) == 2); gcc_assert (loop->inner == NULL); - return loop_version (loops, loop, unshare_expr (cond), - &condition_bb, false); + extract_true_false_edges_from_block (unswitch_on, &edge_true, &edge_false); + prob_true = edge_true->probability; + return loop_version (loop, unshare_expr (cond), + NULL, prob_true, prob_true, + REG_BR_PROB_BASE - prob_true, false); }