gcc/passes.def

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