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

/* Description of pass structure
   Copyright (C) 1987-2013 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_early_local_passes);
  PUSH_INSERT_PASSES_WITHIN (pass_early_local_passes)
      NEXT_PASS (pass_fixup_cfg);
      NEXT_PASS (pass_init_datastructures);

      NEXT_PASS (pass_build_ssa);
      NEXT_PASS (pass_early_warn_uninitialized);
      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_rename_ssa_copies);
	  NEXT_PASS (pass_ccp);
	  /* After CCP we rewrite no longer addressed locals into SSA
	     form if possible.  */
	  NEXT_PASS (pass_forwprop);
	  /* 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_sra_early);
	  NEXT_PASS (pass_fre);
	  NEXT_PASS (pass_copy_prop);
	  NEXT_PASS (pass_merge_phi);
	  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_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_devirt);
  NEXT_PASS (pass_ipa_cp);
  NEXT_PASS (pass_ipa_cdtor_merge);
  NEXT_PASS (pass_ipa_inline);
  NEXT_PASS (pass_ipa_pure_const);
  NEXT_PASS (pass_ipa_reference);
  TERMINATE_PASS_LIST ()

  INSERT_PASSES_AFTER (all_lto_gen_passes)
  NEXT_PASS (pass_ipa_lto_gimple_out);
  NEXT_PASS (pass_ipa_lto_finish_out);  /* This must be the last LTO pass.  */
  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);
  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_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_rename_ssa_copies);
      NEXT_PASS (pass_copy_prop);
      NEXT_PASS (pass_complete_unrolli);
      NEXT_PASS (pass_ccp);
      /* After CCP we rewrite no longer addressed locals into SSA
	 form if possible.  */
      NEXT_PASS (pass_phiprop);
      NEXT_PASS (pass_forwprop);
      /* 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_copy_prop);
      NEXT_PASS (pass_merge_phi);
      NEXT_PASS (pass_vrp);
      NEXT_PASS (pass_dce);
      NEXT_PASS (pass_call_cdce);
      NEXT_PASS (pass_cselim);
      NEXT_PASS (pass_tree_ifcombine);
      NEXT_PASS (pass_phiopt);
      NEXT_PASS (pass_tail_recursion);
      NEXT_PASS (pass_ch);
      NEXT_PASS (pass_stdarg);
      NEXT_PASS (pass_lower_complex);
      NEXT_PASS (pass_sra);
      NEXT_PASS (pass_rename_ssa_copies);
      /* 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);
      /* The only const/copy propagation opportunities left after
	 DOM 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_object_sizes);
      NEXT_PASS (pass_strlen);
      NEXT_PASS (pass_ccp);
      /* After CCP we rewrite no longer addressed locals into SSA
	 form if possible.  */
      NEXT_PASS (pass_copy_prop);
      NEXT_PASS (pass_cse_sincos);
      NEXT_PASS (pass_optimize_bswap);
      NEXT_PASS (pass_split_crit_edges);
      NEXT_PASS (pass_pre);
      NEXT_PASS (pass_sink_code);
      NEXT_PASS (pass_asan);
      NEXT_PASS (pass_tsan);
      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_loop);
	  NEXT_PASS (pass_tree_unswitch);
	  NEXT_PASS (pass_scev_cprop);
	  NEXT_PASS (pass_record_bounds);
	  NEXT_PASS (pass_check_data_deps);
	  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_loop);
	  POP_INSERT_PASSES ()
	  NEXT_PASS (pass_iv_canon);
	  NEXT_PASS (pass_parallelize_loops);
	  NEXT_PASS (pass_if_conversion);
	  NEXT_PASS (pass_vectorize);
          PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
	      NEXT_PASS (pass_dce_loop);
          POP_INSERT_PASSES ()
          NEXT_PASS (pass_predcom);
	  NEXT_PASS (pass_complete_unroll);
	  NEXT_PASS (pass_slp_vectorize);
	  NEXT_PASS (pass_loop_prefetch);
	  NEXT_PASS (pass_iv_optimize);
	  NEXT_PASS (pass_lim);
	  NEXT_PASS (pass_tree_loop_done);
      POP_INSERT_PASSES ()
      NEXT_PASS (pass_lower_vector_ssa);
      NEXT_PASS (pass_cse_reciprocals);
      NEXT_PASS (pass_reassoc);
      NEXT_PASS (pass_strength_reduction);
      NEXT_PASS (pass_dominator);
      /* The only const/copy propagation opportunities left after
	 DOM 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_vrp);
      NEXT_PASS (pass_cd_dce);
      NEXT_PASS (pass_tracer);
      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);
      NEXT_PASS (pass_rename_ssa_copies);
      /* 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);
      NEXT_PASS (pass_rename_ssa_copies);
      /* ???  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_vtable_verify);
  NEXT_PASS (pass_lower_vector);
  NEXT_PASS (pass_lower_complex_O0);
  NEXT_PASS (pass_asan_O0);
  NEXT_PASS (pass_tsan_O0);
  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_unswitch);
	  NEXT_PASS (pass_rtl_unroll_and_peel_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_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_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 ()
	  NEXT_PASS (pass_compute_alignments);
	  NEXT_PASS (pass_duplicate_computed_gotos);
	  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
ca4be2a0	1	/* Description of pass structure
	2	Copyright (C) 1987-2013 Free Software Foundation, Inc.
	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);
ca4be2a0	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);
	52	NEXT_PASS (pass_early_local_passes);
	53	PUSH_INSERT_PASSES_WITHIN (pass_early_local_passes)
	54	NEXT_PASS (pass_fixup_cfg);
	55	NEXT_PASS (pass_init_datastructures);
	56
	57	NEXT_PASS (pass_build_ssa);
	58	NEXT_PASS (pass_early_warn_uninitialized);
	59	NEXT_PASS (pass_rebuild_cgraph_edges);
	60	NEXT_PASS (pass_inline_parameters);
	61	NEXT_PASS (pass_early_inline);
	62	NEXT_PASS (pass_all_early_optimizations);
	63	PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
	64	NEXT_PASS (pass_remove_cgraph_callee_edges);
	65	NEXT_PASS (pass_rename_ssa_copies);
	66	NEXT_PASS (pass_ccp);
	67	/* After CCP we rewrite no longer addressed locals into SSA
	68	form if possible. */
	69	NEXT_PASS (pass_forwprop);
	70	/* pass_build_ealias is a dummy pass that ensures that we
	71	execute TODO_rebuild_alias at this point. */
	72	NEXT_PASS (pass_build_ealias);
	73	NEXT_PASS (pass_sra_early);
	74	NEXT_PASS (pass_fre);
	75	NEXT_PASS (pass_copy_prop);
	76	NEXT_PASS (pass_merge_phi);
	77	NEXT_PASS (pass_cd_dce);
	78	NEXT_PASS (pass_early_ipa_sra);
	79	NEXT_PASS (pass_tail_recursion);
	80	NEXT_PASS (pass_convert_switch);
	81	NEXT_PASS (pass_cleanup_eh);
	82	NEXT_PASS (pass_profile);
	83	NEXT_PASS (pass_local_pure_const);
	84	/* Split functions creates parts that are not run through
	85	early optimizations again. It is thus good idea to do this
	86	late. */
	87	NEXT_PASS (pass_split_functions);
	88	POP_INSERT_PASSES ()
	89	NEXT_PASS (pass_release_ssa_names);
	90	NEXT_PASS (pass_rebuild_cgraph_edges);
	91	NEXT_PASS (pass_inline_parameters);
	92	POP_INSERT_PASSES ()
	93	NEXT_PASS (pass_ipa_free_inline_summary);
	94	NEXT_PASS (pass_ipa_tree_profile);
	95	PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
	96	NEXT_PASS (pass_feedback_split_functions);
	97	POP_INSERT_PASSES ()
	98	NEXT_PASS (pass_ipa_increase_alignment);
	99	NEXT_PASS (pass_ipa_tm);
	100	NEXT_PASS (pass_ipa_lower_emutls);
101	TERMINATE_PASS_LIST ()
102
103	INSERT_PASSES_AFTER (all_regular_ipa_passes)
104	NEXT_PASS (pass_ipa_whole_program_visibility);
105	NEXT_PASS (pass_ipa_profile);
84f6cc40	106	NEXT_PASS (pass_ipa_devirt);
ca4be2a0	107	NEXT_PASS (pass_ipa_cp);
	108	NEXT_PASS (pass_ipa_cdtor_merge);
	109	NEXT_PASS (pass_ipa_inline);
	110	NEXT_PASS (pass_ipa_pure_const);
	111	NEXT_PASS (pass_ipa_reference);
	112	TERMINATE_PASS_LIST ()
	113
	114	INSERT_PASSES_AFTER (all_lto_gen_passes)
	115	NEXT_PASS (pass_ipa_lto_gimple_out);
	116	NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */
	117	TERMINATE_PASS_LIST ()
	118
	119	/* Simple IPA passes executed after the regular passes. In WHOPR mode the
	120	passes are executed after partitioning and thus see just parts of the
	121	compiled unit. */
	122	INSERT_PASSES_AFTER (all_late_ipa_passes)
	123	NEXT_PASS (pass_ipa_pta);
	124	TERMINATE_PASS_LIST ()
	125
	126	/* These passes are run after IPA passes on every function that is being
	127	output to the assembler file. */
	128	INSERT_PASSES_AFTER (all_passes)
f34e160b	129	NEXT_PASS (pass_fixup_cfg);
ca4be2a0	130	NEXT_PASS (pass_lower_eh_dispatch);
	131	NEXT_PASS (pass_all_optimizations);
	132	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
	133	NEXT_PASS (pass_remove_cgraph_callee_edges);
	134	/* Initial scalar cleanups before alias computation.
	135	They ensure memory accesses are not indirect wherever possible. */
	136	NEXT_PASS (pass_strip_predict_hints);
	137	NEXT_PASS (pass_rename_ssa_copies);
	138	NEXT_PASS (pass_copy_prop);
	139	NEXT_PASS (pass_complete_unrolli);
	140	NEXT_PASS (pass_ccp);
	141	/* After CCP we rewrite no longer addressed locals into SSA
	142	form if possible. */
	143	NEXT_PASS (pass_phiprop);
	144	NEXT_PASS (pass_forwprop);
	145	/* pass_build_alias is a dummy pass that ensures that we
	146	execute TODO_rebuild_alias at this point. */
	147	NEXT_PASS (pass_build_alias);
	148	NEXT_PASS (pass_return_slot);
	149	NEXT_PASS (pass_fre);
	150	NEXT_PASS (pass_copy_prop);
	151	NEXT_PASS (pass_merge_phi);
	152	NEXT_PASS (pass_vrp);
	153	NEXT_PASS (pass_dce);
	154	NEXT_PASS (pass_call_cdce);
	155	NEXT_PASS (pass_cselim);
	156	NEXT_PASS (pass_tree_ifcombine);
	157	NEXT_PASS (pass_phiopt);
	158	NEXT_PASS (pass_tail_recursion);
	159	NEXT_PASS (pass_ch);
	160	NEXT_PASS (pass_stdarg);
	161	NEXT_PASS (pass_lower_complex);
	162	NEXT_PASS (pass_sra);
	163	NEXT_PASS (pass_rename_ssa_copies);
	164	/* The dom pass will also resolve all __builtin_constant_p calls
	165	that are still there to 0. This has to be done after some
	166	propagations have already run, but before some more dead code
	167	is removed, and this place fits nicely. Remember this when
	168	trying to move or duplicate pass_dominator somewhere earlier. */
	169	NEXT_PASS (pass_dominator);
	170	/* The only const/copy propagation opportunities left after
	171	DOM should be due to degenerate PHI nodes. So rather than
	172	run the full propagators, run a specialized pass which
	173	only examines PHIs to discover const/copy propagation
	174	opportunities. */
	175	NEXT_PASS (pass_phi_only_cprop);
	176	NEXT_PASS (pass_dse);
	177	NEXT_PASS (pass_reassoc);
	178	NEXT_PASS (pass_dce);
	179	NEXT_PASS (pass_forwprop);
	180	NEXT_PASS (pass_phiopt);
	181	NEXT_PASS (pass_object_sizes);
	182	NEXT_PASS (pass_strlen);
	183	NEXT_PASS (pass_ccp);
	184	/* After CCP we rewrite no longer addressed locals into SSA
	185	form if possible. */
	186	NEXT_PASS (pass_copy_prop);
	187	NEXT_PASS (pass_cse_sincos);
	188	NEXT_PASS (pass_optimize_bswap);
	189	NEXT_PASS (pass_split_crit_edges);
	190	NEXT_PASS (pass_pre);
	191	NEXT_PASS (pass_sink_code);
	192	NEXT_PASS (pass_asan);
	193	NEXT_PASS (pass_tsan);
194	NEXT_PASS (pass_tree_loop);
195	PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
196	NEXT_PASS (pass_tree_loop_init);
197	NEXT_PASS (pass_lim);
198	NEXT_PASS (pass_copy_prop);
199	NEXT_PASS (pass_dce_loop);
200	NEXT_PASS (pass_tree_unswitch);
201	NEXT_PASS (pass_scev_cprop);
202	NEXT_PASS (pass_record_bounds);
203	NEXT_PASS (pass_check_data_deps);
204	NEXT_PASS (pass_loop_distribution);
205	NEXT_PASS (pass_copy_prop);
206	NEXT_PASS (pass_graphite);
207	PUSH_INSERT_PASSES_WITHIN (pass_graphite)
208	NEXT_PASS (pass_graphite_transforms);
209	NEXT_PASS (pass_lim);
210	NEXT_PASS (pass_copy_prop);
211	NEXT_PASS (pass_dce_loop);
212	POP_INSERT_PASSES ()
213	NEXT_PASS (pass_iv_canon);
214	NEXT_PASS (pass_parallelize_loops);
215	NEXT_PASS (pass_if_conversion);
216	NEXT_PASS (pass_vectorize);
217	PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
218	NEXT_PASS (pass_dce_loop);
219	POP_INSERT_PASSES ()
220	NEXT_PASS (pass_predcom);
221	NEXT_PASS (pass_complete_unroll);
222	NEXT_PASS (pass_slp_vectorize);
223	NEXT_PASS (pass_loop_prefetch);
224	NEXT_PASS (pass_iv_optimize);
225	NEXT_PASS (pass_lim);
226	NEXT_PASS (pass_tree_loop_done);
227	POP_INSERT_PASSES ()
228	NEXT_PASS (pass_lower_vector_ssa);
229	NEXT_PASS (pass_cse_reciprocals);
230	NEXT_PASS (pass_reassoc);
231	NEXT_PASS (pass_strength_reduction);
232	NEXT_PASS (pass_dominator);
233	/* The only const/copy propagation opportunities left after
234	DOM should be due to degenerate PHI nodes. So rather than
235	run the full propagators, run a specialized pass which
236	only examines PHIs to discover const/copy propagation
237	opportunities. */
238	NEXT_PASS (pass_phi_only_cprop);
239	NEXT_PASS (pass_vrp);
240	NEXT_PASS (pass_cd_dce);
241	NEXT_PASS (pass_tracer);
55bc8a5a	242	NEXT_PASS (pass_dse);
	243	NEXT_PASS (pass_forwprop);
	244	NEXT_PASS (pass_phiopt);
	245	NEXT_PASS (pass_fold_builtins);
	246	NEXT_PASS (pass_optimize_widening_mul);
	247	NEXT_PASS (pass_tail_calls);
	248	NEXT_PASS (pass_rename_ssa_copies);
ca4be2a0	249	/* FIXME: If DCE is not run before checking for uninitialized uses,
	250	we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
	251	However, this also causes us to misdiagnose cases that should be
	252	real warnings (e.g., testsuite/gcc.dg/pr18501.c).
	253
	254	To fix the false positives in uninit-5.c, we would have to
	255	account for the predicates protecting the set and the use of each
	256	variable. Using a representation like Gated Single Assignment
	257	may help. */
13089d2b	258	/* Split critical edges before late uninit warning to reduce the
	259	number of false positives from it. */
	260	NEXT_PASS (pass_split_crit_edges);
ca4be2a0	261	NEXT_PASS (pass_late_warn_uninitialized);
ca4be2a0	262	NEXT_PASS (pass_uncprop);
	263	NEXT_PASS (pass_local_pure_const);
	264	POP_INSERT_PASSES ()
	265	NEXT_PASS (pass_all_optimizations_g);
	266	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
	267	NEXT_PASS (pass_remove_cgraph_callee_edges);
	268	NEXT_PASS (pass_strip_predict_hints);
	269	/* Lower remaining pieces of GIMPLE. */
	270	NEXT_PASS (pass_lower_complex);
	271	NEXT_PASS (pass_lower_vector_ssa);
	272	/* Perform simple scalar cleanup which is constant/copy propagation. */
	273	NEXT_PASS (pass_ccp);
	274	NEXT_PASS (pass_object_sizes);
	275	/* Fold remaining builtins. */
	276	NEXT_PASS (pass_fold_builtins);
	277	/* Copy propagation also copy-propagates constants, this is necessary
	278	to forward object-size and builtin folding results properly. */
	279	NEXT_PASS (pass_copy_prop);
	280	NEXT_PASS (pass_dce);
	281	NEXT_PASS (pass_asan);
	282	NEXT_PASS (pass_tsan);
	283	NEXT_PASS (pass_rename_ssa_copies);
	284	/* ??? We do want some kind of loop invariant motion, but we possibly
	285	need to adjust LIM to be more friendly towards preserving accurate
	286	debug information here. */
13089d2b	287	/* Split critical edges before late uninit warning to reduce the
	288	number of false positives from it. */
	289	NEXT_PASS (pass_split_crit_edges);
ca4be2a0	290	NEXT_PASS (pass_late_warn_uninitialized);
	291	NEXT_PASS (pass_uncprop);
	292	NEXT_PASS (pass_local_pure_const);
	293	POP_INSERT_PASSES ()
	294	NEXT_PASS (pass_tm_init);
	295	PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
	296	NEXT_PASS (pass_tm_mark);
	297	NEXT_PASS (pass_tm_memopt);
	298	NEXT_PASS (pass_tm_edges);
	299	POP_INSERT_PASSES ()
b710ec85	300	NEXT_PASS (pass_vtable_verify);
ca4be2a0	301	NEXT_PASS (pass_lower_vector);
	302	NEXT_PASS (pass_lower_complex_O0);
	303	NEXT_PASS (pass_asan_O0);
	304	NEXT_PASS (pass_tsan_O0);
	305	NEXT_PASS (pass_cleanup_eh);
	306	NEXT_PASS (pass_lower_resx);
	307	NEXT_PASS (pass_nrv);
ca4be2a0	308	NEXT_PASS (pass_cleanup_cfg_post_optimizing);
	309	NEXT_PASS (pass_warn_function_noreturn);
	310
	311	NEXT_PASS (pass_expand);
	312
	313	NEXT_PASS (pass_rest_of_compilation);
	314	PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
	315	NEXT_PASS (pass_instantiate_virtual_regs);
	316	NEXT_PASS (pass_into_cfg_layout_mode);
	317	NEXT_PASS (pass_jump);
	318	NEXT_PASS (pass_lower_subreg);
	319	NEXT_PASS (pass_df_initialize_opt);
	320	NEXT_PASS (pass_cse);
	321	NEXT_PASS (pass_rtl_fwprop);
	322	NEXT_PASS (pass_rtl_cprop);
	323	NEXT_PASS (pass_rtl_pre);
	324	NEXT_PASS (pass_rtl_hoist);
	325	NEXT_PASS (pass_rtl_cprop);
	326	NEXT_PASS (pass_rtl_store_motion);
	327	NEXT_PASS (pass_cse_after_global_opts);
	328	NEXT_PASS (pass_rtl_ifcvt);
	329	NEXT_PASS (pass_reginfo_init);
	330	/* Perform loop optimizations. It might be better to do them a bit
	331	sooner, but we want the profile feedback to work more
	332	efficiently. */
	333	NEXT_PASS (pass_loop2);
	334	PUSH_INSERT_PASSES_WITHIN (pass_loop2)
	335	NEXT_PASS (pass_rtl_loop_init);
	336	NEXT_PASS (pass_rtl_move_loop_invariants);
	337	NEXT_PASS (pass_rtl_unswitch);
	338	NEXT_PASS (pass_rtl_unroll_and_peel_loops);
	339	NEXT_PASS (pass_rtl_doloop);
	340	NEXT_PASS (pass_rtl_loop_done);
	341	TERMINATE_PASS_LIST ()
	342	POP_INSERT_PASSES ()
	343	NEXT_PASS (pass_web);
	344	NEXT_PASS (pass_rtl_cprop);
	345	NEXT_PASS (pass_cse2);
	346	NEXT_PASS (pass_rtl_dse1);
	347	NEXT_PASS (pass_rtl_fwprop_addr);
	348	NEXT_PASS (pass_inc_dec);
	349	NEXT_PASS (pass_initialize_regs);
	350	NEXT_PASS (pass_ud_rtl_dce);
	351	NEXT_PASS (pass_combine);
	352	NEXT_PASS (pass_if_after_combine);
	353	NEXT_PASS (pass_partition_blocks);
ca4be2a0	354	NEXT_PASS (pass_outof_cfg_layout_mode);
	355	NEXT_PASS (pass_split_all_insns);
	356	NEXT_PASS (pass_lower_subreg2);
	357	NEXT_PASS (pass_df_initialize_no_opt);
	358	NEXT_PASS (pass_stack_ptr_mod);
	359	NEXT_PASS (pass_mode_switching);
	360	NEXT_PASS (pass_match_asm_constraints);
	361	NEXT_PASS (pass_sms);
	362	NEXT_PASS (pass_sched);
	363	NEXT_PASS (pass_ira);
	364	NEXT_PASS (pass_reload);
	365	NEXT_PASS (pass_postreload);
	366	PUSH_INSERT_PASSES_WITHIN (pass_postreload)
	367	NEXT_PASS (pass_postreload_cse);
	368	NEXT_PASS (pass_gcse2);
	369	NEXT_PASS (pass_split_after_reload);
	370	NEXT_PASS (pass_ree);
	371	NEXT_PASS (pass_compare_elim_after_reload);
	372	NEXT_PASS (pass_branch_target_load_optimize1);
	373	NEXT_PASS (pass_thread_prologue_and_epilogue);
	374	NEXT_PASS (pass_rtl_dse2);
	375	NEXT_PASS (pass_stack_adjustments);
	376	NEXT_PASS (pass_jump2);
	377	NEXT_PASS (pass_peephole2);
	378	NEXT_PASS (pass_if_after_reload);
	379	NEXT_PASS (pass_regrename);
	380	NEXT_PASS (pass_cprop_hardreg);
	381	NEXT_PASS (pass_fast_rtl_dce);
	382	NEXT_PASS (pass_reorder_blocks);
	383	NEXT_PASS (pass_branch_target_load_optimize2);
	384	NEXT_PASS (pass_leaf_regs);
	385	NEXT_PASS (pass_split_before_sched2);
	386	NEXT_PASS (pass_sched2);
	387	NEXT_PASS (pass_stack_regs);
	388	PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
	389	NEXT_PASS (pass_split_before_regstack);
	390	NEXT_PASS (pass_stack_regs_run);
	391	POP_INSERT_PASSES ()
	392	NEXT_PASS (pass_compute_alignments);
	393	NEXT_PASS (pass_duplicate_computed_gotos);
	394	NEXT_PASS (pass_variable_tracking);
	395	NEXT_PASS (pass_free_cfg);
	396	NEXT_PASS (pass_machine_reorg);
	397	NEXT_PASS (pass_cleanup_barriers);
	398	NEXT_PASS (pass_delay_slots);
	399	NEXT_PASS (pass_split_for_shorten_branches);
	400	NEXT_PASS (pass_convert_to_eh_region_ranges);
	401	NEXT_PASS (pass_shorten_branches);
	402	NEXT_PASS (pass_set_nothrow_function_flags);
	403	NEXT_PASS (pass_dwarf2_frame);
	404	NEXT_PASS (pass_final);
	405	POP_INSERT_PASSES ()
	406	NEXT_PASS (pass_df_finish);
	407	POP_INSERT_PASSES ()
	408	NEXT_PASS (pass_clean_state);
	409	TERMINATE_PASS_LIST ()