gcc/passes.def

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