1 /* Description of pass structure
2 Copyright (C) 1987-2014 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_early_local_passes);
53 PUSH_INSERT_PASSES_WITHIN (pass_early_local_passes)
54 NEXT_PASS (pass_fixup_cfg);
55 NEXT_PASS (pass_init_datastructures);
57 NEXT_PASS (pass_build_ssa);
58 NEXT_PASS (pass_ubsan);
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);
68 /* After CCP we rewrite no longer addressed locals into SSA
70 NEXT_PASS (pass_forwprop);
71 NEXT_PASS (pass_sra_early);
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);
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
87 NEXT_PASS (pass_split_functions);
89 NEXT_PASS (pass_release_ssa_names);
90 NEXT_PASS (pass_rebuild_cgraph_edges);
91 NEXT_PASS (pass_inline_parameters);
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);
98 NEXT_PASS (pass_ipa_increase_alignment);
99 NEXT_PASS (pass_ipa_tm);
100 NEXT_PASS (pass_ipa_lower_emutls);
101 TERMINATE_PASS_LIST ()
103 INSERT_PASSES_AFTER (all_regular_ipa_passes)
104 NEXT_PASS (pass_ipa_whole_program_visibility);
105 NEXT_PASS (pass_ipa_profile);
106 NEXT_PASS (pass_ipa_devirt);
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);
112 /* This pass needs to be scheduled after any IP code duplication. */
113 NEXT_PASS (pass_ipa_single_use);
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);
118 TERMINATE_PASS_LIST ()
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
123 INSERT_PASSES_AFTER (all_late_ipa_passes)
124 NEXT_PASS (pass_ipa_pta);
125 NEXT_PASS (pass_omp_simd_clone);
126 TERMINATE_PASS_LIST ()
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)
131 NEXT_PASS (pass_fixup_cfg);
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);
140 NEXT_PASS (pass_ccp);
141 /* After CCP we rewrite no longer addressed locals into SSA
143 NEXT_PASS (pass_copy_prop);
144 NEXT_PASS (pass_complete_unrolli);
145 NEXT_PASS (pass_phiprop);
146 NEXT_PASS (pass_forwprop);
147 NEXT_PASS (pass_object_sizes);
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);
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);
158 NEXT_PASS (pass_copy_prop);
159 NEXT_PASS (pass_tree_ifcombine);
160 NEXT_PASS (pass_phiopt);
161 NEXT_PASS (pass_tail_recursion);
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);
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.
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);
180 /* The only const/copy propagation opportunities left after
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
183 only examines PHIs to discover const/copy propagation
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);
191 NEXT_PASS (pass_ccp);
192 /* After CCP we rewrite no longer addressed locals into SSA
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);
202 /* Pass group that runs when 1) enabled, 2) there are loops
204 NEXT_PASS (pass_tree_loop);
205 PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
206 NEXT_PASS (pass_tree_loop_init);
207 NEXT_PASS (pass_lim);
208 NEXT_PASS (pass_copy_prop);
209 NEXT_PASS (pass_dce);
210 NEXT_PASS (pass_tree_unswitch);
211 NEXT_PASS (pass_scev_cprop);
212 NEXT_PASS (pass_record_bounds);
213 NEXT_PASS (pass_check_data_deps);
214 NEXT_PASS (pass_loop_distribution);
215 NEXT_PASS (pass_copy_prop);
216 NEXT_PASS (pass_graphite);
217 PUSH_INSERT_PASSES_WITHIN (pass_graphite)
218 NEXT_PASS (pass_graphite_transforms);
219 NEXT_PASS (pass_lim);
220 NEXT_PASS (pass_copy_prop);
221 NEXT_PASS (pass_dce);
223 NEXT_PASS (pass_iv_canon);
224 NEXT_PASS (pass_parallelize_loops);
225 NEXT_PASS (pass_if_conversion);
226 /* pass_vectorize must immediately follow pass_if_conversion.
227 Please do not add any other passes in between. */
228 NEXT_PASS (pass_vectorize);
229 PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
230 NEXT_PASS (pass_dce);
232 NEXT_PASS (pass_predcom);
233 NEXT_PASS (pass_complete_unroll);
234 NEXT_PASS (pass_slp_vectorize);
235 NEXT_PASS (pass_loop_prefetch);
236 /* Run IVOPTs after the last pass that uses data-reference analysis
237 as that doesn't handle TARGET_MEM_REFs. */
238 NEXT_PASS (pass_iv_optimize);
239 NEXT_PASS (pass_lim);
240 NEXT_PASS (pass_tree_loop_done);
242 /* Pass group that runs when pass_tree_loop is disabled or there
243 are no loops in the function. */
244 NEXT_PASS (pass_tree_no_loop);
245 PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
246 NEXT_PASS (pass_slp_vectorize);
248 NEXT_PASS (pass_lower_vector_ssa);
249 NEXT_PASS (pass_cse_reciprocals);
250 NEXT_PASS (pass_reassoc);
251 NEXT_PASS (pass_strength_reduction);
252 NEXT_PASS (pass_dominator);
253 NEXT_PASS (pass_strlen);
254 NEXT_PASS (pass_vrp);
255 /* The only const/copy propagation opportunities left after
256 DOM and VRP should be due to degenerate PHI nodes. So rather than
257 run the full propagators, run a specialized pass which
258 only examines PHIs to discover const/copy propagation
260 NEXT_PASS (pass_phi_only_cprop);
261 NEXT_PASS (pass_cd_dce);
262 NEXT_PASS (pass_tracer);
263 NEXT_PASS (pass_dse);
264 NEXT_PASS (pass_forwprop);
265 NEXT_PASS (pass_phiopt);
266 NEXT_PASS (pass_fold_builtins);
267 NEXT_PASS (pass_optimize_widening_mul);
268 NEXT_PASS (pass_tail_calls);
269 NEXT_PASS (pass_rename_ssa_copies);
270 /* FIXME: If DCE is not run before checking for uninitialized uses,
271 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
272 However, this also causes us to misdiagnose cases that should be
273 real warnings (e.g., testsuite/gcc.dg/pr18501.c).
275 To fix the false positives in uninit-5.c, we would have to
276 account for the predicates protecting the set and the use of each
277 variable. Using a representation like Gated Single Assignment
279 /* Split critical edges before late uninit warning to reduce the
280 number of false positives from it. */
281 NEXT_PASS (pass_split_crit_edges);
282 NEXT_PASS (pass_late_warn_uninitialized);
283 NEXT_PASS (pass_uncprop);
284 NEXT_PASS (pass_local_pure_const);
286 NEXT_PASS (pass_all_optimizations_g);
287 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
288 NEXT_PASS (pass_remove_cgraph_callee_edges);
289 NEXT_PASS (pass_strip_predict_hints);
290 /* Lower remaining pieces of GIMPLE. */
291 NEXT_PASS (pass_lower_complex);
292 NEXT_PASS (pass_lower_vector_ssa);
293 /* Perform simple scalar cleanup which is constant/copy propagation. */
294 NEXT_PASS (pass_ccp);
295 NEXT_PASS (pass_object_sizes);
296 /* Fold remaining builtins. */
297 NEXT_PASS (pass_fold_builtins);
298 /* Copy propagation also copy-propagates constants, this is necessary
299 to forward object-size and builtin folding results properly. */
300 NEXT_PASS (pass_copy_prop);
301 NEXT_PASS (pass_dce);
302 NEXT_PASS (pass_asan);
303 NEXT_PASS (pass_tsan);
304 NEXT_PASS (pass_rename_ssa_copies);
305 /* ??? We do want some kind of loop invariant motion, but we possibly
306 need to adjust LIM to be more friendly towards preserving accurate
307 debug information here. */
308 /* Split critical edges before late uninit warning to reduce the
309 number of false positives from it. */
310 NEXT_PASS (pass_split_crit_edges);
311 NEXT_PASS (pass_late_warn_uninitialized);
312 NEXT_PASS (pass_uncprop);
313 NEXT_PASS (pass_local_pure_const);
315 NEXT_PASS (pass_tm_init);
316 PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
317 NEXT_PASS (pass_tm_mark);
318 NEXT_PASS (pass_tm_memopt);
319 NEXT_PASS (pass_tm_edges);
321 NEXT_PASS (pass_vtable_verify);
322 NEXT_PASS (pass_lower_vector);
323 NEXT_PASS (pass_lower_complex_O0);
324 NEXT_PASS (pass_asan_O0);
325 NEXT_PASS (pass_tsan_O0);
326 NEXT_PASS (pass_sanopt);
327 NEXT_PASS (pass_cleanup_eh);
328 NEXT_PASS (pass_lower_resx);
329 NEXT_PASS (pass_nrv);
330 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
331 NEXT_PASS (pass_warn_function_noreturn);
333 NEXT_PASS (pass_expand);
335 NEXT_PASS (pass_rest_of_compilation);
336 PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
337 NEXT_PASS (pass_instantiate_virtual_regs);
338 NEXT_PASS (pass_into_cfg_layout_mode);
339 NEXT_PASS (pass_jump);
340 NEXT_PASS (pass_lower_subreg);
341 NEXT_PASS (pass_df_initialize_opt);
342 NEXT_PASS (pass_cse);
343 NEXT_PASS (pass_rtl_fwprop);
344 NEXT_PASS (pass_rtl_cprop);
345 NEXT_PASS (pass_rtl_pre);
346 NEXT_PASS (pass_rtl_hoist);
347 NEXT_PASS (pass_rtl_cprop);
348 NEXT_PASS (pass_rtl_store_motion);
349 NEXT_PASS (pass_cse_after_global_opts);
350 NEXT_PASS (pass_rtl_ifcvt);
351 NEXT_PASS (pass_reginfo_init);
352 /* Perform loop optimizations. It might be better to do them a bit
353 sooner, but we want the profile feedback to work more
355 NEXT_PASS (pass_loop2);
356 PUSH_INSERT_PASSES_WITHIN (pass_loop2)
357 NEXT_PASS (pass_rtl_loop_init);
358 NEXT_PASS (pass_rtl_move_loop_invariants);
359 NEXT_PASS (pass_rtl_unroll_and_peel_loops);
360 NEXT_PASS (pass_rtl_doloop);
361 NEXT_PASS (pass_rtl_loop_done);
362 TERMINATE_PASS_LIST ()
364 NEXT_PASS (pass_web);
365 NEXT_PASS (pass_rtl_cprop);
366 NEXT_PASS (pass_cse2);
367 NEXT_PASS (pass_rtl_dse1);
368 NEXT_PASS (pass_rtl_fwprop_addr);
369 NEXT_PASS (pass_inc_dec);
370 NEXT_PASS (pass_initialize_regs);
371 NEXT_PASS (pass_ud_rtl_dce);
372 NEXT_PASS (pass_combine);
373 NEXT_PASS (pass_if_after_combine);
374 NEXT_PASS (pass_partition_blocks);
375 NEXT_PASS (pass_outof_cfg_layout_mode);
376 NEXT_PASS (pass_split_all_insns);
377 NEXT_PASS (pass_lower_subreg2);
378 NEXT_PASS (pass_df_initialize_no_opt);
379 NEXT_PASS (pass_stack_ptr_mod);
380 NEXT_PASS (pass_mode_switching);
381 NEXT_PASS (pass_match_asm_constraints);
382 NEXT_PASS (pass_sms);
383 NEXT_PASS (pass_live_range_shrinkage);
384 NEXT_PASS (pass_sched);
385 NEXT_PASS (pass_ira);
386 NEXT_PASS (pass_reload);
387 NEXT_PASS (pass_postreload);
388 PUSH_INSERT_PASSES_WITHIN (pass_postreload)
389 NEXT_PASS (pass_postreload_cse);
390 NEXT_PASS (pass_gcse2);
391 NEXT_PASS (pass_split_after_reload);
392 NEXT_PASS (pass_ree);
393 NEXT_PASS (pass_compare_elim_after_reload);
394 NEXT_PASS (pass_branch_target_load_optimize1);
395 NEXT_PASS (pass_thread_prologue_and_epilogue);
396 NEXT_PASS (pass_rtl_dse2);
397 NEXT_PASS (pass_stack_adjustments);
398 NEXT_PASS (pass_jump2);
399 NEXT_PASS (pass_if_after_reload);
400 NEXT_PASS (pass_regrename);
401 NEXT_PASS (pass_cprop_hardreg);
402 NEXT_PASS (pass_fast_rtl_dce);
403 NEXT_PASS (pass_duplicate_computed_gotos);
404 NEXT_PASS (pass_reorder_blocks);
405 /* We need to run peephole2 pass after the duplicate-
406 compute-gotos and the reorder-blocks pass (PR/39284).
407 We have a single indirect branch in the entire function
408 before duplicate-compute-gotos pass. This vastly reduces
410 For preventing to run peephole2 pass twice, its run after
411 the jump2 got removed. */
412 NEXT_PASS (pass_peephole2);
413 NEXT_PASS (pass_branch_target_load_optimize2);
414 NEXT_PASS (pass_leaf_regs);
415 NEXT_PASS (pass_split_before_sched2);
416 NEXT_PASS (pass_sched2);
417 NEXT_PASS (pass_stack_regs);
418 PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
419 NEXT_PASS (pass_split_before_regstack);
420 NEXT_PASS (pass_stack_regs_run);
422 NEXT_PASS (pass_compute_alignments);
423 NEXT_PASS (pass_variable_tracking);
424 NEXT_PASS (pass_free_cfg);
425 NEXT_PASS (pass_machine_reorg);
426 NEXT_PASS (pass_cleanup_barriers);
427 NEXT_PASS (pass_delay_slots);
428 NEXT_PASS (pass_split_for_shorten_branches);
429 NEXT_PASS (pass_convert_to_eh_region_ranges);
430 NEXT_PASS (pass_shorten_branches);
431 NEXT_PASS (pass_set_nothrow_function_flags);
432 NEXT_PASS (pass_dwarf2_frame);
433 NEXT_PASS (pass_final);
435 NEXT_PASS (pass_df_finish);
437 NEXT_PASS (pass_clean_state);
438 TERMINATE_PASS_LIST ()