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

/* Description of pass structure
   Copyright (C) 1987-2014 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_ubsan);
      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);
	  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_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);
  /* 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_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_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_ccp);
      /* After CCP we rewrite no longer addressed locals into SSA
	 form if possible.  */
      NEXT_PASS (pass_copy_prop);
      NEXT_PASS (pass_complete_unrolli);
      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);
      NEXT_PASS (pass_dce);
      NEXT_PASS (pass_call_cdce);
      NEXT_PASS (pass_cselim);
      NEXT_PASS (pass_copy_prop);
      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);
      /* 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_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);
      /* Pass group that runs when 1) enabled, 2) there are loops
	 in the function.  */
      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_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);
	  POP_INSERT_PASSES ()
	  NEXT_PASS (pass_iv_canon);
	  NEXT_PASS (pass_parallelize_loops);
	  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_lower_vector_ssa);
      NEXT_PASS (pass_cse_reciprocals);
      NEXT_PASS (pass_reassoc);
      NEXT_PASS (pass_strength_reduction);
      NEXT_PASS (pass_dominator);
      NEXT_PASS (pass_strlen);
      NEXT_PASS (pass_vrp);
      /* 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_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_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_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_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_if_after_reload);
	  NEXT_PASS (pass_regrename);
	  NEXT_PASS (pass_cprop_hardreg);
	  NEXT_PASS (pass_fast_rtl_dce);
	  NEXT_PASS (pass_duplicate_computed_gotos);
	  NEXT_PASS (pass_reorder_blocks);
	  /* We need to run peephole2 pass after the duplicate-
	     compute-gotos and the reorder-blocks pass (PR/39284).
	     We have a single indirect branch in the entire function
	     before duplicate-compute-gotos pass.  This vastly reduces
	     the size of the CFG.
	     For preventing to run peephole2 pass twice, its run after
	     the jump2 got removed.  */
	  NEXT_PASS (pass_peephole2);
	  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_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
23a5b65a	2	Copyright (C) 1987-2014 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);
	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);
b9a55b13	58	NEXT_PASS (pass_ubsan);
0f9cdef4 DM	59	NEXT_PASS (pass_early_warn_uninitialized);
	60	NEXT_PASS (pass_rebuild_cgraph_edges);
	61	NEXT_PASS (pass_inline_parameters);
	62	NEXT_PASS (pass_early_inline);
	63	NEXT_PASS (pass_all_early_optimizations);
	64	PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
	65	NEXT_PASS (pass_remove_cgraph_callee_edges);
	66	NEXT_PASS (pass_rename_ssa_copies);
	67	NEXT_PASS (pass_ccp);
	68	/* After CCP we rewrite no longer addressed locals into SSA
	69	form if possible. */
	70	NEXT_PASS (pass_forwprop);
a9e4c82f	71	NEXT_PASS (pass_sra_early);
0f9cdef4 DM	72	/* pass_build_ealias is a dummy pass that ensures that we
	73	execute TODO_rebuild_alias at this point. */
	74	NEXT_PASS (pass_build_ealias);
0f9cdef4	75	NEXT_PASS (pass_fre);
0f9cdef4 DM	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);
bbc9396b	106	NEXT_PASS (pass_ipa_devirt);
0f9cdef4 DM	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);
eb6a09a7 JH	112	/* This pass needs to be scheduled after any IP code duplication. */
eb6a09a7 JH	113	NEXT_PASS (pass_ipa_single_use);
a04d9035 JH	114	/* Comdat privatization come last, as direct references to comdat local
	115	symbols are not allowed outside of the comdat group. Privatizing early
	116	would result in missed optimizations due to this restriction. */
	117	NEXT_PASS (pass_ipa_comdats);
0f9cdef4 DM	118	TERMINATE_PASS_LIST ()
0f9cdef4 DM	119
0f9cdef4 DM	120	/* Simple IPA passes executed after the regular passes. In WHOPR mode the
	121	passes are executed after partitioning and thus see just parts of the
	122	compiled unit. */
	123	INSERT_PASSES_AFTER (all_late_ipa_passes)
	124	NEXT_PASS (pass_ipa_pta);
0136f8f0	125	NEXT_PASS (pass_omp_simd_clone);
0f9cdef4 DM	126	TERMINATE_PASS_LIST ()
	127
	128	/* These passes are run after IPA passes on every function that is being
	129	output to the assembler file. */
	130	INSERT_PASSES_AFTER (all_passes)
9c39fca1	131	NEXT_PASS (pass_fixup_cfg);
0f9cdef4 DM	132	NEXT_PASS (pass_lower_eh_dispatch);
	133	NEXT_PASS (pass_all_optimizations);
	134	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
	135	NEXT_PASS (pass_remove_cgraph_callee_edges);
	136	/* Initial scalar cleanups before alias computation.
	137	They ensure memory accesses are not indirect wherever possible. */
	138	NEXT_PASS (pass_strip_predict_hints);
	139	NEXT_PASS (pass_rename_ssa_copies);
0f9cdef4 DM	140	NEXT_PASS (pass_ccp);
	141	/* After CCP we rewrite no longer addressed locals into SSA
	142	form if possible. */
4ee5c752 JL	143	NEXT_PASS (pass_copy_prop);
4ee5c752 JL	144	NEXT_PASS (pass_complete_unrolli);
0f9cdef4 DM	145	NEXT_PASS (pass_phiprop);
0f9cdef4 DM	146	NEXT_PASS (pass_forwprop);
1eadb567	147	NEXT_PASS (pass_object_sizes);
0f9cdef4 DM	148	/* pass_build_alias is a dummy pass that ensures that we
	149	execute TODO_rebuild_alias at this point. */
	150	NEXT_PASS (pass_build_alias);
	151	NEXT_PASS (pass_return_slot);
	152	NEXT_PASS (pass_fre);
0f9cdef4 DM	153	NEXT_PASS (pass_merge_phi);
	154	NEXT_PASS (pass_vrp);
	155	NEXT_PASS (pass_dce);
	156	NEXT_PASS (pass_call_cdce);
	157	NEXT_PASS (pass_cselim);
9e4f27ef	158	NEXT_PASS (pass_copy_prop);
0f9cdef4 DM	159	NEXT_PASS (pass_tree_ifcombine);
	160	NEXT_PASS (pass_phiopt);
	161	NEXT_PASS (pass_tail_recursion);
	162	NEXT_PASS (pass_ch);
	163	NEXT_PASS (pass_stdarg);
	164	NEXT_PASS (pass_lower_complex);
	165	NEXT_PASS (pass_sra);
	166	NEXT_PASS (pass_rename_ssa_copies);
	167	/* The dom pass will also resolve all __builtin_constant_p calls
	168	that are still there to 0. This has to be done after some
	169	propagations have already run, but before some more dead code
	170	is removed, and this place fits nicely. Remember this when
	171	trying to move or duplicate pass_dominator somewhere earlier. */
	172	NEXT_PASS (pass_dominator);
8fdc414d JL	173	/* At this point the majority of const/copy propagations
	174	are exposed. Go ahead and identify paths that should never
	175	be executed in a conforming program and isolate those paths.
	176
	177	This will expose more degenerate PHIs in the main path and
	178	expose more PRE/DOM optimization opportunities. */
	179	NEXT_PASS (pass_isolate_erroneous_paths);
0f9cdef4	180	/* The only const/copy propagation opportunities left after
8fdc414d JL	181	DOM and erroneous path isolation should be due to degenerate PHI nodes.
8fdc414d JL	182	So rather than run the full propagators, run a specialized pass which
0f9cdef4 DM	183	only examines PHIs to discover const/copy propagation
	184	opportunities. */
	185	NEXT_PASS (pass_phi_only_cprop);
	186	NEXT_PASS (pass_dse);
	187	NEXT_PASS (pass_reassoc);
	188	NEXT_PASS (pass_dce);
	189	NEXT_PASS (pass_forwprop);
	190	NEXT_PASS (pass_phiopt);
0f9cdef4 DM	191	NEXT_PASS (pass_ccp);
	192	/* After CCP we rewrite no longer addressed locals into SSA
	193	form if possible. */
	194	NEXT_PASS (pass_copy_prop);
	195	NEXT_PASS (pass_cse_sincos);
	196	NEXT_PASS (pass_optimize_bswap);
	197	NEXT_PASS (pass_split_crit_edges);
	198	NEXT_PASS (pass_pre);
	199	NEXT_PASS (pass_sink_code);
	200	NEXT_PASS (pass_asan);
	201	NEXT_PASS (pass_tsan);
e5d8bd8c RB	202	/* Pass group that runs when 1) enabled, 2) there are loops
e5d8bd8c RB	203	in the function. */
0f9cdef4 DM	204	NEXT_PASS (pass_tree_loop);
	205	PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
	206	NEXT_PASS (pass_tree_loop_init);
	207	NEXT_PASS (pass_lim);
	208	NEXT_PASS (pass_copy_prop);
30866dc9	209	NEXT_PASS (pass_dce);
0f9cdef4 DM	210	NEXT_PASS (pass_tree_unswitch);
	211	NEXT_PASS (pass_scev_cprop);
	212	NEXT_PASS (pass_record_bounds);
	213	NEXT_PASS (pass_check_data_deps);
	214	NEXT_PASS (pass_loop_distribution);
	215	NEXT_PASS (pass_copy_prop);
	216	NEXT_PASS (pass_graphite);
	217	PUSH_INSERT_PASSES_WITHIN (pass_graphite)
	218	NEXT_PASS (pass_graphite_transforms);
	219	NEXT_PASS (pass_lim);
	220	NEXT_PASS (pass_copy_prop);
30866dc9	221	NEXT_PASS (pass_dce);
0f9cdef4 DM	222	POP_INSERT_PASSES ()
	223	NEXT_PASS (pass_iv_canon);
	224	NEXT_PASS (pass_parallelize_loops);
	225	NEXT_PASS (pass_if_conversion);
5ce9450f JJ	226	/* pass_vectorize must immediately follow pass_if_conversion.
5ce9450f JJ	227	Please do not add any other passes in between. */
0f9cdef4 DM	228	NEXT_PASS (pass_vectorize);
0f9cdef4 DM	229	PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
30866dc9	230	NEXT_PASS (pass_dce);
0f9cdef4 DM	231	POP_INSERT_PASSES ()
	232	NEXT_PASS (pass_predcom);
	233	NEXT_PASS (pass_complete_unroll);
	234	NEXT_PASS (pass_slp_vectorize);
	235	NEXT_PASS (pass_loop_prefetch);
e5d8bd8c RB	236	/* Run IVOPTs after the last pass that uses data-reference analysis
e5d8bd8c RB	237	as that doesn't handle TARGET_MEM_REFs. */
0f9cdef4 DM	238	NEXT_PASS (pass_iv_optimize);
	239	NEXT_PASS (pass_lim);
	240	NEXT_PASS (pass_tree_loop_done);
	241	POP_INSERT_PASSES ()
e5d8bd8c RB	242	/* Pass group that runs when pass_tree_loop is disabled or there
	243	are no loops in the function. */
	244	NEXT_PASS (pass_tree_no_loop);
	245	PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
	246	NEXT_PASS (pass_slp_vectorize);
	247	POP_INSERT_PASSES ()
0f9cdef4 DM	248	NEXT_PASS (pass_lower_vector_ssa);
	249	NEXT_PASS (pass_cse_reciprocals);
	250	NEXT_PASS (pass_reassoc);
	251	NEXT_PASS (pass_strength_reduction);
	252	NEXT_PASS (pass_dominator);
24314386	253	NEXT_PASS (pass_strlen);
28a4a292	254	NEXT_PASS (pass_vrp);
0f9cdef4	255	/* The only const/copy propagation opportunities left after
28a4a292	256	DOM and VRP should be due to degenerate PHI nodes. So rather than
0f9cdef4 DM	257	run the full propagators, run a specialized pass which
	258	only examines PHIs to discover const/copy propagation
	259	opportunities. */
	260	NEXT_PASS (pass_phi_only_cprop);
0f9cdef4 DM	261	NEXT_PASS (pass_cd_dce);
0f9cdef4 DM	262	NEXT_PASS (pass_tracer);
154c9188 RB	263	NEXT_PASS (pass_dse);
	264	NEXT_PASS (pass_forwprop);
	265	NEXT_PASS (pass_phiopt);
	266	NEXT_PASS (pass_fold_builtins);
	267	NEXT_PASS (pass_optimize_widening_mul);
	268	NEXT_PASS (pass_tail_calls);
	269	NEXT_PASS (pass_rename_ssa_copies);
0f9cdef4 DM	270	/* FIXME: If DCE is not run before checking for uninitialized uses,
	271	we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
	272	However, this also causes us to misdiagnose cases that should be
	273	real warnings (e.g., testsuite/gcc.dg/pr18501.c).
	274
	275	To fix the false positives in uninit-5.c, we would have to
	276	account for the predicates protecting the set and the use of each
	277	variable. Using a representation like Gated Single Assignment
	278	may help. */
5c2961cf RB	279	/* Split critical edges before late uninit warning to reduce the
	280	number of false positives from it. */
	281	NEXT_PASS (pass_split_crit_edges);
0f9cdef4	282	NEXT_PASS (pass_late_warn_uninitialized);
0f9cdef4 DM	283	NEXT_PASS (pass_uncprop);
	284	NEXT_PASS (pass_local_pure_const);
	285	POP_INSERT_PASSES ()
	286	NEXT_PASS (pass_all_optimizations_g);
	287	PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
	288	NEXT_PASS (pass_remove_cgraph_callee_edges);
	289	NEXT_PASS (pass_strip_predict_hints);
	290	/* Lower remaining pieces of GIMPLE. */
	291	NEXT_PASS (pass_lower_complex);
	292	NEXT_PASS (pass_lower_vector_ssa);
	293	/* Perform simple scalar cleanup which is constant/copy propagation. */
	294	NEXT_PASS (pass_ccp);
	295	NEXT_PASS (pass_object_sizes);
	296	/* Fold remaining builtins. */
	297	NEXT_PASS (pass_fold_builtins);
	298	/* Copy propagation also copy-propagates constants, this is necessary
	299	to forward object-size and builtin folding results properly. */
	300	NEXT_PASS (pass_copy_prop);
	301	NEXT_PASS (pass_dce);
	302	NEXT_PASS (pass_asan);
	303	NEXT_PASS (pass_tsan);
	304	NEXT_PASS (pass_rename_ssa_copies);
	305	/* ??? We do want some kind of loop invariant motion, but we possibly
	306	need to adjust LIM to be more friendly towards preserving accurate
	307	debug information here. */
5c2961cf RB	308	/* Split critical edges before late uninit warning to reduce the
	309	number of false positives from it. */
	310	NEXT_PASS (pass_split_crit_edges);
0f9cdef4 DM	311	NEXT_PASS (pass_late_warn_uninitialized);
	312	NEXT_PASS (pass_uncprop);
	313	NEXT_PASS (pass_local_pure_const);
	314	POP_INSERT_PASSES ()
	315	NEXT_PASS (pass_tm_init);
	316	PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
	317	NEXT_PASS (pass_tm_mark);
	318	NEXT_PASS (pass_tm_memopt);
	319	NEXT_PASS (pass_tm_edges);
	320	POP_INSERT_PASSES ()
2077db1b	321	NEXT_PASS (pass_vtable_verify);
0f9cdef4 DM	322	NEXT_PASS (pass_lower_vector);
	323	NEXT_PASS (pass_lower_complex_O0);
	324	NEXT_PASS (pass_asan_O0);
	325	NEXT_PASS (pass_tsan_O0);
b9a55b13	326	NEXT_PASS (pass_sanopt);
0f9cdef4 DM	327	NEXT_PASS (pass_cleanup_eh);
	328	NEXT_PASS (pass_lower_resx);
	329	NEXT_PASS (pass_nrv);
0f9cdef4 DM	330	NEXT_PASS (pass_cleanup_cfg_post_optimizing);
	331	NEXT_PASS (pass_warn_function_noreturn);
	332
	333	NEXT_PASS (pass_expand);
	334
	335	NEXT_PASS (pass_rest_of_compilation);
	336	PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
	337	NEXT_PASS (pass_instantiate_virtual_regs);
	338	NEXT_PASS (pass_into_cfg_layout_mode);
	339	NEXT_PASS (pass_jump);
	340	NEXT_PASS (pass_lower_subreg);
	341	NEXT_PASS (pass_df_initialize_opt);
	342	NEXT_PASS (pass_cse);
	343	NEXT_PASS (pass_rtl_fwprop);
	344	NEXT_PASS (pass_rtl_cprop);
	345	NEXT_PASS (pass_rtl_pre);
	346	NEXT_PASS (pass_rtl_hoist);
	347	NEXT_PASS (pass_rtl_cprop);
	348	NEXT_PASS (pass_rtl_store_motion);
	349	NEXT_PASS (pass_cse_after_global_opts);
	350	NEXT_PASS (pass_rtl_ifcvt);
	351	NEXT_PASS (pass_reginfo_init);
	352	/* Perform loop optimizations. It might be better to do them a bit
	353	sooner, but we want the profile feedback to work more
	354	efficiently. */
	355	NEXT_PASS (pass_loop2);
	356	PUSH_INSERT_PASSES_WITHIN (pass_loop2)
	357	NEXT_PASS (pass_rtl_loop_init);
	358	NEXT_PASS (pass_rtl_move_loop_invariants);
0f9cdef4 DM	359	NEXT_PASS (pass_rtl_unroll_and_peel_loops);
	360	NEXT_PASS (pass_rtl_doloop);
	361	NEXT_PASS (pass_rtl_loop_done);
	362	TERMINATE_PASS_LIST ()
	363	POP_INSERT_PASSES ()
	364	NEXT_PASS (pass_web);
	365	NEXT_PASS (pass_rtl_cprop);
	366	NEXT_PASS (pass_cse2);
	367	NEXT_PASS (pass_rtl_dse1);
	368	NEXT_PASS (pass_rtl_fwprop_addr);
	369	NEXT_PASS (pass_inc_dec);
	370	NEXT_PASS (pass_initialize_regs);
	371	NEXT_PASS (pass_ud_rtl_dce);
	372	NEXT_PASS (pass_combine);
	373	NEXT_PASS (pass_if_after_combine);
	374	NEXT_PASS (pass_partition_blocks);
0f9cdef4 DM	375	NEXT_PASS (pass_outof_cfg_layout_mode);
	376	NEXT_PASS (pass_split_all_insns);
	377	NEXT_PASS (pass_lower_subreg2);
	378	NEXT_PASS (pass_df_initialize_no_opt);
	379	NEXT_PASS (pass_stack_ptr_mod);
	380	NEXT_PASS (pass_mode_switching);
	381	NEXT_PASS (pass_match_asm_constraints);
	382	NEXT_PASS (pass_sms);
f20f2613	383	NEXT_PASS (pass_live_range_shrinkage);
0f9cdef4 DM	384	NEXT_PASS (pass_sched);
	385	NEXT_PASS (pass_ira);
	386	NEXT_PASS (pass_reload);
	387	NEXT_PASS (pass_postreload);
	388	PUSH_INSERT_PASSES_WITHIN (pass_postreload)
	389	NEXT_PASS (pass_postreload_cse);
	390	NEXT_PASS (pass_gcse2);
	391	NEXT_PASS (pass_split_after_reload);
	392	NEXT_PASS (pass_ree);
	393	NEXT_PASS (pass_compare_elim_after_reload);
	394	NEXT_PASS (pass_branch_target_load_optimize1);
	395	NEXT_PASS (pass_thread_prologue_and_epilogue);
	396	NEXT_PASS (pass_rtl_dse2);
	397	NEXT_PASS (pass_stack_adjustments);
	398	NEXT_PASS (pass_jump2);
0f9cdef4 DM	399	NEXT_PASS (pass_if_after_reload);
	400	NEXT_PASS (pass_regrename);
	401	NEXT_PASS (pass_cprop_hardreg);
	402	NEXT_PASS (pass_fast_rtl_dce);
4ca19309	403	NEXT_PASS (pass_duplicate_computed_gotos);
0f9cdef4	404	NEXT_PASS (pass_reorder_blocks);
47c80ef5 KT	405	/* We need to run peephole2 pass after the duplicate-
	406	compute-gotos and the reorder-blocks pass (PR/39284).
	407	We have a single indirect branch in the entire function
	408	before duplicate-compute-gotos pass. This vastly reduces
	409	the size of the CFG.
	410	For preventing to run peephole2 pass twice, its run after
	411	the jump2 got removed. */
	412	NEXT_PASS (pass_peephole2);
0f9cdef4 DM	413	NEXT_PASS (pass_branch_target_load_optimize2);
	414	NEXT_PASS (pass_leaf_regs);
	415	NEXT_PASS (pass_split_before_sched2);
	416	NEXT_PASS (pass_sched2);
	417	NEXT_PASS (pass_stack_regs);
	418	PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
	419	NEXT_PASS (pass_split_before_regstack);
	420	NEXT_PASS (pass_stack_regs_run);
	421	POP_INSERT_PASSES ()
	422	NEXT_PASS (pass_compute_alignments);
0f9cdef4 DM	423	NEXT_PASS (pass_variable_tracking);
	424	NEXT_PASS (pass_free_cfg);
	425	NEXT_PASS (pass_machine_reorg);
	426	NEXT_PASS (pass_cleanup_barriers);
	427	NEXT_PASS (pass_delay_slots);
	428	NEXT_PASS (pass_split_for_shorten_branches);
	429	NEXT_PASS (pass_convert_to_eh_region_ranges);
	430	NEXT_PASS (pass_shorten_branches);
	431	NEXT_PASS (pass_set_nothrow_function_flags);
	432	NEXT_PASS (pass_dwarf2_frame);
	433	NEXT_PASS (pass_final);
	434	POP_INSERT_PASSES ()
	435	NEXT_PASS (pass_df_finish);
	436	POP_INSERT_PASSES ()
	437	NEXT_PASS (pass_clean_state);
	438	TERMINATE_PASS_LIST ()