1 /* Description of pass structure
2 Copyright (C
) 1987-2023 Free Software Foundation
, Inc.
4 This file is part of GCC.
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
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
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
/>.
*/
21 Macros that should be defined when using this file
:
22 INSERT_PASSES_AFTER (PASS
)
23 PUSH_INSERT_PASSES_WITHIN (PASS
)
26 TERMINATE_PASS_LIST (PASS
)
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
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
)
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_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_walloca
, /*strict_mode_p
=*/true
);
60 NEXT_PASS (pass_warn_printf
);
61 NEXT_PASS (pass_warn_nonnull_compare
);
62 NEXT_PASS (pass_early_warn_uninitialized
);
63 NEXT_PASS (pass_warn_access
, /*early
=*/true
);
64 NEXT_PASS (pass_ubsan
);
65 NEXT_PASS (pass_nothrow
);
66 NEXT_PASS (pass_rebuild_cgraph_edges
);
69 NEXT_PASS (pass_local_optimization_passes
);
70 PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes
)
71 NEXT_PASS (pass_fixup_cfg
);
72 NEXT_PASS (pass_rebuild_cgraph_edges
);
73 NEXT_PASS (pass_local_fn_summary
);
74 NEXT_PASS (pass_early_inline
);
75 NEXT_PASS (pass_warn_recursion
);
76 NEXT_PASS (pass_all_early_optimizations
);
77 PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations
)
78 NEXT_PASS (pass_remove_cgraph_callee_edges
);
79 NEXT_PASS (pass_early_object_sizes
);
80 /* Don
't record nonzero bits before IPA to avoid
81 using too much memory. */
82 NEXT_PASS (pass_ccp, false /* nonzero_p */);
83 /* After CCP we rewrite no longer addressed locals into SSA
85 NEXT_PASS (pass_forwprop);
86 NEXT_PASS (pass_early_thread_jumps, /*first=*/true);
87 NEXT_PASS (pass_sra_early);
88 /* pass_build_ealias is a dummy pass that ensures that we
89 execute TODO_rebuild_alias at this point. */
90 NEXT_PASS (pass_build_ealias);
91 /* Do phiprop before FRE so we optimize std::min and std::max well. */
92 NEXT_PASS (pass_phiprop);
93 NEXT_PASS (pass_fre, true /* may_iterate */);
94 NEXT_PASS (pass_early_vrp);
95 NEXT_PASS (pass_merge_phi);
97 NEXT_PASS (pass_cd_dce, false /* update_address_taken_p */);
98 NEXT_PASS (pass_phiopt, true /* early_p */);
99 NEXT_PASS (pass_tail_recursion);
100 NEXT_PASS (pass_if_to_switch);
101 NEXT_PASS (pass_convert_switch);
102 NEXT_PASS (pass_cleanup_eh);
103 NEXT_PASS (pass_profile);
104 NEXT_PASS (pass_local_pure_const);
105 NEXT_PASS (pass_modref);
106 /* Split functions creates parts that are not run through
107 early optimizations again. It is thus good idea to do this
109 NEXT_PASS (pass_split_functions);
110 NEXT_PASS (pass_strip_predict_hints, true /* early_p */);
112 NEXT_PASS (pass_release_ssa_names);
113 NEXT_PASS (pass_rebuild_cgraph_edges);
114 NEXT_PASS (pass_local_fn_summary);
117 NEXT_PASS (pass_ipa_remove_symbols);
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)
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);
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);
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)
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_cp);
161 NEXT_PASS (pass_ipa_sra);
162 NEXT_PASS (pass_ipa_cdtor_merge);
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)
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
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)
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_all_optimizations);
197 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
198 NEXT_PASS (pass_remove_cgraph_callee_edges);
199 /* Initial scalar cleanups before alias computation.
200 They ensure memory accesses are not indirect wherever possible. */
201 NEXT_PASS (pass_strip_predict_hints, false /* early_p */);
202 NEXT_PASS (pass_ccp, true /* nonzero_p */);
203 /* After CCP we rewrite no longer addressed locals into SSA
205 NEXT_PASS (pass_object_sizes);
206 NEXT_PASS (pass_post_ipa_warn);
207 /* Must run before loop unrolling. */
208 NEXT_PASS (pass_warn_access, /*early=*/true);
209 /* Profile count may overflow as a result of inlinining very large
210 loop nests. This pass should run before any late pass that makes
212 NEXT_PASS (pass_rebuild_frequencies);
213 NEXT_PASS (pass_complete_unrolli);
214 NEXT_PASS (pass_backprop);
215 NEXT_PASS (pass_phiprop);
216 NEXT_PASS (pass_forwprop);
217 /* pass_build_alias is a dummy pass that ensures that we
218 execute TODO_rebuild_alias at this point. */
219 NEXT_PASS (pass_build_alias);
220 NEXT_PASS (pass_return_slot);
221 NEXT_PASS (pass_fre, true /* may_iterate */);
222 NEXT_PASS (pass_merge_phi);
223 NEXT_PASS (pass_thread_jumps_full, /*first=*/true);
224 NEXT_PASS (pass_vrp, true /* warn_array_bounds_p */);
225 NEXT_PASS (pass_dse);
226 NEXT_PASS (pass_dce);
227 /* pass_stdarg is always run and at this point we execute
228 TODO_remove_unused_locals to prune CLOBBERs of dead
229 variables which are otherwise a churn on alias walkings. */
230 NEXT_PASS (pass_stdarg);
231 NEXT_PASS (pass_call_cdce);
232 NEXT_PASS (pass_cselim);
233 NEXT_PASS (pass_copy_prop);
234 NEXT_PASS (pass_tree_ifcombine);
235 NEXT_PASS (pass_merge_phi);
236 NEXT_PASS (pass_phiopt, false /* early_p */);
237 NEXT_PASS (pass_tail_recursion);
239 NEXT_PASS (pass_lower_complex);
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
262 NEXT_PASS (pass_expand_powcabs);
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);
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
283 NEXT_PASS (pass_tree_loop_init);
284 NEXT_PASS (pass_tree_unswitch);
285 NEXT_PASS (pass_scev_cprop);
286 NEXT_PASS (pass_loop_split);
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);
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);
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);
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
);
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
);
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
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
, false
/* warn_array_bounds_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
*/);
356 /* After late DCE we rewrite no longer addressed locals into SSA
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_tail_calls
);
370 /* Split critical edges before late uninit warning to reduce the
371 number of false positives from it.
*/
372 NEXT_PASS (pass_split_crit_edges
);
373 NEXT_PASS (pass_late_warn_uninitialized
);
374 NEXT_PASS (pass_local_pure_const
);
375 NEXT_PASS (pass_modref
);
376 /* uncprop replaces constants by SSA names. This makes analysis harder
377 and thus it should be run last.
*/
378 NEXT_PASS (pass_uncprop
);
380 NEXT_PASS (pass_all_optimizations_g
);
381 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g
)
382 /* The idea is that with
-Og we do not perform any IPA optimization
383 so post
-IPA work should be restricted to semantically required
384 passes and all optimization work is done early.
*/
385 NEXT_PASS (pass_remove_cgraph_callee_edges
);
386 NEXT_PASS (pass_strip_predict_hints
, false
/* early_p
*/);
387 /* Lower remaining pieces of GIMPLE.
*/
388 NEXT_PASS (pass_lower_complex
);
389 NEXT_PASS (pass_lower_vector_ssa
);
390 NEXT_PASS (pass_lower_switch
);
391 /* Perform simple scalar cleanup which is constant
/copy propagation.
*/
392 NEXT_PASS (pass_ccp
, true
/* nonzero_p
*/);
393 NEXT_PASS (pass_post_ipa_warn
);
394 NEXT_PASS (pass_object_sizes
);
395 /* Fold remaining builtins.
*/
396 NEXT_PASS (pass_fold_builtins
);
397 NEXT_PASS (pass_strlen
);
398 /* Copy propagation also copy
-propagates constants
, this is necessary
399 to forward object
-size and builtin folding results properly.
*/
400 NEXT_PASS (pass_copy_prop
);
401 NEXT_PASS (pass_dce
);
402 /* Profile count may overflow as a result of inlinining very large
403 loop nests. This pass should run before any late pass that makes
405 NEXT_PASS (pass_rebuild_frequencies
);
406 NEXT_PASS (pass_sancov
);
407 NEXT_PASS (pass_asan
);
408 NEXT_PASS (pass_tsan
);
409 /* ??? We do want some kind of loop invariant motion
, but we possibly
410 need to adjust LIM to be more friendly towards preserving accurate
411 debug information here.
*/
412 /* Split critical edges before late uninit warning to reduce the
413 number of false positives from it.
*/
414 NEXT_PASS (pass_split_crit_edges
);
415 NEXT_PASS (pass_late_warn_uninitialized
);
416 /* uncprop replaces constants by SSA names. This makes analysis harder
417 and thus it should be run last.
*/
418 NEXT_PASS (pass_uncprop
);
420 NEXT_PASS (pass_assumptions
);
421 NEXT_PASS (pass_tm_init
);
422 PUSH_INSERT_PASSES_WITHIN (pass_tm_init
)
423 NEXT_PASS (pass_tm_mark
);
424 NEXT_PASS (pass_tm_memopt
);
425 NEXT_PASS (pass_tm_edges
);
427 NEXT_PASS (pass_simduid_cleanup
);
428 NEXT_PASS (pass_vtable_verify
);
429 NEXT_PASS (pass_lower_vaarg
);
430 NEXT_PASS (pass_lower_vector
);
431 NEXT_PASS (pass_lower_complex_O0
);
432 NEXT_PASS (pass_sancov_O0
);
433 NEXT_PASS (pass_lower_switch_O0
);
434 NEXT_PASS (pass_asan_O0
);
435 NEXT_PASS (pass_tsan_O0
);
436 NEXT_PASS (pass_sanopt
);
437 NEXT_PASS (pass_cleanup_eh
);
438 NEXT_PASS (pass_lower_resx
);
439 NEXT_PASS (pass_nrv
);
440 NEXT_PASS (pass_gimple_isel
);
441 NEXT_PASS (pass_harden_conditional_branches
);
442 NEXT_PASS (pass_harden_compares
);
443 NEXT_PASS (pass_warn_access
, /*early
=*/false
);
444 NEXT_PASS (pass_cleanup_cfg_post_optimizing
);
445 NEXT_PASS (pass_warn_function_noreturn
);
447 NEXT_PASS (pass_expand
);
449 NEXT_PASS (pass_rest_of_compilation
);
450 PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation
)
451 NEXT_PASS (pass_instantiate_virtual_regs
);
452 NEXT_PASS (pass_into_cfg_layout_mode
);
453 NEXT_PASS (pass_jump
);
454 NEXT_PASS (pass_lower_subreg
);
455 NEXT_PASS (pass_df_initialize_opt
);
456 NEXT_PASS (pass_cse
);
457 NEXT_PASS (pass_rtl_fwprop
);
458 NEXT_PASS (pass_rtl_cprop
);
459 NEXT_PASS (pass_rtl_pre
);
460 NEXT_PASS (pass_rtl_hoist
);
461 NEXT_PASS (pass_rtl_cprop
);
462 NEXT_PASS (pass_rtl_store_motion
);
463 NEXT_PASS (pass_cse_after_global_opts
);
464 NEXT_PASS (pass_rtl_ifcvt
);
465 NEXT_PASS (pass_reginfo_init
);
466 /* Perform loop optimizations. It might be better to do them a bit
467 sooner
, but we want the profile feedback to work more
469 NEXT_PASS (pass_loop2
);
470 PUSH_INSERT_PASSES_WITHIN (pass_loop2
)
471 NEXT_PASS (pass_rtl_loop_init
);
472 NEXT_PASS (pass_rtl_move_loop_invariants
);
473 NEXT_PASS (pass_rtl_unroll_loops
);
474 NEXT_PASS (pass_rtl_doloop
);
475 NEXT_PASS (pass_rtl_loop_done
);
477 NEXT_PASS (pass_lower_subreg2
);
478 NEXT_PASS (pass_web
);
479 NEXT_PASS (pass_rtl_cprop
);
480 NEXT_PASS (pass_cse2
);
481 NEXT_PASS (pass_rtl_dse1
);
482 NEXT_PASS (pass_rtl_fwprop_addr
);
483 NEXT_PASS (pass_inc_dec
);
484 NEXT_PASS (pass_initialize_regs
);
485 NEXT_PASS (pass_ud_rtl_dce
);
486 NEXT_PASS (pass_combine
);
487 NEXT_PASS (pass_if_after_combine
);
488 NEXT_PASS (pass_jump_after_combine
);
489 NEXT_PASS (pass_partition_blocks
);
490 NEXT_PASS (pass_outof_cfg_layout_mode
);
491 NEXT_PASS (pass_split_all_insns
);
492 NEXT_PASS (pass_lower_subreg3
);
493 NEXT_PASS (pass_df_initialize_no_opt
);
494 NEXT_PASS (pass_stack_ptr_mod
);
495 NEXT_PASS (pass_mode_switching
);
496 NEXT_PASS (pass_match_asm_constraints
);
497 NEXT_PASS (pass_sms
);
498 NEXT_PASS (pass_live_range_shrinkage
);
499 NEXT_PASS (pass_sched
);
500 NEXT_PASS (pass_early_remat
);
501 NEXT_PASS (pass_ira
);
502 NEXT_PASS (pass_reload
);
503 NEXT_PASS (pass_postreload
);
504 PUSH_INSERT_PASSES_WITHIN (pass_postreload
)
505 NEXT_PASS (pass_postreload_cse
);
506 NEXT_PASS (pass_gcse2
);
507 NEXT_PASS (pass_split_after_reload
);
508 NEXT_PASS (pass_ree
);
509 NEXT_PASS (pass_compare_elim_after_reload
);
510 NEXT_PASS (pass_thread_prologue_and_epilogue
);
511 NEXT_PASS (pass_rtl_dse2
);
512 NEXT_PASS (pass_stack_adjustments
);
513 NEXT_PASS (pass_jump2
);
514 NEXT_PASS (pass_duplicate_computed_gotos
);
515 NEXT_PASS (pass_sched_fusion
);
516 NEXT_PASS (pass_peephole2
);
517 NEXT_PASS (pass_if_after_reload
);
518 NEXT_PASS (pass_regrename
);
519 NEXT_PASS (pass_cprop_hardreg
);
520 NEXT_PASS (pass_fast_rtl_dce
);
521 NEXT_PASS (pass_reorder_blocks
);
522 NEXT_PASS (pass_leaf_regs
);
523 NEXT_PASS (pass_split_before_sched2
);
524 NEXT_PASS (pass_sched2
);
525 NEXT_PASS (pass_stack_regs
);
526 PUSH_INSERT_PASSES_WITHIN (pass_stack_regs
)
527 NEXT_PASS (pass_split_before_regstack
);
528 NEXT_PASS (pass_stack_regs_run
);
531 NEXT_PASS (pass_late_compilation
);
532 PUSH_INSERT_PASSES_WITHIN (pass_late_compilation
)
533 NEXT_PASS (pass_zero_call_used_regs
);
534 NEXT_PASS (pass_compute_alignments
);
535 NEXT_PASS (pass_variable_tracking
);
536 NEXT_PASS (pass_free_cfg
);
537 NEXT_PASS (pass_machine_reorg
);
538 NEXT_PASS (pass_cleanup_barriers
);
539 NEXT_PASS (pass_delay_slots
);
540 NEXT_PASS (pass_split_for_shorten_branches
);
541 NEXT_PASS (pass_convert_to_eh_region_ranges
);
542 NEXT_PASS (pass_shorten_branches
);
543 NEXT_PASS (pass_set_nothrow_function_flags
);
544 NEXT_PASS (pass_dwarf2_frame
);
545 NEXT_PASS (pass_final
);
547 NEXT_PASS (pass_df_finish
);
549 NEXT_PASS (pass_clean_state
);
550 TERMINATE_PASS_LIST (all_passes
)