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