X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-loop.c;h=4b51f403c497febec3c8cb1480373ab4771160c4;hb=156edce8b8b0a57b4b4d361a6413500ac2144984;hp=c35b6a9633c5826d744ad1ef4393b33a1a826bd5;hpb=4ee9c6840ad3fc92a9034343278a1e476ad6872a;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c index c35b6a9633c..4b51f403c49 100644 --- a/gcc/tree-ssa-loop.c +++ b/gcc/tree-ssa-loop.c @@ -1,35 +1,31 @@ /* Loop optimizations over tree-ssa. - Copyright (C) 2003 Free Software Foundation, Inc. - + Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 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 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, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +along with GCC; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" #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 "basic-block.h" #include "tree-flow.h" #include "tree-dump.h" #include "tree-pass.h" @@ -37,329 +33,682 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "cfgloop.h" #include "flags.h" #include "tree-inline.h" +#include "tree-scalar-evolution.h" +#include "diagnostic-core.h" +#include "tree-vectorizer.h" + +/* The loop superpass. */ + +static bool +gate_tree_loop (void) +{ + return flag_tree_loop_optimize != 0; +} + +struct gimple_opt_pass pass_tree_loop = +{ + { + GIMPLE_PASS, + "loop", /* name */ + gate_tree_loop, /* gate */ + NULL, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + TODO_ggc_collect, /* todo_flags_start */ + TODO_dump_func | TODO_verify_ssa | TODO_ggc_collect /* todo_flags_finish */ + } +}; +/* Loop optimizer initialization. */ -/* Check whether we should duplicate HEADER of LOOP. At most *LIMIT - instructions should be duplicated, limit is decreased by the actual - amount. */ +static unsigned int +tree_ssa_loop_init (void) +{ + loop_optimizer_init (LOOPS_NORMAL + | LOOPS_HAVE_RECORDED_EXITS); + rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa); + + if (number_of_loops () <= 1) + return 0; + + scev_initialize (); + return 0; +} + +struct gimple_opt_pass pass_tree_loop_init = +{ + { + GIMPLE_PASS, + "loopinit", /* name */ + NULL, /* gate */ + tree_ssa_loop_init, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_INIT, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* Loop invariant motion pass. */ + +static unsigned int +tree_ssa_loop_im (void) +{ + if (number_of_loops () <= 1) + return 0; + + return tree_ssa_lim (); +} static bool -should_duplicate_loop_header_p (basic_block header, struct loop *loop, - int *limit) -{ - block_stmt_iterator bsi; - tree last; - - /* Do not copy one block more than once (we do not really want to do - loop peeling here). */ - if (header->aux) - return false; - - if (!header->succ) - abort (); - if (!header->succ->succ_next) - return false; - if (header->succ->succ_next->succ_next) - return false; - if (flow_bb_inside_loop_p (loop, header->succ->dest) - && flow_bb_inside_loop_p (loop, header->succ->succ_next->dest)) - return false; - - /* If this is not the original loop header, we want it to have just - one predecessor in order to match the && pattern. */ - if (header != loop->header - && header->pred->pred_next) - return false; - - last = last_stmt (header); - if (TREE_CODE (last) != COND_EXPR) - return false; - - /* Approximately copy the conditions that used to be used in jump.c -- - at most 20 insns and no calls. */ - for (bsi = bsi_start (header); !bsi_end_p (bsi); bsi_next (&bsi)) - { - last = bsi_stmt (bsi); +gate_tree_ssa_loop_im (void) +{ + return flag_tree_loop_im != 0; +} - if (TREE_CODE (last) == LABEL_EXPR) - continue; +struct gimple_opt_pass pass_lim = +{ + { + GIMPLE_PASS, + "lim", /* name */ + gate_tree_ssa_loop_im, /* gate */ + tree_ssa_loop_im, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_LIM, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; - if (get_call_expr_in (last)) - return false; +/* Loop unswitching pass. */ - *limit -= estimate_num_insns (last); - if (*limit < 0) - return false; - } +static unsigned int +tree_ssa_loop_unswitch (void) +{ + if (number_of_loops () <= 1) + return 0; - return true; + return tree_ssa_unswitch_loops (); } -/* Marks variables defined in basic block BB for rewriting. */ +static bool +gate_tree_ssa_loop_unswitch (void) +{ + return flag_unswitch_loops != 0; +} -static void -mark_defs_for_rewrite (basic_block bb) +struct gimple_opt_pass pass_tree_unswitch = { - tree stmt, var; - block_stmt_iterator bsi; - stmt_ann_t ann; - def_optype defs; - vdef_optype vdefs; - vuse_optype vuses; - unsigned i; + { + GIMPLE_PASS, + "unswitch", /* name */ + gate_tree_ssa_loop_unswitch, /* gate */ + tree_ssa_loop_unswitch, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_UNSWITCH, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_ggc_collect | TODO_dump_func /* todo_flags_finish */ + } +}; - for (stmt = phi_nodes (bb); stmt; stmt = TREE_CHAIN (stmt)) - { - var = SSA_NAME_VAR (PHI_RESULT (stmt)); - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - - /* If we have a type_mem_tag, add it as well. Due to rewriting the - variable out of ssa, we lose its name tag, so we use type_mem_tag - instead. */ - var = var_ann (var)->type_mem_tag; - if (var) - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - } +/* Predictive commoning. */ - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - { - stmt = bsi_stmt (bsi); - get_stmt_operands (stmt); - ann = stmt_ann (stmt); - - defs = DEF_OPS (ann); - for (i = 0; i < NUM_DEFS (defs); i++) - { - var = SSA_NAME_VAR (DEF_OP (defs, i)); - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - - /* If we have a type_mem_tag, add it as well. Due to rewriting the - variable out of ssa, we lose its name tag, so we use type_mem_tag - instead. */ - var = var_ann (var)->type_mem_tag; - if (var) - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - } - - vdefs = VDEF_OPS (ann); - for (i = 0; i < NUM_VDEFS (vdefs); i++) - { - var = SSA_NAME_VAR (VDEF_RESULT (vdefs, i)); - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - } - - /* We also need to rewrite vuses, since we will copy the statements - and the ssa versions could not be recovered in the copy. We do - not have to do this for operands of VDEFS explicitly, since - they have the same underlying variable as the results. */ - vuses = VUSE_OPS (ann); - for (i = 0; i < NUM_VUSES (vuses); i++) - { - var = SSA_NAME_VAR (VUSE_OP (vuses, i)); - bitmap_set_bit (vars_to_rename, var_ann (var)->uid); - } - } +static unsigned +run_tree_predictive_commoning (void) +{ + if (!current_loops) + return 0; + + tree_predictive_commoning (); + return 0; } -/* Duplicates destinations of edges in BBS_TO_DUPLICATE. */ +static bool +gate_tree_predictive_commoning (void) +{ + return flag_predictive_commoning != 0; +} -static void -duplicate_blocks (varray_type bbs_to_duplicate) +struct gimple_opt_pass pass_predcom = { - unsigned i; - edge preheader_edge, e, e1; - basic_block header, new_header; - tree phi; - size_t old_num_referenced_vars = num_referenced_vars; + { + GIMPLE_PASS, + "pcom", /* name */ + gate_tree_predictive_commoning, /* gate */ + run_tree_predictive_commoning, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_PREDCOM, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func + | TODO_update_ssa_only_virtuals /* todo_flags_finish */ + } +}; - for (i = 0; i < VARRAY_ACTIVE_SIZE (bbs_to_duplicate); i++) - { - preheader_edge = VARRAY_GENERIC_PTR_NOGC (bbs_to_duplicate, i); - header = preheader_edge->dest; - - /* It is sufficient to rewrite the definitions, since the uses of - the operands defined outside of the duplicated basic block are - still valid (every basic block that dominates the original block - also dominates the duplicate). */ - mark_defs_for_rewrite (header); - } +/* Loop autovectorization. */ - rewrite_vars_out_of_ssa (vars_to_rename); +static unsigned int +tree_vectorize (void) +{ + if (number_of_loops () <= 1) + return 0; - for (i = old_num_referenced_vars; i < num_referenced_vars; i++) - { - bitmap_set_bit (vars_to_rename, i); - var_ann (referenced_var (i))->out_of_ssa_tag = 0; - } + return vectorize_loops (); +} - for (i = 0; i < VARRAY_ACTIVE_SIZE (bbs_to_duplicate); i++) - { - preheader_edge = VARRAY_GENERIC_PTR_NOGC (bbs_to_duplicate, i); - header = preheader_edge->dest; - - /* We might have split the edge into the loop header when we have - eliminated the phi nodes, so find the edge to that we want to - copy the header. */ - while (!header->aux) - { - preheader_edge = header->succ; - header = preheader_edge->dest; - } - header->aux = NULL; - - new_header = duplicate_block (header, preheader_edge); - - /* Add the phi arguments to the outgoing edges. */ - for (e = header->succ; e; e = e->succ_next) - { - for (e1 = new_header->succ; e1->dest != e->dest; e1 = e1->succ_next) - continue; - - for (phi = phi_nodes (e->dest); phi; phi = TREE_CHAIN (phi)) - { - tree def = phi_element_for_edge (phi, e)->def; - add_phi_arg (&phi, def, e1); - } - } - } +static bool +gate_tree_vectorize (void) +{ + return flag_tree_vectorize; } -/* Checks whether LOOP is a do-while style loop. */ +struct gimple_opt_pass pass_vectorize = +{ + { + GIMPLE_PASS, + "vect", /* name */ + gate_tree_vectorize, /* gate */ + tree_vectorize, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_VECTORIZATION, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func | TODO_update_ssa + | TODO_ggc_collect /* todo_flags_finish */ + } +}; + +/* Loop nest optimizations. */ + +static unsigned int +tree_linear_transform (void) +{ + if (number_of_loops () <= 1) + return 0; + + linear_transform_loops (); + return 0; +} static bool -do_while_loop_p (struct loop *loop) +gate_tree_linear_transform (void) { - tree stmt = last_stmt (loop->latch); + return flag_tree_loop_linear != 0; +} + +struct gimple_opt_pass pass_linear_transform = +{ + { + GIMPLE_PASS, + "ltrans", /* name */ + gate_tree_linear_transform, /* gate */ + tree_linear_transform, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LINEAR_TRANSFORM, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func + | TODO_update_ssa_only_virtuals + | TODO_ggc_collect /* todo_flags_finish */ + } +}; + +/* GRAPHITE optimizations. */ - /* If the latch of the loop is not empty, it is not a do-while loop. */ - if (stmt - && TREE_CODE (stmt) != LABEL_EXPR) - return false; +static unsigned int +graphite_transforms (void) +{ + if (!current_loops) + return 0; - /* If the header contains just a condition, it is not a do-while loop. */ - stmt = last_and_only_stmt (loop->header); - if (stmt - && TREE_CODE (stmt) == COND_EXPR) - return false; + graphite_transform_loops (); - return true; + return 0; } -/* For all loops, copy the condition at the end of the loop body in front - of the loop. This is beneficial since it increases effectivity of - code motion optimizations. It also saves one jump on entry to the loop. */ +static bool +gate_graphite_transforms (void) +{ + /* Enable -fgraphite pass if any one of the graphite optimization flags + is turned on. */ + if (flag_loop_block + || flag_loop_interchange + || flag_loop_strip_mine + || flag_graphite_identity + || flag_loop_parallelize_all + || flag_loop_flatten) + flag_graphite = 1; + + return flag_graphite != 0; +} -static void -copy_loop_headers (void) +struct gimple_opt_pass pass_graphite = { - struct loops *loops; - unsigned i; - struct loop *loop; - basic_block header; - edge preheader_edge; - varray_type bbs_to_duplicate = NULL; + { + GIMPLE_PASS, + "graphite0", /* name */ + gate_graphite_transforms, /* gate */ + NULL, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_GRAPHITE, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + 0 /* todo_flags_finish */ + } +}; - loops = loop_optimizer_init (dump_file); - if (!loops) - return; - - /* We are not going to need or update dominators. */ - free_dominance_info (CDI_DOMINATORS); +struct gimple_opt_pass pass_graphite_transforms = +{ + { + GIMPLE_PASS, + "graphite", /* name */ + gate_graphite_transforms, /* gate */ + graphite_transforms, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_GRAPHITE_TRANSFORMS, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + 0 /* todo_flags_finish */ + } +}; - create_preheaders (loops, CP_SIMPLE_PREHEADERS); +/* Check the correctness of the data dependence analyzers. */ - /* We do not try to keep the information about irreductible regions - up-to-date. */ - loops->state &= ~LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS; +static unsigned int +check_data_deps (void) +{ + if (number_of_loops () <= 1) + return 0; -#ifdef ENABLE_CHECKING - verify_loop_structure (loops); -#endif + tree_check_data_deps (); + return 0; +} - for (i = 1; i < loops->num; i++) - { - /* Copy at most 20 insns. */ - int limit = 20; - - loop = loops->parray[i]; - preheader_edge = loop_preheader_edge (loop); - header = preheader_edge->dest; - - /* If the loop is already a do-while style one (either because it was - written as such, or because jump threading transformed it into one), - we might be in fact peeling the first iteration of the loop. This - in general is not a good idea. */ - if (do_while_loop_p (loop)) - continue; - - /* Iterate the header copying up to limit; this takes care of the cases - like while (a && b) {...}, where we want to have both of the conditions - copied. TODO -- handle while (a || b) - like cases, by not requiring - the header to have just a single successor and copying up to - postdominator. - - We do not really copy the blocks immediately, so that we do not have - to worry about updating loop structures, and also so that we do not - have to rewrite variables out of and into ssa form for each block. - Instead we just record the block into worklist and duplicate all of - them at once. */ - while (should_duplicate_loop_header_p (header, loop, &limit)) - { - if (!bbs_to_duplicate) - VARRAY_GENERIC_PTR_NOGC_INIT (bbs_to_duplicate, 10, - "bbs_to_duplicate"); - VARRAY_PUSH_GENERIC_PTR_NOGC (bbs_to_duplicate, preheader_edge); - header->aux = &header->aux; - - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, - "Scheduled basic block %d for duplication.\n", - header->index); - - /* Find a successor of header that is inside a loop; i.e. the new - header after the condition is copied. */ - if (flow_bb_inside_loop_p (loop, header->succ->dest)) - preheader_edge = header->succ; - else - preheader_edge = header->succ->succ_next; - header = preheader_edge->dest; - } - } +static bool +gate_check_data_deps (void) +{ + return flag_check_data_deps != 0; +} + +struct gimple_opt_pass pass_check_data_deps = +{ + { + GIMPLE_PASS, + "ckdd", /* name */ + gate_check_data_deps, /* gate */ + check_data_deps, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_CHECK_DATA_DEPS, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* Canonical induction variable creation pass. */ + +static unsigned int +tree_ssa_loop_ivcanon (void) +{ + if (number_of_loops () <= 1) + return 0; + + return canonicalize_induction_variables (); +} + +static bool +gate_tree_ssa_loop_ivcanon (void) +{ + return flag_tree_loop_ivcanon != 0; +} + +struct gimple_opt_pass pass_iv_canon = +{ + { + GIMPLE_PASS, + "ivcanon", /* name */ + gate_tree_ssa_loop_ivcanon, /* gate */ + tree_ssa_loop_ivcanon, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_IVCANON, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* Propagation of constants using scev. */ + +static bool +gate_scev_const_prop (void) +{ + return flag_tree_scev_cprop; +} + +struct gimple_opt_pass pass_scev_cprop = +{ + { + GIMPLE_PASS, + "sccp", /* name */ + gate_scev_const_prop, /* gate */ + scev_const_prop, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_SCEV_CONST, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func | TODO_cleanup_cfg + | TODO_update_ssa_only_virtuals + /* todo_flags_finish */ + } +}; - loop_optimizer_finalize (loops, NULL); +/* Record bounds on numbers of iterations of loops. */ - if (bbs_to_duplicate) +static unsigned int +tree_ssa_loop_bounds (void) +{ + if (number_of_loops () <= 1) + return 0; + + estimate_numbers_of_iterations (true); + scev_reset (); + return 0; +} + +struct gimple_opt_pass pass_record_bounds = +{ + { + GIMPLE_PASS, + "*record_bounds", /* name */ + NULL, /* gate */ + tree_ssa_loop_bounds, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_BOUNDS, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + 0 /* todo_flags_finish */ + } +}; + +/* Complete unrolling of loops. */ + +static unsigned int +tree_complete_unroll (void) +{ + if (number_of_loops () <= 1) + return 0; + + return tree_unroll_loops_completely (flag_unroll_loops + || flag_peel_loops + || optimize >= 3, true); +} + +static bool +gate_tree_complete_unroll (void) +{ + return true; +} + +struct gimple_opt_pass pass_complete_unroll = +{ + { + GIMPLE_PASS, + "cunroll", /* name */ + gate_tree_complete_unroll, /* gate */ + tree_complete_unroll, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_COMPLETE_UNROLL, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func + | TODO_ggc_collect /* todo_flags_finish */ + } +}; + +/* Complete unrolling of inner loops. */ + +static unsigned int +tree_complete_unroll_inner (void) +{ + unsigned ret = 0; + + loop_optimizer_init (LOOPS_NORMAL + | LOOPS_HAVE_RECORDED_EXITS); + if (number_of_loops () > 1) { - duplicate_blocks (bbs_to_duplicate); - VARRAY_FREE (bbs_to_duplicate); + scev_initialize (); + ret = tree_unroll_loops_completely (optimize >= 3, false); + free_numbers_of_iterations_estimates (); + scev_finalize (); } + loop_optimizer_finalize (); + + return ret; +} - /* Run cleanup_tree_cfg here regardless of whether we have done anything, so - that we cleanup the blocks created in order to get the loops into a - canonical shape. */ - cleanup_tree_cfg (); +static bool +gate_tree_complete_unroll_inner (void) +{ + return optimize >= 2; } +struct gimple_opt_pass pass_complete_unrolli = +{ + { + GIMPLE_PASS, + "cunrolli", /* name */ + gate_tree_complete_unroll_inner, /* gate */ + tree_complete_unroll_inner, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_COMPLETE_UNROLL, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func + | TODO_ggc_collect /* todo_flags_finish */ + } +}; + +/* Parallelization. */ + static bool -gate_ch (void) +gate_tree_parallelize_loops (void) +{ + return flag_tree_parallelize_loops > 1; +} + +static unsigned +tree_parallelize_loops (void) { - return flag_tree_ch != 0; + if (number_of_loops () <= 1) + return 0; + + if (parallelize_loops ()) + return TODO_cleanup_cfg | TODO_rebuild_alias; + return 0; } -struct tree_opt_pass pass_ch = +struct gimple_opt_pass pass_parallelize_loops = { - "ch", /* name */ - gate_ch, /* gate */ - copy_loop_headers, /* execute */ + { + GIMPLE_PASS, + "parloops", /* name */ + gate_tree_parallelize_loops, /* gate */ + tree_parallelize_loops, /* execute */ NULL, /* sub */ NULL, /* next */ 0, /* static_pass_number */ - TV_TREE_CH, /* tv_id */ + TV_TREE_PARALLELIZE_LOOPS, /* tv_id */ PROP_cfg | PROP_ssa, /* properties_required */ 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ - (TODO_rename_vars - | TODO_dump_func - | TODO_verify_ssa) /* todo_flags_finish */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* Prefetching. */ + +static unsigned int +tree_ssa_loop_prefetch (void) +{ + if (number_of_loops () <= 1) + return 0; + + return tree_ssa_prefetch_arrays (); +} + +static bool +gate_tree_ssa_loop_prefetch (void) +{ + return flag_prefetch_loop_arrays > 0; +} + +struct gimple_opt_pass pass_loop_prefetch = +{ + { + GIMPLE_PASS, + "aprefetch", /* name */ + gate_tree_ssa_loop_prefetch, /* gate */ + tree_ssa_loop_prefetch, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_PREFETCH, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* Induction variable optimizations. */ + +static unsigned int +tree_ssa_loop_ivopts (void) +{ + if (number_of_loops () <= 1) + return 0; + + tree_ssa_iv_optimize (); + return 0; +} + +static bool +gate_tree_ssa_loop_ivopts (void) +{ + return flag_ivopts != 0; +} + +struct gimple_opt_pass pass_iv_optimize = +{ + { + GIMPLE_PASS, + "ivopts", /* name */ + gate_tree_ssa_loop_ivopts, /* gate */ + tree_ssa_loop_ivopts, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_IVOPTS, /* tv_id */ + PROP_cfg | PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func | TODO_update_ssa | TODO_ggc_collect /* todo_flags_finish */ + } +}; + +/* Loop optimizer finalization. */ + +static unsigned int +tree_ssa_loop_done (void) +{ + free_numbers_of_iterations_estimates (); + scev_finalize (); + loop_optimizer_finalize (); + return 0; +} + +struct gimple_opt_pass pass_tree_loop_done = +{ + { + GIMPLE_PASS, + "loopdone", /* name */ + NULL, /* gate */ + tree_ssa_loop_done, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_TREE_LOOP_FINI, /* tv_id */ + PROP_cfg, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_cleanup_cfg | TODO_dump_func /* todo_flags_finish */ + } };