gcc/
[official-gcc.git] / gcc / passes.def
blob0d8356b9bda0aeba72bdb4a6b06abffd5e86058b
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
9 version.
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.
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)
24 POP_INSERT_PASSES ()
25 NEXT_PASS (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
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_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);
62 POP_INSERT_PASSES ()
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);
69 POP_INSERT_PASSES ()
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_rename_ssa_copies);
81 NEXT_PASS (pass_object_sizes);
82 NEXT_PASS (pass_ccp);
83 /* After CCP we rewrite no longer addressed locals into SSA
84 form if possible. */
85 NEXT_PASS (pass_forwprop);
86 NEXT_PASS (pass_sra_early);
87 /* pass_build_ealias is a dummy pass that ensures that we
88 execute TODO_rebuild_alias at this point. */
89 NEXT_PASS (pass_build_ealias);
90 NEXT_PASS (pass_fre);
91 NEXT_PASS (pass_merge_phi);
92 NEXT_PASS (pass_dse);
93 NEXT_PASS (pass_cd_dce);
94 NEXT_PASS (pass_early_ipa_sra);
95 NEXT_PASS (pass_tail_recursion);
96 NEXT_PASS (pass_convert_switch);
97 NEXT_PASS (pass_cleanup_eh);
98 NEXT_PASS (pass_profile);
99 NEXT_PASS (pass_local_pure_const);
100 /* Split functions creates parts that are not run through
101 early optimizations again. It is thus good idea to do this
102 late. */
103 NEXT_PASS (pass_split_functions);
104 POP_INSERT_PASSES ()
105 NEXT_PASS (pass_release_ssa_names);
106 NEXT_PASS (pass_rebuild_cgraph_edges);
107 NEXT_PASS (pass_inline_parameters);
108 POP_INSERT_PASSES ()
109 NEXT_PASS (pass_ipa_chkp_produce_thunks);
110 NEXT_PASS (pass_ipa_auto_profile);
111 NEXT_PASS (pass_ipa_free_inline_summary);
112 NEXT_PASS (pass_ipa_tree_profile);
113 PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
114 NEXT_PASS (pass_feedback_split_functions);
115 POP_INSERT_PASSES ()
116 NEXT_PASS (pass_ipa_increase_alignment);
117 NEXT_PASS (pass_ipa_tm);
118 NEXT_PASS (pass_ipa_lower_emutls);
119 TERMINATE_PASS_LIST ()
121 INSERT_PASSES_AFTER (all_regular_ipa_passes)
122 NEXT_PASS (pass_ipa_whole_program_visibility);
123 NEXT_PASS (pass_ipa_profile);
124 NEXT_PASS (pass_ipa_icf);
125 NEXT_PASS (pass_ipa_devirt);
126 NEXT_PASS (pass_ipa_cp);
127 NEXT_PASS (pass_ipa_cdtor_merge);
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
141 compiled unit. */
142 INSERT_PASSES_AFTER (all_late_ipa_passes)
143 NEXT_PASS (pass_ipa_pta);
144 NEXT_PASS (pass_omp_simd_clone);
145 TERMINATE_PASS_LIST ()
147 /* These passes are run after IPA passes on every function that is being
148 output to the assembler file. */
149 INSERT_PASSES_AFTER (all_passes)
150 NEXT_PASS (pass_fixup_cfg);
151 NEXT_PASS (pass_lower_eh_dispatch);
152 NEXT_PASS (pass_all_optimizations);
153 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
154 NEXT_PASS (pass_remove_cgraph_callee_edges);
155 /* Initial scalar cleanups before alias computation.
156 They ensure memory accesses are not indirect wherever possible. */
157 NEXT_PASS (pass_strip_predict_hints);
158 NEXT_PASS (pass_rename_ssa_copies);
159 NEXT_PASS (pass_ccp);
160 /* After CCP we rewrite no longer addressed locals into SSA
161 form if possible. */
162 NEXT_PASS (pass_complete_unrolli);
163 NEXT_PASS (pass_phiprop);
164 NEXT_PASS (pass_forwprop);
165 NEXT_PASS (pass_object_sizes);
166 /* pass_build_alias is a dummy pass that ensures that we
167 execute TODO_rebuild_alias at this point. */
168 NEXT_PASS (pass_build_alias);
169 NEXT_PASS (pass_return_slot);
170 NEXT_PASS (pass_fre);
171 NEXT_PASS (pass_merge_phi);
172 NEXT_PASS (pass_vrp);
173 NEXT_PASS (pass_chkp_opt);
174 NEXT_PASS (pass_dce);
175 NEXT_PASS (pass_stdarg);
176 NEXT_PASS (pass_call_cdce);
177 NEXT_PASS (pass_cselim);
178 NEXT_PASS (pass_copy_prop);
179 NEXT_PASS (pass_tree_ifcombine);
180 NEXT_PASS (pass_merge_phi);
181 NEXT_PASS (pass_phiopt);
182 NEXT_PASS (pass_tail_recursion);
183 NEXT_PASS (pass_ch);
184 NEXT_PASS (pass_lower_complex);
185 NEXT_PASS (pass_sra);
186 NEXT_PASS (pass_rename_ssa_copies);
187 /* The dom pass will also resolve all __builtin_constant_p calls
188 that are still there to 0. This has to be done after some
189 propagations have already run, but before some more dead code
190 is removed, and this place fits nicely. Remember this when
191 trying to move or duplicate pass_dominator somewhere earlier. */
192 NEXT_PASS (pass_dominator);
193 /* At this point the majority of const/copy propagations
194 are exposed. Go ahead and identify paths that should never
195 be executed in a conforming program and isolate those paths.
197 This will expose more degenerate PHIs in the main path and
198 expose more PRE/DOM optimization opportunities. */
199 NEXT_PASS (pass_isolate_erroneous_paths);
200 /* The only const/copy propagation opportunities left after
201 DOM and erroneous path isolation should be due to degenerate PHI nodes.
202 So rather than run the full propagators, run a specialized pass which
203 only examines PHIs to discover const/copy propagation
204 opportunities. */
205 NEXT_PASS (pass_phi_only_cprop);
206 NEXT_PASS (pass_dse);
207 NEXT_PASS (pass_reassoc);
208 NEXT_PASS (pass_dce);
209 NEXT_PASS (pass_forwprop);
210 NEXT_PASS (pass_phiopt);
211 NEXT_PASS (pass_ccp);
212 /* After CCP we rewrite no longer addressed locals into SSA
213 form if possible. */
214 NEXT_PASS (pass_cse_sincos);
215 NEXT_PASS (pass_optimize_bswap);
216 NEXT_PASS (pass_split_crit_edges);
217 NEXT_PASS (pass_pre);
218 NEXT_PASS (pass_sink_code);
219 NEXT_PASS (pass_asan);
220 NEXT_PASS (pass_tsan);
221 /* Pass group that runs when 1) enabled, 2) there are loops
222 in the function. Make sure to run pass_fix_loops before
223 to discover/remove loops before running the gate function
224 of pass_tree_loop. */
225 NEXT_PASS (pass_fix_loops);
226 NEXT_PASS (pass_tree_loop);
227 PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
228 NEXT_PASS (pass_tree_loop_init);
229 NEXT_PASS (pass_lim);
230 NEXT_PASS (pass_copy_prop);
231 NEXT_PASS (pass_dce);
232 NEXT_PASS (pass_tree_unswitch);
233 NEXT_PASS (pass_scev_cprop);
234 NEXT_PASS (pass_record_bounds);
235 NEXT_PASS (pass_check_data_deps);
236 NEXT_PASS (pass_loop_distribution);
237 NEXT_PASS (pass_copy_prop);
238 NEXT_PASS (pass_graphite);
239 PUSH_INSERT_PASSES_WITHIN (pass_graphite)
240 NEXT_PASS (pass_graphite_transforms);
241 NEXT_PASS (pass_lim);
242 NEXT_PASS (pass_copy_prop);
243 NEXT_PASS (pass_dce);
244 POP_INSERT_PASSES ()
245 NEXT_PASS (pass_iv_canon);
246 NEXT_PASS (pass_parallelize_loops);
247 PUSH_INSERT_PASSES_WITHIN (pass_parallelize_loops)
248 NEXT_PASS (pass_expand_omp_ssa);
249 POP_INSERT_PASSES ()
250 NEXT_PASS (pass_ch_vect);
251 NEXT_PASS (pass_if_conversion);
252 /* pass_vectorize must immediately follow pass_if_conversion.
253 Please do not add any other passes in between. */
254 NEXT_PASS (pass_vectorize);
255 PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
256 NEXT_PASS (pass_dce);
257 POP_INSERT_PASSES ()
258 NEXT_PASS (pass_predcom);
259 NEXT_PASS (pass_complete_unroll);
260 NEXT_PASS (pass_slp_vectorize);
261 NEXT_PASS (pass_loop_prefetch);
262 /* Run IVOPTs after the last pass that uses data-reference analysis
263 as that doesn't handle TARGET_MEM_REFs. */
264 NEXT_PASS (pass_iv_optimize);
265 NEXT_PASS (pass_lim);
266 NEXT_PASS (pass_tree_loop_done);
267 POP_INSERT_PASSES ()
268 /* Pass group that runs when pass_tree_loop is disabled or there
269 are no loops in the function. */
270 NEXT_PASS (pass_tree_no_loop);
271 PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
272 NEXT_PASS (pass_slp_vectorize);
273 POP_INSERT_PASSES ()
274 NEXT_PASS (pass_simduid_cleanup);
275 NEXT_PASS (pass_lower_vector_ssa);
276 NEXT_PASS (pass_cse_reciprocals);
277 NEXT_PASS (pass_reassoc);
278 NEXT_PASS (pass_strength_reduction);
279 NEXT_PASS (pass_tracer);
280 NEXT_PASS (pass_dominator);
281 NEXT_PASS (pass_strlen);
282 NEXT_PASS (pass_vrp);
283 /* The only const/copy propagation opportunities left after
284 DOM and VRP should be due to degenerate PHI nodes. So rather than
285 run the full propagators, run a specialized pass which
286 only examines PHIs to discover const/copy propagation
287 opportunities. */
288 NEXT_PASS (pass_phi_only_cprop);
289 NEXT_PASS (pass_cd_dce);
290 NEXT_PASS (pass_dse);
291 NEXT_PASS (pass_forwprop);
292 NEXT_PASS (pass_phiopt);
293 NEXT_PASS (pass_fold_builtins);
294 NEXT_PASS (pass_optimize_widening_mul);
295 NEXT_PASS (pass_tail_calls);
296 NEXT_PASS (pass_rename_ssa_copies);
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
305 may help. */
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);
312 POP_INSERT_PASSES ()
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 NEXT_PASS (pass_rename_ssa_copies);
332 /* ??? We do want some kind of loop invariant motion, but we possibly
333 need to adjust LIM to be more friendly towards preserving accurate
334 debug information here. */
335 /* Split critical edges before late uninit warning to reduce the
336 number of false positives from it. */
337 NEXT_PASS (pass_split_crit_edges);
338 NEXT_PASS (pass_late_warn_uninitialized);
339 NEXT_PASS (pass_uncprop);
340 NEXT_PASS (pass_local_pure_const);
341 POP_INSERT_PASSES ()
342 NEXT_PASS (pass_tm_init);
343 PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
344 NEXT_PASS (pass_tm_mark);
345 NEXT_PASS (pass_tm_memopt);
346 NEXT_PASS (pass_tm_edges);
347 POP_INSERT_PASSES ()
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
382 efficiently. */
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 ()
391 POP_INSERT_PASSES ()
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);
443 POP_INSERT_PASSES ()
444 POP_INSERT_PASSES ()
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);
459 POP_INSERT_PASSES ()
460 NEXT_PASS (pass_df_finish);
461 POP_INSERT_PASSES ()
462 NEXT_PASS (pass_clean_state);
463 TERMINATE_PASS_LIST ()