+2014-04-17 Trevor Saunders <tsaunders@mozilla.com>
+
+ * passes.c (opt_pass::execute): Adjust.
+ (pass_manager::execute_pass_mode_switching): Likewise.
+ (early_local_passes::execute): Likewise.
+ (execute_one_pass): Pass cfun to the pass's execute method.
+ * tree-pass.h (opt_pass::execute): Add function * argument.
+ * asan.c, auto-inc-dec.c, bb-reorder.c, bt-load.c, cfgcleanup.c,
+ cfgexpand.c, cfgrtl.c, cgraphbuild.c, combine-stack-adj.c, combine.c,
+ compare-elim.c, config/arc/arc.c, config/epiphany/mode-switch-use.c,
+ config/epiphany/resolve-sw-modes.c, config/i386/i386.c,
+ config/mips/mips.c, config/rl78/rl78.c, config/s390/s390.c,
+ config/sparc/sparc.c, cprop.c, dce.c, df-core.c, dse.c, dwarf2cfi.c,
+ except.c, final.c, function.c, fwprop.c, gcse.c, gimple-low.c,
+ gimple-ssa-isolate-paths.c, gimple-ssa-strength-reduction.c,
+ graphite.c, ifcvt.c, init-regs.c, ipa-cp.c, ipa-devirt.c,
+ ipa-inline-analysis.c, ipa-inline.c, ipa-profile.c, ipa-pure-const.c,
+ ipa-reference.c, ipa-split.c, ipa.c, ira.c, jump.c, loop-init.c,
+ lower-subreg.c, mode-switching.c, omp-low.c, postreload-gcse.c,
+ postreload.c, predict.c, recog.c, ree.c, reg-stack.c, regcprop.c,
+ reginfo.c, regrename.c, reorg.c, sched-rgn.c, stack-ptr-mod.c,
+ store-motion.c, tracer.c, trans-mem.c, tree-call-cdce.c, tree-cfg.c,
+ tree-cfgcleanup.c, tree-complex.c, tree-eh.c, tree-emutls.c,
+ tree-if-conv.c, tree-into-ssa.c, tree-loop-distribution.c, tree-nrv.c,
+ tree-object-size.c, tree-parloops.c, tree-predcom.c, tree-ssa-ccp.c,
+ tree-ssa-copy.c, tree-ssa-copyrename.c, tree-ssa-dce.c,
+ tree-ssa-dom.c, tree-ssa-dse.c, tree-ssa-forwprop.c,
+ tree-ssa-ifcombine.c, tree-ssa-loop-ch.c, tree-ssa-loop-im.c,
+ tree-ssa-loop-ivcanon.c, tree-ssa-loop-prefetch.c,
+ tree-ssa-loop-unswitch.c, tree-ssa-loop.c, tree-ssa-math-opts.c,
+ tree-ssa-phiopt.c, tree-ssa-phiprop.c, tree-ssa-pre.c,
+ tree-ssa-reassoc.c, tree-ssa-sink.c, tree-ssa-strlen.c,
+ tree-ssa-structalias.c, tree-ssa-uncprop.c, tree-ssa-uninit.c,
+ tree-ssa.c, tree-ssanames.c, tree-stdarg.c, tree-switch-conversion.c,
+ tree-tailcall.c, tree-vect-generic.c, tree-vectorizer.c, tree-vrp.c,
+ tree.c, tsan.c, ubsan.c, var-tracking.c, vtable-verify.c, web.c:
+ Adjust.
+
2014-04-17 Trevor Saunders <tsaunders@mozilla.com>
* passes.c (opt_pass::gate): Take function * argument.
/* opt_pass methods: */
opt_pass * clone () { return new pass_asan (m_ctxt); }
virtual bool gate (function *) { return gate_asan (); }
- unsigned int execute () { return asan_instrument (); }
+ virtual unsigned int execute (function *) { return asan_instrument (); }
}; // class pass_asan
/* opt_pass methods: */
virtual bool gate (function *) { return !optimize && gate_asan (); }
- unsigned int execute () { return asan_instrument (); }
+ virtual unsigned int execute (function *) { return asan_instrument (); }
}; // class pass_asan_O0
/* Perform optimization of sanitize functions. */
-static unsigned int
-execute_sanopt (void)
+namespace {
+
+const pass_data pass_data_sanopt =
+{
+ GIMPLE_PASS, /* type */
+ "sanopt", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ ( PROP_ssa | PROP_cfg | PROP_gimple_leh ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_verify_flow | TODO_verify_stmts
+ | TODO_update_ssa ), /* todo_flags_finish */
+};
+
+class pass_sanopt : public gimple_opt_pass
+{
+public:
+ pass_sanopt (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_sanopt, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_sanitize; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_sanopt
+
+unsigned int
+pass_sanopt::execute (function *fun)
{
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
return 0;
}
-namespace {
-
-const pass_data pass_data_sanopt =
-{
- GIMPLE_PASS, /* type */
- "sanopt", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- ( PROP_ssa | PROP_cfg | PROP_gimple_leh ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_verify_flow | TODO_verify_stmts
- | TODO_update_ssa ), /* todo_flags_finish */
-};
-
-class pass_sanopt : public gimple_opt_pass
-{
-public:
- pass_sanopt (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_sanopt, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_sanitize; }
- unsigned int execute () { return execute_sanopt (); }
-
-}; // class pass_sanopt
-
} // anon namespace
gimple_opt_pass *
#endif
-static unsigned int
-rest_of_handle_auto_inc_dec (void)
-{
-#ifdef AUTO_INC_DEC
- basic_block bb;
- int max_reg = max_reg_num ();
-
- if (!initialized)
- init_decision_table ();
-
- mem_tmp = gen_rtx_MEM (Pmode, NULL_RTX);
-
- df_note_add_problem ();
- df_analyze ();
-
- reg_next_use = XCNEWVEC (rtx, max_reg);
- reg_next_inc_use = XCNEWVEC (rtx, max_reg);
- reg_next_def = XCNEWVEC (rtx, max_reg);
- FOR_EACH_BB_FN (bb, cfun)
- merge_in_block (max_reg, bb);
-
- free (reg_next_use);
- free (reg_next_inc_use);
- free (reg_next_def);
-
- mem_tmp = NULL;
-#endif
- return 0;
-}
-
-
/* Discover auto-inc auto-dec instructions. */
namespace {
}
- unsigned int execute () { return rest_of_handle_auto_inc_dec (); }
+ unsigned int execute (function *);
}; // class pass_inc_dec
+unsigned int
+pass_inc_dec::execute (function *fun ATTRIBUTE_UNUSED)
+{
+#ifdef AUTO_INC_DEC
+ basic_block bb;
+ int max_reg = max_reg_num ();
+
+ if (!initialized)
+ init_decision_table ();
+
+ mem_tmp = gen_rtx_MEM (Pmode, NULL_RTX);
+
+ df_note_add_problem ();
+ df_analyze ();
+
+ reg_next_use = XCNEWVEC (rtx, max_reg);
+ reg_next_inc_use = XCNEWVEC (rtx, max_reg);
+ reg_next_def = XCNEWVEC (rtx, max_reg);
+ FOR_EACH_BB_FN (bb, fun)
+ merge_in_block (max_reg, bb);
+
+ free (reg_next_use);
+ free (reg_next_inc_use);
+ free (reg_next_def);
+
+ mem_tmp = NULL;
+#endif
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
}
}
-static unsigned int
-rest_of_handle_reorder_blocks (void)
-{
- basic_block bb;
-
- /* Last attempt to optimize CFG, as scheduling, peepholing and insn
- splitting possibly introduced more crossjumping opportunities. */
- cfg_layout_initialize (CLEANUP_EXPENSIVE);
-
- reorder_basic_blocks ();
- cleanup_cfg (CLEANUP_EXPENSIVE);
-
- FOR_EACH_BB_FN (bb, cfun)
- if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
- bb->aux = bb->next_bb;
- cfg_layout_finalize ();
-
- return 0;
-}
-
namespace {
const pass_data pass_data_reorder_blocks =
&& (flag_reorder_blocks || flag_reorder_blocks_and_partition));
}
- unsigned int execute () { return rest_of_handle_reorder_blocks (); }
+ virtual unsigned int execute (function *);
}; // class pass_reorder_blocks
+unsigned int
+pass_reorder_blocks::execute (function *fun)
+{
+ basic_block bb;
+
+ /* Last attempt to optimize CFG, as scheduling, peepholing and insn
+ splitting possibly introduced more crossjumping opportunities. */
+ cfg_layout_initialize (CLEANUP_EXPENSIVE);
+
+ reorder_basic_blocks ();
+ cleanup_cfg (CLEANUP_EXPENSIVE);
+
+ FOR_EACH_BB_FN (bb, fun)
+ if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun))
+ bb->aux = bb->next_bb;
+ cfg_layout_finalize ();
+
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
which can seriously pessimize code with many computed jumps in the source
code, such as interpreters. See e.g. PR15242. */
+namespace {
-static unsigned int
-duplicate_computed_gotos (void)
+const pass_data pass_data_duplicate_computed_gotos =
+{
+ RTL_PASS, /* type */
+ "compgotos", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_REORDER_BLOCKS, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_rtl_sharing, /* todo_flags_finish */
+};
+
+class pass_duplicate_computed_gotos : public rtl_opt_pass
+{
+public:
+ pass_duplicate_computed_gotos (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *);
+ virtual unsigned int execute (function *);
+
+}; // class pass_duplicate_computed_gotos
+
+bool
+pass_duplicate_computed_gotos::gate (function *fun)
+{
+ if (targetm.cannot_modify_jumps_p ())
+ return false;
+ return (optimize > 0
+ && flag_expensive_optimizations
+ && ! optimize_function_for_size_p (fun));
+}
+
+unsigned int
+pass_duplicate_computed_gotos::execute (function *fun)
{
basic_block bb, new_bb;
bitmap candidates;
int max_size;
bool changed = false;
- if (n_basic_blocks_for_fn (cfun) <= NUM_FIXED_BLOCKS + 1)
+ if (n_basic_blocks_for_fn (fun) <= NUM_FIXED_BLOCKS + 1)
return 0;
clear_bb_flags ();
/* Look for blocks that end in a computed jump, and see if such blocks
are suitable for unfactoring. If a block is a candidate for unfactoring,
mark it in the candidates. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
rtx insn;
edge e;
int size, all_flags;
/* Build the reorder chain for the original order of blocks. */
- if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
+ if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun))
bb->aux = bb->next_bb;
/* Obviously the block has to end in a computed jump. */
goto done;
/* Duplicate computed gotos. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
if (bb->flags & BB_VISITED)
continue;
the exit block or the next block.
The destination must have more than one predecessor. */
if (!single_succ_p (bb)
- || single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun)
+ || single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (fun)
|| single_succ (bb) == bb->next_bb
|| single_pred_p (single_succ (bb)))
continue;
return 0;
}
-namespace {
-
-const pass_data pass_data_duplicate_computed_gotos =
-{
- RTL_PASS, /* type */
- "compgotos", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_REORDER_BLOCKS, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_rtl_sharing, /* todo_flags_finish */
-};
-
-class pass_duplicate_computed_gotos : public rtl_opt_pass
-{
-public:
- pass_duplicate_computed_gotos (gcc::context *ctxt)
- : rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *);
- unsigned int execute () { return duplicate_computed_gotos (); }
-
-}; // class pass_duplicate_computed_gotos
-
-bool
-pass_duplicate_computed_gotos::gate (function *fun)
-{
- if (targetm.cannot_modify_jumps_p ())
- return false;
- return (optimize > 0
- && flag_expensive_optimizations
- && ! optimize_function_for_size_p (fun));
-}
-
} // anon namespace
rtl_opt_pass *
Unconditional branches are dealt with by converting them into
indirect jumps. */
-static unsigned
-partition_hot_cold_basic_blocks (void)
+namespace {
+
+const pass_data pass_data_partition_blocks =
+{
+ RTL_PASS, /* type */
+ "bbpart", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_REORDER_BLOCKS, /* tv_id */
+ PROP_cfglayout, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_partition_blocks : public rtl_opt_pass
+{
+public:
+ pass_partition_blocks (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_partition_blocks, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *);
+ virtual unsigned int execute (function *);
+
+}; // class pass_partition_blocks
+
+bool
+pass_partition_blocks::gate (function *fun)
+{
+ /* The optimization to partition hot/cold basic blocks into separate
+ sections of the .o file does not work well with linkonce or with
+ user defined section attributes. Don't call it if either case
+ arises. */
+ return (flag_reorder_blocks_and_partition
+ && optimize
+ /* See gate_handle_reorder_blocks. We should not partition if
+ we are going to omit the reordering. */
+ && optimize_function_for_speed_p (fun)
+ && !DECL_ONE_ONLY (current_function_decl)
+ && !user_defined_section_attribute);
+}
+
+unsigned
+pass_partition_blocks::execute (function *fun)
{
vec<edge> crossing_edges;
- if (n_basic_blocks_for_fn (cfun) <= NUM_FIXED_BLOCKS + 1)
+ if (n_basic_blocks_for_fn (fun) <= NUM_FIXED_BLOCKS + 1)
return 0;
df_set_flags (DF_DEFER_INSN_RESCAN);
In the meantime, we have no other option but to throw away all
of the DF data and recompute it all. */
- if (cfun->eh->lp_array)
+ if (fun->eh->lp_array)
{
df_finish_pass (true);
df_scan_alloc (NULL);
return TODO_verify_flow | TODO_verify_rtl_sharing;
}
-namespace {
-
-const pass_data pass_data_partition_blocks =
-{
- RTL_PASS, /* type */
- "bbpart", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_REORDER_BLOCKS, /* tv_id */
- PROP_cfglayout, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_partition_blocks : public rtl_opt_pass
-{
-public:
- pass_partition_blocks (gcc::context *ctxt)
- : rtl_opt_pass (pass_data_partition_blocks, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *);
- unsigned int execute () { return partition_hot_cold_basic_blocks (); }
-
-}; // class pass_partition_blocks
-
-bool
-pass_partition_blocks::gate (function *fun)
-{
- /* The optimization to partition hot/cold basic blocks into separate
- sections of the .o file does not work well with linkonce or with
- user defined section attributes. Don't call it if either case
- arises. */
- return (flag_reorder_blocks_and_partition
- && optimize
- /* See gate_handle_reorder_blocks. We should not partition if
- we are going to omit the reordering. */
- && optimize_function_for_speed_p (fun)
- && !DECL_ONE_ONLY (current_function_decl)
- && !user_defined_section_attribute);
-}
-
} // anon namespace
rtl_opt_pass *
}
}
\f
-
-static unsigned int
-rest_of_handle_branch_target_load_optimize1 (void)
-{
- branch_target_load_optimize (epilogue_completed);
- return 0;
-}
-
namespace {
const pass_data pass_data_branch_target_load_optimize1 =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_branch_target_load_optimize; }
- unsigned int execute () {
- return rest_of_handle_branch_target_load_optimize1 ();
- }
+ virtual unsigned int execute (function *)
+ {
+ branch_target_load_optimize (epilogue_completed);
+ return 0;
+ }
}; // class pass_branch_target_load_optimize1
}
-static unsigned int
-rest_of_handle_branch_target_load_optimize2 (void)
-{
- static int warned = 0;
-
- /* Leave this a warning for now so that it is possible to experiment
- with running this pass twice. In 3.6, we should either make this
- an error, or use separate dump files. */
- if (flag_branch_target_load_optimize
- && flag_branch_target_load_optimize2
- && !warned)
- {
- warning (0, "branch target register load optimization is not intended "
- "to be run twice");
-
- warned = 1;
- }
-
- branch_target_load_optimize (epilogue_completed);
- return 0;
-}
-
namespace {
const pass_data pass_data_branch_target_load_optimize2 =
return (optimize > 0 && flag_branch_target_load_optimize2);
}
- unsigned int execute () {
- return rest_of_handle_branch_target_load_optimize2 ();
- }
+ virtual unsigned int execute (function *);
}; // class pass_branch_target_load_optimize2
+unsigned int
+pass_branch_target_load_optimize2::execute (function *)
+{
+ static int warned = 0;
+
+ /* Leave this a warning for now so that it is possible to experiment
+ with running this pass twice. In 3.6, we should either make this
+ an error, or use separate dump files. */
+ if (flag_branch_target_load_optimize
+ && flag_branch_target_load_optimize2
+ && !warned)
+ {
+ warning (0, "branch target register load optimization is not intended "
+ "to be run twice");
+
+ warned = 1;
+ }
+
+ branch_target_load_optimize (epilogue_completed);
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
return changed;
}
\f
-static unsigned int
-execute_jump (void)
-{
- delete_trivially_dead_insns (get_insns (), max_reg_num ());
- if (dump_file)
- dump_flow_info (dump_file, dump_flags);
- cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
- | (flag_thread_jumps ? CLEANUP_THREADING : 0));
- return 0;
-}
-
namespace {
const pass_data pass_data_jump =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_jump (); }
+ virtual unsigned int execute (function *);
}; // class pass_jump
+unsigned int
+pass_jump::execute (function *)
+{
+ delete_trivially_dead_insns (get_insns (), max_reg_num ());
+ if (dump_file)
+ dump_flow_info (dump_file, dump_flags);
+ cleanup_cfg ((optimize ? CLEANUP_EXPENSIVE : 0)
+ | (flag_thread_jumps ? CLEANUP_THREADING : 0));
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
return new pass_jump (ctxt);
}
\f
-static unsigned int
-execute_jump2 (void)
-{
- cleanup_cfg (flag_crossjumping ? CLEANUP_CROSSJUMP : 0);
- return 0;
-}
-
namespace {
const pass_data pass_data_jump2 =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_jump2 (); }
+ virtual unsigned int execute (function *)
+ {
+ cleanup_cfg (flag_crossjumping ? CLEANUP_CROSSJUMP : 0);
+ return 0;
+ }
}; // class pass_jump2
confuse the CFG hooks, so be careful to not manipulate CFG during
the expansion. */
-static unsigned int
-gimple_expand_cfg (void)
+namespace {
+
+const pass_data pass_data_expand =
+{
+ RTL_PASS, /* type */
+ "expand", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_EXPAND, /* tv_id */
+ ( PROP_ssa | PROP_gimple_leh | PROP_cfg
+ | PROP_gimple_lcx
+ | PROP_gimple_lvec ), /* properties_required */
+ PROP_rtl, /* properties_provided */
+ ( PROP_ssa | PROP_trees ), /* properties_destroyed */
+ ( TODO_verify_ssa | TODO_verify_flow
+ | TODO_verify_stmts ), /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_expand : public rtl_opt_pass
+{
+public:
+ pass_expand (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_expand, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_expand
+
+unsigned int
+pass_expand::execute (function *fun)
{
basic_block bb, init_block;
sbitmap blocks;
/* Dominators are not kept up-to-date as we may create new basic-blocks. */
free_dominance_info (CDI_DOMINATORS);
- rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
+ rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
insn_locations_init ();
if (!DECL_IS_BUILTIN (current_function_decl))
{
/* Eventually, all FEs should explicitly set function_start_locus. */
- if (LOCATION_LOCUS (cfun->function_start_locus) == UNKNOWN_LOCATION)
- set_curr_insn_location
- (DECL_SOURCE_LOCATION (current_function_decl));
+ if (LOCATION_LOCUS (fun->function_start_locus) == UNKNOWN_LOCATION)
+ set_curr_insn_location
+ (DECL_SOURCE_LOCATION (current_function_decl));
else
- set_curr_insn_location (cfun->function_start_locus);
+ set_curr_insn_location (fun->function_start_locus);
}
else
set_curr_insn_location (UNKNOWN_LOCATION);
crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
crtl->stack_alignment_estimated = 0;
crtl->preferred_stack_boundary = STACK_BOUNDARY;
- cfun->cfg->max_jumptable_ents = 0;
+ fun->cfg->max_jumptable_ents = 0;
/* Resovle the function section. Some targets, like ARM EABI rely on knowledge
of the function section at exapnsion time to predict distance of calls. */
/* Honor stack protection warnings. */
if (warn_stack_protect)
{
- if (cfun->calls_alloca)
+ if (fun->calls_alloca)
warning (OPT_Wstack_protector,
"stack protector not protecting local variables: "
- "variable length buffer");
+ "variable length buffer");
if (has_short_buffer && !crtl->stack_protect_guard)
warning (OPT_Wstack_protector,
"stack protector not protecting function: "
- "all local arrays are less than %d bytes long",
+ "all local arrays are less than %d bytes long",
(int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
}
gcc_assert (SA.partition_to_pseudo[i]);
/* If this decl was marked as living in multiple places, reset
- this now to NULL. */
+ this now to NULL. */
if (DECL_RTL_IF_SET (var) == pc_rtx)
SET_DECL_RTL (var, NULL);
/* Some RTL parts really want to look at DECL_RTL(x) when x
- was a decl marked in REG_ATTR or MEM_ATTR. We could use
+ was a decl marked in REG_ATTR or MEM_ATTR. We could use
SET_DECL_RTL here making this available, but that would mean
to select one of the potentially many RTLs for one DECL. Instead
of doing that we simply reset the MEM_EXPR of the RTL in question,
/* Clear EDGE_EXECUTABLE on the entry edge(s). It is cleaned from the
remaining edges later. */
- FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)
+ FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs)
e->flags &= ~EDGE_EXECUTABLE;
lab_rtx_for_bb = pointer_map_create ();
- FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (cfun),
+ FOR_BB_BETWEEN (bb, init_block->next_bb, EXIT_BLOCK_PTR_FOR_FN (fun),
next_bb)
bb = expand_gimple_basic_block (bb, var_ret_seq != NULL_RTX);
timevar_push (TV_POST_EXPAND);
/* We are no longer in SSA form. */
- cfun->gimple_df->in_ssa_p = false;
+ fun->gimple_df->in_ssa_p = false;
if (current_loops)
loops_state_clear (LOOP_CLOSED_SSA);
}
/* Zap the tree EH table. */
- set_eh_throw_stmt_table (cfun, NULL);
+ set_eh_throw_stmt_table (fun, NULL);
/* We need JUMP_LABEL be set in order to redirect jumps, and hence
split edges which edge insertions might do. */
rebuild_jump_labels (get_insns ());
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
- EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun),
+ EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
{
edge e;
edge_iterator ei;
rebuild_jump_labels_chain (e->insns.r);
/* Put insns after parm birth, but before
NOTE_INSNS_FUNCTION_BEG. */
- if (e->src == ENTRY_BLOCK_PTR_FOR_FN (cfun)
- && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)))
+ if (e->src == ENTRY_BLOCK_PTR_FOR_FN (fun)
+ && single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (fun)))
{
rtx insns = e->insns.r;
e->insns.r = NULL_RTX;
/* We're done expanding trees to RTL. */
currently_expanding_to_rtl = 0;
- FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
- EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
+ FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (fun)->next_bb,
+ EXIT_BLOCK_PTR_FOR_FN (fun), next_bb)
{
edge e;
edge_iterator ei;
}
}
- blocks = sbitmap_alloc (last_basic_block_for_fn (cfun));
+ blocks = sbitmap_alloc (last_basic_block_for_fn (fun));
bitmap_ones (blocks);
find_many_sub_basic_blocks (blocks);
sbitmap_free (blocks);
/* After initial rtl generation, call back to finish generating
exception support code. We need to do this before cleaning up
the CFG as the code does not expect dead landing pads. */
- if (cfun->eh->region_tree != NULL)
+ if (fun->eh->region_tree != NULL)
finish_eh_generation ();
/* Remove unreachable blocks, otherwise we cannot compute dominators
/* If we're emitting a nested function, make sure its parent gets
emitted as well. Doing otherwise confuses debug info. */
- {
- tree parent;
- for (parent = DECL_CONTEXT (current_function_decl);
- parent != NULL_TREE;
- parent = get_containing_scope (parent))
- if (TREE_CODE (parent) == FUNCTION_DECL)
- TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
- }
+ {
+ tree parent;
+ for (parent = DECL_CONTEXT (current_function_decl);
+ parent != NULL_TREE;
+ parent = get_containing_scope (parent))
+ if (TREE_CODE (parent) == FUNCTION_DECL)
+ TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
+ }
/* We are now committed to emitting code for this function. Do any
preparation, such as emitting abstract debug info for the inline
naked_return_label = NULL;
/* After expanding, the tm_restart map is no longer needed. */
- if (cfun->gimple_df->tm_restart)
+ if (fun->gimple_df->tm_restart)
{
- htab_delete (cfun->gimple_df->tm_restart);
- cfun->gimple_df->tm_restart = NULL;
+ htab_delete (fun->gimple_df->tm_restart);
+ fun->gimple_df->tm_restart = NULL;
}
/* Tag the blocks with a depth number so that change_scope can find
the common parent easily. */
- set_block_levels (DECL_INITIAL (cfun->decl), 0);
+ set_block_levels (DECL_INITIAL (fun->decl), 0);
default_rtl_profile ();
timevar_pop (TV_POST_EXPAND);
return 0;
}
-namespace {
-
-const pass_data pass_data_expand =
-{
- RTL_PASS, /* type */
- "expand", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_EXPAND, /* tv_id */
- ( PROP_ssa | PROP_gimple_leh | PROP_cfg
- | PROP_gimple_lcx
- | PROP_gimple_lvec ), /* properties_required */
- PROP_rtl, /* properties_provided */
- ( PROP_ssa | PROP_trees ), /* properties_destroyed */
- ( TODO_verify_ssa | TODO_verify_flow
- | TODO_verify_stmts ), /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_expand : public rtl_opt_pass
-{
-public:
- pass_expand (gcc::context *ctxt)
- : rtl_opt_pass (pass_data_expand, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return gimple_expand_cfg (); }
-
-}; // class pass_expand
-
} // anon namespace
rtl_opt_pass *
return 0;
}
-static unsigned int
-rest_of_pass_free_cfg (void)
-{
-#ifdef DELAY_SLOTS
- /* The resource.c machinery uses DF but the CFG isn't guaranteed to be
- valid at that point so it would be too late to call df_analyze. */
- if (optimize > 0 && flag_delayed_branch)
- {
- df_note_add_problem ();
- df_analyze ();
- }
-#endif
-
- if (crtl->has_bb_partition)
- insert_section_boundary_note ();
-
- free_bb_for_insn ();
- return 0;
-}
-
namespace {
const pass_data pass_data_free_cfg =
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_pass_free_cfg (); }
+ virtual unsigned int execute (function *);
}; // class pass_free_cfg
+unsigned int
+pass_free_cfg::execute (function *)
+{
+#ifdef DELAY_SLOTS
+ /* The resource.c machinery uses DF but the CFG isn't guaranteed to be
+ valid at that point so it would be too late to call df_analyze. */
+ if (optimize > 0 && flag_delayed_branch)
+ {
+ df_note_add_problem ();
+ df_analyze ();
+ }
+#endif
+
+ if (crtl->has_bb_partition)
+ insert_section_boundary_note ();
+
+ free_bb_for_insn ();
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
cfg_layout_function_footer = unlink_insn_chain (cfg_layout_function_footer, get_last_insn ());
}
\f
-static unsigned int
-into_cfg_layout_mode (void)
-{
- cfg_layout_initialize (0);
- return 0;
-}
-
-static unsigned int
-outof_cfg_layout_mode (void)
-{
- basic_block bb;
-
- FOR_EACH_BB_FN (bb, cfun)
- if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
- bb->aux = bb->next_bb;
-
- cfg_layout_finalize ();
-
- return 0;
-}
-
namespace {
const pass_data pass_data_into_cfg_layout_mode =
{}
/* opt_pass methods: */
- unsigned int execute () { return into_cfg_layout_mode (); }
+ virtual unsigned int execute (function *)
+ {
+ cfg_layout_initialize (0);
+ return 0;
+ }
}; // class pass_into_cfg_layout_mode
{}
/* opt_pass methods: */
- unsigned int execute () { return outof_cfg_layout_mode (); }
+ virtual unsigned int execute (function *);
}; // class pass_outof_cfg_layout_mode
+unsigned int
+pass_outof_cfg_layout_mode::execute (function *fun)
+{
+ basic_block bb;
+
+ FOR_EACH_BB_FN (bb, fun)
+ if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun))
+ bb->aux = bb->next_bb;
+
+ cfg_layout_finalize ();
+
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
/* Create cgraph edges for function calls.
Also look for functions and variables having addresses taken. */
-static unsigned int
-build_cgraph_edges (void)
+namespace {
+
+const pass_data pass_data_build_cgraph_edges =
+{
+ GIMPLE_PASS, /* type */
+ "*build_cgraph_edges", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_cfg, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_build_cgraph_edges : public gimple_opt_pass
+{
+public:
+ pass_build_cgraph_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_cgraph_edges, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_build_cgraph_edges
+
+unsigned int
+pass_build_cgraph_edges::execute (function *fun)
{
basic_block bb;
struct cgraph_node *node = cgraph_get_node (current_function_decl);
/* Create the callgraph edges and record the nodes referenced by the function.
body. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
}
/* Look for initializers of constant variables and private statics. */
- FOR_EACH_LOCAL_DECL (cfun, ix, decl)
+ FOR_EACH_LOCAL_DECL (fun, ix, decl)
if (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
&& !DECL_HAS_VALUE_EXPR_P (decl))
varpool_finalize_decl (decl);
- record_eh_tables (node, cfun);
+ record_eh_tables (node, fun);
pointer_set_destroy (visited_nodes);
return 0;
}
-namespace {
-
-const pass_data pass_data_build_cgraph_edges =
-{
- GIMPLE_PASS, /* type */
- "*build_cgraph_edges", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_cfg, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_build_cgraph_edges : public gimple_opt_pass
-{
-public:
- pass_build_cgraph_edges (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_build_cgraph_edges, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return build_cgraph_edges (); }
-
-}; // class pass_build_cgraph_edges
-
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
opt_pass * clone () { return new pass_rebuild_cgraph_edges (m_ctxt); }
- unsigned int execute () { return rebuild_cgraph_edges (); }
+ virtual unsigned int execute (function *) { return rebuild_cgraph_edges (); }
}; // class pass_rebuild_cgraph_edges
}
-static unsigned int
-remove_cgraph_callee_edges (void)
-{
- struct cgraph_node *node = cgraph_get_node (current_function_decl);
- cgraph_node_remove_callees (node);
- ipa_remove_all_references (&node->ref_list);
- return 0;
-}
-
namespace {
const pass_data pass_data_remove_cgraph_callee_edges =
opt_pass * clone () {
return new pass_remove_cgraph_callee_edges (m_ctxt);
}
- unsigned int execute () { return remove_cgraph_callee_edges (); }
+ virtual unsigned int execute (function *);
}; // class pass_remove_cgraph_callee_edges
+unsigned int
+pass_remove_cgraph_callee_edges::execute (function *)
+{
+ struct cgraph_node *node = cgraph_get_node (current_function_decl);
+ cgraph_node_remove_callees (node);
+ ipa_remove_all_references (&node->ref_list);
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return rest_of_handle_stack_adjustments (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_stack_adjustments ();
+ }
}; // class pass_stack_adjustments
/* opt_pass methods: */
virtual bool gate (function *) { return (optimize > 0); }
- unsigned int execute () { return rest_of_handle_combine (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_combine ();
+ }
}; // class pass_combine
return flag_compare_elim_after_reload;
}
- unsigned int execute () { return execute_compare_elim_after_reload (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_compare_elim_after_reload ();
+ }
}; // class pass_compare_elim_after_reload
/* opt_pass methods: */
opt_pass * clone () { return new pass_arc_ifcvt (m_ctxt); }
- unsigned int execute () { return arc_ifcvt (); }
+ virtual unsigned int execute (function *) { return arc_ifcvt (); }
};
} // anon namespace
{}
/* opt_pass methods: */
- unsigned int execute () { return arc_predicate_delay_insns (); }
+ virtual unsigned int execute (function *)
+ {
+ return arc_predicate_delay_insns ();
+ }
};
} // anon namespace
{}
/* opt_pass methods: */
- unsigned int execute () { return insert_uses (); }
+ virtual unsigned int execute (function *) { return insert_uses (); }
}; // class pass_mode_switch_use
#include "insn-attr-common.h"
#include "tree-pass.h"
+namespace {
+
+const pass_data pass_data_resolve_sw_modes =
+{
+ RTL_PASS, /* type */
+ "resolve_sw_modes", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_MODE_SWITCH, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_df_finish | TODO_verify_rtl_sharing | 0 ), /* todo_flags_finish */
+};
+
+class pass_resolve_sw_modes : public rtl_opt_pass
+{
+public:
+ pass_resolve_sw_modes(gcc::context *ctxt)
+ : rtl_opt_pass(pass_data_resolve_sw_modes, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return optimize; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_resolve_sw_modes
+
/* Clean-up after mode switching:
Check for mode setting insns that have FP_MODE_ROUND_UNKNOWN.
If only one rounding mode is required, select that one.
insert new mode setting insns on the edges where the other mode
becomes unambigous. */
-static unsigned
-resolve_sw_modes (void)
+unsigned
+pass_resolve_sw_modes::execute (function *fun)
{
basic_block bb;
rtx insn, src;
bool need_commit = false;
bool finalize_fp_sets = (MACHINE_FUNCTION (cfun)->unknown_mode_sets == 0);
- todo.create (last_basic_block_for_fn (cfun));
- pushed = sbitmap_alloc (last_basic_block_for_fn (cfun));
+ todo.create (last_basic_block_for_fn (fun));
+ pushed = sbitmap_alloc (last_basic_block_for_fn (fun));
bitmap_clear (pushed);
if (!finalize_fp_sets)
{
df_note_add_problem ();
df_analyze ();
}
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
FOR_BB_INSNS (bb, insn)
{
enum attr_fp_mode selected_mode;
return 0;
}
-namespace {
-
-const pass_data pass_data_resolve_sw_modes =
-{
- RTL_PASS, /* type */
- "resolve_sw_modes", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_MODE_SWITCH, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_df_finish | TODO_verify_rtl_sharing | 0 ), /* todo_flags_finish */
-};
-
-class pass_resolve_sw_modes : public rtl_opt_pass
-{
-public:
- pass_resolve_sw_modes(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_resolve_sw_modes, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return optimize; }
- unsigned int execute () { return resolve_sw_modes (); }
-
-}; // class pass_resolve_sw_modes
-
} // anon namespace
rtl_opt_pass *
return TARGET_AVX && !TARGET_AVX512F && TARGET_VZEROUPPER;
}
- unsigned int execute () { return rest_of_handle_insert_vzeroupper (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_insert_vzeroupper ();
+ }
}; // class pass_insert_vzeroupper
{}
/* opt_pass methods: */
- unsigned int execute () { return mips_machine_reorg2 (); }
+ virtual unsigned int execute (function *) { return mips_machine_reorg2 (); }
}; // class pass_mips_machine_reorg2
return m;
}
-/* Runs the devirtualization pass. */
-static unsigned int
-devirt_pass (void)
-{
- rl78_reorg ();
- return 0;
-}
-
/* This pass converts virtual instructions using virtual registers, to
real instructions using real registers. Rather than run it as
reorg, we reschedule it before vartrack to help with debugging. */
}
/* opt_pass methods: */
- unsigned int execute () { return devirt_pass (); }
+ virtual unsigned int execute (function *)
+ {
+ rl78_reorg ();
+ return 0;
+ }
+
};
} // anon namespace
}
/* opt_pass methods: */
- unsigned int execute () { return move_elim_pass (); }
+ virtual unsigned int execute (function *) { return move_elim_pass (); }
};
} // anon namespace
/* A pass run immediately before shrink-wrapping and prologue and epilogue
generation. */
-static unsigned int
-s390_early_mach (void)
-{
- rtx insn;
-
- /* Try to get rid of the FPR clobbers. */
- s390_optimize_nonescaping_tx ();
-
- /* Re-compute register info. */
- s390_register_info ();
-
- /* If we're using a base register, ensure that it is always valid for
- the first non-prologue instruction. */
- if (cfun->machine->base_reg)
- emit_insn_at_entry (gen_main_pool (cfun->machine->base_reg));
-
- /* Annotate all constant pool references to let the scheduler know
- they implicitly use the base register. */
- for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (INSN_P (insn))
- {
- annotate_constant_pool_refs (&PATTERN (insn));
- df_insn_rescan (insn);
- }
- return 0;
-}
-
namespace {
const pass_data pass_data_s390_early_mach =
{}
/* opt_pass methods: */
- unsigned int execute () { return s390_early_mach (); }
+ virtual unsigned int execute (function *);
}; // class pass_s390_early_mach
+unsigned int
+pass_s390_early_mach::execute (function *fun)
+{
+ rtx insn;
+
+ /* Try to get rid of the FPR clobbers. */
+ s390_optimize_nonescaping_tx ();
+
+ /* Re-compute register info. */
+ s390_register_info ();
+
+ /* If we're using a base register, ensure that it is always valid for
+ the first non-prologue instruction. */
+ if (fun->machine->base_reg)
+ emit_insn_at_entry (gen_main_pool (fun->machine->base_reg));
+
+ /* Annotate all constant pool references to let the scheduler know
+ they implicitly use the base register. */
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ if (INSN_P (insn))
+ {
+ annotate_constant_pool_refs (&PATTERN (insn));
+ df_insn_rescan (insn);
+ }
+ return 0;
+}
+
} // anon namespace
/* Expand the prologue into a bunch of separate insns. */
return sparc_fix_at697f != 0 || sparc_fix_ut699 != 0;
}
- unsigned int execute () { return sparc_do_work_around_errata (); }
+ virtual unsigned int execute (function *)
+ {
+ return sparc_do_work_around_errata ();
+ }
}; // class pass_work_around_errata
&& dbg_cnt (cprop);
}
- unsigned int execute () { return execute_rtl_cprop (); }
+ virtual unsigned int execute (function *) { return execute_rtl_cprop (); }
}; // class pass_rtl_cprop
/* opt_pass methods: */
virtual bool gate (function *) { return optimize > 0; }
- unsigned int execute () { return rest_of_handle_cse (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_cse (); }
}; // class pass_cse
return optimize > 0 && flag_rerun_cse_after_loop;
}
- unsigned int execute () { return rest_of_handle_cse2 (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_cse2 (); }
}; // class pass_cse2
return optimize > 0 && flag_rerun_cse_after_global_opts;
}
- unsigned int execute () {
- return rest_of_handle_cse_after_global_opts ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_cse_after_global_opts ();
+ }
}; // class pass_cse_after_global_opts
return optimize > 1 && flag_dce && dbg_cnt (dce_ud);
}
- unsigned int execute () { return rest_of_handle_ud_dce (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_ud_dce ();
+ }
}; // class pass_ud_rtl_dce
return optimize > 0 && flag_dce && dbg_cnt (dce_fast);
}
- unsigned int execute () { return rest_of_handle_fast_dce (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_fast_dce ();
+ }
}; // class pass_fast_rtl_dce
/* opt_pass methods: */
virtual bool gate (function *) { return optimize > 0; }
- unsigned int execute () { return rest_of_handle_df_initialize (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_df_initialize ();
+ }
}; // class pass_df_initialize_opt
/* opt_pass methods: */
virtual bool gate (function *) { return optimize == 0; }
- unsigned int execute () { return rest_of_handle_df_initialize (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_df_initialize ();
+ }
}; // class pass_df_initialize_no_opt
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_df_finish (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_df_finish ();
+ }
}; // class pass_df_finish
return optimize > 0 && flag_dse && dbg_cnt (dse1);
}
- unsigned int execute () { return rest_of_handle_dse (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_dse (); }
}; // class pass_rtl_dse1
return optimize > 0 && flag_dse && dbg_cnt (dse2);
}
- unsigned int execute () { return rest_of_handle_dse (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_dse (); }
}; // class pass_rtl_dse2
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_dwarf2_frame (); }
+ virtual unsigned int execute (function *) { return execute_dwarf2_frame (); }
}; // class pass_dwarf2_frame
{}
/* opt_pass methods: */
- unsigned int execute () { return set_nothrow_function_flags (); }
+ virtual unsigned int execute (function *)
+ {
+ return set_nothrow_function_flags ();
+ }
}; // class pass_set_nothrow_function_flags
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return convert_to_eh_region_ranges (); }
+ virtual unsigned int execute (function *)
+ {
+ return convert_to_eh_region_ranges ();
+ }
}; // class pass_convert_to_eh_region_ranges
{}
/* opt_pass methods: */
- unsigned int execute () { return compute_alignments (); }
+ virtual unsigned int execute (function *) { return compute_alignments (); }
}; // class pass_compute_alignments
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_final (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_final (); }
}; // class pass_final
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_shorten_branches (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_shorten_branches ();
+ }
}; // class pass_shorten_branches
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_clean_state (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_clean_state ();
+ }
}; // class pass_clean_state
{}
/* opt_pass methods: */
- unsigned int execute () { return instantiate_virtual_regs (); }
+ virtual unsigned int execute (function *)
+ {
+ return instantiate_virtual_regs ();
+ }
}; // class pass_instantiate_virtual_regs
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_check_leaf_regs (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_check_leaf_regs ();
+ }
}; // class pass_leaf_regs
{}
/* opt_pass methods: */
- unsigned int execute () {
- return rest_of_handle_thread_prologue_and_epilogue ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_thread_prologue_and_epilogue ();
+ }
}; // class pass_thread_prologue_and_epilogue
df_insn_rescan (insn);
}
-static unsigned
-rest_of_match_asm_constraints (void)
+namespace {
+
+const pass_data pass_data_match_asm_constraints =
+{
+ RTL_PASS, /* type */
+ "asmcons", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_match_asm_constraints : public rtl_opt_pass
+{
+public:
+ pass_match_asm_constraints (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_match_asm_constraints
+
+unsigned
+pass_match_asm_constraints::execute (function *fun)
{
basic_block bb;
rtx insn, pat, *p_sets;
return 0;
df_set_flags (DF_DEFER_INSN_RESCAN);
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
FOR_BB_INSNS (bb, insn)
{
return TODO_df_finish;
}
-namespace {
-
-const pass_data pass_data_match_asm_constraints =
-{
- RTL_PASS, /* type */
- "asmcons", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_match_asm_constraints : public rtl_opt_pass
-{
-public:
- pass_match_asm_constraints (gcc::context *ctxt)
- : rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return rest_of_match_asm_constraints (); }
-
-}; // class pass_match_asm_constraints
-
} // anon namespace
rtl_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return gate_fwprop (); }
- unsigned int execute () { return fwprop (); }
+ virtual unsigned int execute (function *) { return fwprop (); }
}; // class pass_rtl_fwprop
/* opt_pass methods: */
virtual bool gate (function *) { return gate_fwprop (); }
- unsigned int execute () { return fwprop_addr (); }
+ virtual unsigned int execute (function *) { return fwprop_addr (); }
}; // class pass_rtl_fwprop_addr
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_rtl_pre (); }
+ virtual unsigned int execute (function *) { return execute_rtl_pre (); }
}; // class pass_rtl_pre
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_rtl_hoist (); }
+ virtual unsigned int execute (function *) { return execute_rtl_hoist (); }
}; // class pass_rtl_hoist
{}
/* opt_pass methods: */
- unsigned int execute () { return lower_function_body (); }
+ virtual unsigned int execute (function *) { return lower_function_body (); }
}; // class pass_lower_cf
|| flag_isolate_erroneous_paths_attribute != 0);
}
- unsigned int execute () { return gimple_ssa_isolate_erroneous_paths (); }
+ virtual unsigned int execute (function *)
+ {
+ return gimple_ssa_isolate_erroneous_paths ();
+ }
}; // class pass_isolate_erroneous_paths
}
}
}
-static unsigned
-execute_strength_reduction (void)
+namespace {
+
+const pass_data pass_data_strength_reduction =
+{
+ GIMPLE_PASS, /* type */
+ "slsr", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_GIMPLE_SLSR, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_strength_reduction : public gimple_opt_pass
+{
+public:
+ pass_strength_reduction (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_strength_reduction, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_tree_slsr; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_strength_reduction
+
+unsigned
+pass_strength_reduction::execute (function *fun)
{
/* Create the obstack where candidates will reside. */
gcc_obstack_init (&cand_obstack);
/* Walk the CFG in predominator order looking for strength reduction
candidates. */
find_candidates_dom_walker (CDI_DOMINATORS)
- .walk (cfun->cfg->x_entry_block_ptr);
+ .walk (fun->cfg->x_entry_block_ptr);
if (dump_file && (dump_flags & TDF_DETAILS))
{
return 0;
}
-namespace {
-
-const pass_data pass_data_strength_reduction =
-{
- GIMPLE_PASS, /* type */
- "slsr", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_GIMPLE_SLSR, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_strength_reduction : public gimple_opt_pass
-{
-public:
- pass_strength_reduction (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_strength_reduction, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_slsr; }
- unsigned int execute () { return execute_strength_reduction (); }
-
-}; // class pass_strength_reduction
-
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return gate_graphite_transforms (); }
- unsigned int execute () { return graphite_transforms (); }
+ virtual unsigned int execute (function *) { return graphite_transforms (); }
}; // class pass_graphite_transforms
return (optimize > 0) && dbg_cnt (if_conversion);
}
- unsigned int execute () { return rest_of_handle_if_conversion (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_if_conversion ();
+ }
}; // class pass_rtl_ifcvt
/* Rerun if-conversion, as combine may have simplified things enough
to now meet sequence length restrictions. */
-static unsigned int
-rest_of_handle_if_after_combine (void)
-{
- if_convert (true);
- return 0;
-}
namespace {
&& dbg_cnt (if_after_combine);
}
- unsigned int execute () { return rest_of_handle_if_after_combine (); }
+ virtual unsigned int execute (function *)
+ {
+ if_convert (true);
+ return 0;
+ }
}; // class pass_if_after_combine
}
-static unsigned int
-rest_of_handle_if_after_reload (void)
-{
- if_convert (true);
- return 0;
-}
-
-
namespace {
const pass_data pass_data_if_after_reload =
&& dbg_cnt (if_after_reload);
}
- unsigned int execute () { return rest_of_handle_if_after_reload (); }
+ virtual unsigned int execute (function *)
+ {
+ if_convert (true);
+ return 0;
+ }
}; // class pass_if_after_reload
BITMAP_FREE (already_genned);
}
-static unsigned int
-rest_of_handle_initialize_regs (void)
-{
- initialize_uninitialized_regs ();
- return 0;
-}
-
namespace {
const pass_data pass_data_initialize_regs =
/* opt_pass methods: */
virtual bool gate (function *) { return optimize > 0; }
- unsigned int execute () { return rest_of_handle_initialize_regs (); }
+ virtual unsigned int execute (function *)
+ {
+ initialize_uninitialized_regs ();
+ return 0;
+ }
}; // class pass_initialize_regs
return flag_ipa_cp && optimize;
}
- unsigned int execute () { return ipcp_driver (); }
+ virtual unsigned int execute (function *) { return ipcp_driver (); }
}; // class pass_ipa_cp
&& optimize);
}
- unsigned int execute () { return ipa_devirt (); }
+ virtual unsigned int execute (function *) { return ipa_devirt (); }
}; // class pass_ipa_devirt
/* opt_pass methods: */
opt_pass * clone () { return new pass_inline_parameters (m_ctxt); }
- unsigned int execute () {
- return compute_inline_parameters_for_current ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return compute_inline_parameters_for_current ();
+ }
}; // class pass_inline_parameters
/* Do inlining of small functions. Doing so early helps profiling and other
passes to be somewhat more effective and avoids some code duplication in
later real inlining pass for testcases with very many function calls. */
-static unsigned int
-early_inliner (void)
+
+namespace {
+
+const pass_data pass_data_early_inline =
+{
+ GIMPLE_PASS, /* type */
+ "einline", /* name */
+ OPTGROUP_INLINE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_EARLY_INLINING, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_early_inline : public gimple_opt_pass
+{
+public:
+ pass_early_inline (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_early_inline, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_early_inline
+
+unsigned int
+pass_early_inline::execute (function *fun)
{
struct cgraph_node *node = cgraph_get_node (current_function_decl);
struct cgraph_edge *edge;
timevar_pop (TV_INTEGRATION);
}
- cfun->always_inline_functions_inlined = true;
+ fun->always_inline_functions_inlined = true;
return todo;
}
-namespace {
-
-const pass_data pass_data_early_inline =
-{
- GIMPLE_PASS, /* type */
- "einline", /* name */
- OPTGROUP_INLINE, /* optinfo_flags */
- true, /* has_execute */
- TV_EARLY_INLINING, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_early_inline : public gimple_opt_pass
-{
-public:
- pass_early_inline (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_early_inline, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return early_inliner (); }
-
-}; // class pass_early_inline
-
} // anon namespace
gimple_opt_pass *
{}
/* opt_pass methods: */
- unsigned int execute () { return ipa_inline (); }
+ virtual unsigned int execute (function *) { return ipa_inline (); }
}; // class pass_ipa_inline
/* opt_pass methods: */
virtual bool gate (function *) { return flag_ipa_profile; }
- unsigned int execute () { return ipa_profile (); }
+ virtual unsigned int execute (function *) { return ipa_profile (); }
}; // class pass_ipa_profile
/* opt_pass methods: */
virtual bool gate (function *) { return gate_pure_const (); }
- unsigned int execute () { return propagate (); }
+ virtual unsigned int execute (function *) { return propagate (); }
}; // class pass_ipa_pure_const
ipa_pure_const. This pass is effective when executed together with
other optimization passes in early optimization pass queue. */
-static unsigned int
-local_pure_const (void)
+namespace {
+
+const pass_data pass_data_local_pure_const =
+{
+ GIMPLE_PASS, /* type */
+ "local-pure-const", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_IPA_PURE_CONST, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_local_pure_const : public gimple_opt_pass
+{
+public:
+ pass_local_pure_const (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_local_pure_const, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_local_pure_const (m_ctxt); }
+ virtual bool gate (function *) { return gate_pure_const (); }
+ virtual unsigned int execute (function *);
+
+}; // class pass_local_pure_const
+
+unsigned int
+pass_local_pure_const::execute (function *fun)
{
bool changed = false;
funct_state l;
/* Do NORETURN discovery. */
if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
- && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 0)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
{
- warn_function_noreturn (cfun->decl);
+ warn_function_noreturn (fun->decl);
if (dump_file)
- fprintf (dump_file, "Function found to be noreturn: %s\n",
- current_function_name ());
+ fprintf (dump_file, "Function found to be noreturn: %s\n",
+ current_function_name ());
/* Update declaration and reduce profile to executed once. */
TREE_THIS_VOLATILE (current_function_decl) = 1;
if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
- node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
+ node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
changed = true;
}
return 0;
}
-namespace {
-
-const pass_data pass_data_local_pure_const =
-{
- GIMPLE_PASS, /* type */
- "local-pure-const", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_IPA_PURE_CONST, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_local_pure_const : public gimple_opt_pass
-{
-public:
- pass_local_pure_const (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_local_pure_const, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_local_pure_const (m_ctxt); }
- virtual bool gate (function *) { return gate_pure_const (); }
- unsigned int execute () { return local_pure_const (); }
-
-}; // class pass_local_pure_const
-
} // anon namespace
gimple_opt_pass *
/* Emit noreturn warnings. */
-static unsigned int
-execute_warn_function_noreturn (void)
-{
- if (!TREE_THIS_VOLATILE (current_function_decl)
- && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 0)
- warn_function_noreturn (current_function_decl);
- return 0;
-}
-
namespace {
const pass_data pass_data_warn_function_noreturn =
/* opt_pass methods: */
virtual bool gate (function *) { return warn_suggest_attribute_noreturn; }
- unsigned int execute () { return execute_warn_function_noreturn (); }
+ virtual unsigned int execute (function *fun)
+ {
+ if (!TREE_THIS_VOLATILE (current_function_decl)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
+ warn_function_noreturn (current_function_decl);
+ return 0;
+ }
}; // class pass_warn_function_noreturn
&& !seen_error ());
}
- unsigned int execute () { return propagate (); }
+ virtual unsigned int execute (function *) { return propagate (); }
}; // class pass_ipa_reference
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_split_functions (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_split_functions ();
+ }
}; // class pass_split_functions
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_feedback_split_functions (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_feedback_split_functions ();
+ }
}; // class pass_feedback_split_functions
/* Local function pass handling visibilities. This happens before LTO streaming
so in particular -fwhole-program should be ignored at this level. */
-static unsigned int
-local_function_and_variable_visibility (void)
-{
- return function_and_variable_visibility (flag_whole_program && !flag_lto);
-}
-
namespace {
const pass_data pass_data_ipa_function_and_variable_visibility =
{}
/* opt_pass methods: */
- unsigned int execute () {
- return local_function_and_variable_visibility ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return function_and_variable_visibility (flag_whole_program && !flag_lto);
+ }
}; // class pass_ipa_function_and_variable_visibility
/* Free inline summary. */
-static unsigned
-free_inline_summary (void)
-{
- inline_free_summary ();
- return 0;
-}
-
namespace {
const pass_data pass_data_ipa_free_inline_summary =
{}
/* opt_pass methods: */
- unsigned int execute () { return free_inline_summary (); }
+ virtual unsigned int execute (function *)
+ {
+ inline_free_summary ();
+ return 0;
+ }
}; // class pass_ipa_free_inline_summary
/* Do not re-run on ltrans stage. */
return !flag_ltrans;
}
- unsigned int execute () {
- return whole_program_function_and_variable_visibility ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return whole_program_function_and_variable_visibility ();
+ }
}; // class pass_ipa_whole_program_visibility
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return ipa_cdtor_merge (); }
+ virtual unsigned int execute (function *) { return ipa_cdtor_merge (); }
}; // class pass_ipa_cdtor_merge
}
\f
/* Run the integrated register allocator. */
-static unsigned int
-rest_of_handle_ira (void)
-{
- ira (dump_file);
- return 0;
-}
namespace {
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_ira (); }
+ virtual unsigned int execute (function *)
+ {
+ ira (dump_file);
+ return 0;
+ }
}; // class pass_ira
return new pass_ira (ctxt);
}
-static unsigned int
-rest_of_handle_reload (void)
-{
- do_reload ();
- return 0;
-}
-
namespace {
const pass_data pass_data_reload =
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_reload (); }
+ virtual unsigned int execute (function *)
+ {
+ do_reload ();
+ return 0;
+ }
}; // class pass_reload
{}
/* opt_pass methods: */
- unsigned int execute () { return cleanup_barriers (); }
+ virtual unsigned int execute (function *) { return cleanup_barriers (); }
}; // class pass_cleanup_barriers
{}
/* opt_pass methods: */
- unsigned int execute () { return rtl_loop_init (); }
+ virtual unsigned int execute (function *) { return rtl_loop_init (); }
}; // class pass_rtl_loop_init
\f
/* Finalization of the RTL loop passes. */
-static unsigned int
-rtl_loop_done (void)
-{
- /* No longer preserve loops, remove them now. */
- cfun->curr_properties &= ~PROP_loops;
- loop_optimizer_finalize ();
- free_dominance_info (CDI_DOMINATORS);
-
- cleanup_cfg (0);
- if (dump_file)
- {
- dump_reg_info (dump_file);
- dump_flow_info (dump_file, dump_flags);
- }
-
- return 0;
-}
-
namespace {
const pass_data pass_data_rtl_loop_done =
{}
/* opt_pass methods: */
- unsigned int execute () { return rtl_loop_done (); }
+ virtual unsigned int execute (function *);
}; // class pass_rtl_loop_done
+unsigned int
+pass_rtl_loop_done::execute (function *fun)
+{
+ /* No longer preserve loops, remove them now. */
+ fun->curr_properties &= ~PROP_loops;
+ loop_optimizer_finalize ();
+ free_dominance_info (CDI_DOMINATORS);
+
+ cleanup_cfg (0);
+ if (dump_file)
+ {
+ dump_reg_info (dump_file);
+ dump_flow_info (dump_file, dump_flags);
+ }
+
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
\f
/* Loop invariant code motion. */
-static unsigned int
-rtl_move_loop_invariants (void)
-{
- if (number_of_loops (cfun) > 1)
- move_loop_invariants ();
- return 0;
-}
namespace {
/* opt_pass methods: */
virtual bool gate (function *) { return flag_move_loop_invariants; }
- unsigned int execute () { return rtl_move_loop_invariants (); }
+ virtual unsigned int execute (function *fun)
+ {
+ if (number_of_loops (fun) > 1)
+ move_loop_invariants ();
+ return 0;
+ }
}; // class pass_rtl_move_loop_invariants
}
\f
-static unsigned int
-rtl_unswitch (void)
-{
- if (number_of_loops (cfun) > 1)
- unswitch_loops ();
- return 0;
-}
-
namespace {
const pass_data pass_data_rtl_unswitch =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_unswitch_loops; }
- unsigned int execute () { return rtl_unswitch (); }
+ virtual unsigned int execute (function *fun)
+ {
+ if (number_of_loops (fun) > 1)
+ unswitch_loops ();
+ return 0;
+ }
}; // class pass_rtl_unswitch
}
\f
-static unsigned int
-rtl_unroll_and_peel_loops (void)
-{
- if (number_of_loops (cfun) > 1)
- {
- int flags = 0;
- if (dump_file)
- df_dump (dump_file);
-
- if (flag_peel_loops)
- flags |= UAP_PEEL;
- if (flag_unroll_loops)
- flags |= UAP_UNROLL;
- if (flag_unroll_all_loops)
- flags |= UAP_UNROLL_ALL;
-
- unroll_and_peel_loops (flags);
- }
- return 0;
-}
-
namespace {
const pass_data pass_data_rtl_unroll_and_peel_loops =
return (flag_peel_loops || flag_unroll_loops || flag_unroll_all_loops);
}
- unsigned int execute () { return rtl_unroll_and_peel_loops (); }
+ virtual unsigned int execute (function *);
}; // class pass_rtl_unroll_and_peel_loops
+unsigned int
+pass_rtl_unroll_and_peel_loops::execute (function *fun)
+{
+ if (number_of_loops (fun) > 1)
+ {
+ int flags = 0;
+ if (dump_file)
+ df_dump (dump_file);
+
+ if (flag_peel_loops)
+ flags |= UAP_PEEL;
+ if (flag_unroll_loops)
+ flags |= UAP_UNROLL;
+ if (flag_unroll_all_loops)
+ flags |= UAP_UNROLL_ALL;
+
+ unroll_and_peel_loops (flags);
+ }
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
}
\f
-static unsigned int
-rtl_doloop (void)
-{
-#ifdef HAVE_doloop_end
- if (number_of_loops (cfun) > 1)
- doloop_optimize_loops ();
-#endif
- return 0;
-}
-
namespace {
const pass_data pass_data_rtl_doloop =
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return rtl_doloop (); }
+ virtual unsigned int execute (function *);
}; // class pass_rtl_doloop
#endif
}
+unsigned int
+pass_rtl_doloop::execute (function *fun ATTRIBUTE_UNUSED)
+{
+#ifdef HAVE_doloop_end
+ if (number_of_loops (fun) > 1)
+ doloop_optimize_loops ();
+#endif
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
\f
/* Implement first lower subreg pass. */
-static unsigned int
-rest_of_handle_lower_subreg (void)
-{
- decompose_multiword_subregs (false);
- return 0;
-}
-
-/* Implement second lower subreg pass. */
-
-static unsigned int
-rest_of_handle_lower_subreg2 (void)
-{
- decompose_multiword_subregs (true);
- return 0;
-}
-
namespace {
const pass_data pass_data_lower_subreg =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_split_wide_types != 0; }
- unsigned int execute () { return rest_of_handle_lower_subreg (); }
+ virtual unsigned int execute (function *)
+ {
+ decompose_multiword_subregs (false);
+ return 0;
+ }
}; // class pass_lower_subreg
return new pass_lower_subreg (ctxt);
}
+/* Implement second lower subreg pass. */
+
namespace {
const pass_data pass_data_lower_subreg2 =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_split_wide_types != 0; }
- unsigned int execute () { return rest_of_handle_lower_subreg2 (); }
+ virtual unsigned int execute (function *)
+ {
+ decompose_multiword_subregs (true);
+ return 0;
+ }
}; // class pass_lower_subreg2
#endif /* OPTIMIZE_MODE_SWITCHING */
\f
-static unsigned int
-rest_of_handle_mode_switching (void)
-{
-#ifdef OPTIMIZE_MODE_SWITCHING
- optimize_mode_switching ();
-#endif /* OPTIMIZE_MODE_SWITCHING */
- return 0;
-}
-
-
namespace {
const pass_data pass_data_mode_switching =
#endif
}
- unsigned int execute () { return rest_of_handle_mode_switching (); }
+ virtual unsigned int execute (function *)
+ {
+#ifdef OPTIMIZE_MODE_SWITCHING
+ optimize_mode_switching ();
+#endif /* OPTIMIZE_MODE_SWITCHING */
+ return 0;
+ }
}; // class pass_mode_switching
\f
/* Run instruction scheduler. */
/* Perform SMS module scheduling. */
-static unsigned int
-rest_of_handle_sms (void)
-{
-#ifdef INSN_SCHEDULING
- basic_block bb;
-
- /* Collect loop information to be used in SMS. */
- cfg_layout_initialize (0);
- sms_schedule ();
-
- /* Update the life information, because we add pseudos. */
- max_regno = max_reg_num ();
-
- /* Finalize layout changes. */
- FOR_EACH_BB_FN (bb, cfun)
- if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
- bb->aux = bb->next_bb;
- free_dominance_info (CDI_DOMINATORS);
- cfg_layout_finalize ();
-#endif /* INSN_SCHEDULING */
- return 0;
-}
namespace {
return (optimize > 0 && flag_modulo_sched);
}
- unsigned int execute () { return rest_of_handle_sms (); }
+ virtual unsigned int execute (function *);
}; // class pass_sms
+unsigned int
+pass_sms::execute (function *fun ATTRIBUTE_UNUSED)
+{
+#ifdef INSN_SCHEDULING
+ basic_block bb;
+
+ /* Collect loop information to be used in SMS. */
+ cfg_layout_initialize (0);
+ sms_schedule ();
+
+ /* Update the life information, because we add pseudos. */
+ max_regno = max_reg_num ();
+
+ /* Finalize layout changes. */
+ FOR_EACH_BB_FN (bb, fun)
+ if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (fun))
+ bb->aux = bb->next_bb;
+ free_dominance_info (CDI_DOMINATORS);
+ cfg_layout_finalize ();
+#endif /* INSN_SCHEDULING */
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
|| flag_cilkplus != 0) && !seen_error ());
}
- unsigned int execute () { return execute_expand_omp (); }
+ virtual unsigned int execute (function *) { return execute_expand_omp (); }
}; // class pass_expand_omp
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_lower_omp (); }
+ virtual unsigned int execute (function *) { return execute_lower_omp (); }
}; // class pass_lower_omp
/* opt_pass methods: */
virtual bool gate (function *) { return flag_openmp || flag_cilkplus; }
- unsigned int execute () {
- return diagnose_omp_structured_block_errors ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return diagnose_omp_structured_block_errors ();
+ }
}; // class pass_diagnose_omp_blocks
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return ipa_omp_simd_clone (); }
+ virtual unsigned int execute (function *) { return ipa_omp_simd_clone (); }
};
bool
}
unsigned int
-opt_pass::execute ()
+opt_pass::execute (function *)
{
return 0;
}
unsigned int
pass_manager::execute_pass_mode_switching ()
{
- return pass_mode_switching_1->execute ();
+ return pass_mode_switching_1->execute (cfun);
}
return (!seen_error () && !in_lto_p);
}
- unsigned int execute () { return execute_all_early_local_passes (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_all_early_local_passes ();
+ }
}; // class pass_early_local_passes
/* Do it! */
if (pass->has_execute)
{
- todo_after = pass->execute ();
+ todo_after = pass->execute (cfun);
do_per_function (clear_last_verified, NULL);
}
&& optimize_function_for_speed_p (fun));
}
- unsigned int execute () { return rest_of_handle_gcse2 (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_gcse2 (); }
}; // class pass_gcse2
}
}
\f
-static unsigned int
-rest_of_handle_postreload (void)
-{
- if (!dbg_cnt (postreload_cse))
- return 0;
-
- /* Do a very simple CSE pass over just the hard registers. */
- reload_cse_regs (get_insns ());
- /* Reload_cse_regs can eliminate potentially-trapping MEMs.
- Remove any EH edges associated with them. */
- if (cfun->can_throw_non_call_exceptions
- && purge_all_dead_edges ())
- cleanup_cfg (0);
-
- return 0;
-}
-
namespace {
const pass_data pass_data_postreload_cse =
/* opt_pass methods: */
virtual bool gate (function *) { return (optimize > 0 && reload_completed); }
- unsigned int execute () { return rest_of_handle_postreload (); }
+ virtual unsigned int execute (function *);
}; // class pass_postreload_cse
+unsigned int
+pass_postreload_cse::execute (function *fun)
+{
+ if (!dbg_cnt (postreload_cse))
+ return 0;
+
+ /* Do a very simple CSE pass over just the hard registers. */
+ reload_cse_regs (get_insns ());
+ /* Reload_cse_regs can eliminate potentially-trapping MEMs.
+ Remove any EH edges associated with them. */
+ if (fun->can_throw_non_call_exceptions
+ && purge_all_dead_edges ())
+ cleanup_cfg (0);
+
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
return expr_expected_value_1 (TREE_TYPE (expr),
op0, code, op1, visited, predictor);
}
-
-\f
-/* Get rid of all builtin_expect calls and GIMPLE_PREDICT statements
- we no longer need. */
-static unsigned int
-strip_predict_hints (void)
-{
- basic_block bb;
- gimple ass_stmt;
- tree var;
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- gimple_stmt_iterator bi;
- for (bi = gsi_start_bb (bb); !gsi_end_p (bi);)
- {
- gimple stmt = gsi_stmt (bi);
-
- if (gimple_code (stmt) == GIMPLE_PREDICT)
- {
- gsi_remove (&bi, true);
- continue;
- }
- else if (is_gimple_call (stmt))
- {
- tree fndecl = gimple_call_fndecl (stmt);
-
- if ((fndecl
- && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
- && gimple_call_num_args (stmt) == 2)
- || (gimple_call_internal_p (stmt)
- && gimple_call_internal_fn (stmt) == IFN_BUILTIN_EXPECT))
- {
- var = gimple_call_lhs (stmt);
- if (var)
- {
- ass_stmt
- = gimple_build_assign (var, gimple_call_arg (stmt, 0));
- gsi_replace (&bi, ass_stmt, true);
- }
- else
- {
- gsi_remove (&bi, true);
- continue;
- }
- }
- }
- gsi_next (&bi);
- }
- }
- return 0;
-}
\f
/* Predict using opcode of the last statement in basic block. */
static void
free_dominance_info (CDI_POST_DOMINATORS);
remove_fake_exit_edges ();
}
-
-/* Predict branch probabilities and estimate profile of the tree CFG.
- This is the driver function for PASS_PROFILE. */
-
-static unsigned int
-tree_estimate_probability_driver (void)
-{
- unsigned nb_loops;
-
- loop_optimizer_init (LOOPS_NORMAL);
- if (dump_file && (dump_flags & TDF_DETAILS))
- flow_loops_dump (dump_file, NULL, 0);
-
- mark_irreducible_loops ();
-
- nb_loops = number_of_loops (cfun);
- if (nb_loops > 1)
- scev_initialize ();
-
- tree_estimate_probability ();
-
- if (nb_loops > 1)
- scev_finalize ();
-
- loop_optimizer_finalize ();
- if (dump_file && (dump_flags & TDF_DETAILS))
- gimple_dump_cfg (dump_file, dump_flags);
- if (profile_status_for_fn (cfun) == PROFILE_ABSENT)
- profile_status_for_fn (cfun) = PROFILE_GUESSED;
- return 0;
-}
\f
/* Predict edges to successors of CUR whose sources are not postdominated by
BB by PRED and recurse to all postdominators. */
return predictor_info[predictor].name;
}
+/* Predict branch probabilities and estimate profile of the tree CFG. */
+
namespace {
const pass_data pass_data_profile =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_guess_branch_prob; }
- unsigned int execute () { return tree_estimate_probability_driver (); }
+ virtual unsigned int execute (function *);
}; // class pass_profile
+unsigned int
+pass_profile::execute (function *fun)
+{
+ unsigned nb_loops;
+
+ loop_optimizer_init (LOOPS_NORMAL);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ flow_loops_dump (dump_file, NULL, 0);
+
+ mark_irreducible_loops ();
+
+ nb_loops = number_of_loops (fun);
+ if (nb_loops > 1)
+ scev_initialize ();
+
+ tree_estimate_probability ();
+
+ if (nb_loops > 1)
+ scev_finalize ();
+
+ loop_optimizer_finalize ();
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ gimple_dump_cfg (dump_file, dump_flags);
+ if (profile_status_for_fn (fun) == PROFILE_ABSENT)
+ profile_status_for_fn (fun) = PROFILE_GUESSED;
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
opt_pass * clone () { return new pass_strip_predict_hints (m_ctxt); }
- unsigned int execute () { return strip_predict_hints (); }
+ virtual unsigned int execute (function *);
}; // class pass_strip_predict_hints
+/* Get rid of all builtin_expect calls and GIMPLE_PREDICT statements
+ we no longer need. */
+unsigned int
+pass_strip_predict_hints::execute (function *fun)
+{
+ basic_block bb;
+ gimple ass_stmt;
+ tree var;
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ gimple_stmt_iterator bi;
+ for (bi = gsi_start_bb (bb); !gsi_end_p (bi);)
+ {
+ gimple stmt = gsi_stmt (bi);
+
+ if (gimple_code (stmt) == GIMPLE_PREDICT)
+ {
+ gsi_remove (&bi, true);
+ continue;
+ }
+ else if (is_gimple_call (stmt))
+ {
+ tree fndecl = gimple_call_fndecl (stmt);
+
+ if ((fndecl
+ && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+ && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
+ && gimple_call_num_args (stmt) == 2)
+ || (gimple_call_internal_p (stmt)
+ && gimple_call_internal_fn (stmt) == IFN_BUILTIN_EXPECT))
+ {
+ var = gimple_call_lhs (stmt);
+ if (var)
+ {
+ ass_stmt
+ = gimple_build_assign (var, gimple_call_arg (stmt, 0));
+ gsi_replace (&bi, ass_stmt, true);
+ }
+ else
+ {
+ gsi_remove (&bi, true);
+ continue;
+ }
+ }
+ }
+ gsi_next (&bi);
+ }
+ }
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
a clone method. */
opt_pass * clone () { return new pass_peephole2 (m_ctxt); }
virtual bool gate (function *) { return (optimize > 0 && flag_peephole2); }
- unsigned int execute () { return rest_of_handle_peephole2 (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_peephole2 ();
+ }
}; // class pass_peephole2
return new pass_peephole2 (ctxt);
}
-static unsigned int
-rest_of_handle_split_all_insns (void)
-{
- split_all_insns ();
- return 0;
-}
-
namespace {
const pass_data pass_data_split_all_insns =
/* The epiphany backend creates a second instance of this pass, so
we need a clone method. */
opt_pass * clone () { return new pass_split_all_insns (m_ctxt); }
- unsigned int execute () { return rest_of_handle_split_all_insns (); }
+ virtual unsigned int execute (function *)
+ {
+ split_all_insns ();
+ return 0;
+ }
}; // class pass_split_all_insns
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_split_after_reload (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_split_after_reload ();
+ }
}; // class pass_split_after_reload
return new pass_split_after_reload (ctxt);
}
-static unsigned int
-rest_of_handle_split_before_regstack (void)
-{
- split_all_insns ();
- return 0;
-}
-
namespace {
const pass_data pass_data_split_before_regstack =
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () {
- return rest_of_handle_split_before_regstack ();
- }
+ virtual unsigned int execute (function *)
+ {
+ split_all_insns ();
+ return 0;
+ }
}; // class pass_split_before_regstack
#endif
}
- unsigned int execute () { return rest_of_handle_split_before_sched2 (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_split_before_sched2 ();
+ }
}; // class pass_split_before_sched2
#endif
}
- unsigned int execute () { return split_all_insns_noflow (); }
+ virtual unsigned int execute (function *)
+ {
+ return split_all_insns_noflow ();
+ }
}; // class pass_split_for_shorten_branches
/* opt_pass methods: */
virtual bool gate (function *) { return (optimize > 0 && flag_ree); }
- unsigned int execute () { return rest_of_handle_ree (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_ree (); }
}; // class pass_ree
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_stack_regs (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_stack_regs ();
+ }
}; // class pass_stack_regs_run
return anything_changed;
}
-/* Main entry point for the forward copy propagation optimization. */
-
-static unsigned int
-copyprop_hardreg_forward (void)
-{
- struct value_data *all_vd;
- basic_block bb;
- sbitmap visited;
- bool analyze_called = false;
-
- all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (cfun));
-
- visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
- bitmap_clear (visited);
-
- if (MAY_HAVE_DEBUG_INSNS)
- debug_insn_changes_pool
- = create_alloc_pool ("debug insn changes pool",
- sizeof (struct queued_debug_insn_change), 256);
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- bitmap_set_bit (visited, bb->index);
-
- /* If a block has a single predecessor, that we've already
- processed, begin with the value data that was live at
- the end of the predecessor block. */
- /* ??? Ought to use more intelligent queuing of blocks. */
- if (single_pred_p (bb)
- && bitmap_bit_p (visited, single_pred (bb)->index)
- && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
- {
- all_vd[bb->index] = all_vd[single_pred (bb)->index];
- if (all_vd[bb->index].n_debug_insn_changes)
- {
- unsigned int regno;
-
- for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
- {
- if (all_vd[bb->index].e[regno].debug_insn_changes)
- {
- all_vd[bb->index].e[regno].debug_insn_changes = NULL;
- if (--all_vd[bb->index].n_debug_insn_changes == 0)
- break;
- }
- }
- }
- }
- else
- init_value_data (all_vd + bb->index);
-
- copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
- }
-
- if (MAY_HAVE_DEBUG_INSNS)
- {
- FOR_EACH_BB_FN (bb, cfun)
- if (bitmap_bit_p (visited, bb->index)
- && all_vd[bb->index].n_debug_insn_changes)
- {
- unsigned int regno;
- bitmap live;
-
- if (!analyze_called)
- {
- df_analyze ();
- analyze_called = true;
- }
- live = df_get_live_out (bb);
- for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
- if (all_vd[bb->index].e[regno].debug_insn_changes)
- {
- if (REGNO_REG_SET_P (live, regno))
- apply_debug_insn_changes (all_vd + bb->index, regno);
- if (all_vd[bb->index].n_debug_insn_changes == 0)
- break;
- }
- }
-
- free_alloc_pool (debug_insn_changes_pool);
- }
-
- sbitmap_free (visited);
- free (all_vd);
- return 0;
-}
-
/* Dump the value chain data to stderr. */
DEBUG_FUNCTION void
return (optimize > 0 && (flag_cprop_registers));
}
- unsigned int execute () { return copyprop_hardreg_forward (); }
+ virtual unsigned int execute (function *);
}; // class pass_cprop_hardreg
+unsigned int
+pass_cprop_hardreg::execute (function *fun)
+{
+ struct value_data *all_vd;
+ basic_block bb;
+ sbitmap visited;
+ bool analyze_called = false;
+
+ all_vd = XNEWVEC (struct value_data, last_basic_block_for_fn (fun));
+
+ visited = sbitmap_alloc (last_basic_block_for_fn (fun));
+ bitmap_clear (visited);
+
+ if (MAY_HAVE_DEBUG_INSNS)
+ debug_insn_changes_pool
+ = create_alloc_pool ("debug insn changes pool",
+ sizeof (struct queued_debug_insn_change), 256);
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ bitmap_set_bit (visited, bb->index);
+
+ /* If a block has a single predecessor, that we've already
+ processed, begin with the value data that was live at
+ the end of the predecessor block. */
+ /* ??? Ought to use more intelligent queuing of blocks. */
+ if (single_pred_p (bb)
+ && bitmap_bit_p (visited, single_pred (bb)->index)
+ && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
+ {
+ all_vd[bb->index] = all_vd[single_pred (bb)->index];
+ if (all_vd[bb->index].n_debug_insn_changes)
+ {
+ unsigned int regno;
+
+ for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
+ {
+ if (all_vd[bb->index].e[regno].debug_insn_changes)
+ {
+ all_vd[bb->index].e[regno].debug_insn_changes = NULL;
+ if (--all_vd[bb->index].n_debug_insn_changes == 0)
+ break;
+ }
+ }
+ }
+ }
+ else
+ init_value_data (all_vd + bb->index);
+
+ copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
+ }
+
+ if (MAY_HAVE_DEBUG_INSNS)
+ {
+ FOR_EACH_BB_FN (bb, fun)
+ if (bitmap_bit_p (visited, bb->index)
+ && all_vd[bb->index].n_debug_insn_changes)
+ {
+ unsigned int regno;
+ bitmap live;
+
+ if (!analyze_called)
+ {
+ df_analyze ();
+ analyze_called = true;
+ }
+ live = df_get_live_out (bb);
+ for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
+ if (all_vd[bb->index].e[regno].debug_insn_changes)
+ {
+ if (REGNO_REG_SET_P (live, regno))
+ apply_debug_insn_changes (all_vd + bb->index, regno);
+ if (all_vd[bb->index].n_debug_insn_changes == 0)
+ break;
+ }
+ }
+
+ free_alloc_pool (debug_insn_changes_pool);
+ }
+
+ sbitmap_free (visited);
+ free (all_vd);
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
{}
/* opt_pass methods: */
- unsigned int execute () { return reginfo_init (); }
+ virtual unsigned int execute (function *) { return reginfo_init (); }
}; // class pass_reginfo_init
return (optimize > 0 && (flag_rename_registers));
}
- unsigned int execute () { return regrename_optimize (); }
+ virtual unsigned int execute (function *) { return regrename_optimize (); }
}; // class pass_regrename
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return rest_of_handle_delay_slots (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_delay_slots ();
+ }
}; // class pass_delay_slots
/* Machine dependent reorg pass. */
-static unsigned int
-rest_of_handle_machine_reorg (void)
-{
- targetm.machine_dependent_reorg ();
- return 0;
-}
-
namespace {
const pass_data pass_data_machine_reorg =
return targetm.machine_dependent_reorg != 0;
}
- unsigned int execute () { return rest_of_handle_machine_reorg (); }
+ virtual unsigned int execute (function *)
+ {
+ targetm.machine_dependent_reorg ();
+ return 0;
+ }
}; // class pass_machine_reorg
#endif
}
- unsigned int execute () { return rest_of_handle_live_range_shrinkage (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_live_range_shrinkage ();
+ }
}; // class pass_live_range_shrinkage
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return rest_of_handle_sched (); }
+ virtual unsigned int execute (function *) { return rest_of_handle_sched (); }
}; // class pass_sched
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return rest_of_handle_sched2 (); }
+ virtual unsigned int execute (function *)
+ {
+ return rest_of_handle_sched2 ();
+ }
}; // class pass_sched2
crtl->sp_is_unchanging = 0;
}
-static void
-notice_stack_pointer_modification (void)
-{
- basic_block bb;
- rtx insn;
-
- /* Assume that the stack pointer is unchanging if alloca hasn't
- been used. */
- crtl->sp_is_unchanging = !cfun->calls_alloca;
- if (crtl->sp_is_unchanging)
- FOR_EACH_BB_FN (bb, cfun)
- FOR_BB_INSNS (bb, insn)
- {
- if (INSN_P (insn))
- {
- /* Check if insn modifies the stack pointer. */
- note_stores (PATTERN (insn),
- notice_stack_pointer_modification_1,
- NULL);
- if (! crtl->sp_is_unchanging)
- return;
- }
- }
-
- /* The value coming into this pass was 0, and the exit block uses
- are based on this. If the value is now 1, we need to redo the
- exit block uses. */
- if (df && crtl->sp_is_unchanging)
- df_update_exit_block_uses ();
-}
-
/* Some targets can emit simpler epilogues if they know that sp was
not ever modified during the function. After reload, of course,
we've already emitted the epilogue so there's no sense searching. */
-static unsigned int
-rest_of_handle_stack_ptr_mod (void)
-{
- notice_stack_pointer_modification ();
- return 0;
-}
-
namespace {
const pass_data pass_data_stack_ptr_mod =
{}
/* opt_pass methods: */
- unsigned int execute () { return rest_of_handle_stack_ptr_mod (); }
+ virtual unsigned int execute (function *);
}; // class pass_stack_ptr_mod
+unsigned int
+pass_stack_ptr_mod::execute (function *fun)
+{
+ basic_block bb;
+ rtx insn;
+
+ /* Assume that the stack pointer is unchanging if alloca hasn't
+ been used. */
+ crtl->sp_is_unchanging = !fun->calls_alloca;
+ if (crtl->sp_is_unchanging)
+ FOR_EACH_BB_FN (bb, fun)
+ FOR_BB_INSNS (bb, insn)
+ {
+ if (INSN_P (insn))
+ {
+ /* Check if insn modifies the stack pointer. */
+ note_stores (PATTERN (insn),
+ notice_stack_pointer_modification_1,
+ NULL);
+ if (! crtl->sp_is_unchanging)
+ return 0;
+ }
+ }
+
+ /* The value coming into this pass was 0, and the exit block uses
+ are based on this. If the value is now 1, we need to redo the
+ exit block uses. */
+ if (df && crtl->sp_is_unchanging)
+ df_update_exit_block_uses ();
+
+ return 0;
+}
+
} // anon namespace
rtl_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return execute_rtl_store_motion (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_rtl_store_motion ();
+ }
}; // class pass_rtl_store_motion
}
-static unsigned int
-execute_dumb_plugin_example (void)
-{
- warning (0, G_("Analyze function %s"),
- IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
- return 0;
-}
-
namespace {
const pass_data pass_data_dumb_plugin_example =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_dumb_plugin_example (); }
+ virtual unsigned int execute (function *);
}; // class pass_dumb_plugin_example
+unsigned int
+pass_dumb_plugin_example::execute (function *)
+{
+ warning (0, G_("Analyze function %s"),
+ IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
+ return 0;
+}
+
} // anon namespace
static gimple_opt_pass *
}
}
-/* Entry point for the self-assignment detection pass. */
-
-static unsigned int
-execute_warn_self_assign (void)
-{
- gimple_stmt_iterator gsi;
- basic_block bb;
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- warn_self_assign (gsi_stmt (gsi));
- }
-
- return 0;
-}
-
namespace {
const pass_data pass_data_warn_self_assign =
/* opt_pass methods: */
bool gate (function *) { return true; }
- unsigned int execute () { return execute_warn_self_assign (); }
+ virtual unsigned int execute (function *);
}; // class pass_warn_self_assign
+unsigned int
+pass_warn_self_assign::execute (function *fun)
+{
+ gimple_stmt_iterator gsi;
+ basic_block bb;
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ warn_self_assign (gsi_stmt (gsi));
+ }
+
+ return 0;
+}
+
} // anon namespace
static gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute ();
+ virtual unsigned int execute (function *);
private:
int counter;
return true;
}
-unsigned int one_pass::execute ()
+unsigned int
+one_pass::execute (function *)
{
if (counter > 0) {
printf ("Executed more than once \n");
}
}
-/* Entry point for the self-assignment detection pass. */
-
-static unsigned int
-execute_warn_self_assign (void)
-{
- gimple_stmt_iterator gsi;
- basic_block bb;
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- warn_self_assign (gsi_stmt (gsi));
- }
-
- return 0;
-}
-
namespace {
const pass_data pass_data_warn_self_assign =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_warn_self_assign (); }
+ virtual unsigned int execute (function *);
}; // class pass_warn_self_assign
+unsigned int
+pass_warn_self_assign::execute (function *fun)
+{
+ gimple_stmt_iterator gsi;
+ basic_block bb;
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ warn_self_assign (gsi_stmt (gsi));
+ }
+
+ return 0;
+}
+
} // anon namespace
static gimple_opt_pass *
return changed;
}
-
-/* Main entry point to this file. */
-
-static unsigned int
-tracer (void)
-{
- bool changed;
-
- if (n_basic_blocks_for_fn (cfun) <= NUM_FIXED_BLOCKS + 1)
- return 0;
-
- mark_dfs_back_edges ();
- if (dump_file)
- brief_dump_cfg (dump_file, dump_flags);
-
- /* Trace formation is done on the fly inside tail_duplicate */
- changed = tail_duplicate ();
- if (changed)
- {
- free_dominance_info (CDI_DOMINATORS);
- /* If we changed the CFG schedule loops for fixup by cleanup_cfg. */
- if (current_loops)
- loops_state_set (LOOPS_NEED_FIXUP);
- }
-
- if (dump_file)
- brief_dump_cfg (dump_file, dump_flags);
-
- return changed ? TODO_cleanup_cfg : 0;
-}
\f
namespace {
return (optimize > 0 && flag_tracer && flag_reorder_blocks);
}
- unsigned int execute () { return tracer (); }
+ virtual unsigned int execute (function *);
}; // class pass_tracer
+unsigned int
+pass_tracer::execute (function *fun)
+{
+ bool changed;
+
+ if (n_basic_blocks_for_fn (fun) <= NUM_FIXED_BLOCKS + 1)
+ return 0;
+
+ mark_dfs_back_edges ();
+ if (dump_file)
+ brief_dump_cfg (dump_file, dump_flags);
+
+ /* Trace formation is done on the fly inside tail_duplicate */
+ changed = tail_duplicate ();
+ if (changed)
+ {
+ free_dominance_info (CDI_DOMINATORS);
+ /* If we changed the CFG schedule loops for fixup by cleanup_cfg. */
+ if (current_loops)
+ loops_state_set (LOOPS_NEED_FIXUP);
+ }
+
+ if (dump_file)
+ brief_dump_cfg (dump_file, dump_flags);
+
+ return changed ? TODO_cleanup_cfg : 0;
+}
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tm; }
- unsigned int execute () { return diagnose_tm_blocks (); }
+ virtual unsigned int execute (function *) { return diagnose_tm_blocks (); }
}; // class pass_diagnose_tm_blocks
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tm; }
- unsigned int execute () { return execute_lower_tm (); }
+ virtual unsigned int execute (function *) { return execute_lower_tm (); }
}; // class pass_lower_tm
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_tm_mark (); }
+ virtual unsigned int execute (function *) { return execute_tm_mark (); }
}; // class pass_tm_mark
/* Entry point to the final expansion of transactional nodes. */
-static unsigned int
-execute_tm_edges (void)
-{
- vec<tm_region_p> bb_regions
- = get_bb_regions_instrumented (/*traverse_clones=*/false,
- /*include_uninstrumented_p=*/true);
- struct tm_region *r;
- unsigned i;
-
- FOR_EACH_VEC_ELT (bb_regions, i, r)
- if (r != NULL)
- expand_block_edges (r, BASIC_BLOCK_FOR_FN (cfun, i));
-
- bb_regions.release ();
-
- /* We've got to release the dominance info now, to indicate that it
- must be rebuilt completely. Otherwise we'll crash trying to update
- the SSA web in the TODO section following this pass. */
- free_dominance_info (CDI_DOMINATORS);
- bitmap_obstack_release (&tm_obstack);
- all_tm_regions = NULL;
-
- return 0;
-}
-
namespace {
const pass_data pass_data_tm_edges =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_tm_edges (); }
+ virtual unsigned int execute (function *);
}; // class pass_tm_edges
+unsigned int
+pass_tm_edges::execute (function *fun)
+{
+ vec<tm_region_p> bb_regions
+ = get_bb_regions_instrumented (/*traverse_clones=*/false,
+ /*include_uninstrumented_p=*/true);
+ struct tm_region *r;
+ unsigned i;
+
+ FOR_EACH_VEC_ELT (bb_regions, i, r)
+ if (r != NULL)
+ expand_block_edges (r, BASIC_BLOCK_FOR_FN (fun, i));
+
+ bb_regions.release ();
+
+ /* We've got to release the dominance info now, to indicate that it
+ must be rebuilt completely. Otherwise we'll crash trying to update
+ the SSA web in the TODO section following this pass. */
+ free_dominance_info (CDI_DOMINATORS);
+ bitmap_obstack_release (&tm_obstack);
+ all_tm_regions = NULL;
+
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tm && optimize > 0; }
- unsigned int execute () { return execute_tm_memopt (); }
+ virtual unsigned int execute (function *) { return execute_tm_memopt (); }
}; // class pass_tm_memopt
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tm; }
- unsigned int execute () { return ipa_tm_execute (); }
+ virtual unsigned int execute (function *) { return ipa_tm_execute (); }
}; // class pass_ipa_tm
return changed;
}
-/* Pass entry points. */
+namespace {
+
+const pass_data pass_data_call_cdce =
+{
+ GIMPLE_PASS, /* type */
+ "cdce", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_CALL_CDCE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_call_cdce : public gimple_opt_pass
+{
+public:
+ pass_call_cdce (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_call_cdce, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *fun)
+ {
+ /* The limit constants used in the implementation
+ assume IEEE floating point format. Other formats
+ can be supported in the future if needed. */
+ return flag_tree_builtin_call_dce != 0
+ && optimize_function_for_speed_p (fun);
+ }
-static unsigned int
-tree_call_cdce (void)
+ virtual unsigned int execute (function *);
+
+}; // class pass_call_cdce
+
+unsigned int
+pass_call_cdce::execute (function *fun)
{
basic_block bb;
gimple_stmt_iterator i;
bool something_changed = false;
auto_vec<gimple> cond_dead_built_in_calls;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
/* Collect dead call candidates. */
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
free_dominance_info (CDI_POST_DOMINATORS);
/* As we introduced new control-flow we need to insert PHI-nodes
for the call-clobbers of the remaining call. */
- mark_virtual_operands_for_renaming (cfun);
+ mark_virtual_operands_for_renaming (fun);
return TODO_update_ssa;
}
return 0;
}
-namespace {
-
-const pass_data pass_data_call_cdce =
-{
- GIMPLE_PASS, /* type */
- "cdce", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_CALL_CDCE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_call_cdce : public gimple_opt_pass
-{
-public:
- pass_call_cdce (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_call_cdce, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *fun)
- {
- /* The limit constants used in the implementation
- assume IEEE floating point format. Other formats
- can be supported in the future if needed. */
- return flag_tree_builtin_call_dce != 0
- && optimize_function_for_speed_p (fun);
- }
-
- unsigned int execute () { return tree_call_cdce (); }
-
-}; // class pass_call_cdce
-
} // anon namespace
gimple_opt_pass *
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_build_cfg (); }
+ virtual unsigned int execute (function *) { return execute_build_cfg (); }
}; // class pass_build_cfg
{}
/* opt_pass methods: */
- unsigned int execute () { return split_critical_edges (); }
+ virtual unsigned int execute (function *) { return split_critical_edges (); }
opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
}; // class pass_split_crit_edges
\f
-/* Emit return warnings. */
-
-static unsigned int
-execute_warn_function_return (void)
-{
- source_location location;
- gimple last;
- edge e;
- edge_iterator ei;
-
- if (!targetm.warn_func_return (cfun->decl))
- return 0;
-
- /* If we have a path to EXIT, then we do return. */
- if (TREE_THIS_VOLATILE (cfun->decl)
- && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) > 0)
- {
- location = UNKNOWN_LOCATION;
- FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
- {
- last = last_stmt (e->src);
- if ((gimple_code (last) == GIMPLE_RETURN
- || gimple_call_builtin_p (last, BUILT_IN_RETURN))
- && (location = gimple_location (last)) != UNKNOWN_LOCATION)
- break;
- }
- if (location == UNKNOWN_LOCATION)
- location = cfun->function_end_locus;
- warning_at (location, 0, "%<noreturn%> function does return");
- }
-
- /* If we see "return;" in some basic block, then we do reach the end
- without returning a value. */
- else if (warn_return_type
- && !TREE_NO_WARNING (cfun->decl)
- && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) > 0
- && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun->decl))))
- {
- FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
- {
- gimple last = last_stmt (e->src);
- if (gimple_code (last) == GIMPLE_RETURN
- && gimple_return_retval (last) == NULL
- && !gimple_no_warning_p (last))
- {
- location = gimple_location (last);
- if (location == UNKNOWN_LOCATION)
- location = cfun->function_end_locus;
- warning_at (location, OPT_Wreturn_type, "control reaches end of non-void function");
- TREE_NO_WARNING (cfun->decl) = 1;
- break;
- }
- }
- }
- return 0;
-}
-
-
/* Given a basic block B which ends with a conditional and has
precisely two successors, determine which of the edges is taken if
the conditional is true and which is taken if the conditional is
}
}
+/* Emit return warnings. */
+
namespace {
const pass_data pass_data_warn_function_return =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_warn_function_return (); }
+ virtual unsigned int execute (function *);
}; // class pass_warn_function_return
+unsigned int
+pass_warn_function_return::execute (function *fun)
+{
+ source_location location;
+ gimple last;
+ edge e;
+ edge_iterator ei;
+
+ if (!targetm.warn_func_return (fun->decl))
+ return 0;
+
+ /* If we have a path to EXIT, then we do return. */
+ if (TREE_THIS_VOLATILE (fun->decl)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0)
+ {
+ location = UNKNOWN_LOCATION;
+ FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
+ {
+ last = last_stmt (e->src);
+ if ((gimple_code (last) == GIMPLE_RETURN
+ || gimple_call_builtin_p (last, BUILT_IN_RETURN))
+ && (location = gimple_location (last)) != UNKNOWN_LOCATION)
+ break;
+ }
+ if (location == UNKNOWN_LOCATION)
+ location = cfun->function_end_locus;
+ warning_at (location, 0, "%<noreturn%> function does return");
+ }
+
+ /* If we see "return;" in some basic block, then we do reach the end
+ without returning a value. */
+ else if (warn_return_type
+ && !TREE_NO_WARNING (fun->decl)
+ && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0
+ && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun->decl))))
+ {
+ FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
+ {
+ gimple last = last_stmt (e->src);
+ if (gimple_code (last) == GIMPLE_RETURN
+ && gimple_return_retval (last) == NULL
+ && !gimple_no_warning_p (last))
+ {
+ location = gimple_location (last);
+ if (location == UNKNOWN_LOCATION)
+ location = fun->function_end_locus;
+ warning_at (location, OPT_Wreturn_type, "control reaches end of non-void function");
+ TREE_NO_WARNING (fun->decl) = 1;
+ break;
+ }
+ }
+ }
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
}
}
-static unsigned int
-run_warn_unused_result (void)
-{
- do_warn_unused_result (gimple_body (current_function_decl));
- return 0;
-}
-
namespace {
const pass_data pass_data_warn_unused_result =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_warn_unused_result; }
- unsigned int execute () { return run_warn_unused_result (); }
+ virtual unsigned int execute (function *)
+ {
+ do_warn_unused_result (gimple_body (current_function_decl));
+ return 0;
+ }
}; // class pass_warn_unused_result
/* opt_pass methods: */
opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
- unsigned int execute () { return execute_fixup_cfg (); }
+ virtual unsigned int execute (function *) { return execute_fixup_cfg (); }
}; // class pass_fixup_cfg
<L10>:;
*/
-static unsigned int
-merge_phi_nodes (void)
+namespace {
+
+const pass_data pass_data_merge_phi =
+{
+ GIMPLE_PASS, /* type */
+ "mergephi", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_MERGE_PHI, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_merge_phi : public gimple_opt_pass
{
- basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun));
+public:
+ pass_merge_phi (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_merge_phi, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_merge_phi (m_ctxt); }
+ virtual unsigned int execute (function *);
+
+}; // class pass_merge_phi
+
+unsigned int
+pass_merge_phi::execute (function *fun)
+{
+ basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks_for_fn (fun));
basic_block *current = worklist;
basic_block bb;
calculate_dominance_info (CDI_DOMINATORS);
/* Find all PHI nodes that we may be able to merge. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
basic_block dest;
return 0;
}
-namespace {
-
-const pass_data pass_data_merge_phi =
-{
- GIMPLE_PASS, /* type */
- "mergephi", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_MERGE_PHI, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_merge_phi : public gimple_opt_pass
-{
-public:
- pass_merge_phi (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_merge_phi, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_merge_phi (m_ctxt); }
- unsigned int execute () { return merge_phi_nodes (); }
-
-}; // class pass_merge_phi
-
} // anon namespace
gimple_opt_pass *
{}
/* opt_pass methods: */
- unsigned int execute () {
- return execute_cleanup_cfg_post_optimizing ();
- }
+ virtual unsigned int execute (function *)
+ {
+ return execute_cleanup_cfg_post_optimizing ();
+ }
}; // class pass_cleanup_cfg_post_optimizing
/* opt_pass methods: */
opt_pass * clone () { return new pass_lower_complex (m_ctxt); }
- unsigned int execute () { return tree_lower_complex (); }
+ virtual unsigned int execute (function *) { return tree_lower_complex (); }
}; // class pass_lower_complex
return !(fun->curr_properties & PROP_gimple_lcx);
}
- unsigned int execute () { return tree_lower_complex (); }
+ virtual unsigned int execute (function *) { return tree_lower_complex (); }
}; // class pass_lower_complex_O0
lower_eh_constructs_2 (state, &gsi);
}
-static unsigned int
-lower_eh_constructs (void)
+namespace {
+
+const pass_data pass_data_lower_eh =
+{
+ GIMPLE_PASS, /* type */
+ "eh", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_EH, /* tv_id */
+ PROP_gimple_lcf, /* properties_required */
+ PROP_gimple_leh, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_lower_eh : public gimple_opt_pass
+{
+public:
+ pass_lower_eh (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_eh, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_lower_eh
+
+unsigned int
+pass_lower_eh::execute (function *fun)
{
struct leh_state null_state;
gimple_seq bodyp;
/* If this function needs a language specific EH personality routine
and the frontend didn't already set one do so now. */
- if (function_needs_eh_personality (cfun) == eh_personality_lang
+ if (function_needs_eh_personality (fun) == eh_personality_lang
&& !DECL_FUNCTION_PERSONALITY (current_function_decl))
DECL_FUNCTION_PERSONALITY (current_function_decl)
= lang_hooks.eh_personality ();
return 0;
}
-namespace {
-
-const pass_data pass_data_lower_eh =
-{
- GIMPLE_PASS, /* type */
- "eh", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_EH, /* tv_id */
- PROP_gimple_lcf, /* properties_required */
- PROP_gimple_leh, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_lower_eh : public gimple_opt_pass
-{
-public:
- pass_lower_eh (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_lower_eh, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return lower_eh_constructs (); }
-
-}; // class pass_lower_eh
-
} // anon namespace
gimple_opt_pass *
}
}
-static unsigned
-refactor_eh (void)
-{
- refactor_eh_r (gimple_body (current_function_decl));
- return 0;
-}
-
namespace {
const pass_data pass_data_refactor_eh =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_exceptions != 0; }
- unsigned int execute () { return refactor_eh (); }
+ virtual unsigned int execute (function *)
+ {
+ refactor_eh_r (gimple_body (current_function_decl));
+ return 0;
+ }
}; // class pass_refactor_eh
return ret;
}
-static unsigned
-execute_lower_resx (void)
-{
- basic_block bb;
- struct pointer_map_t *mnt_map;
- bool dominance_invalidated = false;
- bool any_rewritten = false;
-
- mnt_map = pointer_map_create ();
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- gimple last = last_stmt (bb);
- if (last && is_gimple_resx (last))
- {
- dominance_invalidated |= lower_resx (bb, last, mnt_map);
- any_rewritten = true;
- }
- }
-
- pointer_map_destroy (mnt_map);
-
- if (dominance_invalidated)
- {
- free_dominance_info (CDI_DOMINATORS);
- free_dominance_info (CDI_POST_DOMINATORS);
- }
-
- return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
-}
-
namespace {
const pass_data pass_data_lower_resx =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_exceptions != 0; }
- unsigned int execute () { return execute_lower_resx (); }
+ virtual unsigned int execute (function *);
}; // class pass_lower_resx
+unsigned
+pass_lower_resx::execute (function *fun)
+{
+ basic_block bb;
+ struct pointer_map_t *mnt_map;
+ bool dominance_invalidated = false;
+ bool any_rewritten = false;
+
+ mnt_map = pointer_map_create ();
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ gimple last = last_stmt (bb);
+ if (last && is_gimple_resx (last))
+ {
+ dominance_invalidated |= lower_resx (bb, last, mnt_map);
+ any_rewritten = true;
+ }
+ }
+
+ pointer_map_destroy (mnt_map);
+
+ if (dominance_invalidated)
+ {
+ free_dominance_info (CDI_DOMINATORS);
+ free_dominance_info (CDI_POST_DOMINATORS);
+ }
+
+ return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
+}
+
} // anon namespace
gimple_opt_pass *
return redirected;
}
-static unsigned
-execute_lower_eh_dispatch (void)
+namespace {
+
+const pass_data pass_data_lower_eh_dispatch =
+{
+ GIMPLE_PASS, /* type */
+ "ehdisp", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_EH, /* tv_id */
+ PROP_gimple_lcf, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_flow, /* todo_flags_finish */
+};
+
+class pass_lower_eh_dispatch : public gimple_opt_pass
+{
+public:
+ pass_lower_eh_dispatch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_eh_dispatch, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *fun) { return fun->eh->region_tree != NULL; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_lower_eh_dispatch
+
+unsigned
+pass_lower_eh_dispatch::execute (function *fun)
{
basic_block bb;
int flags = 0;
assign_filter_values ();
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple last = last_stmt (bb);
if (last == NULL)
return flags;
}
-namespace {
-
-const pass_data pass_data_lower_eh_dispatch =
-{
- GIMPLE_PASS, /* type */
- "ehdisp", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_EH, /* tv_id */
- PROP_gimple_lcf, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_flow, /* todo_flags_finish */
-};
-
-class pass_lower_eh_dispatch : public gimple_opt_pass
-{
-public:
- pass_lower_eh_dispatch (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_lower_eh_dispatch, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *fun) { return fun->eh->region_tree != NULL; }
-
- unsigned int execute () { return execute_lower_eh_dispatch (); }
-
-}; // class pass_lower_eh_dispatch
-
} // anon namespace
gimple_opt_pass *
return 0;
}
-static unsigned int
-execute_cleanup_eh (void)
-{
- int ret = execute_cleanup_eh_1 ();
-
- /* If the function no longer needs an EH personality routine
- clear it. This exposes cross-language inlining opportunities
- and avoids references to a never defined personality routine. */
- if (DECL_FUNCTION_PERSONALITY (current_function_decl)
- && function_needs_eh_personality (cfun) != eh_personality_lang)
- DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
-
- return ret;
-}
-
namespace {
const pass_data pass_data_cleanup_eh =
return fun->eh != NULL && fun->eh->region_tree != NULL;
}
- unsigned int execute () { return execute_cleanup_eh (); }
+ virtual unsigned int execute (function *);
}; // class pass_cleanup_eh
+unsigned int
+pass_cleanup_eh::execute (function *fun)
+{
+ int ret = execute_cleanup_eh_1 ();
+
+ /* If the function no longer needs an EH personality routine
+ clear it. This exposes cross-language inlining opportunities
+ and avoids references to a never defined personality routine. */
+ if (DECL_FUNCTION_PERSONALITY (current_function_decl)
+ && function_needs_eh_personality (fun) != eh_personality_lang)
+ DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
+
+ return ret;
+}
+
} // anon namespace
gimple_opt_pass *
return !targetm.have_tls;
}
- unsigned int execute () { return ipa_lower_emutls (); }
+ virtual unsigned int execute (function *) { return ipa_lower_emutls (); }
}; // class pass_ipa_lower_emutls
/* Tree if-conversion pass management. */
-static unsigned int
-main_tree_if_conversion (void)
-{
- struct loop *loop;
- unsigned todo = 0;
-
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- FOR_EACH_LOOP (loop, 0)
- if (flag_tree_loop_if_convert == 1
- || flag_tree_loop_if_convert_stores == 1
- || ((flag_tree_loop_vectorize || loop->force_vectorize)
- && !loop->dont_vectorize))
- todo |= tree_if_conversion (loop);
-
-#ifdef ENABLE_CHECKING
- {
- basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
- gcc_assert (!bb->aux);
- }
-#endif
-
- return todo;
-}
-
namespace {
const pass_data pass_data_if_conversion =
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return main_tree_if_conversion (); }
+ virtual unsigned int execute (function *);
}; // class pass_if_conversion
|| flag_tree_loop_if_convert_stores == 1);
}
+unsigned int
+pass_if_conversion::execute (function *fun)
+{
+ struct loop *loop;
+ unsigned todo = 0;
+
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ FOR_EACH_LOOP (loop, 0)
+ if (flag_tree_loop_if_convert == 1
+ || flag_tree_loop_if_convert_stores == 1
+ || ((flag_tree_loop_vectorize || loop->force_vectorize)
+ && !loop->dont_vectorize))
+ todo |= tree_if_conversion (loop);
+
+#ifdef ENABLE_CHECKING
+ {
+ basic_block bb;
+ FOR_EACH_BB_FN (bb, fun)
+ gcc_assert (!bb->aux);
+ }
+#endif
+
+ return todo;
+}
+
} // anon namespace
gimple_opt_pass *
Steps 3 and 4 are done using the dominator tree walker
(walk_dominator_tree). */
-static unsigned int
-rewrite_into_ssa (void)
+namespace {
+
+const pass_data pass_data_build_ssa =
+{
+ GIMPLE_PASS, /* type */
+ "ssa", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_SSA_OTHER, /* tv_id */
+ PROP_cfg, /* properties_required */
+ PROP_ssa, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_verify_ssa | TODO_remove_unused_locals ), /* todo_flags_finish */
+};
+
+class pass_build_ssa : public gimple_opt_pass
+{
+public:
+ pass_build_ssa (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_ssa, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *fun)
+ {
+ /* Do nothing for funcions that was produced already in SSA form. */
+ return !(fun->curr_properties & PROP_ssa);
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_build_ssa
+
+unsigned int
+pass_build_ssa::execute (function *fun)
{
bitmap_head *dfs;
basic_block bb;
unsigned i;
/* Initialize operand data structures. */
- init_ssa_operands (cfun);
+ init_ssa_operands (fun);
/* Initialize internal data needed by the renamer. */
init_ssa_renamer ();
/* Initialize the set of interesting blocks. The callback
mark_def_sites will add to this set those blocks that the renamer
should process. */
- interesting_blocks = sbitmap_alloc (last_basic_block_for_fn (cfun));
+ interesting_blocks = sbitmap_alloc (last_basic_block_for_fn (fun));
bitmap_clear (interesting_blocks);
/* Initialize dominance frontier. */
- dfs = XNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
- FOR_EACH_BB_FN (bb, cfun)
+ dfs = XNEWVEC (bitmap_head, last_basic_block_for_fn (fun));
+ FOR_EACH_BB_FN (bb, fun)
bitmap_initialize (&dfs[bb->index], &bitmap_default_obstack);
/* 1- Compute dominance frontiers. */
compute_dominance_frontiers (dfs);
/* 2- Find and mark definition sites. */
- mark_def_dom_walker (CDI_DOMINATORS).walk (cfun->cfg->x_entry_block_ptr);
+ mark_def_dom_walker (CDI_DOMINATORS).walk (fun->cfg->x_entry_block_ptr);
/* 3- Insert PHI nodes at dominance frontiers of definition blocks. */
insert_phi_nodes (dfs);
/* 4- Rename all the blocks. */
- rewrite_blocks (ENTRY_BLOCK_PTR_FOR_FN (cfun), REWRITE_ALL);
+ rewrite_blocks (ENTRY_BLOCK_PTR_FOR_FN (fun), REWRITE_ALL);
/* Free allocated memory. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
bitmap_clear (&dfs[bb->index]);
free (dfs);
return 0;
}
-namespace {
-
-const pass_data pass_data_build_ssa =
-{
- GIMPLE_PASS, /* type */
- "ssa", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_SSA_OTHER, /* tv_id */
- PROP_cfg, /* properties_required */
- PROP_ssa, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_verify_ssa | TODO_remove_unused_locals ), /* todo_flags_finish */
-};
-
-class pass_build_ssa : public gimple_opt_pass
-{
-public:
- pass_build_ssa (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_build_ssa, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *fun)
- {
- /* Do nothing for funcions that was produced already in SSA form. */
- return !(fun->curr_properties & PROP_ssa);
- }
-
- unsigned int execute () { return rewrite_into_ssa (); }
-
-}; // class pass_build_ssa
-
} // anon namespace
gimple_opt_pass *
/* Distribute all loops in the current function. */
-static unsigned int
-tree_loop_distribution (void)
+namespace {
+
+const pass_data pass_data_loop_distribution =
+{
+ GIMPLE_PASS, /* type */
+ "ldist", /* name */
+ OPTGROUP_LOOP, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_LOOP_DISTRIBUTION, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_loop_distribution : public gimple_opt_pass
+{
+public:
+ pass_loop_distribution (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_loop_distribution, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return flag_tree_loop_distribution
+ || flag_tree_loop_distribute_patterns;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_loop_distribution
+
+unsigned int
+pass_loop_distribution::execute (function *fun)
{
struct loop *loop;
bool changed = false;
basic_block bb;
control_dependences *cd = NULL;
- FOR_ALL_BB_FN (bb, cfun)
+ FOR_ALL_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
if (virtual_operand_p (gimple_phi_result (phi)))
continue;
/* Distribute stmts which have defs that are used outside of
- the loop. */
+ the loop. */
if (!stmt_has_scalar_dependences_outside_loop (loop, phi))
continue;
work_list.safe_push (phi);
gimple stmt = gsi_stmt (gsi);
/* If there is a stmt with side-effects bail out - we
- cannot and should not distribute this loop. */
+ cannot and should not distribute this loop. */
if (gimple_has_side_effects (stmt))
{
work_list.truncate (0);
}
/* Distribute stmts which have defs that are used outside of
- the loop. */
+ the loop. */
if (stmt_has_scalar_dependences_outside_loop (loop, stmt))
;
/* Otherwise only distribute stores for now. */
if (changed)
{
- mark_virtual_operands_for_renaming (cfun);
+ mark_virtual_operands_for_renaming (fun);
rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
}
return 0;
}
-namespace {
-
-const pass_data pass_data_loop_distribution =
-{
- GIMPLE_PASS, /* type */
- "ldist", /* name */
- OPTGROUP_LOOP, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_LOOP_DISTRIBUTION, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_loop_distribution : public gimple_opt_pass
-{
-public:
- pass_loop_distribution (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_loop_distribution, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *)
- {
- return flag_tree_loop_distribution
- || flag_tree_loop_distribute_patterns;
- }
-
- unsigned int execute () { return tree_loop_distribution (); }
-
-}; // class pass_loop_distribution
-
} // anon namespace
gimple_opt_pass *
then we could either have the languages register the optimization or
we could change the gating function to check the current language. */
-static unsigned int
-tree_nrv (void)
+namespace {
+
+const pass_data pass_data_nrv =
+{
+ GIMPLE_PASS, /* type */
+ "nrv", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_NRV, /* tv_id */
+ ( PROP_ssa | PROP_cfg ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_nrv : public gimple_opt_pass
+{
+public:
+ pass_nrv (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_nrv, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return optimize > 0; }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_nrv
+
+unsigned int
+pass_nrv::execute (function *fun)
{
tree result = DECL_RESULT (current_function_decl);
tree result_type = TREE_TYPE (result);
return 0;
/* Look through each block for assignments to the RESULT_DECL. */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
RESULT. */
data.var = found;
data.result = result;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
{
return 0;
}
-namespace {
-
-const pass_data pass_data_nrv =
-{
- GIMPLE_PASS, /* type */
- "nrv", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_NRV, /* tv_id */
- ( PROP_ssa | PROP_cfg ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_nrv : public gimple_opt_pass
-{
-public:
- pass_nrv (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_nrv, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return optimize > 0; }
-
- unsigned int execute () { return tree_nrv (); }
-
-}; // class pass_nrv
-
} // anon namespace
gimple_opt_pass *
escaped prior to the call. If it has, modifications to the local
variable will produce visible changes elsewhere, as in PR c++/19317. */
-static unsigned int
-execute_return_slot_opt (void)
-{
- basic_block bb;
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- gimple_stmt_iterator gsi;
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- {
- gimple stmt = gsi_stmt (gsi);
- bool slot_opt_p;
-
- if (is_gimple_call (stmt)
- && gimple_call_lhs (stmt)
- && !gimple_call_return_slot_opt_p (stmt)
- && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
- gimple_call_fndecl (stmt)))
- {
- /* Check if the location being assigned to is
- clobbered by the call. */
- slot_opt_p = dest_safe_for_nrv_p (stmt);
- gimple_call_set_return_slot_opt (stmt, slot_opt_p);
- }
- }
- }
- return 0;
-}
-
namespace {
const pass_data pass_data_return_slot =
{}
/* opt_pass methods: */
- unsigned int execute () { return execute_return_slot_opt (); }
+ virtual unsigned int execute (function *);
}; // class pass_return_slot
+unsigned int
+pass_return_slot::execute (function *fun)
+{
+ basic_block bb;
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ gimple_stmt_iterator gsi;
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple stmt = gsi_stmt (gsi);
+ bool slot_opt_p;
+
+ if (is_gimple_call (stmt)
+ && gimple_call_lhs (stmt)
+ && !gimple_call_return_slot_opt_p (stmt)
+ && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
+ gimple_call_fndecl (stmt)))
+ {
+ /* Check if the location being assigned to is
+ clobbered by the call. */
+ slot_opt_p = dest_safe_for_nrv_p (stmt);
+ gimple_call_set_return_slot_opt (stmt, slot_opt_p);
+ }
+ }
+ }
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
unsigned HOST_WIDE_INT);
static bool plus_stmt_object_size (struct object_size_info *, tree, gimple);
static bool cond_expr_object_size (struct object_size_info *, tree, gimple);
-static unsigned int compute_object_sizes (void);
static void init_offset_limit (void);
static void check_for_plus_in_loops (struct object_size_info *, tree);
static void check_for_plus_in_loops_1 (struct object_size_info *, tree,
/* Simple pass to optimize all __builtin_object_size () builtins. */
-static unsigned int
-compute_object_sizes (void)
+namespace {
+
+const pass_data pass_data_object_sizes =
+{
+ GIMPLE_PASS, /* type */
+ "objsz", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_object_sizes : public gimple_opt_pass
+{
+public:
+ pass_object_sizes (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_object_sizes, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_object_sizes (m_ctxt); }
+ virtual unsigned int execute (function *);
+
+}; // class pass_object_sizes
+
+unsigned int
+pass_object_sizes::execute (function *fun)
{
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator i;
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
return 0;
}
-namespace {
-
-const pass_data pass_data_object_sizes =
-{
- GIMPLE_PASS, /* type */
- "objsz", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_object_sizes : public gimple_opt_pass
-{
-public:
- pass_object_sizes (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_object_sizes, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_object_sizes (m_ctxt); }
- unsigned int execute () { return compute_object_sizes (); }
-
-}; // class pass_object_sizes
-
} // anon namespace
gimple_opt_pass *
/* Parallelization. */
-static unsigned
-tree_parallelize_loops (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- if (parallelize_loops ())
- return TODO_cleanup_cfg | TODO_rebuild_alias;
- return 0;
-}
-
namespace {
const pass_data pass_data_parallelize_loops =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_parallelize_loops > 1; }
- unsigned int execute () { return tree_parallelize_loops (); }
+ virtual unsigned int execute (function *);
}; // class pass_parallelize_loops
+unsigned
+pass_parallelize_loops::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ if (parallelize_loops ())
+ return TODO_cleanup_cfg | TODO_rebuild_alias;
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
be sub-passes otherwise this pass does nothing.
The return value contains TODOs to execute in addition to those in
TODO_flags_finish. */
- virtual unsigned int execute ();
+ virtual unsigned int execute (function *fun);
protected:
opt_pass (const pass_data&, gcc::context *);
/* opt_pass methods: */
virtual bool gate (function *) { return flag_predictive_commoning != 0; }
- unsigned int execute () { return run_tree_predictive_commoning (); }
+ virtual unsigned int execute (function *)
+ {
+ return run_tree_predictive_commoning ();
+ }
}; // class pass_predcom
/* opt_pass methods: */
virtual bool gate (function *);
- unsigned int execute () { return tree_profiling (); }
+ virtual unsigned int execute (function *) { return tree_profiling (); }
}; // class pass_ipa_tree_profile
/* opt_pass methods: */
virtual bool gate (function *) { return gate_intra_sra (); }
- unsigned int execute () { return early_intra_sra (); }
+ virtual unsigned int execute (function *) { return early_intra_sra (); }
}; // class pass_sra_early
/* opt_pass methods: */
virtual bool gate (function *) { return gate_intra_sra (); }
- unsigned int execute () { return late_intra_sra (); }
+ virtual unsigned int execute (function *) { return late_intra_sra (); }
}; // class pass_sra
/* opt_pass methods: */
virtual bool gate (function *) { return flag_ipa_sra && dbg_cnt (eipa_sra); }
- unsigned int execute () { return ipa_early_sra (); }
+ virtual unsigned int execute (function *) { return ipa_early_sra (); }
}; // class pass_early_ipa_sra
/* opt_pass methods: */
opt_pass * clone () { return new pass_ccp (m_ctxt); }
virtual bool gate (function *) { return flag_tree_ccp != 0; }
- unsigned int execute () { return do_ssa_ccp (); }
+ virtual unsigned int execute (function *) { return do_ssa_ccp (); }
}; // class pass_ccp
/* A simple pass that attempts to fold all builtin functions. This pass
is run after we've propagated as many constants as we can. */
-static unsigned int
-execute_fold_all_builtins (void)
+namespace {
+
+const pass_data pass_data_fold_builtins =
+{
+ GIMPLE_PASS, /* type */
+ "fab", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_verify_ssa | TODO_update_ssa ), /* todo_flags_finish */
+};
+
+class pass_fold_builtins : public gimple_opt_pass
+{
+public:
+ pass_fold_builtins (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_fold_builtins, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_fold_builtins (m_ctxt); }
+ virtual unsigned int execute (function *);
+
+}; // class pass_fold_builtins
+
+unsigned int
+pass_fold_builtins::execute (function *fun)
{
bool cfg_changed = false;
basic_block bb;
unsigned int todoflags = 0;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator i;
for (i = gsi_start_bb (bb); !gsi_end_p (i); )
result = gimple_fold_builtin (stmt);
if (result)
- gimple_remove_stmt_histograms (cfun, stmt);
+ gimple_remove_stmt_histograms (fun, stmt);
if (!result)
switch (DECL_FUNCTION_CODE (callee))
return todoflags;
}
-
-namespace {
-
-const pass_data pass_data_fold_builtins =
-{
- GIMPLE_PASS, /* type */
- "fab", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_verify_ssa | TODO_update_ssa ), /* todo_flags_finish */
-};
-
-class pass_fold_builtins : public gimple_opt_pass
-{
-public:
- pass_fold_builtins (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_fold_builtins, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_fold_builtins (m_ctxt); }
- unsigned int execute () { return execute_fold_all_builtins (); }
-
-}; // class pass_fold_builtins
-
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
opt_pass * clone () { return new pass_copy_prop (m_ctxt); }
virtual bool gate (function *) { return flag_tree_copy_prop != 0; }
- unsigned int execute () { return execute_copy_prop (); }
+ virtual unsigned int execute (function *) { return execute_copy_prop (); }
}; // class pass_copy_prop
}
+namespace {
+
+const pass_data pass_data_rename_ssa_copies =
+{
+ GIMPLE_PASS, /* type */
+ "copyrename", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_COPY_RENAME, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_rename_ssa_copies : public gimple_opt_pass
+{
+public:
+ pass_rename_ssa_copies (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_rename_ssa_copies (m_ctxt); }
+ virtual bool gate (function *) { return flag_tree_copyrename != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_rename_ssa_copies
+
/* This function will make a pass through the IL, and attempt to coalesce any
SSA versions which occur in PHI's or copies. Coalescing is accomplished by
changing the underlying root variable of all coalesced version. This will
then cause the SSA->normal pass to attempt to coalesce them all to the same
variable. */
-static unsigned int
-rename_ssa_copies (void)
+unsigned int
+pass_rename_ssa_copies::execute (function *fun)
{
var_map map;
basic_block bb;
map = init_var_map (num_ssa_names);
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
/* Scan for real copies. */
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
}
}
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
/* Treat PHI nodes as copies between the result and each argument. */
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
replace_ssa_name_symbol (var, SSA_NAME_VAR (part_var));
}
- statistics_counter_event (cfun, "copies coalesced",
+ statistics_counter_event (fun, "copies coalesced",
stats.coalesced);
delete_var_map (map);
return 0;
}
-namespace {
-
-const pass_data pass_data_rename_ssa_copies =
-{
- GIMPLE_PASS, /* type */
- "copyrename", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_COPY_RENAME, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_rename_ssa_copies : public gimple_opt_pass
-{
-public:
- pass_rename_ssa_copies (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_rename_ssa_copies (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_copyrename != 0; }
- unsigned int execute () { return rename_ssa_copies (); }
-
-}; // class pass_rename_ssa_copies
-
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
opt_pass * clone () { return new pass_dce (m_ctxt); }
virtual bool gate (function *) { return flag_tree_dce != 0; }
- unsigned int execute () { return tree_ssa_dce (); }
+ virtual unsigned int execute (function *) { return tree_ssa_dce (); }
}; // class pass_dce
/* opt_pass methods: */
opt_pass * clone () { return new pass_dce_loop (m_ctxt); }
virtual bool gate (function *) { return flag_tree_dce != 0; }
- unsigned int execute () { return tree_ssa_dce_loop (); }
+ virtual unsigned int execute (function *) { return tree_ssa_dce_loop (); }
}; // class pass_dce_loop
/* opt_pass methods: */
opt_pass * clone () { return new pass_cd_dce (m_ctxt); }
virtual bool gate (function *) { return flag_tree_dce != 0; }
- unsigned int execute () { return tree_ssa_cd_dce (); }
+ virtual unsigned int execute (function *) { return tree_ssa_cd_dce (); }
}; // class pass_cd_dce
every new symbol exposed, its corresponding bit will be set in
VARS_TO_RENAME. */
-static unsigned int
-tree_ssa_dominator_optimize (void)
+namespace {
+
+const pass_data pass_data_dominator =
+{
+ GIMPLE_PASS, /* type */
+ "dom", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_SSA_DOMINATOR_OPTS, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_cleanup_cfg | TODO_update_ssa
+ | TODO_verify_ssa
+ | TODO_verify_flow ), /* todo_flags_finish */
+};
+
+class pass_dominator : public gimple_opt_pass
+{
+public:
+ pass_dominator (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dominator, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_dominator (m_ctxt); }
+ virtual bool gate (function *) { return flag_tree_dom != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_dominator
+
+unsigned int
+pass_dominator::execute (function *fun)
{
memset (&opt_stats, 0, sizeof (opt_stats));
mark_dfs_back_edges ();
/* Recursively walk the dominator tree optimizing statements. */
- dom_opt_dom_walker (CDI_DOMINATORS).walk (cfun->cfg->x_entry_block_ptr);
+ dom_opt_dom_walker (CDI_DOMINATORS).walk (fun->cfg->x_entry_block_ptr);
{
gimple_stmt_iterator gsi;
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
update_stmt_if_modified (gsi_stmt (gsi));
iterator. */
EXECUTE_IF_SET_IN_BITMAP (need_eh_cleanup, 0, i, bi)
{
- basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
+ basic_block bb = BASIC_BLOCK_FOR_FN (fun, i);
if (bb == NULL)
continue;
while (single_succ_p (bb)
&& (single_succ_edge (bb)->flags & EDGE_EH) == 0)
bb = single_succ (bb);
- if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
+ if (bb == EXIT_BLOCK_PTR_FOR_FN (fun))
continue;
if ((unsigned) bb->index != i)
bitmap_set_bit (need_eh_cleanup, bb->index);
bitmap_clear (need_eh_cleanup);
}
- statistics_counter_event (cfun, "Redundant expressions eliminated",
+ statistics_counter_event (fun, "Redundant expressions eliminated",
opt_stats.num_re);
- statistics_counter_event (cfun, "Constants propagated",
+ statistics_counter_event (fun, "Constants propagated",
opt_stats.num_const_prop);
- statistics_counter_event (cfun, "Copies propagated",
+ statistics_counter_event (fun, "Copies propagated",
opt_stats.num_copy_prop);
/* Debugging dumps. */
return 0;
}
-namespace {
-
-const pass_data pass_data_dominator =
-{
- GIMPLE_PASS, /* type */
- "dom", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_SSA_DOMINATOR_OPTS, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_cleanup_cfg | TODO_update_ssa
- | TODO_verify_ssa
- | TODO_verify_flow ), /* todo_flags_finish */
-};
-
-class pass_dominator : public gimple_opt_pass
-{
-public:
- pass_dominator (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_dominator, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_dominator (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_dom != 0; }
- unsigned int execute () { return tree_ssa_dominator_optimize (); }
-
-}; // class pass_dominator
-
} // anon namespace
gimple_opt_pass *
pick up the secondary optimization opportunities with minimal
cost. */
-static unsigned int
-eliminate_degenerate_phis (void)
+namespace {
+
+const pass_data pass_data_phi_only_cprop =
+{
+ GIMPLE_PASS, /* type */
+ "phicprop", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_PHI_CPROP, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_cleanup_cfg | TODO_verify_ssa
+ | TODO_verify_stmts
+ | TODO_update_ssa ), /* todo_flags_finish */
+};
+
+class pass_phi_only_cprop : public gimple_opt_pass
+{
+public:
+ pass_phi_only_cprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_phi_only_cprop, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_phi_only_cprop (m_ctxt); }
+ virtual bool gate (function *) { return flag_tree_dom != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_phi_only_cprop
+
+unsigned int
+pass_phi_only_cprop::execute (function *fun)
{
bitmap interesting_names;
bitmap interesting_names1;
phase in dominator order. Presumably this is because walking
in dominator order leaves fewer PHIs for later examination
by the worklist phase. */
- eliminate_degenerate_phis_1 (ENTRY_BLOCK_PTR_FOR_FN (cfun),
+ eliminate_degenerate_phis_1 (ENTRY_BLOCK_PTR_FOR_FN (fun),
interesting_names);
/* Second phase. Eliminate second order degenerate PHIs as well
return 0;
}
-namespace {
-
-const pass_data pass_data_phi_only_cprop =
-{
- GIMPLE_PASS, /* type */
- "phicprop", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_PHI_CPROP, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_cleanup_cfg | TODO_verify_ssa
- | TODO_verify_stmts
- | TODO_update_ssa ), /* todo_flags_finish */
-};
-
-class pass_phi_only_cprop : public gimple_opt_pass
-{
-public:
- pass_phi_only_cprop (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_phi_only_cprop, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_phi_only_cprop (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_dom != 0; }
- unsigned int execute () { return eliminate_degenerate_phis (); }
-
-}; // class pass_phi_only_cprop
-
} // anon namespace
gimple_opt_pass *
remove their dead edges eventually. */
static bitmap need_eh_cleanup;
-static unsigned int tree_ssa_dse (void);
-
/* A helper of dse_optimize_stmt.
Given a GIMPLE_ASSIGN in STMT, find a candidate statement *USE_STMT that
}
}
-/* Main entry point. */
+namespace {
+
+const pass_data pass_data_dse =
+{
+ GIMPLE_PASS, /* type */
+ "dse", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_DSE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_dse : public gimple_opt_pass
+{
+public:
+ pass_dse (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dse, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_dse (m_ctxt); }
+ virtual bool gate (function *) { return flag_tree_dse != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_dse
-static unsigned int
-tree_ssa_dse (void)
+unsigned int
+pass_dse::execute (function *fun)
{
need_eh_cleanup = BITMAP_ALLOC (NULL);
/* Dead store elimination is fundamentally a walk of the post-dominator
tree and a backwards walk of statements within each block. */
- dse_dom_walker (CDI_POST_DOMINATORS).walk (cfun->cfg->x_exit_block_ptr);
+ dse_dom_walker (CDI_POST_DOMINATORS).walk (fun->cfg->x_exit_block_ptr);
/* Removal of stores may make some EH edges dead. Purge such edges from
the CFG as needed. */
return 0;
}
-namespace {
-
-const pass_data pass_data_dse =
-{
- GIMPLE_PASS, /* type */
- "dse", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_DSE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_dse : public gimple_opt_pass
-{
-public:
- pass_dse (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_dse, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_dse (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_dse != 0; }
- unsigned int execute () { return tree_ssa_dse (); }
-
-}; // class pass_dse
-
} // anon namespace
gimple_opt_pass *
/* Main entry point for the forward propagation and statement combine
optimizer. */
-static unsigned int
-ssa_forward_propagate_and_combine (void)
+namespace {
+
+const pass_data pass_data_forwprop =
+{
+ GIMPLE_PASS, /* type */
+ "forwprop", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_FORWPROP, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
+};
+
+class pass_forwprop : public gimple_opt_pass
+{
+public:
+ pass_forwprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_forwprop, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_forwprop (m_ctxt); }
+ virtual bool gate (function *) { return flag_tree_forwprop; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_forwprop
+
+unsigned int
+pass_forwprop::execute (function *fun)
{
basic_block bb;
unsigned int todoflags = 0;
cfg_changed = false;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
else if (TREE_CODE_CLASS (code) == tcc_comparison)
{
if (forward_propagate_comparison (&gsi))
- cfg_changed = true;
+ cfg_changed = true;
}
else
gsi_next (&gsi);
return todoflags;
}
-namespace {
-
-const pass_data pass_data_forwprop =
-{
- GIMPLE_PASS, /* type */
- "forwprop", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_FORWPROP, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
-};
-
-class pass_forwprop : public gimple_opt_pass
-{
-public:
- pass_forwprop (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_forwprop, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_forwprop (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_forwprop; }
- unsigned int execute () { return ssa_forward_propagate_and_combine (); }
-
-}; // class pass_forwprop
-
} // anon namespace
gimple_opt_pass *
/* Main entry for the tree if-conversion pass. */
-static unsigned int
-tree_ssa_ifcombine (void)
+namespace {
+
+const pass_data pass_data_tree_ifcombine =
+{
+ GIMPLE_PASS, /* type */
+ "ifcombine", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_IFCOMBINE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
+};
+
+class pass_tree_ifcombine : public gimple_opt_pass
+{
+public:
+ pass_tree_ifcombine (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_ifcombine, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual unsigned int execute (function *);
+
+}; // class pass_tree_ifcombine
+
+unsigned int
+pass_tree_ifcombine::execute (function *fun)
{
basic_block *bbs;
bool cfg_changed = false;
inner ones, and also that we do not try to visit a removed
block. This is opposite of PHI-OPT, because we cascade the
combining rather than cascading PHIs. */
- for (i = n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
+ for (i = n_basic_blocks_for_fn (fun) - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
{
basic_block bb = bbs[i];
gimple stmt = last_stmt (bb);
return cfg_changed ? TODO_cleanup_cfg : 0;
}
-namespace {
-
-const pass_data pass_data_tree_ifcombine =
-{
- GIMPLE_PASS, /* type */
- "ifcombine", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_IFCOMBINE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
-};
-
-class pass_tree_ifcombine : public gimple_opt_pass
-{
-public:
- pass_tree_ifcombine (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_tree_ifcombine, ctxt)
- {}
-
- /* opt_pass methods: */
- unsigned int execute () { return tree_ssa_ifcombine (); }
-
-}; // class pass_tree_ifcombine
-
} // anon namespace
gimple_opt_pass *
of the loop. This is beneficial since it increases efficiency of
code motion optimizations. It also saves one jump on entry to the loop. */
-static unsigned int
-copy_loop_headers (void)
+namespace {
+
+const pass_data pass_data_ch =
+{
+ GIMPLE_PASS, /* type */
+ "ch", /* name */
+ OPTGROUP_LOOP, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_CH, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_cleanup_cfg | TODO_verify_ssa
+ | TODO_verify_flow ), /* todo_flags_finish */
+};
+
+class pass_ch : public gimple_opt_pass
+{
+public:
+ pass_ch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_ch, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_tree_ch != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_ch
+
+unsigned int
+pass_ch::execute (function *fun)
{
struct loop *loop;
basic_block header;
loop_optimizer_init (LOOPS_HAVE_PREHEADERS
| LOOPS_HAVE_SIMPLE_LATCHES);
- if (number_of_loops (cfun) <= 1)
+ if (number_of_loops (fun) <= 1)
{
loop_optimizer_finalize ();
return 0;
}
- bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun));
- copied_bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun));
- bbs_size = n_basic_blocks_for_fn (cfun);
+ bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (fun));
+ copied_bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (fun));
+ bbs_size = n_basic_blocks_for_fn (fun);
FOR_EACH_LOOP (loop, 0)
{
return 0;
}
-namespace {
-
-const pass_data pass_data_ch =
-{
- GIMPLE_PASS, /* type */
- "ch", /* name */
- OPTGROUP_LOOP, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_CH, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_cleanup_cfg | TODO_verify_ssa
- | TODO_verify_flow ), /* todo_flags_finish */
-};
-
-class pass_ch : public gimple_opt_pass
-{
-public:
- pass_ch (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_ch, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_ch != 0; }
- unsigned int execute () { return copy_loop_headers (); }
-
-}; // class pass_ch
-
} // anon namespace
gimple_opt_pass *
/* Loop invariant motion pass. */
-static unsigned int
-tree_ssa_loop_im (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return tree_ssa_lim ();
-}
-
namespace {
const pass_data pass_data_lim =
/* opt_pass methods: */
opt_pass * clone () { return new pass_lim (m_ctxt); }
virtual bool gate (function *) { return flag_tree_loop_im != 0; }
- unsigned int execute () { return tree_ssa_loop_im (); }
+ virtual unsigned int execute (function *);
}; // class pass_lim
+unsigned int
+pass_lim::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return tree_ssa_lim ();
+}
+
} // anon namespace
gimple_opt_pass *
/* Canonical induction variable creation pass. */
-static unsigned int
-tree_ssa_loop_ivcanon (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return canonicalize_induction_variables ();
-}
-
namespace {
const pass_data pass_data_iv_canon =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_loop_ivcanon != 0; }
- unsigned int execute () { return tree_ssa_loop_ivcanon (); }
+ virtual unsigned int execute (function *fun);
}; // class pass_iv_canon
+unsigned int
+pass_iv_canon::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return canonicalize_induction_variables ();
+}
+
} // anon namespace
gimple_opt_pass *
/* Complete unrolling of loops. */
-static unsigned int
-tree_complete_unroll (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return tree_unroll_loops_completely (flag_unroll_loops
- || flag_peel_loops
- || optimize >= 3, true);
-}
-
namespace {
const pass_data pass_data_complete_unroll =
{}
/* opt_pass methods: */
- unsigned int execute () { return tree_complete_unroll (); }
+ virtual unsigned int execute (function *);
}; // class pass_complete_unroll
+unsigned int
+pass_complete_unroll::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return tree_unroll_loops_completely (flag_unroll_loops
+ || flag_peel_loops
+ || optimize >= 3, true);
+}
+
} // anon namespace
gimple_opt_pass *
/* 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 (cfun) > 1)
- {
- scev_initialize ();
- ret = tree_unroll_loops_completely (optimize >= 3, false);
- free_numbers_of_iterations_estimates ();
- scev_finalize ();
- }
- loop_optimizer_finalize ();
-
- return ret;
-}
-
namespace {
const pass_data pass_data_complete_unrolli =
/* opt_pass methods: */
virtual bool gate (function *) { return optimize >= 2; }
- unsigned int execute () { return tree_complete_unroll_inner (); }
+ virtual unsigned int execute (function *);
}; // class pass_complete_unrolli
+unsigned int
+pass_complete_unrolli::execute (function *fun)
+{
+ unsigned ret = 0;
+
+ loop_optimizer_init (LOOPS_NORMAL
+ | LOOPS_HAVE_RECORDED_EXITS);
+ if (number_of_loops (fun) > 1)
+ {
+ scev_initialize ();
+ ret = tree_unroll_loops_completely (optimize >= 3, false);
+ free_numbers_of_iterations_estimates ();
+ scev_finalize ();
+ }
+ loop_optimizer_finalize ();
+
+ return ret;
+}
+
} // anon namespace
gimple_opt_pass *
/* Prefetching. */
-static unsigned int
-tree_ssa_loop_prefetch (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return tree_ssa_prefetch_arrays ();
-}
-
namespace {
const pass_data pass_data_loop_prefetch =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_prefetch_loop_arrays > 0; }
- unsigned int execute () { return tree_ssa_loop_prefetch (); }
+ virtual unsigned int execute (function *);
}; // class pass_loop_prefetch
+unsigned int
+pass_loop_prefetch::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return tree_ssa_prefetch_arrays ();
+}
+
} // anon namespace
gimple_opt_pass *
/* Loop unswitching pass. */
-static unsigned int
-tree_ssa_loop_unswitch (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return tree_ssa_unswitch_loops ();
-}
-
namespace {
const pass_data pass_data_tree_unswitch =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_unswitch_loops != 0; }
- unsigned int execute () { return tree_ssa_loop_unswitch (); }
+ virtual unsigned int execute (function *);
}; // class pass_tree_unswitch
+unsigned int
+pass_tree_unswitch::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return tree_ssa_unswitch_loops ();
+}
+
} // anon namespace
gimple_opt_pass *
/* 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);
-
- /* We might discover new loops, e.g. when turning irreducible
- regions into reducible. */
- scev_initialize ();
-
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return 0;
-}
-
namespace {
const pass_data pass_data_tree_loop_init =
{}
/* opt_pass methods: */
- unsigned int execute () { return tree_ssa_loop_init (); }
+ virtual unsigned int execute (function *);
}; // class pass_tree_loop_init
+unsigned int
+pass_tree_loop_init::execute (function *fun)
+{
+ loop_optimizer_init (LOOPS_NORMAL
+ | LOOPS_HAVE_RECORDED_EXITS);
+ rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
+
+ /* We might discover new loops, e.g. when turning irreducible
+ regions into reducible. */
+ scev_initialize ();
+
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* Loop autovectorization. */
-static unsigned int
-tree_loop_vectorize (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- return vectorize_loops ();
-}
-
namespace {
const pass_data pass_data_vectorize =
return flag_tree_loop_vectorize || fun->has_force_vectorize_loops;
}
- unsigned int execute () { return tree_loop_vectorize (); }
+ virtual unsigned int execute (function *);
}; // class pass_vectorize
+unsigned int
+pass_vectorize::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ return vectorize_loops ();
+}
+
} // anon namespace
gimple_opt_pass *
/* Check the correctness of the data dependence analyzers. */
-static unsigned int
-check_data_deps (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- tree_check_data_deps ();
- return 0;
-}
-
namespace {
const pass_data pass_data_check_data_deps =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_check_data_deps != 0; }
- unsigned int execute () { return check_data_deps (); }
+ virtual unsigned int execute (function *);
}; // class pass_check_data_deps
+unsigned int
+pass_check_data_deps::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ tree_check_data_deps ();
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_scev_cprop; }
- unsigned int execute () { return scev_const_prop (); }
+ virtual unsigned int execute (function *) { return scev_const_prop (); }
}; // class pass_scev_cprop
/* Record bounds on numbers of iterations of loops. */
-static unsigned int
-tree_ssa_loop_bounds (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- estimate_numbers_of_iterations ();
- scev_reset ();
- return 0;
-}
-
namespace {
const pass_data pass_data_record_bounds =
{}
/* opt_pass methods: */
- unsigned int execute () { return tree_ssa_loop_bounds (); }
+ virtual unsigned int execute (function *);
}; // class pass_record_bounds
+unsigned int
+pass_record_bounds::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ estimate_numbers_of_iterations ();
+ scev_reset ();
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* Induction variable optimizations. */
-static unsigned int
-tree_ssa_loop_ivopts (void)
-{
- if (number_of_loops (cfun) <= 1)
- return 0;
-
- tree_ssa_iv_optimize ();
- return 0;
-}
-
namespace {
const pass_data pass_data_iv_optimize =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_ivopts != 0; }
- unsigned int execute () { return tree_ssa_loop_ivopts (); }
+ virtual unsigned int execute (function *);
}; // class pass_iv_optimize
+unsigned int
+pass_iv_optimize::execute (function *fun)
+{
+ if (number_of_loops (fun) <= 1)
+ return 0;
+
+ tree_ssa_iv_optimize ();
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
{}
/* opt_pass methods: */
- unsigned int execute () { return tree_ssa_loop_done (); }
+ virtual unsigned int execute (function *) { return tree_ssa_loop_done (); }
}; // class pass_tree_loop_done
/* Go through all the floating-point SSA_NAMEs, and call
execute_cse_reciprocals_1 on each of them. */
-static unsigned int
-execute_cse_reciprocals (void)
+namespace {
+
+const pass_data pass_data_cse_reciprocals =
+{
+ GIMPLE_PASS, /* type */
+ "recip", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa
+ | TODO_verify_stmts ), /* todo_flags_finish */
+};
+
+class pass_cse_reciprocals : public gimple_opt_pass
+{
+public:
+ pass_cse_reciprocals (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cse_reciprocals, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return optimize && flag_reciprocal_math; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_cse_reciprocals
+
+unsigned int
+pass_cse_reciprocals::execute (function *fun)
{
basic_block bb;
tree arg;
occ_pool = create_alloc_pool ("dominators for recip",
sizeof (struct occurrence),
- n_basic_blocks_for_fn (cfun) / 3 + 1);
+ n_basic_blocks_for_fn (fun) / 3 + 1);
memset (&reciprocal_stats, 0, sizeof (reciprocal_stats));
calculate_dominance_info (CDI_DOMINATORS);
calculate_dominance_info (CDI_POST_DOMINATORS);
#ifdef ENABLE_CHECKING
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
gcc_assert (!bb->aux);
#endif
- for (arg = DECL_ARGUMENTS (cfun->decl); arg; arg = DECL_CHAIN (arg))
+ for (arg = DECL_ARGUMENTS (fun->decl); arg; arg = DECL_CHAIN (arg))
if (FLOAT_TYPE_P (TREE_TYPE (arg))
&& is_gimple_reg (arg))
{
- tree name = ssa_default_def (cfun, arg);
+ tree name = ssa_default_def (fun, arg);
if (name)
execute_cse_reciprocals_1 (NULL, name);
}
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
gimple phi;
}
}
- statistics_counter_event (cfun, "reciprocal divs inserted",
+ statistics_counter_event (fun, "reciprocal divs inserted",
reciprocal_stats.rdivs_inserted);
- statistics_counter_event (cfun, "reciprocal functions inserted",
+ statistics_counter_event (fun, "reciprocal functions inserted",
reciprocal_stats.rfuncs_inserted);
free_dominance_info (CDI_DOMINATORS);
return 0;
}
-namespace {
-
-const pass_data pass_data_cse_reciprocals =
-{
- GIMPLE_PASS, /* type */
- "recip", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa
- | TODO_verify_stmts ), /* todo_flags_finish */
-};
-
-class pass_cse_reciprocals : public gimple_opt_pass
-{
-public:
- pass_cse_reciprocals (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_cse_reciprocals, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return optimize && flag_reciprocal_math; }
- unsigned int execute () { return execute_cse_reciprocals (); }
-
-}; // class pass_cse_reciprocals
-
} // anon namespace
gimple_opt_pass *
on the SSA_NAME argument of each of them. Also expand powi(x,n) into
an optimal number of multiplies, when n is a constant. */
-static unsigned int
-execute_cse_sincos (void)
+namespace {
+
+const pass_data pass_data_cse_sincos =
+{
+ GIMPLE_PASS, /* type */
+ "sincos", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa
+ | TODO_verify_stmts ), /* todo_flags_finish */
+};
+
+class pass_cse_sincos : public gimple_opt_pass
+{
+public:
+ pass_cse_sincos (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cse_sincos, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ /* We no longer require either sincos or cexp, since powi expansion
+ piggybacks on this pass. */
+ return optimize;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_cse_sincos
+
+unsigned int
+pass_cse_sincos::execute (function *fun)
{
basic_block bb;
bool cfg_changed = false;
calculate_dominance_info (CDI_DOMINATORS);
memset (&sincos_stats, 0, sizeof (sincos_stats));
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
bool cleanup_eh = false;
cfg_changed |= gimple_purge_dead_eh_edges (bb);
}
- statistics_counter_event (cfun, "sincos statements inserted",
+ statistics_counter_event (fun, "sincos statements inserted",
sincos_stats.inserted);
free_dominance_info (CDI_DOMINATORS);
return cfg_changed ? TODO_cleanup_cfg : 0;
}
-namespace {
-
-const pass_data pass_data_cse_sincos =
-{
- GIMPLE_PASS, /* type */
- "sincos", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa
- | TODO_verify_stmts ), /* todo_flags_finish */
-};
-
-class pass_cse_sincos : public gimple_opt_pass
-{
-public:
- pass_cse_sincos (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_cse_sincos, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *)
- {
- /* We no longer require either sincos or cexp, since powi expansion
- piggybacks on this pass. */
- return optimize;
- }
-
- unsigned int execute () { return execute_cse_sincos (); }
-
-}; // class pass_cse_sincos
-
} // anon namespace
gimple_opt_pass *
/* Find manual byte swap implementations and turn them into a bswap
builtin invokation. */
-static unsigned int
-execute_optimize_bswap (void)
+namespace {
+
+const pass_data pass_data_optimize_bswap =
+{
+ GIMPLE_PASS, /* type */
+ "bswap", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_optimize_bswap : public gimple_opt_pass
+{
+public:
+ pass_optimize_bswap (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_optimize_bswap, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return flag_expensive_optimizations && optimize;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_optimize_bswap
+
+unsigned int
+pass_optimize_bswap::execute (function *fun)
{
basic_block bb;
bool bswap16_p, bswap32_p, bswap64_p;
memset (&bswap_stats, 0, sizeof (bswap_stats));
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
}
}
- statistics_counter_event (cfun, "16-bit bswap implementations found",
+ statistics_counter_event (fun, "16-bit bswap implementations found",
bswap_stats.found_16bit);
- statistics_counter_event (cfun, "32-bit bswap implementations found",
+ statistics_counter_event (fun, "32-bit bswap implementations found",
bswap_stats.found_32bit);
- statistics_counter_event (cfun, "64-bit bswap implementations found",
+ statistics_counter_event (fun, "64-bit bswap implementations found",
bswap_stats.found_64bit);
return (changed ? TODO_update_ssa | TODO_verify_ssa
| TODO_verify_stmts : 0);
}
-namespace {
-
-const pass_data pass_data_optimize_bswap =
-{
- GIMPLE_PASS, /* type */
- "bswap", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_optimize_bswap : public gimple_opt_pass
-{
-public:
- pass_optimize_bswap (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_optimize_bswap, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *)
- {
- return flag_expensive_optimizations && optimize;
- }
-
- unsigned int execute () { return execute_optimize_bswap (); }
-
-}; // class pass_optimize_bswap
-
} // anon namespace
gimple_opt_pass *
smaller types, and replace the MULT_EXPR with a WIDEN_MULT_EXPR
where appropriate. */
-static unsigned int
-execute_optimize_widening_mul (void)
+namespace {
+
+const pass_data pass_data_optimize_widening_mul =
+{
+ GIMPLE_PASS, /* type */
+ "widening_mul", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_verify_ssa | TODO_verify_stmts
+ | TODO_update_ssa ), /* todo_flags_finish */
+};
+
+class pass_optimize_widening_mul : public gimple_opt_pass
+{
+public:
+ pass_optimize_widening_mul (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_optimize_widening_mul, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return flag_expensive_optimizations && optimize;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_optimize_widening_mul
+
+unsigned int
+pass_optimize_widening_mul::execute (function *fun)
{
basic_block bb;
bool cfg_changed = false;
memset (&widen_mul_stats, 0, sizeof (widen_mul_stats));
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator gsi;
}
}
- statistics_counter_event (cfun, "widening multiplications inserted",
+ statistics_counter_event (fun, "widening multiplications inserted",
widen_mul_stats.widen_mults_inserted);
- statistics_counter_event (cfun, "widening maccs inserted",
+ statistics_counter_event (fun, "widening maccs inserted",
widen_mul_stats.maccs_inserted);
- statistics_counter_event (cfun, "fused multiply-adds inserted",
+ statistics_counter_event (fun, "fused multiply-adds inserted",
widen_mul_stats.fmas_inserted);
return cfg_changed ? TODO_cleanup_cfg : 0;
}
-namespace {
-
-const pass_data pass_data_optimize_widening_mul =
-{
- GIMPLE_PASS, /* type */
- "widening_mul", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_verify_ssa | TODO_verify_stmts
- | TODO_update_ssa ), /* todo_flags_finish */
-};
-
-class pass_optimize_widening_mul : public gimple_opt_pass
-{
-public:
- pass_optimize_widening_mul (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_optimize_widening_mul, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *)
- {
- return flag_expensive_optimizations && optimize;
- }
-
- unsigned int execute () { return execute_optimize_widening_mul (); }
-
-}; // class pass_optimize_widening_mul
-
} // anon namespace
gimple_opt_pass *
#define HAVE_conditional_move (0)
#endif
-static unsigned int tree_ssa_phiopt (void);
static unsigned int tree_ssa_phiopt_worker (bool, bool);
static bool conditional_replacement (basic_block, basic_block,
edge, edge, gimple, tree, tree);
basic_block, basic_block);
static bool gate_hoist_loads (void);
-/* This pass tries to replaces an if-then-else block with an
- assignment. We have four kinds of transformations. Some of these
- transformations are also performed by the ifcvt RTL optimizer.
-
- Conditional Replacement
- -----------------------
-
- This transformation, implemented in conditional_replacement,
- replaces
-
- bb0:
- if (cond) goto bb2; else goto bb1;
- bb1:
- bb2:
- x = PHI <0 (bb1), 1 (bb0), ...>;
-
- with
-
- bb0:
- x' = cond;
- goto bb2;
- bb2:
- x = PHI <x' (bb0), ...>;
-
- We remove bb1 as it becomes unreachable. This occurs often due to
- gimplification of conditionals.
-
- Value Replacement
- -----------------
-
- This transformation, implemented in value_replacement, replaces
-
- bb0:
- if (a != b) goto bb2; else goto bb1;
- bb1:
- bb2:
- x = PHI <a (bb1), b (bb0), ...>;
-
- with
-
- bb0:
- bb2:
- x = PHI <b (bb0), ...>;
-
- This opportunity can sometimes occur as a result of other
- optimizations.
-
-
- Another case caught by value replacement looks like this:
-
- bb0:
- t1 = a == CONST;
- t2 = b > c;
- t3 = t1 & t2;
- if (t3 != 0) goto bb1; else goto bb2;
- bb1:
- bb2:
- x = PHI (CONST, a)
-
- Gets replaced with:
- bb0:
- bb2:
- t1 = a == CONST;
- t2 = b > c;
- t3 = t1 & t2;
- x = a;
-
- ABS Replacement
- ---------------
-
- This transformation, implemented in abs_replacement, replaces
-
- bb0:
- if (a >= 0) goto bb2; else goto bb1;
- bb1:
- x = -a;
- bb2:
- x = PHI <x (bb1), a (bb0), ...>;
-
- with
-
- bb0:
- x' = ABS_EXPR< a >;
- bb2:
- x = PHI <x' (bb0), ...>;
-
- MIN/MAX Replacement
- -------------------
-
- This transformation, minmax_replacement replaces
-
- bb0:
- if (a <= b) goto bb2; else goto bb1;
- bb1:
- bb2:
- x = PHI <b (bb1), a (bb0), ...>;
-
- with
-
- bb0:
- x' = MIN_EXPR (a, b)
- bb2:
- x = PHI <x' (bb0), ...>;
-
- A similar transformation is done for MAX_EXPR.
-
-
- This pass also performs a fifth transformation of a slightly different
- flavor.
-
- Adjacent Load Hoisting
- ----------------------
-
- This transformation replaces
-
- bb0:
- if (...) goto bb2; else goto bb1;
- bb1:
- x1 = (<expr>).field1;
- goto bb3;
- bb2:
- x2 = (<expr>).field2;
- bb3:
- # x = PHI <x1, x2>;
-
- with
-
- bb0:
- x1 = (<expr>).field1;
- x2 = (<expr>).field2;
- if (...) goto bb2; else goto bb1;
- bb1:
- goto bb3;
- bb2:
- bb3:
- # x = PHI <x1, x2>;
-
- The purpose of this transformation is to enable generation of conditional
- move instructions such as Intel CMOVE or PowerPC ISEL. Because one of
- the loads is speculative, the transformation is restricted to very
- specific cases to avoid introducing a page fault. We are looking for
- the common idiom:
-
- if (...)
- x = y->left;
- else
- x = y->right;
-
- where left and right are typically adjacent pointers in a tree structure. */
-
-static unsigned int
-tree_ssa_phiopt (void)
-{
- return tree_ssa_phiopt_worker (false, gate_hoist_loads ());
-}
-
/* This pass tries to transform conditional stores into unconditional
ones, enabling further simplifications with the simpler then and else
blocks. In particular it replaces this:
&& HAVE_conditional_move);
}
-/* Always do these optimizations if we have SSA
- trees to work on. */
+/* This pass tries to replaces an if-then-else block with an
+ assignment. We have four kinds of transformations. Some of these
+ transformations are also performed by the ifcvt RTL optimizer.
+
+ Conditional Replacement
+ -----------------------
+
+ This transformation, implemented in conditional_replacement,
+ replaces
+
+ bb0:
+ if (cond) goto bb2; else goto bb1;
+ bb1:
+ bb2:
+ x = PHI <0 (bb1), 1 (bb0), ...>;
+
+ with
+
+ bb0:
+ x' = cond;
+ goto bb2;
+ bb2:
+ x = PHI <x' (bb0), ...>;
+
+ We remove bb1 as it becomes unreachable. This occurs often due to
+ gimplification of conditionals.
+
+ Value Replacement
+ -----------------
+
+ This transformation, implemented in value_replacement, replaces
+
+ bb0:
+ if (a != b) goto bb2; else goto bb1;
+ bb1:
+ bb2:
+ x = PHI <a (bb1), b (bb0), ...>;
+
+ with
+
+ bb0:
+ bb2:
+ x = PHI <b (bb0), ...>;
+
+ This opportunity can sometimes occur as a result of other
+ optimizations.
+
+
+ Another case caught by value replacement looks like this:
+
+ bb0:
+ t1 = a == CONST;
+ t2 = b > c;
+ t3 = t1 & t2;
+ if (t3 != 0) goto bb1; else goto bb2;
+ bb1:
+ bb2:
+ x = PHI (CONST, a)
+
+ Gets replaced with:
+ bb0:
+ bb2:
+ t1 = a == CONST;
+ t2 = b > c;
+ t3 = t1 & t2;
+ x = a;
+
+ ABS Replacement
+ ---------------
+
+ This transformation, implemented in abs_replacement, replaces
+
+ bb0:
+ if (a >= 0) goto bb2; else goto bb1;
+ bb1:
+ x = -a;
+ bb2:
+ x = PHI <x (bb1), a (bb0), ...>;
+
+ with
+
+ bb0:
+ x' = ABS_EXPR< a >;
+ bb2:
+ x = PHI <x' (bb0), ...>;
+
+ MIN/MAX Replacement
+ -------------------
+
+ This transformation, minmax_replacement replaces
+
+ bb0:
+ if (a <= b) goto bb2; else goto bb1;
+ bb1:
+ bb2:
+ x = PHI <b (bb1), a (bb0), ...>;
+
+ with
+
+ bb0:
+ x' = MIN_EXPR (a, b)
+ bb2:
+ x = PHI <x' (bb0), ...>;
+
+ A similar transformation is done for MAX_EXPR.
+
+
+ This pass also performs a fifth transformation of a slightly different
+ flavor.
+
+ Adjacent Load Hoisting
+ ----------------------
+
+ This transformation replaces
+
+ bb0:
+ if (...) goto bb2; else goto bb1;
+ bb1:
+ x1 = (<expr>).field1;
+ goto bb3;
+ bb2:
+ x2 = (<expr>).field2;
+ bb3:
+ # x = PHI <x1, x2>;
+
+ with
+
+ bb0:
+ x1 = (<expr>).field1;
+ x2 = (<expr>).field2;
+ if (...) goto bb2; else goto bb1;
+ bb1:
+ goto bb3;
+ bb2:
+ bb3:
+ # x = PHI <x1, x2>;
+
+ The purpose of this transformation is to enable generation of conditional
+ move instructions such as Intel CMOVE or PowerPC ISEL. Because one of
+ the loads is speculative, the transformation is restricted to very
+ specific cases to avoid introducing a page fault. We are looking for
+ the common idiom:
+
+ if (...)
+ x = y->left;
+ else
+ x = y->right;
+
+ where left and right are typically adjacent pointers in a tree structure. */
namespace {
/* opt_pass methods: */
opt_pass * clone () { return new pass_phiopt (m_ctxt); }
- unsigned int execute () { return tree_ssa_phiopt (); }
+ virtual unsigned int execute (function *)
+ {
+ return tree_ssa_phiopt_worker (false, gate_hoist_loads ());
+ }
}; // class pass_phiopt
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_cselim; }
- unsigned int execute () { return tree_ssa_cs_elim (); }
+ virtual unsigned int execute (function *) { return tree_ssa_cs_elim (); }
}; // class pass_cselim
/* Main entry for phiprop pass. */
-static unsigned int
-tree_ssa_phiprop (void)
+namespace {
+
+const pass_data pass_data_phiprop =
+{
+ GIMPLE_PASS, /* type */
+ "phiprop", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_PHIPROP, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
+};
+
+class pass_phiprop : public gimple_opt_pass
+{
+public:
+ pass_phiprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_phiprop, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_tree_phiprop; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_phiprop
+
+unsigned int
+pass_phiprop::execute (function *fun)
{
vec<basic_block> bbs;
struct phiprop_d *phivn;
/* Walk the dominator tree in preorder. */
bbs = get_all_dominated_blocks (CDI_DOMINATORS,
- single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
+ single_succ (ENTRY_BLOCK_PTR_FOR_FN (fun)));
FOR_EACH_VEC_ELT (bbs, i, bb)
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
did_something |= propagate_with_phi (bb, gsi_stmt (gsi), phivn, n);
return 0;
}
-namespace {
-
-const pass_data pass_data_phiprop =
-{
- GIMPLE_PASS, /* type */
- "phiprop", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_PHIPROP, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa ), /* todo_flags_finish */
-};
-
-class pass_phiprop : public gimple_opt_pass
-{
-public:
- pass_phiprop (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_phiprop, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_phiprop; }
- unsigned int execute () { return tree_ssa_phiprop (); }
-
-}; // class pass_phiprop
-
} // anon namespace
gimple_opt_pass *
free_dominance_info (CDI_POST_DOMINATORS);
}
-/* Gate and execute functions for PRE. */
+namespace {
-static unsigned int
-do_pre (void)
+const pass_data pass_data_pre =
+{
+ GIMPLE_PASS, /* type */
+ "pre", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_PRE, /* tv_id */
+ /* PROP_no_crit_edges is ensured by placing pass_split_crit_edges before
+ pass_pre. */
+ ( PROP_no_crit_edges | PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ PROP_no_crit_edges, /* properties_destroyed */
+ TODO_rebuild_alias, /* todo_flags_start */
+ TODO_verify_ssa, /* todo_flags_finish */
+};
+
+class pass_pre : public gimple_opt_pass
+{
+public:
+ pass_pre (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_pre, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_tree_pre != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_pre
+
+unsigned int
+pass_pre::execute (function *fun)
{
unsigned int todo = 0;
do_partial_partial =
- flag_tree_partial_pre && optimize_function_for_speed_p (cfun);
+ flag_tree_partial_pre && optimize_function_for_speed_p (fun);
/* This has to happen before SCCVN runs because
loop_optimizer_init may create new phis, etc. */
fixed, don't run it when he have an incredibly large number of
bb's. If we aren't going to run insert, there is no point in
computing ANTIC, either, even though it's plenty fast. */
- if (n_basic_blocks_for_fn (cfun) < 4000)
+ if (n_basic_blocks_for_fn (fun) < 4000)
{
compute_antic ();
insert ();
/* Remove all the redundant expressions. */
todo |= eliminate ();
- statistics_counter_event (cfun, "Insertions", pre_stats.insertions);
- statistics_counter_event (cfun, "PA inserted", pre_stats.pa_insert);
- statistics_counter_event (cfun, "New PHIs", pre_stats.phis);
- statistics_counter_event (cfun, "Eliminated", pre_stats.eliminations);
+ statistics_counter_event (fun, "Insertions", pre_stats.insertions);
+ statistics_counter_event (fun, "PA inserted", pre_stats.pa_insert);
+ statistics_counter_event (fun, "New PHIs", pre_stats.phis);
+ statistics_counter_event (fun, "Eliminated", pre_stats.eliminations);
clear_expression_ids ();
remove_dead_inserted_code ();
return todo;
}
-namespace {
-
-const pass_data pass_data_pre =
-{
- GIMPLE_PASS, /* type */
- "pre", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_PRE, /* tv_id */
- /* PROP_no_crit_edges is ensured by placing pass_split_crit_edges before
- pass_pre. */
- ( PROP_no_crit_edges | PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- PROP_no_crit_edges, /* properties_destroyed */
- TODO_rebuild_alias, /* todo_flags_start */
- TODO_verify_ssa, /* todo_flags_finish */
-};
-
-class pass_pre : public gimple_opt_pass
-{
-public:
- pass_pre (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_pre, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_pre != 0; }
- unsigned int execute () { return do_pre (); }
-
-}; // class pass_pre
-
} // anon namespace
gimple_opt_pass *
return new pass_pre (ctxt);
}
-
-/* Gate and execute functions for FRE. */
-
-static unsigned int
-execute_fre (void)
-{
- unsigned int todo = 0;
-
- if (!run_scc_vn (VN_WALKREWRITE))
- return 0;
-
- memset (&pre_stats, 0, sizeof (pre_stats));
-
- /* Remove all the redundant expressions. */
- todo |= eliminate ();
-
- todo |= fini_eliminate ();
-
- free_scc_vn ();
-
- statistics_counter_event (cfun, "Insertions", pre_stats.insertions);
- statistics_counter_event (cfun, "Eliminated", pre_stats.eliminations);
-
- return todo;
-}
-
namespace {
const pass_data pass_data_fre =
/* opt_pass methods: */
opt_pass * clone () { return new pass_fre (m_ctxt); }
virtual bool gate (function *) { return flag_tree_fre != 0; }
- unsigned int execute () { return execute_fre (); }
+ virtual unsigned int execute (function *);
}; // class pass_fre
+unsigned int
+pass_fre::execute (function *fun)
+{
+ unsigned int todo = 0;
+
+ if (!run_scc_vn (VN_WALKREWRITE))
+ return 0;
+
+ memset (&pre_stats, 0, sizeof (pre_stats));
+
+ /* Remove all the redundant expressions. */
+ todo |= eliminate ();
+
+ todo |= fini_eliminate ();
+
+ free_scc_vn ();
+
+ statistics_counter_event (fun, "Insertions", pre_stats.insertions);
+ statistics_counter_event (fun, "Eliminated", pre_stats.eliminations);
+
+ return todo;
+}
+
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
opt_pass * clone () { return new pass_reassoc (m_ctxt); }
virtual bool gate (function *) { return flag_tree_reassoc != 0; }
- unsigned int execute () { return execute_reassoc (); }
+ virtual unsigned int execute (function *) { return execute_reassoc (); }
}; // class pass_reassoc
Note that this reduces the number of computations of a = b + c to 1
when we take the else edge, instead of 2.
*/
-static void
-execute_sink_code (void)
-{
- loop_optimizer_init (LOOPS_NORMAL);
- split_critical_edges ();
- connect_infinite_loops_to_exit ();
- memset (&sink_stats, 0, sizeof (sink_stats));
- calculate_dominance_info (CDI_DOMINATORS);
- calculate_dominance_info (CDI_POST_DOMINATORS);
- sink_code_in_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
- statistics_counter_event (cfun, "Sunk statements", sink_stats.sunk);
- free_dominance_info (CDI_POST_DOMINATORS);
- remove_fake_exit_edges ();
- loop_optimizer_finalize ();
-}
-
-/* Gate and execute functions for PRE. */
-
-static unsigned int
-do_sink (void)
-{
- execute_sink_code ();
- return 0;
-}
-
namespace {
const pass_data pass_data_sink_code =
true, /* has_execute */
TV_TREE_SINK, /* tv_id */
/* PROP_no_crit_edges is ensured by running split_critical_edges in
- execute_sink_code. */
+ pass_data_sink_code::execute (). */
( PROP_cfg | PROP_ssa ), /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_sink != 0; }
- unsigned int execute () { return do_sink (); }
+ virtual unsigned int execute (function *);
}; // class pass_sink_code
+unsigned int
+pass_sink_code::execute (function *fun)
+{
+ loop_optimizer_init (LOOPS_NORMAL);
+ split_critical_edges ();
+ connect_infinite_loops_to_exit ();
+ memset (&sink_stats, 0, sizeof (sink_stats));
+ calculate_dominance_info (CDI_DOMINATORS);
+ calculate_dominance_info (CDI_POST_DOMINATORS);
+ sink_code_in_bb (EXIT_BLOCK_PTR_FOR_FN (fun));
+ statistics_counter_event (fun, "Sunk statements", sink_stats.sunk);
+ free_dominance_info (CDI_POST_DOMINATORS);
+ remove_fake_exit_edges ();
+ loop_optimizer_finalize ();
+
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
/* Main entry point. */
-static unsigned int
-tree_ssa_strlen (void)
-{
- ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
- max_stridx = 1;
- strinfo_pool = create_alloc_pool ("strinfo_struct pool",
- sizeof (struct strinfo_struct), 64);
-
- calculate_dominance_info (CDI_DOMINATORS);
-
- /* String length optimization is implemented as a walk of the dominator
- tree and a forward walk of statements within each block. */
- strlen_dom_walker (CDI_DOMINATORS).walk (cfun->cfg->x_entry_block_ptr);
-
- ssa_ver_to_stridx.release ();
- free_alloc_pool (strinfo_pool);
- if (decl_to_stridxlist_htab.is_created ())
- {
- obstack_free (&stridx_obstack, NULL);
- decl_to_stridxlist_htab.dispose ();
- }
- laststmt.stmt = NULL;
- laststmt.len = NULL_TREE;
- laststmt.stridx = 0;
-
- return 0;
-}
-
namespace {
const pass_data pass_data_strlen =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_optimize_strlen != 0; }
- unsigned int execute () { return tree_ssa_strlen (); }
+ virtual unsigned int execute (function *);
}; // class pass_strlen
+unsigned int
+pass_strlen::execute (function *fun)
+{
+ ssa_ver_to_stridx.safe_grow_cleared (num_ssa_names);
+ max_stridx = 1;
+ strinfo_pool = create_alloc_pool ("strinfo_struct pool",
+ sizeof (struct strinfo_struct), 64);
+
+ calculate_dominance_info (CDI_DOMINATORS);
+
+ /* String length optimization is implemented as a walk of the dominator
+ tree and a forward walk of statements within each block. */
+ strlen_dom_walker (CDI_DOMINATORS).walk (fun->cfg->x_entry_block_ptr);
+
+ ssa_ver_to_stridx.release ();
+ free_alloc_pool (strinfo_pool);
+ if (decl_to_stridxlist_htab.is_created ())
+ {
+ obstack_free (&stridx_obstack, NULL);
+ decl_to_stridxlist_htab.dispose ();
+ }
+ laststmt.stmt = NULL;
+ laststmt.len = NULL_TREE;
+ laststmt.stridx = 0;
+
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
&& !seen_error ());
}
- unsigned int execute () { return ipa_pta_execute (); }
+ virtual unsigned int execute (function *) { return ipa_pta_execute (); }
}; // class pass_ipa_pta
auto_vec<tree, 2> m_equiv_stack;
};
-/* Main driver for un-cprop. */
-
-static unsigned int
-tree_ssa_uncprop (void)
-{
- basic_block bb;
-
- associate_equivalences_with_edges ();
-
- /* Create our global data structures. */
- val_ssa_equiv.create (1024);
-
- /* We're going to do a dominator walk, so ensure that we have
- dominance information. */
- calculate_dominance_info (CDI_DOMINATORS);
-
- /* Recursively walk the dominator tree undoing unprofitable
- constant/copy propagations. */
- uncprop_dom_walker (CDI_DOMINATORS).walk (cfun->cfg->x_entry_block_ptr);
-
- /* we just need to empty elements out of the hash table, and cleanup the
- AUX field on the edges. */
- val_ssa_equiv.dispose ();
- FOR_EACH_BB_FN (bb, cfun)
- {
- edge e;
- edge_iterator ei;
-
- FOR_EACH_EDGE (e, ei, bb->succs)
- {
- if (e->aux)
- {
- free (e->aux);
- e->aux = NULL;
- }
- }
- }
- return 0;
-}
-
-
/* We have finished processing the dominator children of BB, perform
any finalization actions in preparation for leaving this node in
the dominator tree. */
/* opt_pass methods: */
opt_pass * clone () { return new pass_uncprop (m_ctxt); }
virtual bool gate (function *) { return flag_tree_dom != 0; }
- unsigned int execute () { return tree_ssa_uncprop (); }
+ virtual unsigned int execute (function *);
}; // class pass_uncprop
+unsigned int
+pass_uncprop::execute (function *fun)
+{
+ basic_block bb;
+
+ associate_equivalences_with_edges ();
+
+ /* Create our global data structures. */
+ val_ssa_equiv.create (1024);
+
+ /* We're going to do a dominator walk, so ensure that we have
+ dominance information. */
+ calculate_dominance_info (CDI_DOMINATORS);
+
+ /* Recursively walk the dominator tree undoing unprofitable
+ constant/copy propagations. */
+ uncprop_dom_walker (CDI_DOMINATORS).walk (fun->cfg->x_entry_block_ptr);
+
+ /* we just need to empty elements out of the hash table, and cleanup the
+ AUX field on the edges. */
+ val_ssa_equiv.dispose ();
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ edge e;
+ edge_iterator ei;
+
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ if (e->aux)
+ {
+ free (e->aux);
+ e->aux = NULL;
+ }
+ }
+ }
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
}
+static bool
+gate_warn_uninitialized (void)
+{
+ return warn_uninitialized || warn_maybe_uninitialized;
+}
-/* Entry point to the late uninitialized warning pass. */
+namespace {
-static unsigned int
-execute_late_warn_uninitialized (void)
+const pass_data pass_data_late_warn_uninitialized =
+{
+ GIMPLE_PASS, /* type */
+ "uninit", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_late_warn_uninitialized : public gimple_opt_pass
+{
+public:
+ pass_late_warn_uninitialized (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_late_warn_uninitialized, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_late_warn_uninitialized (m_ctxt); }
+ virtual bool gate (function *) { return gate_warn_uninitialized (); }
+ virtual unsigned int execute (function *);
+
+}; // class pass_late_warn_uninitialized
+
+unsigned int
+pass_late_warn_uninitialized::execute (function *fun)
{
basic_block bb;
gimple_stmt_iterator gsi;
added_to_worklist = pointer_set_create ();
/* Initialize worklist */
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple phi = gsi_stmt (gsi);
- size_t n, i;
-
- n = gimple_phi_num_args (phi);
-
- /* Don't look at virtual operands. */
- if (virtual_operand_p (gimple_phi_result (phi)))
- continue;
-
- for (i = 0; i < n; ++i)
- {
- tree op = gimple_phi_arg_def (phi, i);
- if (TREE_CODE (op) == SSA_NAME
- && uninit_undefined_value_p (op))
- {
- worklist.safe_push (phi);
+ gimple phi = gsi_stmt (gsi);
+ size_t n, i;
+
+ n = gimple_phi_num_args (phi);
+
+ /* Don't look at virtual operands. */
+ if (virtual_operand_p (gimple_phi_result (phi)))
+ continue;
+
+ for (i = 0; i < n; ++i)
+ {
+ tree op = gimple_phi_arg_def (phi, i);
+ if (TREE_CODE (op) == SSA_NAME
+ && uninit_undefined_value_p (op))
+ {
+ worklist.safe_push (phi);
pointer_set_insert (added_to_worklist, phi);
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "[WORKLIST]: add to initial list: ");
- print_gimple_stmt (dump_file, phi, 0, 0);
- }
- break;
- }
- }
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "[WORKLIST]: add to initial list: ");
+ print_gimple_stmt (dump_file, phi, 0, 0);
+ }
+ break;
+ }
+ }
}
while (worklist.length () != 0)
return 0;
}
-static bool
-gate_warn_uninitialized (void)
-{
- return warn_uninitialized || warn_maybe_uninitialized;
-}
-
-namespace {
-
-const pass_data pass_data_late_warn_uninitialized =
-{
- GIMPLE_PASS, /* type */
- "uninit", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_late_warn_uninitialized : public gimple_opt_pass
-{
-public:
- pass_late_warn_uninitialized (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_late_warn_uninitialized, ctxt)
- {}
-
- /* opt_pass methods: */
- opt_pass * clone () { return new pass_late_warn_uninitialized (m_ctxt); }
- virtual bool gate (function *) { return gate_warn_uninitialized (); }
- unsigned int execute () { return execute_late_warn_uninitialized (); }
-
-}; // class pass_late_warn_uninitialized
-
} // anon namespace
gimple_opt_pass *
/* opt_pass methods: */
virtual bool gate (function *) { return gate_warn_uninitialized (); }
- unsigned int execute () { return execute_early_warn_uninitialized (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_early_warn_uninitialized ();
+ }
}; // class pass_early_warn_uninitialized
return !(fun->curr_properties & PROP_ssa);
}
- unsigned int execute () { return execute_init_datastructures (); }
+ virtual unsigned int execute (function *)
+ {
+ return execute_init_datastructures ();
+ }
}; // class pass_init_datastructures
/* Return SSA names that are unused to GGC memory and compact the SSA
version namespace. This is used to keep footprint of compiler during
interprocedural optimization. */
-static unsigned int
-release_dead_ssa_names (void)
-{
- unsigned i, j;
- int n = vec_safe_length (FREE_SSANAMES (cfun));
-
- /* Now release the freelist. */
- vec_free (FREE_SSANAMES (cfun));
-
- /* And compact the SSA number space. We make sure to not change the
- relative order of SSA versions. */
- for (i = 1, j = 1; i < cfun->gimple_df->ssa_names->length (); ++i)
- {
- tree name = ssa_name (i);
- if (name)
- {
- if (i != j)
- {
- SSA_NAME_VERSION (name) = j;
- (*cfun->gimple_df->ssa_names)[j] = name;
- }
- j++;
- }
- }
- cfun->gimple_df->ssa_names->truncate (j);
-
- statistics_counter_event (cfun, "SSA names released", n);
- statistics_counter_event (cfun, "SSA name holes removed", i - j);
- if (dump_file)
- fprintf (dump_file, "Released %i names, %.2f%%, removed %i holes\n",
- n, n * 100.0 / num_ssa_names, i - j);
- return 0;
-}
namespace {
{}
/* opt_pass methods: */
- unsigned int execute () { return release_dead_ssa_names (); }
+ virtual unsigned int execute (function *);
}; // class pass_release_ssa_names
+unsigned int
+pass_release_ssa_names::execute (function *fun)
+{
+ unsigned i, j;
+ int n = vec_safe_length (FREE_SSANAMES (fun));
+
+ /* Now release the freelist. */
+ vec_free (FREE_SSANAMES (fun));
+
+ /* And compact the SSA number space. We make sure to not change the
+ relative order of SSA versions. */
+ for (i = 1, j = 1; i < fun->gimple_df->ssa_names->length (); ++i)
+ {
+ tree name = ssa_name (i);
+ if (name)
+ {
+ if (i != j)
+ {
+ SSA_NAME_VERSION (name) = j;
+ (*fun->gimple_df->ssa_names)[j] = name;
+ }
+ j++;
+ }
+ }
+ fun->gimple_df->ssa_names->truncate (j);
+
+ statistics_counter_event (fun, "SSA names released", n);
+ statistics_counter_event (fun, "SSA name holes removed", i - j);
+ if (dump_file)
+ fprintf (dump_file, "Released %i names, %.2f%%, removed %i holes\n",
+ n, n * 100.0 / num_ssa_names, i - j);
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
return false;
}
-/* Entry point to the stdarg optimization pass. */
-static unsigned int
-execute_optimize_stdarg (void)
+namespace {
+
+const pass_data pass_data_stdarg =
+{
+ GIMPLE_PASS, /* type */
+ "stdarg", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_NONE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_stdarg : public gimple_opt_pass
+{
+public:
+ pass_stdarg (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_stdarg, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *fun)
+ {
+ /* This optimization is only for stdarg functions. */
+ return fun->stdarg != 0;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_stdarg
+
+unsigned int
+pass_stdarg::execute (function *fun)
{
basic_block bb;
bool va_list_escapes = false;
const char *funcname = NULL;
tree cfun_va_list;
- cfun->va_list_gpr_size = 0;
- cfun->va_list_fpr_size = 0;
+ fun->va_list_gpr_size = 0;
+ fun->va_list_fpr_size = 0;
memset (&si, 0, sizeof (si));
si.va_list_vars = BITMAP_ALLOC (NULL);
si.va_list_escape_vars = BITMAP_ALLOC (NULL);
if (dump_file)
funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
- cfun_va_list = targetm.fn_abi_va_list (cfun->decl);
+ cfun_va_list = targetm.fn_abi_va_list (fun->decl);
va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
&& (TREE_TYPE (cfun_va_list) == void_type_node
|| TREE_TYPE (cfun_va_list) == char_type_node);
gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr);
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator i;
ap = TREE_OPERAND (ap, 0);
}
if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
- != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (cfun->decl))
+ != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (fun->decl))
|| TREE_CODE (ap) != VAR_DECL)
{
va_list_escapes = true;
/* For void * or char * va_list there is just one counter
(va_list itself). Use VA_LIST_GPR_SIZE for it. */
if (va_list_simple_ptr)
- cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
+ fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
calculate_dominance_info (CDI_DOMINATORS);
memset (&wi, 0, sizeof (wi));
wi.info = si.va_list_vars;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
gimple_stmt_iterator i;
finish:
if (va_list_escapes)
{
- cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
- cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
+ fun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
+ fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
}
BITMAP_FREE (si.va_list_vars);
BITMAP_FREE (si.va_list_escape_vars);
{
fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
funcname, (int) va_list_escapes);
- if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
+ if (fun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
fputs ("all", dump_file);
else
fprintf (dump_file, "%d", cfun->va_list_gpr_size);
fputs (" GPR units and ", dump_file);
- if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
+ if (fun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
fputs ("all", dump_file);
else
fprintf (dump_file, "%d", cfun->va_list_fpr_size);
return 0;
}
-
-namespace {
-
-const pass_data pass_data_stdarg =
-{
- GIMPLE_PASS, /* type */
- "stdarg", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_NONE, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0, /* todo_flags_finish */
-};
-
-class pass_stdarg : public gimple_opt_pass
-{
-public:
- pass_stdarg (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_stdarg, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *fun)
- {
- /* This optimization is only for stdarg functions. */
- return fun->stdarg != 0;
- }
-
- unsigned int execute () { return execute_optimize_stdarg (); }
-
-}; // class pass_stdarg
-
} // anon namespace
gimple_opt_pass *
/* The main function of the pass scans statements for switches and invokes
process_switch on them. */
-static unsigned int
-do_switchconv (void)
+namespace {
+
+const pass_data pass_data_convert_switch =
+{
+ GIMPLE_PASS, /* type */
+ "switchconv", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_SWITCH_CONVERSION, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_update_ssa | TODO_verify_ssa
+ | TODO_verify_stmts
+ | TODO_verify_flow ), /* todo_flags_finish */
+};
+
+class pass_convert_switch : public gimple_opt_pass
+{
+public:
+ pass_convert_switch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_convert_switch, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return flag_tree_switch_conversion != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_convert_switch
+
+unsigned int
+pass_convert_switch::execute (function *fun)
{
basic_block bb;
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
const char *failure_reason;
gimple stmt = last_stmt (bb);
return 0;
}
-namespace {
-
-const pass_data pass_data_convert_switch =
-{
- GIMPLE_PASS, /* type */
- "switchconv", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_SWITCH_CONVERSION, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_update_ssa | TODO_verify_ssa
- | TODO_verify_stmts
- | TODO_verify_flow ), /* todo_flags_finish */
-};
-
-class pass_convert_switch : public gimple_opt_pass
-{
-public:
- pass_convert_switch (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_convert_switch, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_switch_conversion != 0; }
- unsigned int execute () { return do_switchconv (); }
-
-}; // class pass_convert_switch
-
} // anon namespace
gimple_opt_pass *
return 0;
}
-static unsigned int
-execute_tail_recursion (void)
-{
- return tree_optimize_tail_calls_1 (false);
-}
-
static bool
gate_tail_calls (void)
{
/* opt_pass methods: */
opt_pass * clone () { return new pass_tail_recursion (m_ctxt); }
virtual bool gate (function *) { return gate_tail_calls (); }
- unsigned int execute () { return execute_tail_recursion (); }
+ virtual unsigned int execute (function *)
+ {
+ return tree_optimize_tail_calls_1 (false);
+ }
}; // class pass_tail_recursion
/* opt_pass methods: */
virtual bool gate (function *) { return gate_tail_calls (); }
- unsigned int execute () { return execute_tail_calls (); }
+ virtual unsigned int execute (function *) { return execute_tail_calls (); }
}; // class pass_tail_calls
return !(fun->curr_properties & PROP_gimple_lvec);
}
- unsigned int execute () { return expand_vector_operations (); }
+ virtual unsigned int execute (function *)
+ {
+ return expand_vector_operations ();
+ }
}; // class pass_lower_vector
/* opt_pass methods: */
opt_pass * clone () { return new pass_lower_vector_ssa (m_ctxt); }
- unsigned int execute () { return expand_vector_operations (); }
+ virtual unsigned int execute (function *)
+ {
+ return expand_vector_operations ();
+ }
}; // class pass_lower_vector_ssa
/* Entry point to basic block SLP phase. */
-static unsigned int
-execute_vect_slp (void)
-{
- basic_block bb;
-
- init_stmt_vec_info_vec ();
-
- FOR_EACH_BB_FN (bb, cfun)
- {
- vect_location = find_bb_location (bb);
-
- if (vect_slp_analyze_bb (bb))
- {
- if (!dbg_cnt (vect_slp))
- break;
-
- vect_slp_transform_bb (bb);
- if (dump_enabled_p ())
- dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
- "basic block vectorized\n");
- }
- }
-
- free_stmt_vec_info_vec ();
- return 0;
-}
-
namespace {
const pass_data pass_data_slp_vectorize =
/* opt_pass methods: */
virtual bool gate (function *) { return flag_tree_slp_vectorize != 0; }
- unsigned int execute () { return execute_vect_slp (); }
+ virtual unsigned int execute (function *);
}; // class pass_slp_vectorize
+unsigned int
+pass_slp_vectorize::execute (function *fun)
+{
+ basic_block bb;
+
+ init_stmt_vec_info_vec ();
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ vect_location = find_bb_location (bb);
+
+ if (vect_slp_analyze_bb (bb))
+ {
+ if (!dbg_cnt (vect_slp))
+ break;
+
+ vect_slp_transform_bb (bb);
+ if (dump_enabled_p ())
+ dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
+ "basic block vectorized\n");
+ }
+ }
+
+ free_stmt_vec_info_vec ();
+ return 0;
+}
+
} // anon namespace
gimple_opt_pass *
return flag_section_anchors && flag_tree_loop_vectorize;
}
- unsigned int execute () { return increase_alignment (); }
+ virtual unsigned int execute (function *) { return increase_alignment (); }
}; // class pass_ipa_increase_alignment
/* opt_pass methods: */
opt_pass * clone () { return new pass_vrp (m_ctxt); }
virtual bool gate (function *) { return flag_tree_vrp != 0; }
- unsigned int execute () { return execute_vrp (); }
+ virtual unsigned int execute (function *) { return execute_vrp (); }
}; // class pass_vrp
{}
/* opt_pass methods: */
- unsigned int execute () { return free_lang_data (); }
+ virtual unsigned int execute (function *) { return free_lang_data (); }
}; // class pass_ipa_free_lang_data
return (flag_sanitize & SANITIZE_THREAD) != 0;
}
- unsigned int execute () { return tsan_pass (); }
+ virtual unsigned int execute (function *) { return tsan_pass (); }
}; // class pass_tsan
return (flag_sanitize & SANITIZE_THREAD) != 0 && !optimize;
}
- unsigned int execute () { return tsan_pass (); }
+ virtual unsigned int execute (function *) { return tsan_pass (); }
}; // class pass_tsan_O0
gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
}
-/* Gate and execute functions for ubsan pass. */
+namespace {
-static unsigned int
-ubsan_pass (void)
+const pass_data pass_data_ubsan =
+{
+ GIMPLE_PASS, /* type */
+ "ubsan", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_TREE_UBSAN, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_update_ssa, /* todo_flags_finish */
+};
+
+class pass_ubsan : public gimple_opt_pass
+{
+public:
+ pass_ubsan (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_ubsan, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return flag_sanitize & (SANITIZE_NULL | SANITIZE_SI_OVERFLOW
+ | SANITIZE_BOOL | SANITIZE_ENUM);
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_ubsan
+
+unsigned int
+pass_ubsan::execute (function *fun)
{
basic_block bb;
gimple_stmt_iterator gsi;
initialize_sanitizer_builtins ();
- FOR_EACH_BB_FN (bb, cfun)
+ FOR_EACH_BB_FN (bb, fun)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
{
return 0;
}
-namespace {
-
-const pass_data pass_data_ubsan =
-{
- GIMPLE_PASS, /* type */
- "ubsan", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_TREE_UBSAN, /* tv_id */
- ( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_update_ssa, /* todo_flags_finish */
-};
-
-class pass_ubsan : public gimple_opt_pass
-{
-public:
- pass_ubsan (gcc::context *ctxt)
- : gimple_opt_pass (pass_data_ubsan, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *)
- {
- return flag_sanitize & (SANITIZE_NULL | SANITIZE_SI_OVERFLOW
- | SANITIZE_BOOL | SANITIZE_ENUM);
- }
-
- unsigned int execute () { return ubsan_pass (); }
-
-}; // class pass_ubsan
-
} // anon namespace
gimple_opt_pass *
return (flag_var_tracking && !targetm.delay_vartrack);
}
- unsigned int execute () { return variable_tracking_main (); }
+ virtual unsigned int execute (function *)
+ {
+ return variable_tracking_main ();
+ }
}; // class pass_variable_tracking
}
}
-/* Main function, called from pass->excute(). Loop through all the
- basic blocks in the current function, passing them to
- verify_bb_vtables, which searches for virtual calls, and inserts
- calls to __VLTVerifyVtablePointer. */
-
-unsigned int
-vtable_verify_main (void)
-{
- unsigned int ret = 1;
- basic_block bb;
-
- FOR_ALL_BB_FN (bb, cfun)
- verify_bb_vtables (bb);
-
- return ret;
-}
-
/* Definition of this optimization pass. */
namespace {
/* opt_pass methods: */
virtual bool gate (function *) { return (flag_vtable_verify); }
- unsigned int execute () { return vtable_verify_main (); }
+ virtual unsigned int execute (function *);
}; // class pass_vtable_verify
+/* Loop through all the basic blocks in the current function, passing them to
+ verify_bb_vtables, which searches for virtual calls, and inserts
+ calls to __VLTVerifyVtablePointer. */
+
+unsigned int
+pass_vtable_verify::execute (function *fun)
+{
+ unsigned int ret = 1;
+ basic_block bb;
+
+ FOR_ALL_BB_FN (bb, fun)
+ verify_bb_vtables (bb);
+
+ return ret;
+}
+
} // anon namespace
gimple_opt_pass *
}
\f
-/* Main entry point. */
+namespace {
+
+const pass_data pass_data_web =
+{
+ RTL_PASS, /* type */
+ "web", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ true, /* has_execute */
+ TV_WEB, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_df_finish | TODO_verify_rtl_sharing ), /* todo_flags_finish */
+};
+
+class pass_web : public rtl_opt_pass
+{
+public:
+ pass_web (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_web, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *) { return (optimize > 0 && flag_web); }
+ virtual unsigned int execute (function *);
-static unsigned int
-web_main (void)
+}; // class pass_web
+
+unsigned int
+pass_web::execute (function *fun)
{
struct web_entry *def_entry;
struct web_entry *use_entry;
df_set_flags (DF_DEFER_INSN_RESCAN);
/* Assign ids to the uses. */
- FOR_ALL_BB_FN (bb, cfun)
+ FOR_ALL_BB_FN (bb, fun)
FOR_BB_INSNS (bb, insn)
{
unsigned int uid = INSN_UID (insn);
use_entry = XCNEWVEC (struct web_entry, uses_num);
/* Produce the web. */
- FOR_ALL_BB_FN (bb, cfun)
+ FOR_ALL_BB_FN (bb, fun)
FOR_BB_INSNS (bb, insn)
{
unsigned int uid = INSN_UID (insn);
/* Update the instruction stream, allocating new registers for split pseudos
in progress. */
- FOR_ALL_BB_FN (bb, cfun)
+ FOR_ALL_BB_FN (bb, fun)
FOR_BB_INSNS (bb, insn)
{
unsigned int uid = INSN_UID (insn);
return 0;
}
\f
-namespace {
-
-const pass_data pass_data_web =
-{
- RTL_PASS, /* type */
- "web", /* name */
- OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
- TV_WEB, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- ( TODO_df_finish | TODO_verify_rtl_sharing ), /* todo_flags_finish */
-};
-
-class pass_web : public rtl_opt_pass
-{
-public:
- pass_web (gcc::context *ctxt)
- : rtl_opt_pass (pass_data_web, ctxt)
- {}
-
- /* opt_pass methods: */
- virtual bool gate (function *) { return (optimize > 0 && flag_web); }
- unsigned int execute () { return web_main (); }
-
-}; // class pass_web
-
} // anon namespace
rtl_opt_pass *
projects / thirdparty / gcc.git / commitdiff
