: gimple_opt_pass (pass_data_adjust_alignment, ctxt)
{}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_adjust_alignment
} // anon namespace
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_asan (m_ctxt); }
- virtual bool gate (function *) { return gate_asan () || gate_hwasan (); }
- virtual unsigned int execute (function *) { return asan_instrument (); }
+ opt_pass * clone () final override { return new pass_asan (m_ctxt); }
+ bool gate (function *) final override
+ {
+ return gate_asan () || gate_hwasan ();
+ }
+ unsigned int execute (function *) final override
+ {
+ return asan_instrument ();
+ }
}; // class pass_asan
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return !optimize && (gate_asan () || gate_hwasan ());
}
- virtual unsigned int execute (function *) { return asan_instrument (); }
+ unsigned int execute (function *) final override
+ {
+ return asan_instrument ();
+ }
}; // class pass_asan_O0
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
if (!AUTO_INC_DEC)
return false;
}
- unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_inc_dec
}
/* opt_pass methods: */
- virtual bool
- gate (function *)
+ bool
+ gate (function *) final override
{
return flag_auto_profile;
}
- virtual unsigned int
- execute (function *)
+ unsigned int
+ execute (function *) final override
{
return autofdo::auto_profile ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
if (targetm.cannot_modify_jumps_p ())
return false;
&& (flag_reorder_blocks || flag_reorder_blocks_and_partition));
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_reorder_blocks
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
}; // class pass_duplicate_computed_gotos
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
}; // class pass_partition_blocks
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_jump
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_thread_jumps && flag_expensive_optimizations;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_jump_after_combine
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
cleanup_cfg (flag_crossjumping ? CLEANUP_CROSSJUMP : 0);
return 0;
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_expand
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_free_cfg
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
cfg_layout_initialize (0);
return 0;
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_outof_cfg_layout_mode
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_build_cgraph_edges
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_rebuild_cgraph_edges (m_ctxt); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_rebuild_cgraph_edges (m_ctxt);
+ }
+ unsigned int execute (function *) final override
{
return cgraph_edge::rebuild_edges ();
}
{}
/* opt_pass methods: */
- opt_pass * clone () {
+ opt_pass * clone () final override {
return new pass_remove_cgraph_callee_edges (m_ctxt);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_remove_cgraph_callee_edges
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return rest_of_handle_stack_adjustments ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return (optimize > 0); }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return (optimize > 0); }
+ unsigned int execute (function *) final override
{
return rest_of_handle_combine ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Setting this target hook value is how a backend indicates the need. */
if (targetm.flags_regnum == INVALID_REGNUM)
return flag_compare_elim_after_reload;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_compare_elim_after_reload ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return TARGET_AVX && TARGET_VZEROUPPER
&& flag_expensive_optimizations && !optimize_size;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_insert_vzeroupper ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return ((!timode_p || TARGET_64BIT)
&& TARGET_STV && TARGET_SSE2 && optimize > 1);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return convert_scalars_to_vector (timode_p);
}
- opt_pass *clone ()
+ opt_pass *clone () final override
{
return new pass_stv (m_ctxt);
}
- void set_pass_param (unsigned int n, bool param)
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
timode_p = param;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
need_endbr = (flag_cf_protection & CF_BRANCH) != 0;
patchable_area_size = crtl->patch_area_size - crtl->patch_area_entry;
return need_endbr || patchable_area_size;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
timevar_push (TV_MACH_DEP);
rest_of_insert_endbr_and_patchable_area (need_endbr,
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (TARGET_AVX
&& TARGET_SSE_PARTIAL_REG_DEPENDENCY
&& optimize_function_for_speed_p (cfun));
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return remove_partial_avx_dependency ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_coroutines; };
+ bool gate (function *) final override { return flag_coroutines; };
- virtual unsigned int execute (function *f ATTRIBUTE_UNUSED)
+ unsigned int execute (function *f ATTRIBUTE_UNUSED) final override
{
return execute_lower_coro_builtins ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *f)
+ bool gate (function *f) final override
{
return flag_coroutines && f->coroutine_component;
}
- virtual unsigned int execute (function *f ATTRIBUTE_UNUSED)
+ unsigned int execute (function *f ATTRIBUTE_UNUSED) final override
{
return execute_early_expand_coro_ifns ();
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_rtl_cprop (m_ctxt); }
- virtual bool gate (function *fun)
+ opt_pass * clone () final override { return new pass_rtl_cprop (m_ctxt); }
+ bool gate (function *fun) final override
{
return optimize > 0 && flag_gcse
&& !fun->calls_setjmp
&& dbg_cnt (cprop);
}
- virtual unsigned int execute (function *) { return execute_rtl_cprop (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_rtl_cprop ();
+ }
}; // class pass_rtl_cprop
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize > 0; }
- virtual unsigned int execute (function *) { return rest_of_handle_cse (); }
+ bool gate (function *) final override { return optimize > 0; }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_cse ();
+ }
}; // class pass_cse
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_rerun_cse_after_loop;
}
- virtual unsigned int execute (function *) { return rest_of_handle_cse2 (); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_cse2 ();
+ }
}; // class pass_cse2
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_rerun_cse_after_global_opts;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_cse_after_global_opts ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 1 && flag_dce && dbg_cnt (dce_ud);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_ud_dce ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_dce && dbg_cnt (dce_fast);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_fast_dce ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize > 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return optimize > 0; }
+ unsigned int execute (function *) final override
{
return rest_of_handle_df_initialize ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize == 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return optimize == 0; }
+ unsigned int execute (function *) final override
{
return rest_of_handle_df_initialize ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_df_finish ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_dse && dbg_cnt (dse1);
}
- virtual unsigned int execute (function *) { return rest_of_handle_dse (); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_dse ();
+ }
}; // class pass_rtl_dse1
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_dse && dbg_cnt (dse2);
}
- virtual unsigned int execute (function *) { return rest_of_handle_dse (); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_dse ();
+ }
}; // class pass_rtl_dse2
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return execute_dwarf2_frame (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return execute_dwarf2_frame ();
+ }
}; // class pass_dwarf2_frame
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 1 && NUM_POLY_INT_COEFFS > 1;
}
- virtual unsigned int execute (function *f)
+ unsigned int execute (function *f) final override
{
auto_sbitmap selected_modes (NUM_MACHINE_MODES);
bitmap_clear (selected_modes);
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return set_nothrow_function_flags ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
int ret = convert_to_eh_region_ranges ();
maybe_add_nop_after_section_switch ();
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return compute_alignments (); }
+ unsigned int execute (function *) final override
+ {
+ return compute_alignments ();
+ }
}; // class pass_compute_alignments
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return rest_of_handle_final (); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_final ();
+ }
}; // class pass_final
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_shorten_branches ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_clean_state ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return instantiate_virtual_regs ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_check_leaf_regs ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_thread_prologue_and_epilogue ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_zero_call_used_regs
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_match_asm_constraints
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_fwprop (); }
- virtual unsigned int execute (function *) { return fwprop (false); }
+ bool gate (function *) final override { return gate_fwprop (); }
+ unsigned int execute (function *) final override { return fwprop (false); }
}; // class pass_rtl_fwprop
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_fwprop (); }
- virtual unsigned int execute (function *) { return fwprop (true); }
+ bool gate (function *) final override { return gate_fwprop (); }
+ unsigned int execute (function *) final override { return fwprop (true); }
}; // class pass_rtl_fwprop_addr
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return execute_rtl_pre (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return execute_rtl_pre ();
+ }
}; // class pass_rtl_pre
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return execute_rtl_hoist (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return execute_rtl_hoist ();
+ }
}; // class pass_rtl_hoist
pass_harden_compares (gcc::context *ctxt)
: gimple_opt_pass (pass_data_harden_compares, ctxt)
{}
- opt_pass *clone () { return new pass_harden_compares (m_ctxt); }
- virtual bool gate (function *) {
+ opt_pass *clone () final override
+ {
+ return new pass_harden_compares (m_ctxt);
+ }
+ bool gate (function *) final override
+ {
return flag_harden_compares;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
};
/* Define a pass to harden conditionals in branches. This pass must
pass_harden_conditional_branches (gcc::context *ctxt)
: gimple_opt_pass (pass_data_harden_conditional_branches, ctxt)
{}
- opt_pass *clone () { return new pass_harden_conditional_branches (m_ctxt); }
- virtual bool gate (function *) {
+ opt_pass *clone () final override
+ {
+ return new pass_harden_conditional_branches (m_ctxt);
+ }
+ bool gate (function *) final override
+ {
return flag_harden_conditional_branches;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
};
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (jump_table_cluster::is_enabled ()
|| bit_test_cluster::is_enabled ());
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_if_to_switch
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return true;
}
- virtual unsigned int execute (function *fun)
+ unsigned int execute (function *fun) final override
{
return gimple_expand_vec_exprs (fun);
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_laddress (m_ctxt); }
- virtual bool gate (function *) { return optimize != 0; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_laddress (m_ctxt); }
+ bool gate (function *) final override { return optimize != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_laddress
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_linterchange (m_ctxt); }
- virtual bool gate (function *) { return flag_loop_interchange; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_linterchange (m_ctxt); }
+ bool gate (function *) final override { return flag_loop_interchange; }
+ unsigned int execute (function *) final override;
}; // class pass_linterchange
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_unroll_jam != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_unroll_jam != 0; }
+ unsigned int execute (function *) final override;
};
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_version_loops_for_strides; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override
+ {
+ return flag_version_loops_for_strides;
+ }
+ unsigned int execute (function *) final override;
};
unsigned int
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return lower_function_body (); }
+ unsigned int execute (function *) final override
+ {
+ return lower_function_body ();
+ }
}; // class pass_lower_cf
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_backprop (m_ctxt); }
- virtual bool gate (function *) { return flag_ssa_backprop; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_backprop (m_ctxt); }
+ bool gate (function *) final override { return flag_ssa_backprop; }
+ unsigned int execute (function *) final override;
}; // class pass_backprop
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_early_vrp (m_ctxt); }
- virtual bool gate (function *)
+ opt_pass * clone () final override { return new pass_early_vrp (m_ctxt); }
+ bool gate (function *) final override
{
return flag_tree_vrp != 0;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{ return execute_early_vrp (); }
}; // class pass_vrp
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_isolate_erroneous_paths (m_ctxt); }
- virtual bool gate (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_isolate_erroneous_paths (m_ctxt);
+ }
+ bool gate (function *) final override
{
/* If we do not have a suitable builtin function for the trap statement,
then do not perform the optimization. */
|| warn_null_dereference);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return gimple_ssa_isolate_erroneous_paths ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return warn_nonnull_compare; }
+ bool gate (function *) final override { return warn_nonnull_compare; }
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_warn_nonnull_compare
: gimple_opt_pass (pass_data_split_paths, ctxt)
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_split_paths (m_ctxt); }
- virtual bool gate (function *) { return gate_split_paths (); }
- virtual unsigned int execute (function *) { return execute_split_paths (); }
+ opt_pass * clone () final override { return new pass_split_paths (m_ctxt); }
+ bool gate (function *) final override { return gate_split_paths (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_split_paths ();
+ }
}; // class pass_split_paths
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_expensive_optimizations && optimize && BITS_PER_UNIT == 8;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_optimize_bswap
/* Pass not supported for PDP-endian, nor for insane hosts or
target character sizes where native_{encode,interpret}_expr
doesn't work properly. */
- virtual bool
- gate (function *)
+ bool
+ gate (function *) final override
{
return flag_store_merging
&& BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
&& BITS_PER_UNIT == 8;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
private:
hash_map<tree_operand_hash, class imm_store_chain_info *> m_stores;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_slsr; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_tree_slsr; }
+ unsigned int execute (function *) final override;
}; // class pass_strength_reduction
~pass_waccess ();
- opt_pass *clone ();
+ opt_pass *clone () final override;
- virtual bool gate (function *);
+ bool gate (function *) final override;
- void set_pass_param (unsigned, bool);
+ void set_pass_param (unsigned, bool) final override;
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
private:
/* Not copyable or assignable. */
pass_walloca (gcc::context *ctxt)
: gimple_opt_pass(pass_data_walloca, ctxt), xlimit_certain_p (false)
{}
- opt_pass *clone () { return new pass_walloca (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass *clone () final override { return new pass_walloca (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
// Set to true to enable only warnings for alloca calls that
// the "may be too large" kind.
xlimit_certain_p = param;
}
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
private:
// Set to TRUE the first time we run this pass on a function.
public:
pass_wrestrict (gcc::context *);
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
void check_call (gimple *);
pass_warn_recursion (gcc::context *);
private:
- virtual bool gate (function *) { return warn_infinite_recursion; }
+ bool gate (function *) final override { return warn_infinite_recursion; }
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
bool find_function_exit (basic_block);
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_graphite_transforms (); }
+ bool gate (function *) final override { return gate_graphite_transforms (); }
}; // class pass_graphite
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_graphite_transforms (); }
- virtual unsigned int execute (function *fun) { return graphite_transforms (fun); }
+ bool gate (function *) final override { return gate_graphite_transforms (); }
+ unsigned int execute (function *fun) final override
+ {
+ return graphite_transforms (fun);
+ }
}; // class pass_graphite_transforms
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize > 0) && dbg_cnt (if_conversion);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_if_conversion ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_if_conversion
&& dbg_cnt (if_after_combine);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
if_convert (true);
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return optimize > 0 && flag_if_conversion2
&& dbg_cnt (if_after_reload);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
if_convert (true);
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize > 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return optimize > 0; }
+ unsigned int execute (function *) final override
{
initialize_uninitialized_regs ();
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return ipa_comdats (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override { return ipa_comdats (); }
}; // class pass_ipa_comdats
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* FIXME: We should remove the optimize check after we ensure we never run
IPA passes when not optimizing. */
return (flag_ipa_cp && optimize) || in_lto_p;
}
- virtual unsigned int execute (function *) { return ipcp_driver (); }
+ unsigned int execute (function *) final override { return ipcp_driver (); }
}; // class pass_ipa_cp
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* In LTO, always run the IPA passes and decide on function basis if the
pass is enabled. */
&& optimize);
}
- virtual unsigned int execute (function *) { return ipa_devirt (); }
+ unsigned int execute (function *) final override { return ipa_devirt (); }
}; // class pass_ipa_devirt
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (in_lto_p || flag_lto);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return 0;
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_local_fn_summary (m_ctxt); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_local_fn_summary (m_ctxt);
+ }
+ unsigned int execute (function *) final override
{
return compute_fn_summary_for_current ();
}
{}
/* opt_pass methods: */
- opt_pass *clone () { return new pass_ipa_free_fn_summary (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass *clone () final override
+ {
+ return new pass_ipa_free_fn_summary (m_ctxt);
+ }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
small_p = param;
}
- virtual bool gate (function *) { return true; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return true; }
+ unsigned int execute (function *) final override
{
ipa_free_fn_summary ();
/* Free ipa-prop structures if they are no longer needed. */
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return 0; }
+ unsigned int execute (function *) final override { return 0; }
}; // class pass_ipa_fn_summary
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return free_lang_data (); }
+ unsigned int execute (function *) final override { return free_lang_data (); }
}; // class pass_ipa_free_lang_data
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return in_lto_p || flag_ipa_icf_variables || flag_ipa_icf_functions;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return ipa_icf_driver();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_early_inline
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return ipa_inline (); }
+ unsigned int execute (function *) final override { return ipa_inline (); }
}; // class pass_ipa_inline
: gimple_opt_pass (pass_data_modref, ctxt) {}
/* opt_pass methods: */
- opt_pass *clone ()
+ opt_pass *clone () final override
{
return new pass_modref (m_ctxt);
}
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_ipa_modref;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
};
/* Encode TT to the output block OB using the summary streaming API. */
{}
/* opt_pass methods: */
- opt_pass *clone () { return new pass_ipa_modref (m_ctxt); }
- virtual bool gate (function *)
+ opt_pass *clone () final override { return new pass_ipa_modref (m_ctxt); }
+ bool gate (function *) final override
{
return true;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
};
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_ipa_profile || in_lto_p; }
- virtual unsigned int execute (function *) { return ipa_profile (); }
+ bool gate (function *) final override { return flag_ipa_profile || in_lto_p; }
+ unsigned int execute (function *) final override { return ipa_profile (); }
}; // class pass_ipa_profile
pass_ipa_pure_const(gcc::context *ctxt);
/* opt_pass methods: */
- bool gate (function *) { return gate_pure_const (); }
- unsigned int execute (function *fun);
+ bool gate (function *) final override { return gate_pure_const (); }
+ unsigned int execute (function *fun) final override;
void register_hooks (void);
{}
/* 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 *);
+ opt_pass * clone () final override
+ {
+ return new pass_local_pure_const (m_ctxt);
+ }
+ bool gate (function *) final override { return gate_pure_const (); }
+ unsigned int execute (function *) final override;
}; // class pass_local_pure_const
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return warn_suggest_attribute_noreturn; }
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override
+ {
+ return warn_suggest_attribute_noreturn;
+ }
+ unsigned int execute (function *fun) final override
{
if (!TREE_THIS_VOLATILE (current_function_decl)
&& EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_nothrow (m_ctxt); }
- virtual bool gate (function *) { return optimize; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_nothrow (m_ctxt); }
+ bool gate (function *) final override { return optimize; }
+ unsigned int execute (function *) final override;
}; // class pass_nothrow
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return ((in_lto_p || flag_ipa_reference)
/* Don't bother doing anything if the program has errors. */
&& !seen_error ());
}
- virtual unsigned int execute (function *) { return propagate (); }
+ unsigned int execute (function *) final override { return propagate (); }
}; // class pass_ipa_reference
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return execute_split_functions ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return execute_feedback_split_functions ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* TODO: We should remove the optimize check after we ensure we never run
IPA passes when not optimizing. */
return (flag_ipa_sra && optimize);
}
- virtual unsigned int execute (function *) { return ipa_sra_analysis (); }
+ unsigned int execute (function *) final override
+ {
+ return ipa_sra_analysis ();
+ }
}; // class pass_ipa_sra
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Do not re-run on ltrans stage. */
return !flag_ltrans;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return whole_program_function_and_variable_visibility ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return function_and_variable_visibility (flag_whole_program && !flag_lto);
}
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return ipa_cdtor_merge (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return ipa_cdtor_merge ();
+ }
}; // class pass_ipa_cdtor_merge
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return ipa_single_use (); }
+ unsigned int execute (function *) final override { return ipa_single_use (); }
}; // class pass_ipa_single_use
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return !targetm.no_register_allocation;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
ira (dump_file);
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return !targetm.no_register_allocation;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
do_reload ();
return 0;
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return cleanup_barriers (); }
+ unsigned int execute (function *) final override
+ {
+ return cleanup_barriers ();
+ }
}; // class pass_cleanup_barriers
{}
/* opt_pass methods: */
- virtual bool gate (function *);
+ bool gate (function *) final override;
}; // class pass_loop2
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return rtl_loop_init (); }
+ unsigned int execute (function *) final override { return rtl_loop_init (); }
}; // class pass_rtl_loop_init
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_rtl_loop_done
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_move_loop_invariants; }
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override { return flag_move_loop_invariants; }
+ unsigned int execute (function *fun) final override
{
if (number_of_loops (fun) > 1)
move_loop_invariants ();
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (flag_unroll_loops || flag_unroll_all_loops || cfun->has_unroll);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_rtl_unroll_loops
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
}; // class pass_rtl_doloop
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_split_wide_types != 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_split_wide_types != 0; }
+ unsigned int execute (function *) final override
{
decompose_multiword_subregs (false);
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_split_wide_types
- && flag_split_wide_types_early; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override
+ {
+ return flag_split_wide_types && flag_split_wide_types_early;
+ }
+ unsigned int execute (function *) final override
{
decompose_multiword_subregs (true);
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_split_wide_types; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_split_wide_types; }
+ unsigned int execute (function *) final override
{
decompose_multiword_subregs (true);
return 0;
/* opt_pass methods: */
/* The epiphany backend creates a second instance of this pass, so we need
a clone method. */
- opt_pass * clone () { return new pass_mode_switching (m_ctxt); }
- virtual bool gate (function *)
+ opt_pass * clone () final override { return new pass_mode_switching (m_ctxt); }
+ bool gate (function *) final override
{
#ifdef OPTIMIZE_MODE_SWITCHING
return true;
#endif
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
#ifdef OPTIMIZE_MODE_SWITCHING
optimize_mode_switching ();
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize > 0 && flag_modulo_sched);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_sms
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return ipa_target_clone (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return ipa_target_clone ();
+ }
};
bool
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
bool gate = ((flag_openacc != 0 || flag_openmp != 0
|| flag_openmp_simd != 0)
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return !(fun->curr_properties & PROP_gimple_eomp);
}
- virtual unsigned int execute (function *) { return execute_expand_omp (); }
- opt_pass * clone () { return new pass_expand_omp_ssa (m_ctxt); }
+ unsigned int execute (function *) final override
+ {
+ return execute_expand_omp ();
+ }
+ opt_pass * clone () final override
+ {
+ return new pass_expand_omp_ssa (m_ctxt);
+ }
}; // class pass_expand_omp_ssa
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return execute_lower_omp (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_lower_omp ();
+ }
}; // class pass_lower_omp
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_openacc || flag_openmp || flag_openmp_simd;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return diagnose_omp_structured_block_errors ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (flag_openacc
&& param_openacc_kernels == OPENACC_KERNELS_DECOMPOSE);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return omp_oacc_kernels_decompose ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
if (!flag_openacc)
return false;
return true;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_omp_oacc_neuter_broadcast ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_openacc; };
+ bool gate (function *) final override { return flag_openacc; };
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_oacc_loop_designation ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_openacc; };
+ bool gate (function *) final override { return flag_openacc; };
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_oacc_device_lower ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return (!(fun->curr_properties & PROP_gimple_lomp_dev)
|| (flag_openmp
&& cgraph_node::get (fun->decl)->calls_declare_variant_alt));
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_omp_device_lower ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
#ifdef ACCEL_COMPILER
return offloading_function_p (fun->decl);
#endif
}
- virtual unsigned execute (function *);
+ unsigned execute (function *) final override;
};
/* Callback for walk_gimple_stmt used to scan for link var operands. */
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return ipa_omp_simd_clone (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return ipa_omp_simd_clone ();
+ }
};
bool
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Don't bother doing anything if the program has errors. */
return (!seen_error () && !in_lto_p);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_build_ssa_passes ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Don't bother doing anything if the program has errors. */
return (!seen_error () && !in_lto_p);
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Don't bother doing anything if the program has errors. */
return (!seen_error () && !in_lto_p);
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize >= 1
/* Don't bother doing anything if the program has errors. */
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize >= 1 && !optimize_debug; }
+ bool gate (function *) final override
+ {
+ return optimize >= 1 && !optimize_debug;
+ }
}; // class pass_all_optimizations
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize >= 1 && optimize_debug; }
+ bool gate (function *) final override
+ {
+ return optimize >= 1 && optimize_debug;
+ }
}; // class pass_all_optimizations_g
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Early return if there were errors. We can run afoul of our
consistency checks, and there's not really much point in fixing them. */
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return reload_completed; }
+ bool gate (function *) final override { return reload_completed; }
}; // class pass_postreload
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return reload_completed || targetm.no_register_allocation;
}
{
}
- virtual bool
- gate (function *fun)
+ bool
+ gate (function *fun) final override
{
return flag_tree_slp_vectorize
&& (fun->pending_TODOs & PENDING_TODO_force_next_scalar_cleanup);
}
- virtual unsigned int
- execute (function *fun)
+ unsigned int
+ execute (function *fun) final override
{
fun->pending_TODOs &= ~PENDING_TODO_force_next_scalar_cleanup;
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return (optimize > 0 && flag_gcse_after_reload
&& optimize_function_for_speed_p (fun));
}
- virtual unsigned int execute (function *) { return rest_of_handle_gcse2 (); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_gcse2 ();
+ }
}; // class pass_gcse2
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return (optimize > 0 && reload_completed); }
+ bool gate (function *) final override
+ {
+ return (optimize > 0 && reload_completed);
+ }
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_postreload_cse
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_guess_branch_prob; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_guess_branch_prob; }
+ unsigned int execute (function *) final override;
}; // class pass_profile
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_strip_predict_hints (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override
+ {
+ return new pass_strip_predict_hints (m_ctxt);
+ }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
early_p = param;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
private:
bool early_p;
/* opt_pass methods: */
/* The epiphany backend creates a second instance of this pass, so we need
a clone method. */
- opt_pass * clone () { return new pass_peephole2 (m_ctxt); }
- virtual bool gate (function *) { return (optimize > 0 && flag_peephole2); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override { return new pass_peephole2 (m_ctxt); }
+ bool gate (function *) final override
+ {
+ return (optimize > 0 && flag_peephole2);
+ }
+ unsigned int execute (function *) final override
{
return rest_of_handle_peephole2 ();
}
/* opt_pass methods: */
/* 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); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_split_all_insns (m_ctxt);
+ }
+ unsigned int execute (function *) final override
{
split_all_insns ();
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* If optimizing, then go ahead and split insns now. */
return optimize > 0;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
split_all_insns ();
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return enable_split_before_sched2 ();
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
split_all_insns ();
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
split_all_insns ();
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* The placement of the splitting that we do for shorten_branches
depends on whether regstack is used by the target or not. */
#endif
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return split_all_insns_noflow ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return (optimize > 0 && flag_ree); }
- virtual unsigned int execute (function *) { return rest_of_handle_ree (); }
+ bool gate (function *) final override { return (optimize > 0 && flag_ree); }
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_ree ();
+ }
}; // class pass_ree
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
#ifdef STACK_REGS
return true;
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_stack_regs ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize > 0 && (flag_cprop_registers));
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_cprop_hardreg
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return reginfo_init (); }
+ unsigned int execute (function *) final override { return reginfo_init (); }
}; // class pass_reginfo_init
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize > 0 && (flag_rename_registers));
}
- virtual unsigned int execute (function *) { return regrename_optimize (); }
+ unsigned int execute (function *) final override
+ {
+ return regrename_optimize ();
+ }
}; // class pass_regrename
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return rest_of_handle_delay_slots ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return targetm.machine_dependent_reorg != 0;
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
targetm.machine_dependent_reorg ();
return 0;
static const pass_data data;
opt_pass *
- clone ()
+ clone () final override
{
return new pass_sancov<O0> (m_ctxt);
}
- virtual bool
- gate (function *fun)
+ bool
+ gate (function *fun) final override
{
return sanitize_coverage_p (fun->decl) && (!O0 || !optimize);
}
- virtual unsigned int
- execute (function *fun)
+ unsigned int
+ execute (function *fun) final override
{
return sancov_pass (fun);
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* SANITIZE_RETURN is handled in the front-end. When trapping,
SANITIZE_UNREACHABLE is handled by builtin_decl_unreachable. */
mask |= SANITIZE_UNREACHABLE;
return flag_sanitize & ~mask;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_sanopt
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
#ifdef INSN_SCHEDULING
return flag_live_range_shrinkage;
#endif
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return rest_of_handle_live_range_shrinkage ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return rest_of_handle_sched (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
+ {
+ return rest_of_handle_sched ();
+ }
}; // class pass_sched
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return rest_of_handle_sched2 ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return rest_of_handle_sched_fusion ();
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_stack_ptr_mod
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *)
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override
{
return execute_rtl_store_motion ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize > 0 && flag_tracer && flag_reorder_blocks);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_tracer
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tm; }
- virtual unsigned int execute (function *) { return diagnose_tm_blocks (); }
+ bool gate (function *) final override { return flag_tm; }
+ unsigned int execute (function *) final override
+ {
+ return diagnose_tm_blocks ();
+ }
}; // class pass_diagnose_tm_blocks
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tm; }
- virtual unsigned int execute (function *) { return execute_lower_tm (); }
+ bool gate (function *) final override { return flag_tm; }
+ unsigned int execute (function *) final override
+ {
+ return execute_lower_tm ();
+ }
}; // class pass_lower_tm
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_tm_init (); }
+ bool gate (function *) final override { return gate_tm_init (); }
}; // class pass_tm_init
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return execute_tm_mark (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_tm_mark ();
+ }
}; // class pass_tm_mark
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_tm_edges
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tm && optimize > 0; }
- virtual unsigned int execute (function *) { return execute_tm_memopt (); }
+ bool gate (function *) final override { return flag_tm && optimize > 0; }
+ unsigned int execute (function *) final override
+ {
+ return execute_tm_memopt ();
+ }
}; // class pass_tm_memopt
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tm; }
- virtual unsigned int execute (function *) { return ipa_tm_execute (); }
+ bool gate (function *) final override { return flag_tm; }
+ unsigned int execute (function *) final override { return ipa_tm_execute (); }
}; // class pass_ipa_tm
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* The limit constants used in the implementation
assume IEEE floating point format. Other formats
return flag_tree_builtin_call_dce != 0;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_call_cdce
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return execute_build_cfg (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_build_cfg ();
+ }
}; // class pass_build_cfg
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return split_critical_edges (); }
+ unsigned int execute (function *) final override
+ {
+ return split_critical_edges ();
+ }
- opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
+ opt_pass * clone () final override
+ {
+ return new pass_split_crit_edges (m_ctxt);
+ }
}; // class pass_split_crit_edges
} // anon namespace
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_warn_function_return
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_warn_unused_result; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_warn_unused_result; }
+ unsigned int execute (function *) final override
{
do_warn_unused_result (gimple_body (current_function_decl));
return 0;
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
- virtual unsigned int execute (function *) { return execute_fixup_cfg (); }
+ opt_pass * clone () final override { return new pass_fixup_cfg (m_ctxt); }
+ unsigned int execute (function *) final override
+ {
+ return execute_fixup_cfg ();
+ }
}; // class pass_fixup_cfg
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_merge_phi (m_ctxt); }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_merge_phi (m_ctxt); }
+ unsigned int execute (function *) final override;
}; // class pass_merge_phi
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return execute_cleanup_cfg_post_optimizing ();
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_lower_complex (m_ctxt); }
- virtual unsigned int execute (function *) { return tree_lower_complex (); }
+ opt_pass * clone () final override { return new pass_lower_complex (m_ctxt); }
+ unsigned int execute (function *) final override
+ {
+ return tree_lower_complex ();
+ }
}; // class pass_lower_complex
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
/* With errors, normal optimization passes are not run. If we don't
lower complex operations at all, rtl expansion will abort. */
return !(fun->curr_properties & PROP_gimple_lcx);
}
- virtual unsigned int execute (function *) { return tree_lower_complex (); }
+ unsigned int execute (function *) final override
+ {
+ return tree_lower_complex ();
+ }
}; // class pass_lower_complex_O0
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_lower_eh
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_exceptions != 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_exceptions != 0; }
+ unsigned int execute (function *) final override
{
refactor_eh_r (gimple_body (current_function_decl));
return 0;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_exceptions != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_exceptions != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_lower_resx
{}
/* opt_pass methods: */
- virtual bool gate (function *fun) { return fun->eh->region_tree != NULL; }
- virtual unsigned int execute (function *);
+ bool gate (function *fun) final override
+ {
+ return fun->eh->region_tree != NULL;
+ }
+ unsigned int execute (function *) final override;
}; // class pass_lower_eh_dispatch
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_cleanup_eh (m_ctxt); }
- virtual bool gate (function *fun)
+ opt_pass * clone () final override { return new pass_cleanup_eh (m_ctxt); }
+ bool gate (function *fun) final override
{
return fun->eh != NULL && fun->eh->region_tree != NULL;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_cleanup_eh
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* If the target supports TLS natively, we need do nothing here. */
return !targetm.have_tls;
}
- virtual unsigned int execute (function *) { return ipa_lower_emutls (); }
+ unsigned int execute (function *) final override
+ {
+ return ipa_lower_emutls ();
+ }
}; // class pass_ipa_lower_emutls
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *);
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override;
}; // class pass_if_conversion
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
/* Do nothing for funcions that was produced already in SSA form. */
return !(fun->curr_properties & PROP_ssa);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_build_ssa
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_tree_loop_distribution
|| flag_tree_loop_distribute_patterns;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_loop_distribution
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize > 0; }
+ bool gate (function *) final override { return optimize > 0; }
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_nrv
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_return_slot
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_object_sizes (m_ctxt); }
- virtual unsigned int execute (function *fun)
+ opt_pass * clone () final override { return new pass_object_sizes (m_ctxt); }
+ unsigned int execute (function *fun) final override
{
return object_sizes_execute (fun, false);
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *fun)
+ unsigned int execute (function *fun) final override
{
return object_sizes_execute (fun, true);
}
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
if (oacc_kernels_p)
return flag_openacc;
else
return flag_tree_parallelize_loops > 1;
}
- virtual unsigned int execute (function *);
- opt_pass * clone () { return new pass_parallelize_loops (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ unsigned int execute (function *) final override;
+ opt_pass * clone () final override
+ {
+ return new pass_parallelize_loops (m_ctxt);
+ }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
oacc_kernels_p = param;
{}
/* opt_pass methods: */
- virtual bool
- gate (function *)
+ bool
+ gate (function *) final override
{
if (flag_predictive_commoning != 0)
return true;
return false;
}
- virtual unsigned int
- execute (function *fun)
+ unsigned int
+ execute (function *fun) final override
{
bool allow_unroll_p = flag_predictive_commoning != 0;
return run_tree_predictive_commoning (fun, allow_unroll_p);
{}
/* opt_pass methods: */
- virtual bool gate (function *);
- virtual unsigned int execute (function *) { return tree_profiling (); }
+ bool gate (function *) final override;
+ unsigned int execute (function *) final override { return tree_profiling (); }
}; // class pass_ipa_tree_profile
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_intra_sra (); }
- virtual unsigned int execute (function *) { return early_intra_sra (); }
+ bool gate (function *) final override { return gate_intra_sra (); }
+ unsigned int execute (function *) final override
+ {
+ return early_intra_sra ();
+ }
}; // class pass_sra_early
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_intra_sra (); }
- virtual unsigned int execute (function *) { return late_intra_sra (); }
+ bool gate (function *) final override { return gate_intra_sra (); }
+ unsigned int execute (function *) final override { return late_intra_sra (); }
}; // class pass_sra
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_ccp (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override { return new pass_ccp (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
nonzero_p = param;
}
- virtual bool gate (function *) { return flag_tree_ccp != 0; }
- virtual unsigned int execute (function *) { return do_ssa_ccp (nonzero_p); }
+ bool gate (function *) final override { return flag_tree_ccp != 0; }
+ unsigned int execute (function *) final override
+ {
+ return do_ssa_ccp (nonzero_p);
+ }
private:
/* Determines whether the pass instance records nonzero bits. */
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_fold_builtins (m_ctxt); }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_fold_builtins (m_ctxt); }
+ unsigned int execute (function *) final override;
}; // class pass_fold_builtins
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_post_ipa_warn (m_ctxt); }
- virtual bool gate (function *) { return warn_nonnull != 0; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_post_ipa_warn (m_ctxt); }
+ bool gate (function *) final override { return warn_nonnull != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_fold_builtins
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_copy_prop (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_copy_prop != 0; }
- virtual unsigned int execute (function *) { return execute_copy_prop (); }
+ opt_pass * clone () final override { return new pass_copy_prop (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_copy_prop != 0; }
+ unsigned int execute (function *) final override
+ {
+ return execute_copy_prop ();
+ }
}; // class pass_copy_prop
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_dce (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_dce != 0; }
- virtual unsigned int execute (function *) { return tree_ssa_dce (); }
+ opt_pass * clone () final override { return new pass_dce (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_dce != 0; }
+ unsigned int execute (function *) final override { return tree_ssa_dce (); }
}; // class pass_dce
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_cd_dce (m_ctxt); }
- void set_pass_param (unsigned n, bool param)
+ opt_pass * clone () final override { return new pass_cd_dce (m_ctxt); }
+ void set_pass_param (unsigned n, bool param) final override
{
gcc_assert (n == 0);
update_address_taken_p = param;
}
- virtual bool gate (function *) { return flag_tree_dce != 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_tree_dce != 0; }
+ unsigned int execute (function *) final override
{
return (tree_ssa_cd_dce ()
| (update_address_taken_p ? TODO_update_address_taken : 0));
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_dominator (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override { return new pass_dominator (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
may_peel_loop_headers_p = param;
}
- virtual bool gate (function *) { return flag_tree_dom != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_tree_dom != 0; }
+ unsigned int execute (function *) final override;
private:
/* This flag is used to prevent loops from being peeled repeatedly in jump
{}
/* 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 *);
+ opt_pass * clone () final override { return new pass_dse (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_dse != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_dse
{}
/* 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 *);
+ opt_pass * clone () final override { return new pass_forwprop (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_forwprop; }
+ unsigned int execute (function *) final override;
}; // class pass_forwprop
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_tree_ifcombine
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_ch != 0; }
+ bool gate (function *) final override { return flag_tree_ch != 0; }
/* Initialize and finalize loop structures, copying headers inbetween. */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
- opt_pass * clone () { return new pass_ch (m_ctxt); }
+ opt_pass * clone () final override { return new pass_ch (m_ctxt); }
protected:
/* ch_base method: */
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return flag_tree_ch != 0
&& (flag_tree_loop_vectorize != 0 || fun->has_force_vectorize_loops);
}
/* Just copy headers, no initialization/finalization of loop structures. */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
protected:
/* ch_base method: */
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_lim (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_loop_im != 0; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_lim (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_loop_im != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_lim
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_loop_ivcanon != 0; }
- virtual unsigned int execute (function *fun);
+ bool gate (function *) final override { return flag_tree_loop_ivcanon != 0; }
+ unsigned int execute (function *fun) final override;
}; // class pass_iv_canon
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_complete_unroll
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize >= 2; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return optimize >= 2; }
+ unsigned int execute (function *) final override;
}; // class pass_complete_unrolli
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_prefetch_loop_arrays > 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override
+ {
+ return flag_prefetch_loop_arrays > 0;
+ }
+ unsigned int execute (function *) final override;
}; // class pass_loop_prefetch
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_split_loops != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_split_loops != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_loop_split
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_unswitch_loops != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_unswitch_loops != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_tree_unswitch
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_loop_optimize; }
+ bool gate (function *) final override { return flag_tree_loop_optimize; }
- virtual unsigned int execute (function *fn);
+ unsigned int execute (function *fn) final override;
}; // class pass_fix_loops
unsigned int
{}
/* opt_pass methods: */
- virtual bool gate (function *fn) { return gate_loop (fn); }
+ bool gate (function *fn) final override { return gate_loop (fn); }
}; // class pass_tree_loop
{}
/* opt_pass methods: */
- virtual bool gate (function *fn) { return gate_oacc_kernels (fn); }
+ bool gate (function *fn) final override { return gate_oacc_kernels (fn); }
}; // class pass_oacc_kernels
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize
&& flag_openacc
{}
/* opt_pass methods: */
- virtual bool gate (function *fn) { return !gate_loop (fn); }
+ bool gate (function *fn) final override { return !gate_loop (fn); }
}; // class pass_tree_no_loop
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_tree_loop_init
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_scev_cprop; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_tree_scev_cprop; }
+ unsigned int execute (function *) final override;
}; // class pass_scev_cprop
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_ivopts != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_ivopts != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_iv_optimize
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *) { return tree_ssa_loop_done (); }
+ unsigned int execute (function *) final override
+ {
+ return tree_ssa_loop_done ();
+ }
}; // class pass_tree_loop_done
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return optimize && flag_reciprocal_math; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override
+ {
+ return optimize && flag_reciprocal_math;
+ }
+ unsigned int execute (function *) final override;
}; // class pass_cse_reciprocals
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* We no longer require either sincos or cexp, since powi expansion
piggybacks on this pass. */
return optimize;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_cse_sincos
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_expensive_optimizations && optimize;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_optimize_widening_mul
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_phiopt (m_ctxt); }
- void set_pass_param (unsigned n, bool param)
+ opt_pass * clone () final override { return new pass_phiopt (m_ctxt); }
+ void set_pass_param (unsigned n, bool param) final override
{
gcc_assert (n == 0);
early_p = param;
}
- virtual bool gate (function *) { return flag_ssa_phiopt; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_ssa_phiopt; }
+ unsigned int execute (function *) final override
{
return tree_ssa_phiopt_worker (false,
!early_p ? gate_hoist_loads () : false,
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_cselim; }
- virtual unsigned int execute (function *) { return tree_ssa_cs_elim (); }
+ bool gate (function *) final override { return flag_tree_cselim; }
+ unsigned int execute (function *) final override
+ {
+ return tree_ssa_cs_elim ();
+ }
}; // class pass_cselim
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_phiprop; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return flag_tree_phiprop; }
+ unsigned int execute (function *) final override;
}; // class pass_phiprop
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{ return flag_tree_pre != 0 || flag_code_hoisting != 0; }
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_pre
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_reassoc (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override { return new pass_reassoc (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
insert_powi_p = param;
bias_loop_carried_phi_ranks_p = !param;
}
- virtual bool gate (function *) { return flag_tree_reassoc != 0; }
- virtual unsigned int execute (function *)
+ bool gate (function *) final override { return flag_tree_reassoc != 0; }
+ unsigned int execute (function *) final override
{
return execute_reassoc (insert_powi_p, bias_loop_carried_phi_ranks_p);
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_fre (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override { return new pass_fre (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
may_iterate = param;
}
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_tree_fre != 0 && (may_iterate || optimize > 1);
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
private:
bool may_iterate;
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_sink != 0; }
- virtual unsigned int execute (function *);
- opt_pass *clone (void) { return new pass_sink_code (m_ctxt); }
- void set_pass_param (unsigned n, bool param)
+ bool gate (function *) final override { return flag_tree_sink != 0; }
+ unsigned int execute (function *) final override;
+ opt_pass *clone (void) final override { return new pass_sink_code (m_ctxt); }
+ void set_pass_param (unsigned n, bool param) final override
{
gcc_assert (n == 0);
unsplit_edges = param;
: gimple_opt_pass (pass_data_warn_printf, ctxt)
{}
- virtual bool gate (function *);
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override;
+ unsigned int execute (function *fun) final override
{
return printf_strlen_execute (fun, true);
}
: gimple_opt_pass (pass_data_strlen, ctxt)
{}
- opt_pass * clone () { return new pass_strlen (m_ctxt); }
+ opt_pass * clone () final override { return new pass_strlen (m_ctxt); }
- virtual bool gate (function *);
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override;
+ unsigned int execute (function *fun) final override
{
return printf_strlen_execute (fun, false);
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_pta; }
+ bool gate (function *) final override { return flag_tree_pta; }
}; // class pass_build_alias
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_pta; }
+ bool gate (function *) final override { return flag_tree_pta; }
}; // class pass_build_ealias
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (optimize
&& flag_ipa_pta
&& !seen_error ());
}
- opt_pass * clone () { return new pass_ipa_pta (m_ctxt); }
+ opt_pass * clone () final override { return new pass_ipa_pta (m_ctxt); }
- virtual unsigned int execute (function *) { return ipa_pta_execute (); }
+ unsigned int execute (function *) final override
+ {
+ return ipa_pta_execute ();
+ }
}; // class pass_ipa_pta
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_uncprop (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_dom != 0; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_uncprop (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_dom != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_uncprop
{}
/* 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 *);
+ opt_pass *clone () final override
+ {
+ return new pass_late_warn_uninitialized (m_ctxt);
+ }
+ bool gate (function *) final override { return gate_warn_uninitialized (); }
+ unsigned int execute (function *) final override;
}; // class pass_late_warn_uninitialized
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_warn_uninitialized (); }
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override { return gate_warn_uninitialized (); }
+ unsigned int execute (function *fun) final override
{
return execute_early_warn_uninitialized (fun);
}
{}
/* opt_pass methods: */
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_release_ssa_names
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
/* Always run this pass, in order to expand va_arg internal_fns. We
also need to do that if fun->stdarg == 0, because a va_arg may also
return true;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_stdarg
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (cfun->curr_properties & PROP_gimple_lva) == 0;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_lower_vaarg
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return flag_tree_switch_conversion != 0; }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override
+ {
+ return flag_tree_switch_conversion != 0;
+ }
+ unsigned int execute (function *) final override;
}; // class pass_convert_switch
static const pass_data data;
opt_pass *
- clone ()
+ clone () final override
{
return new pass_lower_switch<O0> (m_ctxt);
}
- virtual bool
- gate (function *)
+ bool
+ gate (function *) final override
{
return !O0 || !optimize;
}
- virtual unsigned int execute (function *fun);
+ unsigned int execute (function *fun) final override;
}; // class pass_lower_switch
template <bool O0>
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_tail_recursion (m_ctxt); }
- virtual bool gate (function *) { return gate_tail_calls (); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_tail_recursion (m_ctxt);
+ }
+ bool gate (function *) final override { return gate_tail_calls (); }
+ unsigned int execute (function *) final override
{
return tree_optimize_tail_calls_1 (false);
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return gate_tail_calls (); }
- virtual unsigned int execute (function *) { return execute_tail_calls (); }
+ bool gate (function *) final override { return gate_tail_calls (); }
+ unsigned int execute (function *) final override
+ {
+ return execute_tail_calls ();
+ }
}; // class pass_tail_calls
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return !(fun->curr_properties & PROP_gimple_lvec);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return expand_vector_operations ();
}
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_lower_vector_ssa (m_ctxt); }
- virtual unsigned int execute (function *)
+ opt_pass * clone () final override
+ {
+ return new pass_lower_vector_ssa (m_ctxt);
+ }
+ unsigned int execute (function *) final override
{
return expand_vector_operations ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ bool gate (function *fun) final override
{
return flag_tree_loop_vectorize || fun->has_force_vectorize_loops;
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_vectorize
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_simduid_cleanup (m_ctxt); }
- virtual bool gate (function *fun) { return fun->has_simduid_loops; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override
+ {
+ return new pass_simduid_cleanup (m_ctxt);
+ }
+ bool gate (function *fun) final override { return fun->has_simduid_loops; }
+ unsigned int execute (function *) final override;
}; // class pass_simduid_cleanup
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_slp_vectorize (m_ctxt); }
- virtual bool gate (function *) { return flag_tree_slp_vectorize != 0; }
- virtual unsigned int execute (function *);
+ opt_pass * clone () final override { return new pass_slp_vectorize (m_ctxt); }
+ bool gate (function *) final override { return flag_tree_slp_vectorize != 0; }
+ unsigned int execute (function *) final override;
}; // class pass_slp_vectorize
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return flag_section_anchors && flag_tree_loop_vectorize;
}
- virtual unsigned int execute (function *) { return increase_alignment (); }
+ unsigned int execute (function *) final override
+ {
+ return increase_alignment ();
+ }
}; // class pass_ipa_increase_alignment
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_vrp (m_ctxt); }
- void set_pass_param (unsigned int n, bool param)
+ opt_pass * clone () final override { return new pass_vrp (m_ctxt); }
+ void set_pass_param (unsigned int n, bool param) final override
{
gcc_assert (n == 0);
warn_array_bounds_p = param;
}
- virtual bool gate (function *) { return flag_tree_vrp != 0; }
- virtual unsigned int execute (function *fun)
+ bool gate (function *) final override { return flag_tree_vrp != 0; }
+ unsigned int execute (function *fun) final override
{
if ((my_pass == 1 && param_vrp1_mode == VRP_MODE_RANGER)
|| (my_pass == 2 && param_vrp2_mode == VRP_MODE_RANGER))
{}
/* opt_pass methods: */
- opt_pass * clone () { return new pass_tsan (m_ctxt); }
- virtual bool gate (function *)
+ opt_pass * clone () final override { return new pass_tsan (m_ctxt); }
+ bool gate (function *) final override
{
return sanitize_flags_p (SANITIZE_THREAD);
}
- virtual unsigned int execute (function *) { return tsan_pass (); }
+ unsigned int execute (function *) final override { return tsan_pass (); }
}; // class pass_tsan
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (sanitize_flags_p (SANITIZE_THREAD) && !optimize);
}
- virtual unsigned int execute (function *) { return tsan_pass (); }
+ unsigned int execute (function *) final override { return tsan_pass (); }
}; // class pass_tsan_O0
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return sanitize_flags_p ((SANITIZE_NULL | SANITIZE_SI_OVERFLOW
| SANITIZE_BOOL | SANITIZE_ENUM
| SANITIZE_BUILTIN));
}
- virtual unsigned int execute (function *);
+ unsigned int execute (function *) final override;
}; // class pass_ubsan
{}
/* opt_pass methods: */
- virtual bool gate (function *)
+ bool gate (function *) final override
{
return (flag_var_tracking && !targetm.delay_vartrack);
}
- virtual unsigned int execute (function *)
+ unsigned int execute (function *) final override
{
return variable_tracking_main ();
}
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return (flag_vtable_verify); }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return (flag_vtable_verify); }
+ unsigned int execute (function *) final override;
}; // class pass_vtable_verify
{}
/* opt_pass methods: */
- virtual bool gate (function *) { return (optimize > 0 && flag_web); }
- virtual unsigned int execute (function *);
+ bool gate (function *) final override { return (optimize > 0 && flag_web); }
+ unsigned int execute (function *) final override;
}; // class pass_web
projects / platform / upstream / gcc.git / commitdiff