gcc/passes.def

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