[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_ipa_chkp_versioning);
  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);
  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_ipa_chkp_produce_thunks);

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