comparison gcc/passes.def @ 16:04ced10e8804

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