gcc/passes.def

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