gcc/passes.def

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