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