/* Loop optimizations over tree-ssa.
- Copyright (C) 2003 Free Software Foundation, Inc.
-
+ Copyright (C) 2003, 2005, 2006, 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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.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"
#include "cfgloop.h"
#include "flags.h"
#include "tree-inline.h"
+#include "tree-scalar-evolution.h"
+#include "toplev.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. */
+
+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;
-/* Check whether we should duplicate HEADER of LOOP. At most *LIMIT
- instructions should be duplicated, limit is decreased by the actual
- amount. */
+ tree_ssa_lim ();
+ return 0;
+}
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;
- v_may_def_optype v_may_defs;
- vuse_optype vuses;
- v_must_def_optype v_must_defs;
- 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);
- }
-
- v_may_defs = V_MAY_DEF_OPS (ann);
- for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
- {
- var = SSA_NAME_VAR (V_MAY_DEF_RESULT (v_may_defs, i));
- bitmap_set_bit (vars_to_rename, var_ann (var)->uid);
- }
-
- v_must_defs = V_MUST_DEF_OPS (ann);
- for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
- {
- var = SSA_NAME_VAR (V_MUST_DEF_OP (v_must_defs, 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 V_MAY_DEFS 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;
+}
- /* 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;
+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 */
+ }
+};
- /* 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 optimizations. */
- return true;
+static unsigned int
+graphite_transforms (void)
+{
+ if (!current_loops)
+ return 0;
+
+ graphite_transform_loops ();
+
+ 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_graphite = 1;
-static void
-copy_loop_headers (void)
+ return flag_graphite != 0;
+}
+
+struct gimple_opt_pass pass_graphite_transforms =
{
- struct loops *loops;
- unsigned i;
- struct loop *loop;
- basic_block header;
- edge preheader_edge;
- varray_type bbs_to_duplicate = NULL;
+ {
+ 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 */
+ }
+};
- loops = loop_optimizer_init (dump_file);
- if (!loops)
- return;
-
- /* We are not going to need or update dominators. */
- free_dominance_info (CDI_DOMINATORS);
+/* Check the correctness of the data dependence analyzers. */
+
+static unsigned int
+check_data_deps (void)
+{
+ if (number_of_loops () <= 1)
+ return 0;
- create_preheaders (loops, CP_SIMPLE_PREHEADERS);
+ tree_check_data_deps ();
+ return 0;
+}
- /* We do not try to keep the information about irreducible regions
- up-to-date. */
- loops->state &= ~LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS;
+static bool
+gate_check_data_deps (void)
+{
+ return flag_check_data_deps != 0;
+}
-#ifdef ENABLE_CHECKING
- verify_loop_structure (loops);
-#endif
+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 */
+ }
+};
- 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;
- }
- }
+/* Canonical induction variable creation pass. */
- loop_optimizer_finalize (loops, NULL);
+static unsigned int
+tree_ssa_loop_ivcanon (void)
+{
+ if (number_of_loops () <= 1)
+ return 0;
- if (bbs_to_duplicate)
+ 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 */
+ }
+};
+
+/* Record bounds on numbers of iterations of loops. */
+
+static unsigned int
+tree_ssa_loop_bounds (void)
+{
+ if (number_of_loops () <= 1)
+ return 0;
+
+ estimate_numbers_of_iterations ();
+ 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_ch != 0;
+ return flag_tree_parallelize_loops > 1;
+}
+
+static unsigned
+tree_parallelize_loops (void)
+{
+ 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 */
+ }
};
OSDN Git Service
