gcc/passes.def

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