[thirdparty/gcc.git] / gcc / passes.def

/* Description of pass structure
   Copyright (C) 1987-2015 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

/*
 Macros that should be defined when using this file:
   INSERT_PASSES_AFTER (PASS)
   PUSH_INSERT_PASSES_WITHIN (PASS)
   POP_INSERT_PASSES ()
   NEXT_PASS (PASS)
   TERMINATE_PASS_LIST ()
 */

 /* All passes needed to lower the function into shape optimizers can
    operate on.  These passes are always run first on the function, but
    backend might produce already lowered functions that are not processed
    by these passes.  */
  INSERT_PASSES_AFTER (all_lowering_passes)
  NEXT_PASS (pass_warn_unused_result);
  NEXT_PASS (pass_diagnose_omp_blocks);
  NEXT_PASS (pass_diagnose_tm_blocks);
  NEXT_PASS (pass_lower_omp);
  NEXT_PASS (pass_lower_cf);
  NEXT_PASS (pass_lower_tm);
  NEXT_PASS (pass_refactor_eh);
  NEXT_PASS (pass_lower_eh);
  NEXT_PASS (pass_build_cfg);
  NEXT_PASS (pass_warn_function_return);
  NEXT_PASS (pass_expand_omp);
  NEXT_PASS (pass_build_cgraph_edges);
  TERMINATE_PASS_LIST ()

  /* Interprocedural optimization passes.  */
  INSERT_PASSES_AFTER (all_small_ipa_passes)
  NEXT_PASS (pass_ipa_free_lang_data);
  NEXT_PASS (pass_ipa_function_and_variable_visibility);
  NEXT_PASS (pass_ipa_chkp_versioning);
  NEXT_PASS (pass_ipa_chkp_early_produce_thunks);
  NEXT_PASS (pass_build_ssa_passes);
  PUSH_INSERT_PASSES_WITHIN (pass_build_ssa_passes)
      NEXT_PASS (pass_fixup_cfg);
      NEXT_PASS (pass_init_datastructures);
      NEXT_PASS (pass_build_ssa);
      NEXT_PASS (pass_ubsan);
      NEXT_PASS (pass_early_warn_uninitialized);
      NEXT_PASS (pass_nothrow);
  POP_INSERT_PASSES ()

  NEXT_PASS (pass_chkp_instrumentation_passes);
  PUSH_INSERT_PASSES_WITHIN (pass_chkp_instrumentation_passes)
      NEXT_PASS (pass_fixup_cfg);
      NEXT_PASS (pass_chkp);
      NEXT_PASS (pass_rebuild_cgraph_edges);
  POP_INSERT_PASSES ()

  NEXT_PASS (pass_local_optimization_passes);
  PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes)
      NEXT_PASS (pass_fixup_cfg);
      NEXT_PASS (pass_rebuild_cgraph_edges);
      NEXT_PASS (pass_inline_parameters);
      NEXT_PASS (pass_early_inline);
      NEXT_PASS (pass_all_early_optimizations);
      PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
	  NEXT_PASS (pass_remove_cgraph_callee_edges);
	  NEXT_PASS (pass_object_sizes);
	  NEXT_PASS (pass_ccp);
	  /* After CCP we rewrite no longer addressed locals into SSA
	     form if possible.  */
	  NEXT_PASS (pass_forwprop);
	  NEXT_PASS (pass_sra_early);
	  /* pass_build_ealias is a dummy pass that ensures that we
	     execute TODO_rebuild_alias at this point.  */
	  NEXT_PASS (pass_build_ealias);
	  NEXT_PASS (pass_fre);
	  NEXT_PASS (pass_merge_phi);
          NEXT_PASS (pass_dse);
	  NEXT_PASS (pass_cd_dce);
	  NEXT_PASS (pass_early_ipa_sra);
	  NEXT_PASS (pass_tail_recursion);
	  NEXT_PASS (pass_convert_switch);
	  NEXT_PASS (pass_cleanup_eh);
	  NEXT_PASS (pass_profile);
	  NEXT_PASS (pass_local_pure_const);
	  /* Split functions creates parts that are not run through
	     early optimizations again.  It is thus good idea to do this
	      late.  */
	  NEXT_PASS (pass_split_functions);
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_release_ssa_names);
      NEXT_PASS (pass_rebuild_cgraph_edges);
      NEXT_PASS (pass_inline_parameters);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_ipa_chkp_produce_thunks);
  NEXT_PASS (pass_ipa_auto_profile);
  NEXT_PASS (pass_ipa_free_inline_summary);
  NEXT_PASS (pass_ipa_tree_profile);
  PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
      NEXT_PASS (pass_feedback_split_functions);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_ipa_increase_alignment);
  NEXT_PASS (pass_ipa_tm);
  NEXT_PASS (pass_ipa_lower_emutls);
  TERMINATE_PASS_LIST ()

  INSERT_PASSES_AFTER (all_regular_ipa_passes)
  NEXT_PASS (pass_ipa_whole_program_visibility);
  NEXT_PASS (pass_ipa_profile);
  NEXT_PASS (pass_ipa_icf);
  NEXT_PASS (pass_ipa_devirt);
  NEXT_PASS (pass_ipa_cp);
  NEXT_PASS (pass_ipa_cdtor_merge);
  NEXT_PASS (pass_target_clone);
  NEXT_PASS (pass_ipa_inline);
  NEXT_PASS (pass_ipa_pure_const);
  NEXT_PASS (pass_ipa_reference);
  /* This pass needs to be scheduled after any IP code duplication.   */
  NEXT_PASS (pass_ipa_single_use);
  /* Comdat privatization come last, as direct references to comdat local
     symbols are not allowed outside of the comdat group.  Privatizing early
     would result in missed optimizations due to this restriction.  */
  NEXT_PASS (pass_ipa_comdats);
  TERMINATE_PASS_LIST ()

  /* Simple IPA passes executed after the regular passes.  In WHOPR mode the
     passes are executed after partitioning and thus see just parts of the
     compiled unit.  */
  INSERT_PASSES_AFTER (all_late_ipa_passes)
  NEXT_PASS (pass_ipa_pta);
  NEXT_PASS (pass_dispatcher_calls);
  NEXT_PASS (pass_omp_simd_clone);
  TERMINATE_PASS_LIST ()

  /* These passes are run after IPA passes on every function that is being
     output to the assembler file.  */
  INSERT_PASSES_AFTER (all_passes)
  NEXT_PASS (pass_fixup_cfg);
  NEXT_PASS (pass_lower_eh_dispatch);
  NEXT_PASS (pass_oacc_device_lower);
  NEXT_PASS (pass_all_optimizations);
  PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
      NEXT_PASS (pass_remove_cgraph_callee_edges);
      /* Initial scalar cleanups before alias computation.
	 They ensure memory accesses are not indirect wherever possible.  */
      NEXT_PASS (pass_strip_predict_hints);
      NEXT_PASS (pass_ccp);
      /* After CCP we rewrite no longer addressed locals into SSA
	 form if possible.  */
      NEXT_PASS (pass_complete_unrolli);
      NEXT_PASS (pass_backprop);
      NEXT_PASS (pass_phiprop);
      NEXT_PASS (pass_forwprop);
      NEXT_PASS (pass_object_sizes);
      /* pass_build_alias is a dummy pass that ensures that we
	 execute TODO_rebuild_alias at this point.  */
      NEXT_PASS (pass_build_alias);
      NEXT_PASS (pass_return_slot);
      NEXT_PASS (pass_fre);
      NEXT_PASS (pass_merge_phi);
      NEXT_PASS (pass_vrp, true /* warn_array_bounds_p */);
      NEXT_PASS (pass_chkp_opt);
      NEXT_PASS (pass_dce);
      NEXT_PASS (pass_stdarg);
      NEXT_PASS (pass_call_cdce);
      NEXT_PASS (pass_cselim);
      NEXT_PASS (pass_copy_prop);
      NEXT_PASS (pass_tree_ifcombine);
      NEXT_PASS (pass_merge_phi);
      NEXT_PASS (pass_phiopt);
      NEXT_PASS (pass_tail_recursion);
      NEXT_PASS (pass_ch);
      NEXT_PASS (pass_lower_complex);
      NEXT_PASS (pass_sra);
      /* The dom pass will also resolve all __builtin_constant_p calls
         that are still there to 0.  This has to be done after some
	 propagations have already run, but before some more dead code
	 is removed, and this place fits nicely.  Remember this when
	 trying to move or duplicate pass_dominator somewhere earlier.  */
      NEXT_PASS (pass_dominator);
      /* At this point the majority of const/copy propagations
	 are exposed.  Go ahead and identify paths that should never
	 be executed in a conforming program and isolate those paths.

	 This will expose more degenerate PHIs in the main path and
	 expose more PRE/DOM optimization opportunities.  */
      NEXT_PASS (pass_isolate_erroneous_paths);
      /* The only const/copy propagation opportunities left after
	 DOM and erroneous path isolation should be due to degenerate PHI nodes.
	 So rather than run the full propagators, run a specialized pass which
	 only examines PHIs to discover const/copy propagation
	 opportunities.  */
      NEXT_PASS (pass_phi_only_cprop);
      NEXT_PASS (pass_dse);
      NEXT_PASS (pass_reassoc);
      NEXT_PASS (pass_dce);
      NEXT_PASS (pass_forwprop);
      NEXT_PASS (pass_phiopt);
      NEXT_PASS (pass_ccp);
      /* After CCP we rewrite no longer addressed locals into SSA
	 form if possible.  */
      NEXT_PASS (pass_cse_sincos);
      NEXT_PASS (pass_optimize_bswap);
      NEXT_PASS (pass_laddress);
      NEXT_PASS (pass_split_crit_edges);
      NEXT_PASS (pass_pre);
      NEXT_PASS (pass_sink_code);
      NEXT_PASS (pass_asan);
      NEXT_PASS (pass_tsan);
      /* Pass group that runs when 1) enabled, 2) there are loops
	 in the function.  Make sure to run pass_fix_loops before
	 to discover/remove loops before running the gate function
	 of pass_tree_loop.  */
      NEXT_PASS (pass_fix_loops);
      NEXT_PASS (pass_tree_loop);
      PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
	  NEXT_PASS (pass_tree_loop_init);
	  NEXT_PASS (pass_lim);
	  NEXT_PASS (pass_copy_prop);
	  NEXT_PASS (pass_dce);
	  NEXT_PASS (pass_tree_unswitch);
	  NEXT_PASS (pass_scev_cprop);
	  NEXT_PASS (pass_record_bounds);
	  NEXT_PASS (pass_loop_distribution);
	  NEXT_PASS (pass_copy_prop);
	  NEXT_PASS (pass_graphite);
	  PUSH_INSERT_PASSES_WITHIN (pass_graphite)
	      NEXT_PASS (pass_graphite_transforms);
	      NEXT_PASS (pass_lim);
	      NEXT_PASS (pass_copy_prop);
	      NEXT_PASS (pass_dce);
	  POP_INSERT_PASSES ()
	  NEXT_PASS (pass_iv_canon);
	  NEXT_PASS (pass_parallelize_loops);
	  PUSH_INSERT_PASSES_WITHIN (pass_parallelize_loops)
	      NEXT_PASS (pass_expand_omp_ssa);
	  POP_INSERT_PASSES ()
	  NEXT_PASS (pass_ch_vect);
	  NEXT_PASS (pass_if_conversion);
	  /* pass_vectorize must immediately follow pass_if_conversion.
	     Please do not add any other passes in between.  */
	  NEXT_PASS (pass_vectorize);
          PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
	      NEXT_PASS (pass_dce);
          POP_INSERT_PASSES ()
          NEXT_PASS (pass_predcom);
	  NEXT_PASS (pass_complete_unroll);
	  NEXT_PASS (pass_slp_vectorize);
	  NEXT_PASS (pass_loop_prefetch);
	  /* Run IVOPTs after the last pass that uses data-reference analysis
	     as that doesn't handle TARGET_MEM_REFs.  */
	  NEXT_PASS (pass_iv_optimize);
	  NEXT_PASS (pass_lim);
	  NEXT_PASS (pass_tree_loop_done);
      POP_INSERT_PASSES ()
      /* Pass group that runs when pass_tree_loop is disabled or there
         are no loops in the function.  */
      NEXT_PASS (pass_tree_no_loop);
      PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
	  NEXT_PASS (pass_slp_vectorize);
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_simduid_cleanup);
      NEXT_PASS (pass_lower_vector_ssa);
      NEXT_PASS (pass_split_paths);
      NEXT_PASS (pass_cse_reciprocals);
      NEXT_PASS (pass_reassoc);
      NEXT_PASS (pass_strength_reduction);
      NEXT_PASS (pass_tracer);
      NEXT_PASS (pass_dominator);
      NEXT_PASS (pass_strlen);
      NEXT_PASS (pass_vrp, false /* warn_array_bounds_p */);
      /* The only const/copy propagation opportunities left after
	 DOM and VRP should be due to degenerate PHI nodes.  So rather than
	 run the full propagators, run a specialized pass which
	 only examines PHIs to discover const/copy propagation
	 opportunities.  */
      NEXT_PASS (pass_phi_only_cprop);
      NEXT_PASS (pass_cd_dce);
      NEXT_PASS (pass_dse);
      NEXT_PASS (pass_forwprop);
      NEXT_PASS (pass_phiopt);
      NEXT_PASS (pass_fold_builtins);
      NEXT_PASS (pass_optimize_widening_mul);
      NEXT_PASS (pass_tail_calls);
      /* FIXME: If DCE is not run before checking for uninitialized uses,
	 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
	 However, this also causes us to misdiagnose cases that should be
	 real warnings (e.g., testsuite/gcc.dg/pr18501.c).

	 To fix the false positives in uninit-5.c, we would have to
	 account for the predicates protecting the set and the use of each
	 variable.  Using a representation like Gated Single Assignment
	 may help.  */
      /* Split critical edges before late uninit warning to reduce the
         number of false positives from it.  */
      NEXT_PASS (pass_split_crit_edges);
      NEXT_PASS (pass_late_warn_uninitialized);
      NEXT_PASS (pass_uncprop);
      NEXT_PASS (pass_local_pure_const);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_all_optimizations_g);
  PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
      NEXT_PASS (pass_remove_cgraph_callee_edges);
      NEXT_PASS (pass_strip_predict_hints);
      /* Lower remaining pieces of GIMPLE.  */
      NEXT_PASS (pass_lower_complex);
      NEXT_PASS (pass_lower_vector_ssa);
      /* Perform simple scalar cleanup which is constant/copy propagation.  */
      NEXT_PASS (pass_ccp);
      NEXT_PASS (pass_object_sizes);
      /* Fold remaining builtins.  */
      NEXT_PASS (pass_fold_builtins);
      /* Copy propagation also copy-propagates constants, this is necessary
         to forward object-size and builtin folding results properly.  */
      NEXT_PASS (pass_copy_prop);
      NEXT_PASS (pass_dce);
      NEXT_PASS (pass_asan);
      NEXT_PASS (pass_tsan);
      /* ???  We do want some kind of loop invariant motion, but we possibly
         need to adjust LIM to be more friendly towards preserving accurate
	 debug information here.  */
      /* Split critical edges before late uninit warning to reduce the
         number of false positives from it.  */
      NEXT_PASS (pass_split_crit_edges);
      NEXT_PASS (pass_late_warn_uninitialized);
      NEXT_PASS (pass_uncprop);
      NEXT_PASS (pass_local_pure_const);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_tm_init);
  PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
      NEXT_PASS (pass_tm_mark);
      NEXT_PASS (pass_tm_memopt);
      NEXT_PASS (pass_tm_edges);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_simduid_cleanup);
  NEXT_PASS (pass_vtable_verify);
  NEXT_PASS (pass_lower_vaarg);
  NEXT_PASS (pass_lower_vector);
  NEXT_PASS (pass_lower_complex_O0);
  NEXT_PASS (pass_asan_O0);
  NEXT_PASS (pass_tsan_O0);
  NEXT_PASS (pass_sanopt);
  NEXT_PASS (pass_cleanup_eh);
  NEXT_PASS (pass_lower_resx);
  NEXT_PASS (pass_nrv);
  NEXT_PASS (pass_cleanup_cfg_post_optimizing);
  NEXT_PASS (pass_warn_function_noreturn);

  NEXT_PASS (pass_expand);

  NEXT_PASS (pass_rest_of_compilation);
  PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
      NEXT_PASS (pass_instantiate_virtual_regs);
      NEXT_PASS (pass_into_cfg_layout_mode);
      NEXT_PASS (pass_jump);
      NEXT_PASS (pass_lower_subreg);
      NEXT_PASS (pass_df_initialize_opt);
      NEXT_PASS (pass_cse);
      NEXT_PASS (pass_rtl_fwprop);
      NEXT_PASS (pass_rtl_cprop);
      NEXT_PASS (pass_rtl_pre);
      NEXT_PASS (pass_rtl_hoist);
      NEXT_PASS (pass_rtl_cprop);
      NEXT_PASS (pass_rtl_store_motion);
      NEXT_PASS (pass_cse_after_global_opts);
      NEXT_PASS (pass_rtl_ifcvt);
      NEXT_PASS (pass_reginfo_init);
      /* Perform loop optimizations.  It might be better to do them a bit
	 sooner, but we want the profile feedback to work more
	 efficiently.  */
      NEXT_PASS (pass_loop2);
      PUSH_INSERT_PASSES_WITHIN (pass_loop2)
	  NEXT_PASS (pass_rtl_loop_init);
	  NEXT_PASS (pass_rtl_move_loop_invariants);
	  NEXT_PASS (pass_rtl_unroll_loops);
	  NEXT_PASS (pass_rtl_doloop);
	  NEXT_PASS (pass_rtl_loop_done);
	  TERMINATE_PASS_LIST ()
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_web);
      NEXT_PASS (pass_rtl_cprop);
      NEXT_PASS (pass_cse2);
      NEXT_PASS (pass_rtl_dse1);
      NEXT_PASS (pass_rtl_fwprop_addr);
      NEXT_PASS (pass_inc_dec);
      NEXT_PASS (pass_initialize_regs);
      NEXT_PASS (pass_ud_rtl_dce);
      NEXT_PASS (pass_combine);
      NEXT_PASS (pass_if_after_combine);
      NEXT_PASS (pass_partition_blocks);
      NEXT_PASS (pass_outof_cfg_layout_mode);
      NEXT_PASS (pass_split_all_insns);
      NEXT_PASS (pass_lower_subreg2);
      NEXT_PASS (pass_df_initialize_no_opt);
      NEXT_PASS (pass_stack_ptr_mod);
      NEXT_PASS (pass_mode_switching);
      NEXT_PASS (pass_match_asm_constraints);
      NEXT_PASS (pass_sms);
      NEXT_PASS (pass_live_range_shrinkage);
      NEXT_PASS (pass_sched);
      NEXT_PASS (pass_ira);
      NEXT_PASS (pass_reload);
      NEXT_PASS (pass_postreload);
      PUSH_INSERT_PASSES_WITHIN (pass_postreload)
	  NEXT_PASS (pass_postreload_cse);
	  NEXT_PASS (pass_gcse2);
	  NEXT_PASS (pass_split_after_reload);
	  NEXT_PASS (pass_ree);
	  NEXT_PASS (pass_compare_elim_after_reload);
	  NEXT_PASS (pass_branch_target_load_optimize1);
	  NEXT_PASS (pass_thread_prologue_and_epilogue);
	  NEXT_PASS (pass_rtl_dse2);
	  NEXT_PASS (pass_stack_adjustments);
	  NEXT_PASS (pass_jump2);
	  NEXT_PASS (pass_duplicate_computed_gotos);
	  NEXT_PASS (pass_sched_fusion);
	  NEXT_PASS (pass_peephole2);
	  NEXT_PASS (pass_if_after_reload);
	  NEXT_PASS (pass_regrename);
	  NEXT_PASS (pass_cprop_hardreg);
	  NEXT_PASS (pass_fast_rtl_dce);
	  NEXT_PASS (pass_reorder_blocks);
	  NEXT_PASS (pass_branch_target_load_optimize2);
	  NEXT_PASS (pass_leaf_regs);
	  NEXT_PASS (pass_split_before_sched2);
	  NEXT_PASS (pass_sched2);
	  NEXT_PASS (pass_stack_regs);
	  PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
	      NEXT_PASS (pass_split_before_regstack);
	      NEXT_PASS (pass_stack_regs_run);
	  POP_INSERT_PASSES ()
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_late_compilation);
      PUSH_INSERT_PASSES_WITHIN (pass_late_compilation)
	  NEXT_PASS (pass_compute_alignments);
	  NEXT_PASS (pass_variable_tracking);
	  NEXT_PASS (pass_free_cfg);
	  NEXT_PASS (pass_machine_reorg);
	  NEXT_PASS (pass_cleanup_barriers);
	  NEXT_PASS (pass_delay_slots);
	  NEXT_PASS (pass_split_for_shorten_branches);
	  NEXT_PASS (pass_convert_to_eh_region_ranges);
	  NEXT_PASS (pass_shorten_branches);
	  NEXT_PASS (pass_set_nothrow_function_flags);
	  NEXT_PASS (pass_dwarf2_frame);
	  NEXT_PASS (pass_final);
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_df_finish);
  POP_INSERT_PASSES ()
  NEXT_PASS (pass_clean_state);
  TERMINATE_PASS_LIST ()
Commit	Line	Data
0f9cdef4	1	/* Description of pass structure
5624e564	2	Copyright (C) 1987-2015 Free Software Foundation, Inc.
0f9cdef4 DM	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	/*
	21	Macros that should be defined when using this file:
	22	INSERT_PASSES_AFTER (PASS)
	23	PUSH_INSERT_PASSES_WITHIN (PASS)
	24	POP_INSERT_PASSES ()
	25	NEXT_PASS (PASS)
	26	TERMINATE_PASS_LIST ()
	27	*/
	28
	29	/* All passes needed to lower the function into shape optimizers can
	30	operate on. These passes are always run first on the function, but
	31	backend might produce already lowered functions that are not processed
	32	by these passes. */
	33	INSERT_PASSES_AFTER (all_lowering_passes)
	34	NEXT_PASS (pass_warn_unused_result);
	35	NEXT_PASS (pass_diagnose_omp_blocks);
	36	NEXT_PASS (pass_diagnose_tm_blocks);
0f9cdef4 DM	37	NEXT_PASS (pass_lower_omp);
	38	NEXT_PASS (pass_lower_cf);
	39	NEXT_PASS (pass_lower_tm);
	40	NEXT_PASS (pass_refactor_eh);
	41	NEXT_PASS (pass_lower_eh);
	42	NEXT_PASS (pass_build_cfg);
	43	NEXT_PASS (pass_warn_function_return);
	44	NEXT_PASS (pass_expand_omp);
	45	NEXT_PASS (pass_build_cgraph_edges);
	46	TERMINATE_PASS_LIST ()
	47
	48	/* Interprocedural optimization passes. */
	49	INSERT_PASSES_AFTER (all_small_ipa_passes)
	50	NEXT_PASS (pass_ipa_free_lang_data);
	51	NEXT_PASS (pass_ipa_function_and_variable_visibility);
d5e254e1	52	NEXT_PASS (pass_ipa_chkp_versioning);
c11d86b4	53	NEXT_PASS (pass_ipa_chkp_early_produce_thunks);
d5e254e1 IE	54	NEXT_PASS (pass_build_ssa_passes);
d5e254e1 IE	55	PUSH_INSERT_PASSES_WITHIN (pass_build_ssa_passes)
0f9cdef4 DM	56	NEXT_PASS (pass_fixup_cfg);
0f9cdef4 DM	57	NEXT_PASS (pass_init_datastructures);
0f9cdef4	58	NEXT_PASS (pass_build_ssa);
b9a55b13	59	NEXT_PASS (pass_ubsan);
0f9cdef4	60	NEXT_PASS (pass_early_warn_uninitialized);
38147a2a	61	NEXT_PASS (pass_nothrow);
d5e254e1 IE	62	POP_INSERT_PASSES ()
	63
	64	NEXT_PASS (pass_chkp_instrumentation_passes);
	65	PUSH_INSERT_PASSES_WITHIN (pass_chkp_instrumentation_passes)
	66	NEXT_PASS (pass_fixup_cfg);
	67	NEXT_PASS (pass_chkp);
	68	NEXT_PASS (pass_rebuild_cgraph_edges);
	69	POP_INSERT_PASSES ()
d5e254e1 IE	70
	71	NEXT_PASS (pass_local_optimization_passes);
	72	PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes)
	73	NEXT_PASS (pass_fixup_cfg);
0f9cdef4 DM	74	NEXT_PASS (pass_rebuild_cgraph_edges);
	75	NEXT_PASS (pass_inline_parameters);
	76	NEXT_PASS (pass_early_inline);
	77	NEXT_PASS (pass_all_early_optimizations);
	78	PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
	79	NEXT_PASS (pass_remove_cgraph_callee_edges);
672ff0b6	80	NEXT_PASS (pass_object_sizes);
0f9cdef4 DM	81	NEXT_PASS (pass_ccp);
	82	/* After CCP we rewrite no longer addressed locals into SSA
	83	form if possible. */
	84	NEXT_PASS (pass_forwprop);
a9e4c82f	85	NEXT_PASS (pass_sra_early);
0f9cdef4 DM	86	/* pass_build_ealias is a dummy pass that ensures that we
	87	execute TODO_rebuild_alias at this point. */
	88	NEXT_PASS (pass_build_ealias);
0f9cdef4	89	NEXT_PASS (pass_fre);
0f9cdef4	90	NEXT_PASS (pass_merge_phi);
5a33401e	91	NEXT_PASS (pass_dse);
0f9cdef4 DM	92	NEXT_PASS (pass_cd_dce);
	93	NEXT_PASS (pass_early_ipa_sra);
	94	NEXT_PASS (pass_tail_recursion);
	95	NEXT_PASS (pass_convert_switch);
d5e254e1 IE	96	NEXT_PASS (pass_cleanup_eh);
	97	NEXT_PASS (pass_profile);
	98	NEXT_PASS (pass_local_pure_const);
0f9cdef4 DM	99	/* Split functions creates parts that are not run through
0f9cdef4 DM	100	early optimizations again. It is thus good idea to do this
d5e254e1 IE	101	late. */
d5e254e1 IE	102	NEXT_PASS (pass_split_functions);
0f9cdef4 DM	103	POP_INSERT_PASSES ()
	104	NEXT_PASS (pass_release_ssa_names);
	105	NEXT_PASS (pass_rebuild_cgraph_edges);
	106	NEXT_PASS (pass_inline_parameters);
	107	POP_INSERT_PASSES ()
c11d86b4	108	NEXT_PASS (pass_ipa_chkp_produce_thunks);
be3c16c4	109	NEXT_PASS (pass_ipa_auto_profile);
0f9cdef4 DM	110	NEXT_PASS (pass_ipa_free_inline_summary);
	111	NEXT_PASS (pass_ipa_tree_profile);
	112	PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
	113	NEXT_PASS (pass_feedback_split_functions);
	114	POP_INSERT_PASSES ()
	115	NEXT_PASS (pass_ipa_increase_alignment);
	116	NEXT_PASS (pass_ipa_tm);
	117	NEXT_PASS (pass_ipa_lower_emutls);
	118	TERMINATE_PASS_LIST ()
	119
	120	INSERT_PASSES_AFTER (all_regular_ipa_passes)
	121	NEXT_PASS (pass_ipa_whole_program_visibility);
	122	NEXT_PASS (pass_ipa_profile);
b84d4347	123	NEXT_PASS (pass_ipa_icf);
bbc9396b	124	NEXT_PASS (pass_ipa_devirt);
0f9cdef4 DM	125	NEXT_PASS (pass_ipa_cp);
0f9cdef4 DM	126	NEXT_PASS (pass_ipa_cdtor_merge);
3b1661a9	127	NEXT_PASS (pass_target_clone);
0f9cdef4 DM	128	NEXT_PASS (pass_ipa_inline);
	129	NEXT_PASS (pass_ipa_pure_const);
	130	NEXT_PASS (pass_ipa_reference);
eb6a09a7 JH	131	/* This pass needs to be scheduled after any IP code duplication. */
eb6a09a7 JH	132	NEXT_PASS (pass_ipa_single_use);
a04d9035 JH	133	/* Comdat privatization come last, as direct references to comdat local
	134	symbols are not allowed outside of the comdat group. Privatizing early
	135	would result in missed optimizations due to this restriction. */
	136	NEXT_PASS (pass_ipa_comdats);
0f9cdef4 DM	137	TERMINATE_PASS_LIST ()
0f9cdef4 DM	138
0f9cdef4 DM	139	/* Simple IPA passes executed after the regular passes. In WHOPR mode the
	140	passes are executed after partitioning and thus see just parts of the
	141	compiled unit. */
	142	INSERT_PASSES_AFTER (all_late_ipa_passes)
	143	NEXT_PASS (pass_ipa_pta);
3b1661a9	144	NEXT_PASS (pass_dispatcher_calls);
0136f8f0	145	NEXT_PASS (pass_omp_simd_clone);
0f9cdef4 DM	146	TERMINATE_PASS_LIST ()
	147
	148	/* These passes are run after IPA passes on every function that is being
	149	output to the assembler file. */
	150	INSERT_PASSES_AFTER (all_passes)
9c39fca1	151	NEXT_PASS (pass_fixup_cfg);
0f9cdef4	152	NEXT_PASS (pass_lower_eh_dispatch);
94829f87	153	NEXT_PASS (pass_oacc_device_lower);
0f9cdef4 DM	154	NEXT_PASS (pass_all_optimizations);
	155	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
	156	NEXT_PASS (pass_remove_cgraph_callee_edges);
	157	/* Initial scalar cleanups before alias computation.
	158	They ensure memory accesses are not indirect wherever possible. */
	159	NEXT_PASS (pass_strip_predict_hints);
0f9cdef4 DM	160	NEXT_PASS (pass_ccp);
	161	/* After CCP we rewrite no longer addressed locals into SSA
	162	form if possible. */
4ee5c752	163	NEXT_PASS (pass_complete_unrolli);
6a75d560	164	NEXT_PASS (pass_backprop);
0f9cdef4 DM	165	NEXT_PASS (pass_phiprop);
0f9cdef4 DM	166	NEXT_PASS (pass_forwprop);
1eadb567	167	NEXT_PASS (pass_object_sizes);
0f9cdef4 DM	168	/* pass_build_alias is a dummy pass that ensures that we
	169	execute TODO_rebuild_alias at this point. */
	170	NEXT_PASS (pass_build_alias);
	171	NEXT_PASS (pass_return_slot);
	172	NEXT_PASS (pass_fre);
0f9cdef4	173	NEXT_PASS (pass_merge_phi);
b0c77505	174	NEXT_PASS (pass_vrp, true /* warn_array_bounds_p */);
d5e254e1	175	NEXT_PASS (pass_chkp_opt);
0f9cdef4	176	NEXT_PASS (pass_dce);
32966af8	177	NEXT_PASS (pass_stdarg);
0f9cdef4 DM	178	NEXT_PASS (pass_call_cdce);
0f9cdef4 DM	179	NEXT_PASS (pass_cselim);
9e4f27ef	180	NEXT_PASS (pass_copy_prop);
0f9cdef4	181	NEXT_PASS (pass_tree_ifcombine);
465770e4	182	NEXT_PASS (pass_merge_phi);
0f9cdef4 DM	183	NEXT_PASS (pass_phiopt);
	184	NEXT_PASS (pass_tail_recursion);
	185	NEXT_PASS (pass_ch);
0f9cdef4 DM	186	NEXT_PASS (pass_lower_complex);
0f9cdef4 DM	187	NEXT_PASS (pass_sra);
0f9cdef4 DM	188	/* The dom pass will also resolve all __builtin_constant_p calls
	189	that are still there to 0. This has to be done after some
	190	propagations have already run, but before some more dead code
	191	is removed, and this place fits nicely. Remember this when
	192	trying to move or duplicate pass_dominator somewhere earlier. */
	193	NEXT_PASS (pass_dominator);
8fdc414d JL	194	/* At this point the majority of const/copy propagations
	195	are exposed. Go ahead and identify paths that should never
	196	be executed in a conforming program and isolate those paths.
	197
	198	This will expose more degenerate PHIs in the main path and
	199	expose more PRE/DOM optimization opportunities. */
	200	NEXT_PASS (pass_isolate_erroneous_paths);
0f9cdef4	201	/* The only const/copy propagation opportunities left after
8fdc414d JL	202	DOM and erroneous path isolation should be due to degenerate PHI nodes.
8fdc414d JL	203	So rather than run the full propagators, run a specialized pass which
0f9cdef4 DM	204	only examines PHIs to discover const/copy propagation
	205	opportunities. */
	206	NEXT_PASS (pass_phi_only_cprop);
	207	NEXT_PASS (pass_dse);
	208	NEXT_PASS (pass_reassoc);
	209	NEXT_PASS (pass_dce);
	210	NEXT_PASS (pass_forwprop);
	211	NEXT_PASS (pass_phiopt);
0f9cdef4 DM	212	NEXT_PASS (pass_ccp);
	213	/* After CCP we rewrite no longer addressed locals into SSA
	214	form if possible. */
0f9cdef4 DM	215	NEXT_PASS (pass_cse_sincos);
0f9cdef4 DM	216	NEXT_PASS (pass_optimize_bswap);
ca87c493	217	NEXT_PASS (pass_laddress);
0f9cdef4 DM	218	NEXT_PASS (pass_split_crit_edges);
	219	NEXT_PASS (pass_pre);
	220	NEXT_PASS (pass_sink_code);
	221	NEXT_PASS (pass_asan);
	222	NEXT_PASS (pass_tsan);
e5d8bd8c	223	/* Pass group that runs when 1) enabled, 2) there are loops
7d39012c RB	224	in the function. Make sure to run pass_fix_loops before
	225	to discover/remove loops before running the gate function
	226	of pass_tree_loop. */
	227	NEXT_PASS (pass_fix_loops);
0f9cdef4 DM	228	NEXT_PASS (pass_tree_loop);
	229	PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
	230	NEXT_PASS (pass_tree_loop_init);
	231	NEXT_PASS (pass_lim);
	232	NEXT_PASS (pass_copy_prop);
30866dc9	233	NEXT_PASS (pass_dce);
0f9cdef4 DM	234	NEXT_PASS (pass_tree_unswitch);
	235	NEXT_PASS (pass_scev_cprop);
	236	NEXT_PASS (pass_record_bounds);
0f9cdef4 DM	237	NEXT_PASS (pass_loop_distribution);
	238	NEXT_PASS (pass_copy_prop);
	239	NEXT_PASS (pass_graphite);
	240	PUSH_INSERT_PASSES_WITHIN (pass_graphite)
	241	NEXT_PASS (pass_graphite_transforms);
	242	NEXT_PASS (pass_lim);
	243	NEXT_PASS (pass_copy_prop);
30866dc9	244	NEXT_PASS (pass_dce);
0f9cdef4 DM	245	POP_INSERT_PASSES ()
	246	NEXT_PASS (pass_iv_canon);
	247	NEXT_PASS (pass_parallelize_loops);
18751894 TV	248	PUSH_INSERT_PASSES_WITHIN (pass_parallelize_loops)
	249	NEXT_PASS (pass_expand_omp_ssa);
	250	POP_INSERT_PASSES ()
4f9a2b4e	251	NEXT_PASS (pass_ch_vect);
0f9cdef4	252	NEXT_PASS (pass_if_conversion);
5ce9450f JJ	253	/* pass_vectorize must immediately follow pass_if_conversion.
5ce9450f JJ	254	Please do not add any other passes in between. */
0f9cdef4 DM	255	NEXT_PASS (pass_vectorize);
0f9cdef4 DM	256	PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
30866dc9	257	NEXT_PASS (pass_dce);
0f9cdef4 DM	258	POP_INSERT_PASSES ()
	259	NEXT_PASS (pass_predcom);
	260	NEXT_PASS (pass_complete_unroll);
	261	NEXT_PASS (pass_slp_vectorize);
	262	NEXT_PASS (pass_loop_prefetch);
e5d8bd8c RB	263	/* Run IVOPTs after the last pass that uses data-reference analysis
e5d8bd8c RB	264	as that doesn't handle TARGET_MEM_REFs. */
0f9cdef4 DM	265	NEXT_PASS (pass_iv_optimize);
	266	NEXT_PASS (pass_lim);
	267	NEXT_PASS (pass_tree_loop_done);
	268	POP_INSERT_PASSES ()
e5d8bd8c RB	269	/* Pass group that runs when pass_tree_loop is disabled or there
	270	are no loops in the function. */
	271	NEXT_PASS (pass_tree_no_loop);
	272	PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
	273	NEXT_PASS (pass_slp_vectorize);
	274	POP_INSERT_PASSES ()
8c8b9f32	275	NEXT_PASS (pass_simduid_cleanup);
0f9cdef4	276	NEXT_PASS (pass_lower_vector_ssa);
8fe17e23	277	NEXT_PASS (pass_split_paths);
0f9cdef4 DM	278	NEXT_PASS (pass_cse_reciprocals);
	279	NEXT_PASS (pass_reassoc);
	280	NEXT_PASS (pass_strength_reduction);
8cce4dbf	281	NEXT_PASS (pass_tracer);
0f9cdef4	282	NEXT_PASS (pass_dominator);
24314386	283	NEXT_PASS (pass_strlen);
b0c77505	284	NEXT_PASS (pass_vrp, false /* warn_array_bounds_p */);
0f9cdef4	285	/* The only const/copy propagation opportunities left after
28a4a292	286	DOM and VRP should be due to degenerate PHI nodes. So rather than
0f9cdef4 DM	287	run the full propagators, run a specialized pass which
	288	only examines PHIs to discover const/copy propagation
	289	opportunities. */
	290	NEXT_PASS (pass_phi_only_cprop);
0f9cdef4	291	NEXT_PASS (pass_cd_dce);
154c9188 RB	292	NEXT_PASS (pass_dse);
	293	NEXT_PASS (pass_forwprop);
	294	NEXT_PASS (pass_phiopt);
	295	NEXT_PASS (pass_fold_builtins);
	296	NEXT_PASS (pass_optimize_widening_mul);
	297	NEXT_PASS (pass_tail_calls);
0f9cdef4 DM	298	/* FIXME: If DCE is not run before checking for uninitialized uses,
	299	we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
	300	However, this also causes us to misdiagnose cases that should be
	301	real warnings (e.g., testsuite/gcc.dg/pr18501.c).
	302
	303	To fix the false positives in uninit-5.c, we would have to
	304	account for the predicates protecting the set and the use of each
	305	variable. Using a representation like Gated Single Assignment
	306	may help. */
5c2961cf RB	307	/* Split critical edges before late uninit warning to reduce the
	308	number of false positives from it. */
	309	NEXT_PASS (pass_split_crit_edges);
0f9cdef4	310	NEXT_PASS (pass_late_warn_uninitialized);
0f9cdef4 DM	311	NEXT_PASS (pass_uncprop);
	312	NEXT_PASS (pass_local_pure_const);
	313	POP_INSERT_PASSES ()
	314	NEXT_PASS (pass_all_optimizations_g);
	315	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
	316	NEXT_PASS (pass_remove_cgraph_callee_edges);
	317	NEXT_PASS (pass_strip_predict_hints);
	318	/* Lower remaining pieces of GIMPLE. */
	319	NEXT_PASS (pass_lower_complex);
	320	NEXT_PASS (pass_lower_vector_ssa);
	321	/* Perform simple scalar cleanup which is constant/copy propagation. */
	322	NEXT_PASS (pass_ccp);
	323	NEXT_PASS (pass_object_sizes);
	324	/* Fold remaining builtins. */
	325	NEXT_PASS (pass_fold_builtins);
	326	/* Copy propagation also copy-propagates constants, this is necessary
	327	to forward object-size and builtin folding results properly. */
	328	NEXT_PASS (pass_copy_prop);
	329	NEXT_PASS (pass_dce);
	330	NEXT_PASS (pass_asan);
	331	NEXT_PASS (pass_tsan);
0f9cdef4 DM	332	/* ??? We do want some kind of loop invariant motion, but we possibly
	333	need to adjust LIM to be more friendly towards preserving accurate
	334	debug information here. */
5c2961cf RB	335	/* Split critical edges before late uninit warning to reduce the
	336	number of false positives from it. */
	337	NEXT_PASS (pass_split_crit_edges);
0f9cdef4 DM	338	NEXT_PASS (pass_late_warn_uninitialized);
	339	NEXT_PASS (pass_uncprop);
	340	NEXT_PASS (pass_local_pure_const);
	341	POP_INSERT_PASSES ()
	342	NEXT_PASS (pass_tm_init);
	343	PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
	344	NEXT_PASS (pass_tm_mark);
	345	NEXT_PASS (pass_tm_memopt);
	346	NEXT_PASS (pass_tm_edges);
	347	POP_INSERT_PASSES ()
d9a6bd32	348	NEXT_PASS (pass_simduid_cleanup);
2077db1b	349	NEXT_PASS (pass_vtable_verify);
f8e89441	350	NEXT_PASS (pass_lower_vaarg);
0f9cdef4 DM	351	NEXT_PASS (pass_lower_vector);
	352	NEXT_PASS (pass_lower_complex_O0);
	353	NEXT_PASS (pass_asan_O0);
	354	NEXT_PASS (pass_tsan_O0);
b9a55b13	355	NEXT_PASS (pass_sanopt);
0f9cdef4 DM	356	NEXT_PASS (pass_cleanup_eh);
	357	NEXT_PASS (pass_lower_resx);
	358	NEXT_PASS (pass_nrv);
0f9cdef4 DM	359	NEXT_PASS (pass_cleanup_cfg_post_optimizing);
	360	NEXT_PASS (pass_warn_function_noreturn);
	361
	362	NEXT_PASS (pass_expand);
	363
	364	NEXT_PASS (pass_rest_of_compilation);
	365	PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
	366	NEXT_PASS (pass_instantiate_virtual_regs);
	367	NEXT_PASS (pass_into_cfg_layout_mode);
	368	NEXT_PASS (pass_jump);
	369	NEXT_PASS (pass_lower_subreg);
	370	NEXT_PASS (pass_df_initialize_opt);
	371	NEXT_PASS (pass_cse);
	372	NEXT_PASS (pass_rtl_fwprop);
	373	NEXT_PASS (pass_rtl_cprop);
	374	NEXT_PASS (pass_rtl_pre);
	375	NEXT_PASS (pass_rtl_hoist);
	376	NEXT_PASS (pass_rtl_cprop);
	377	NEXT_PASS (pass_rtl_store_motion);
	378	NEXT_PASS (pass_cse_after_global_opts);
	379	NEXT_PASS (pass_rtl_ifcvt);
	380	NEXT_PASS (pass_reginfo_init);
	381	/* Perform loop optimizations. It might be better to do them a bit
	382	sooner, but we want the profile feedback to work more
	383	efficiently. */
	384	NEXT_PASS (pass_loop2);
	385	PUSH_INSERT_PASSES_WITHIN (pass_loop2)
	386	NEXT_PASS (pass_rtl_loop_init);
	387	NEXT_PASS (pass_rtl_move_loop_invariants);
f8934be7	388	NEXT_PASS (pass_rtl_unroll_loops);
0f9cdef4 DM	389	NEXT_PASS (pass_rtl_doloop);
	390	NEXT_PASS (pass_rtl_loop_done);
	391	TERMINATE_PASS_LIST ()
	392	POP_INSERT_PASSES ()
	393	NEXT_PASS (pass_web);
	394	NEXT_PASS (pass_rtl_cprop);
	395	NEXT_PASS (pass_cse2);
	396	NEXT_PASS (pass_rtl_dse1);
	397	NEXT_PASS (pass_rtl_fwprop_addr);
	398	NEXT_PASS (pass_inc_dec);
	399	NEXT_PASS (pass_initialize_regs);
	400	NEXT_PASS (pass_ud_rtl_dce);
	401	NEXT_PASS (pass_combine);
	402	NEXT_PASS (pass_if_after_combine);
	403	NEXT_PASS (pass_partition_blocks);
0f9cdef4 DM	404	NEXT_PASS (pass_outof_cfg_layout_mode);
	405	NEXT_PASS (pass_split_all_insns);
	406	NEXT_PASS (pass_lower_subreg2);
	407	NEXT_PASS (pass_df_initialize_no_opt);
	408	NEXT_PASS (pass_stack_ptr_mod);
	409	NEXT_PASS (pass_mode_switching);
	410	NEXT_PASS (pass_match_asm_constraints);
	411	NEXT_PASS (pass_sms);
f20f2613	412	NEXT_PASS (pass_live_range_shrinkage);
0f9cdef4 DM	413	NEXT_PASS (pass_sched);
	414	NEXT_PASS (pass_ira);
	415	NEXT_PASS (pass_reload);
	416	NEXT_PASS (pass_postreload);
	417	PUSH_INSERT_PASSES_WITHIN (pass_postreload)
	418	NEXT_PASS (pass_postreload_cse);
	419	NEXT_PASS (pass_gcse2);
	420	NEXT_PASS (pass_split_after_reload);
	421	NEXT_PASS (pass_ree);
	422	NEXT_PASS (pass_compare_elim_after_reload);
	423	NEXT_PASS (pass_branch_target_load_optimize1);
	424	NEXT_PASS (pass_thread_prologue_and_epilogue);
	425	NEXT_PASS (pass_rtl_dse2);
	426	NEXT_PASS (pass_stack_adjustments);
	427	NEXT_PASS (pass_jump2);
fc56f9d2	428	NEXT_PASS (pass_duplicate_computed_gotos);
b16abbcb	429	NEXT_PASS (pass_sched_fusion);
fc56f9d2	430	NEXT_PASS (pass_peephole2);
0f9cdef4 DM	431	NEXT_PASS (pass_if_after_reload);
	432	NEXT_PASS (pass_regrename);
	433	NEXT_PASS (pass_cprop_hardreg);
	434	NEXT_PASS (pass_fast_rtl_dce);
	435	NEXT_PASS (pass_reorder_blocks);
	436	NEXT_PASS (pass_branch_target_load_optimize2);
	437	NEXT_PASS (pass_leaf_regs);
	438	NEXT_PASS (pass_split_before_sched2);
	439	NEXT_PASS (pass_sched2);
	440	NEXT_PASS (pass_stack_regs);
	441	PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
	442	NEXT_PASS (pass_split_before_regstack);
	443	NEXT_PASS (pass_stack_regs_run);
	444	POP_INSERT_PASSES ()
433e4164 BS	445	POP_INSERT_PASSES ()
	446	NEXT_PASS (pass_late_compilation);
	447	PUSH_INSERT_PASSES_WITHIN (pass_late_compilation)
0f9cdef4	448	NEXT_PASS (pass_compute_alignments);
0f9cdef4 DM	449	NEXT_PASS (pass_variable_tracking);
	450	NEXT_PASS (pass_free_cfg);
	451	NEXT_PASS (pass_machine_reorg);
	452	NEXT_PASS (pass_cleanup_barriers);
	453	NEXT_PASS (pass_delay_slots);
	454	NEXT_PASS (pass_split_for_shorten_branches);
	455	NEXT_PASS (pass_convert_to_eh_region_ranges);
	456	NEXT_PASS (pass_shorten_branches);
	457	NEXT_PASS (pass_set_nothrow_function_flags);
	458	NEXT_PASS (pass_dwarf2_frame);
	459	NEXT_PASS (pass_final);
	460	POP_INSERT_PASSES ()
	461	NEXT_PASS (pass_df_finish);
	462	POP_INSERT_PASSES ()
	463	NEXT_PASS (pass_clean_state);
	464	TERMINATE_PASS_LIST ()