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