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