gcc/passes.def

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