gcc/passes.def

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