gcc/passes.def

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