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