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