gcc/passes.def

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