1/* Description of pass structure
2   Copyright (C) 1987-2015 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along 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);
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_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 ()
63
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 ()
70
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_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
101	      late.  */
102	  NEXT_PASS (pass_split_functions);
103      POP_INSERT_PASSES ()
104      NEXT_PASS (pass_release_ssa_names);
105      NEXT_PASS (pass_rebuild_cgraph_edges);
106      NEXT_PASS (pass_inline_parameters);
107  POP_INSERT_PASSES ()
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);
114  POP_INSERT_PASSES ()
115  NEXT_PASS (pass_ipa_increase_alignment);
116  NEXT_PASS (pass_ipa_tm);
117  NEXT_PASS (pass_ipa_lower_emutls);
118  TERMINATE_PASS_LIST ()
119
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_ipa_inline);
128  NEXT_PASS (pass_ipa_pure_const);
129  NEXT_PASS (pass_ipa_reference);
130  /* This pass needs to be scheduled after any IP code duplication.   */
131  NEXT_PASS (pass_ipa_single_use);
132  /* Comdat privatization come last, as direct references to comdat local
133     symbols are not allowed outside of the comdat group.  Privatizing early
134     would result in missed optimizations due to this restriction.  */
135  NEXT_PASS (pass_ipa_comdats);
136  TERMINATE_PASS_LIST ()
137
138  /* Simple IPA passes executed after the regular passes.  In WHOPR mode the
139     passes are executed after partitioning and thus see just parts of the
140     compiled unit.  */
141  INSERT_PASSES_AFTER (all_late_ipa_passes)
142  NEXT_PASS (pass_ipa_pta);
143  NEXT_PASS (pass_omp_simd_clone);
144  TERMINATE_PASS_LIST ()
145
146  /* These passes are run after IPA passes on every function that is being
147     output to the assembler file.  */
148  INSERT_PASSES_AFTER (all_passes)
149  NEXT_PASS (pass_fixup_cfg);
150  NEXT_PASS (pass_lower_eh_dispatch);
151  NEXT_PASS (pass_all_optimizations);
152  PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
153      NEXT_PASS (pass_remove_cgraph_callee_edges);
154      /* Initial scalar cleanups before alias computation.
155	 They ensure memory accesses are not indirect wherever possible.  */
156      NEXT_PASS (pass_strip_predict_hints);
157      NEXT_PASS (pass_rename_ssa_copies);
158      NEXT_PASS (pass_ccp);
159      /* After CCP we rewrite no longer addressed locals into SSA
160	 form if possible.  */
161      NEXT_PASS (pass_copy_prop);
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_call_cdce);
176      NEXT_PASS (pass_cselim);
177      NEXT_PASS (pass_copy_prop);
178      NEXT_PASS (pass_tree_ifcombine);
179      NEXT_PASS (pass_phiopt);
180      NEXT_PASS (pass_tail_recursion);
181      NEXT_PASS (pass_ch);
182      NEXT_PASS (pass_stdarg);
183      NEXT_PASS (pass_lower_complex);
184      NEXT_PASS (pass_sra);
185      NEXT_PASS (pass_rename_ssa_copies);
186      /* The dom pass will also resolve all __builtin_constant_p calls
187         that are still there to 0.  This has to be done after some
188	 propagations have already run, but before some more dead code
189	 is removed, and this place fits nicely.  Remember this when
190	 trying to move or duplicate pass_dominator somewhere earlier.  */
191      NEXT_PASS (pass_dominator);
192      /* At this point the majority of const/copy propagations
193	 are exposed.  Go ahead and identify paths that should never
194	 be executed in a conforming program and isolate those paths.
195
196	 This will expose more degenerate PHIs in the main path and
197	 expose more PRE/DOM optimization opportunities.  */
198      NEXT_PASS (pass_isolate_erroneous_paths);
199      /* The only const/copy propagation opportunities left after
200	 DOM and erroneous path isolation should be due to degenerate PHI nodes.
201	 So rather than run the full propagators, run a specialized pass which
202	 only examines PHIs to discover const/copy propagation
203	 opportunities.  */
204      NEXT_PASS (pass_phi_only_cprop);
205      NEXT_PASS (pass_dse);
206      NEXT_PASS (pass_reassoc);
207      NEXT_PASS (pass_dce);
208      NEXT_PASS (pass_forwprop);
209      NEXT_PASS (pass_phiopt);
210      NEXT_PASS (pass_ccp);
211      /* After CCP we rewrite no longer addressed locals into SSA
212	 form if possible.  */
213      NEXT_PASS (pass_copy_prop);
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_if_conversion);
251	  /* pass_vectorize must immediately follow pass_if_conversion.
252	     Please do not add any other passes in between.  */
253	  NEXT_PASS (pass_vectorize);
254          PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
255	      NEXT_PASS (pass_dce);
256          POP_INSERT_PASSES ()
257          NEXT_PASS (pass_predcom);
258	  NEXT_PASS (pass_complete_unroll);
259	  NEXT_PASS (pass_slp_vectorize);
260	  NEXT_PASS (pass_loop_prefetch);
261	  /* Run IVOPTs after the last pass that uses data-reference analysis
262	     as that doesn't handle TARGET_MEM_REFs.  */
263	  NEXT_PASS (pass_iv_optimize);
264	  NEXT_PASS (pass_lim);
265	  NEXT_PASS (pass_tree_loop_done);
266      POP_INSERT_PASSES ()
267      /* Pass group that runs when pass_tree_loop is disabled or there
268         are no loops in the function.  */
269      NEXT_PASS (pass_tree_no_loop);
270      PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
271	  NEXT_PASS (pass_slp_vectorize);
272      POP_INSERT_PASSES ()
273      NEXT_PASS (pass_simduid_cleanup);
274      NEXT_PASS (pass_lower_vector_ssa);
275      NEXT_PASS (pass_cse_reciprocals);
276      NEXT_PASS (pass_reassoc);
277      NEXT_PASS (pass_strength_reduction);
278      NEXT_PASS (pass_tracer);
279      NEXT_PASS (pass_dominator);
280      NEXT_PASS (pass_strlen);
281      NEXT_PASS (pass_vrp);
282      /* The only const/copy propagation opportunities left after
283	 DOM and VRP should be due to degenerate PHI nodes.  So rather than
284	 run the full propagators, run a specialized pass which
285	 only examines PHIs to discover const/copy propagation
286	 opportunities.  */
287      NEXT_PASS (pass_phi_only_cprop);
288      NEXT_PASS (pass_cd_dce);
289      NEXT_PASS (pass_dse);
290      NEXT_PASS (pass_forwprop);
291      NEXT_PASS (pass_phiopt);
292      NEXT_PASS (pass_fold_builtins);
293      NEXT_PASS (pass_optimize_widening_mul);
294      NEXT_PASS (pass_tail_calls);
295      NEXT_PASS (pass_rename_ssa_copies);
296      /* FIXME: If DCE is not run before checking for uninitialized uses,
297	 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
298	 However, this also causes us to misdiagnose cases that should be
299	 real warnings (e.g., testsuite/gcc.dg/pr18501.c).
300
301	 To fix the false positives in uninit-5.c, we would have to
302	 account for the predicates protecting the set and the use of each
303	 variable.  Using a representation like Gated Single Assignment
304	 may help.  */
305      /* Split critical edges before late uninit warning to reduce the
306         number of false positives from it.  */
307      NEXT_PASS (pass_split_crit_edges);
308      NEXT_PASS (pass_late_warn_uninitialized);
309      NEXT_PASS (pass_uncprop);
310      NEXT_PASS (pass_local_pure_const);
311  POP_INSERT_PASSES ()
312  NEXT_PASS (pass_all_optimizations_g);
313  PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
314      NEXT_PASS (pass_remove_cgraph_callee_edges);
315      NEXT_PASS (pass_strip_predict_hints);
316      /* Lower remaining pieces of GIMPLE.  */
317      NEXT_PASS (pass_lower_complex);
318      NEXT_PASS (pass_lower_vector_ssa);
319      /* Perform simple scalar cleanup which is constant/copy propagation.  */
320      NEXT_PASS (pass_ccp);
321      NEXT_PASS (pass_object_sizes);
322      /* Fold remaining builtins.  */
323      NEXT_PASS (pass_fold_builtins);
324      /* Copy propagation also copy-propagates constants, this is necessary
325         to forward object-size and builtin folding results properly.  */
326      NEXT_PASS (pass_copy_prop);
327      NEXT_PASS (pass_dce);
328      NEXT_PASS (pass_asan);
329      NEXT_PASS (pass_tsan);
330      NEXT_PASS (pass_rename_ssa_copies);
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);
340  POP_INSERT_PASSES ()
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);
346  POP_INSERT_PASSES ()
347  NEXT_PASS (pass_vtable_verify);
348  NEXT_PASS (pass_lower_vector);
349  NEXT_PASS (pass_lower_complex_O0);
350  NEXT_PASS (pass_asan_O0);
351  NEXT_PASS (pass_tsan_O0);
352  NEXT_PASS (pass_sanopt);
353  NEXT_PASS (pass_cleanup_eh);
354  NEXT_PASS (pass_lower_resx);
355  NEXT_PASS (pass_nrv);
356  NEXT_PASS (pass_cleanup_cfg_post_optimizing);
357  NEXT_PASS (pass_warn_function_noreturn);
358
359  NEXT_PASS (pass_expand);
360
361  NEXT_PASS (pass_rest_of_compilation);
362  PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
363      NEXT_PASS (pass_instantiate_virtual_regs);
364      NEXT_PASS (pass_into_cfg_layout_mode);
365      NEXT_PASS (pass_jump);
366      NEXT_PASS (pass_lower_subreg);
367      NEXT_PASS (pass_df_initialize_opt);
368      NEXT_PASS (pass_cse);
369      NEXT_PASS (pass_rtl_fwprop);
370      NEXT_PASS (pass_rtl_cprop);
371      NEXT_PASS (pass_rtl_pre);
372      NEXT_PASS (pass_rtl_hoist);
373      NEXT_PASS (pass_rtl_cprop);
374      NEXT_PASS (pass_rtl_store_motion);
375      NEXT_PASS (pass_cse_after_global_opts);
376      NEXT_PASS (pass_rtl_ifcvt);
377      NEXT_PASS (pass_reginfo_init);
378      /* Perform loop optimizations.  It might be better to do them a bit
379	 sooner, but we want the profile feedback to work more
380	 efficiently.  */
381      NEXT_PASS (pass_loop2);
382      PUSH_INSERT_PASSES_WITHIN (pass_loop2)
383	  NEXT_PASS (pass_rtl_loop_init);
384	  NEXT_PASS (pass_rtl_move_loop_invariants);
385	  NEXT_PASS (pass_rtl_unroll_loops);
386	  NEXT_PASS (pass_rtl_doloop);
387	  NEXT_PASS (pass_rtl_loop_done);
388	  TERMINATE_PASS_LIST ()
389      POP_INSERT_PASSES ()
390      NEXT_PASS (pass_web);
391      NEXT_PASS (pass_rtl_cprop);
392      NEXT_PASS (pass_cse2);
393      NEXT_PASS (pass_rtl_dse1);
394      NEXT_PASS (pass_rtl_fwprop_addr);
395      NEXT_PASS (pass_inc_dec);
396      NEXT_PASS (pass_initialize_regs);
397      NEXT_PASS (pass_ud_rtl_dce);
398      NEXT_PASS (pass_combine);
399      NEXT_PASS (pass_if_after_combine);
400      NEXT_PASS (pass_partition_blocks);
401      NEXT_PASS (pass_outof_cfg_layout_mode);
402      NEXT_PASS (pass_split_all_insns);
403      NEXT_PASS (pass_lower_subreg2);
404      NEXT_PASS (pass_df_initialize_no_opt);
405      NEXT_PASS (pass_stack_ptr_mod);
406      NEXT_PASS (pass_mode_switching);
407      NEXT_PASS (pass_match_asm_constraints);
408      NEXT_PASS (pass_sms);
409      NEXT_PASS (pass_live_range_shrinkage);
410      NEXT_PASS (pass_sched);
411      NEXT_PASS (pass_ira);
412      NEXT_PASS (pass_reload);
413      NEXT_PASS (pass_postreload);
414      PUSH_INSERT_PASSES_WITHIN (pass_postreload)
415	  NEXT_PASS (pass_postreload_cse);
416	  NEXT_PASS (pass_gcse2);
417	  NEXT_PASS (pass_split_after_reload);
418	  NEXT_PASS (pass_ree);
419	  NEXT_PASS (pass_compare_elim_after_reload);
420	  NEXT_PASS (pass_branch_target_load_optimize1);
421	  NEXT_PASS (pass_thread_prologue_and_epilogue);
422	  NEXT_PASS (pass_rtl_dse2);
423	  NEXT_PASS (pass_stack_adjustments);
424	  NEXT_PASS (pass_jump2);
425	  NEXT_PASS (pass_duplicate_computed_gotos);
426	  NEXT_PASS (pass_sched_fusion);
427	  NEXT_PASS (pass_peephole2);
428	  NEXT_PASS (pass_if_after_reload);
429	  NEXT_PASS (pass_regrename);
430	  NEXT_PASS (pass_cprop_hardreg);
431	  NEXT_PASS (pass_fast_rtl_dce);
432	  NEXT_PASS (pass_reorder_blocks);
433	  NEXT_PASS (pass_branch_target_load_optimize2);
434	  NEXT_PASS (pass_leaf_regs);
435	  NEXT_PASS (pass_split_before_sched2);
436	  NEXT_PASS (pass_sched2);
437	  NEXT_PASS (pass_stack_regs);
438	  PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
439	      NEXT_PASS (pass_split_before_regstack);
440	      NEXT_PASS (pass_stack_regs_run);
441	  POP_INSERT_PASSES ()
442      POP_INSERT_PASSES ()
443      NEXT_PASS (pass_late_compilation);
444      PUSH_INSERT_PASSES_WITHIN (pass_late_compilation)
445	  NEXT_PASS (pass_compute_alignments);
446	  NEXT_PASS (pass_variable_tracking);
447	  NEXT_PASS (pass_free_cfg);
448	  NEXT_PASS (pass_machine_reorg);
449	  NEXT_PASS (pass_cleanup_barriers);
450	  NEXT_PASS (pass_delay_slots);
451	  NEXT_PASS (pass_split_for_shorten_branches);
452	  NEXT_PASS (pass_convert_to_eh_region_ranges);
453	  NEXT_PASS (pass_shorten_branches);
454	  NEXT_PASS (pass_set_nothrow_function_flags);
455	  NEXT_PASS (pass_dwarf2_frame);
456	  NEXT_PASS (pass_final);
457      POP_INSERT_PASSES ()
458      NEXT_PASS (pass_df_finish);
459  POP_INSERT_PASSES ()
460  NEXT_PASS (pass_clean_state);
461  TERMINATE_PASS_LIST ()
462