Mercurial > hg > CbC > CbC_gcc
comparison gcc/passes.def @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111: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) |