|
111
|
1 /* Description of pass structure
|
|
145
|
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
|
|
111
|
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);
|
|
145
|
42 NEXT_PASS (pass_coroutine_lower_builtins);
|
|
111
|
43 NEXT_PASS (pass_build_cfg);
|
|
|
44 NEXT_PASS (pass_warn_function_return);
|
|
145
|
45 NEXT_PASS (pass_coroutine_early_expand_ifns);
|
|
111
|
46 NEXT_PASS (pass_expand_omp);
|
|
145
|
47 NEXT_PASS (pass_warn_printf);
|
|
111
|
48 NEXT_PASS (pass_walloca, /*strict_mode_p=*/true);
|
|
|
49 NEXT_PASS (pass_build_cgraph_edges);
|
|
|
50 TERMINATE_PASS_LIST (all_lowering_passes)
|
|
|
51
|
|
|
52 /* Interprocedural optimization passes. */
|
|
|
53 INSERT_PASSES_AFTER (all_small_ipa_passes)
|
|
|
54 NEXT_PASS (pass_ipa_free_lang_data);
|
|
|
55 NEXT_PASS (pass_ipa_function_and_variable_visibility);
|
|
|
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);
|
|
145
|
61 NEXT_PASS (pass_early_warn_uninitialized);
|
|
111
|
62 NEXT_PASS (pass_ubsan);
|
|
|
63 NEXT_PASS (pass_nothrow);
|
|
|
64 NEXT_PASS (pass_rebuild_cgraph_edges);
|
|
|
65 POP_INSERT_PASSES ()
|
|
|
66
|
|
|
67 NEXT_PASS (pass_local_optimization_passes);
|
|
|
68 PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes)
|
|
|
69 NEXT_PASS (pass_fixup_cfg);
|
|
|
70 NEXT_PASS (pass_rebuild_cgraph_edges);
|
|
|
71 NEXT_PASS (pass_local_fn_summary);
|
|
|
72 NEXT_PASS (pass_early_inline);
|
|
|
73 NEXT_PASS (pass_all_early_optimizations);
|
|
|
74 PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
|
|
|
75 NEXT_PASS (pass_remove_cgraph_callee_edges);
|
|
|
76 NEXT_PASS (pass_object_sizes, true /* insert_min_max_p */);
|
|
|
77 /* Don't record nonzero bits before IPA to avoid
|
|
|
78 using too much memory. */
|
|
|
79 NEXT_PASS (pass_ccp, false /* nonzero_p */);
|
|
|
80 /* After CCP we rewrite no longer addressed locals into SSA
|
|
|
81 form if possible. */
|
|
|
82 NEXT_PASS (pass_forwprop);
|
|
|
83 NEXT_PASS (pass_early_thread_jumps);
|
|
|
84 NEXT_PASS (pass_sra_early);
|
|
|
85 /* pass_build_ealias is a dummy pass that ensures that we
|
|
|
86 execute TODO_rebuild_alias at this point. */
|
|
|
87 NEXT_PASS (pass_build_ealias);
|
|
145
|
88 NEXT_PASS (pass_fre, true /* may_iterate */);
|
|
111
|
89 NEXT_PASS (pass_early_vrp);
|
|
|
90 NEXT_PASS (pass_merge_phi);
|
|
|
91 NEXT_PASS (pass_dse);
|
|
|
92 NEXT_PASS (pass_cd_dce);
|
|
131
|
93 NEXT_PASS (pass_phiopt, true /* early_p */);
|
|
111
|
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);
|
|
131
|
103 NEXT_PASS (pass_strip_predict_hints, true /* early_p */);
|
|
111
|
104 POP_INSERT_PASSES ()
|
|
|
105 NEXT_PASS (pass_release_ssa_names);
|
|
|
106 NEXT_PASS (pass_rebuild_cgraph_edges);
|
|
|
107 NEXT_PASS (pass_local_fn_summary);
|
|
|
108 POP_INSERT_PASSES ()
|
|
|
109
|
|
145
|
110 NEXT_PASS (pass_ipa_remove_symbols);
|
|
111
|
111 NEXT_PASS (pass_ipa_oacc);
|
|
|
112 PUSH_INSERT_PASSES_WITHIN (pass_ipa_oacc)
|
|
|
113 NEXT_PASS (pass_ipa_pta);
|
|
|
114 /* Pass group that runs when the function is an offloaded function
|
|
|
115 containing oacc kernels loops. */
|
|
|
116 NEXT_PASS (pass_ipa_oacc_kernels);
|
|
|
117 PUSH_INSERT_PASSES_WITHIN (pass_ipa_oacc_kernels)
|
|
|
118 NEXT_PASS (pass_oacc_kernels);
|
|
|
119 PUSH_INSERT_PASSES_WITHIN (pass_oacc_kernels)
|
|
|
120 NEXT_PASS (pass_ch);
|
|
145
|
121 NEXT_PASS (pass_fre, true /* may_iterate */);
|
|
111
|
122 /* We use pass_lim to rewrite in-memory iteration and reduction
|
|
|
123 variable accesses in loops into local variables accesses. */
|
|
|
124 NEXT_PASS (pass_lim);
|
|
|
125 NEXT_PASS (pass_dominator, false /* may_peel_loop_headers_p */);
|
|
|
126 NEXT_PASS (pass_dce);
|
|
|
127 NEXT_PASS (pass_parallelize_loops, true /* oacc_kernels_p */);
|
|
|
128 NEXT_PASS (pass_expand_omp_ssa);
|
|
|
129 NEXT_PASS (pass_rebuild_cgraph_edges);
|
|
|
130 POP_INSERT_PASSES ()
|
|
|
131 POP_INSERT_PASSES ()
|
|
|
132 POP_INSERT_PASSES ()
|
|
|
133
|
|
|
134 NEXT_PASS (pass_target_clone);
|
|
|
135 NEXT_PASS (pass_ipa_auto_profile);
|
|
|
136 NEXT_PASS (pass_ipa_tree_profile);
|
|
|
137 PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
|
|
|
138 NEXT_PASS (pass_feedback_split_functions);
|
|
|
139 POP_INSERT_PASSES ()
|
|
131
|
140 NEXT_PASS (pass_ipa_free_fn_summary, true /* small_p */);
|
|
111
|
141 NEXT_PASS (pass_ipa_increase_alignment);
|
|
|
142 NEXT_PASS (pass_ipa_tm);
|
|
|
143 NEXT_PASS (pass_ipa_lower_emutls);
|
|
|
144 TERMINATE_PASS_LIST (all_small_ipa_passes)
|
|
|
145
|
|
|
146 INSERT_PASSES_AFTER (all_regular_ipa_passes)
|
|
145
|
147 NEXT_PASS (pass_analyzer);
|
|
111
|
148 NEXT_PASS (pass_ipa_whole_program_visibility);
|
|
|
149 NEXT_PASS (pass_ipa_profile);
|
|
|
150 NEXT_PASS (pass_ipa_icf);
|
|
|
151 NEXT_PASS (pass_ipa_devirt);
|
|
|
152 NEXT_PASS (pass_ipa_cp);
|
|
145
|
153 NEXT_PASS (pass_ipa_sra);
|
|
111
|
154 NEXT_PASS (pass_ipa_cdtor_merge);
|
|
|
155 NEXT_PASS (pass_ipa_hsa);
|
|
|
156 NEXT_PASS (pass_ipa_fn_summary);
|
|
|
157 NEXT_PASS (pass_ipa_inline);
|
|
|
158 NEXT_PASS (pass_ipa_pure_const);
|
|
131
|
159 NEXT_PASS (pass_ipa_free_fn_summary, false /* small_p */);
|
|
111
|
160 NEXT_PASS (pass_ipa_reference);
|
|
|
161 /* This pass needs to be scheduled after any IP code duplication. */
|
|
|
162 NEXT_PASS (pass_ipa_single_use);
|
|
|
163 /* Comdat privatization come last, as direct references to comdat local
|
|
|
164 symbols are not allowed outside of the comdat group. Privatizing early
|
|
|
165 would result in missed optimizations due to this restriction. */
|
|
|
166 NEXT_PASS (pass_ipa_comdats);
|
|
|
167 TERMINATE_PASS_LIST (all_regular_ipa_passes)
|
|
|
168
|
|
|
169 /* Simple IPA passes executed after the regular passes. In WHOPR mode the
|
|
|
170 passes are executed after partitioning and thus see just parts of the
|
|
|
171 compiled unit. */
|
|
|
172 INSERT_PASSES_AFTER (all_late_ipa_passes)
|
|
|
173 NEXT_PASS (pass_materialize_all_clones);
|
|
|
174 NEXT_PASS (pass_ipa_pta);
|
|
|
175 NEXT_PASS (pass_omp_simd_clone);
|
|
|
176 TERMINATE_PASS_LIST (all_late_ipa_passes)
|
|
|
177
|
|
|
178 /* These passes are run after IPA passes on every function that is being
|
|
|
179 output to the assembler file. */
|
|
|
180 INSERT_PASSES_AFTER (all_passes)
|
|
|
181 NEXT_PASS (pass_fixup_cfg);
|
|
|
182 NEXT_PASS (pass_lower_eh_dispatch);
|
|
|
183 NEXT_PASS (pass_oacc_device_lower);
|
|
|
184 NEXT_PASS (pass_omp_device_lower);
|
|
|
185 NEXT_PASS (pass_omp_target_link);
|
|
|
186 NEXT_PASS (pass_all_optimizations);
|
|
|
187 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
|
|
|
188 NEXT_PASS (pass_remove_cgraph_callee_edges);
|
|
|
189 /* Initial scalar cleanups before alias computation.
|
|
|
190 They ensure memory accesses are not indirect wherever possible. */
|
|
131
|
191 NEXT_PASS (pass_strip_predict_hints, false /* early_p */);
|
|
111
|
192 NEXT_PASS (pass_ccp, true /* nonzero_p */);
|
|
|
193 NEXT_PASS (pass_post_ipa_warn);
|
|
|
194 /* After CCP we rewrite no longer addressed locals into SSA
|
|
|
195 form if possible. */
|
|
|
196 NEXT_PASS (pass_complete_unrolli);
|
|
|
197 NEXT_PASS (pass_backprop);
|
|
|
198 NEXT_PASS (pass_phiprop);
|
|
|
199 NEXT_PASS (pass_forwprop);
|
|
|
200 NEXT_PASS (pass_object_sizes, false /* insert_min_max_p */);
|
|
|
201 /* pass_build_alias is a dummy pass that ensures that we
|
|
|
202 execute TODO_rebuild_alias at this point. */
|
|
|
203 NEXT_PASS (pass_build_alias);
|
|
|
204 NEXT_PASS (pass_return_slot);
|
|
145
|
205 NEXT_PASS (pass_fre, true /* may_iterate */);
|
|
111
|
206 NEXT_PASS (pass_merge_phi);
|
|
|
207 NEXT_PASS (pass_thread_jumps);
|
|
|
208 NEXT_PASS (pass_vrp, true /* warn_array_bounds_p */);
|
|
|
209 NEXT_PASS (pass_dce);
|
|
|
210 NEXT_PASS (pass_stdarg);
|
|
|
211 NEXT_PASS (pass_call_cdce);
|
|
|
212 NEXT_PASS (pass_cselim);
|
|
|
213 NEXT_PASS (pass_copy_prop);
|
|
|
214 NEXT_PASS (pass_tree_ifcombine);
|
|
|
215 NEXT_PASS (pass_merge_phi);
|
|
131
|
216 NEXT_PASS (pass_phiopt, false /* early_p */);
|
|
111
|
217 NEXT_PASS (pass_tail_recursion);
|
|
|
218 NEXT_PASS (pass_ch);
|
|
|
219 NEXT_PASS (pass_lower_complex);
|
|
|
220 NEXT_PASS (pass_sra);
|
|
|
221 /* The dom pass will also resolve all __builtin_constant_p calls
|
|
|
222 that are still there to 0. This has to be done after some
|
|
|
223 propagations have already run, but before some more dead code
|
|
|
224 is removed, and this place fits nicely. Remember this when
|
|
|
225 trying to move or duplicate pass_dominator somewhere earlier. */
|
|
|
226 NEXT_PASS (pass_thread_jumps);
|
|
|
227 NEXT_PASS (pass_dominator, true /* may_peel_loop_headers_p */);
|
|
145
|
228 /* Threading can leave many const/copy propagations in the IL.
|
|
|
229 Clean them up. Failure to do so well can lead to false
|
|
|
230 positives from warnings for erroneous code. */
|
|
|
231 NEXT_PASS (pass_copy_prop);
|
|
|
232 /* Identify paths that should never be executed in a conforming
|
|
|
233 program and isolate those paths. */
|
|
111
|
234 NEXT_PASS (pass_isolate_erroneous_paths);
|
|
|
235 NEXT_PASS (pass_dse);
|
|
|
236 NEXT_PASS (pass_reassoc, true /* insert_powi_p */);
|
|
|
237 NEXT_PASS (pass_dce);
|
|
|
238 NEXT_PASS (pass_forwprop);
|
|
131
|
239 NEXT_PASS (pass_phiopt, false /* early_p */);
|
|
111
|
240 NEXT_PASS (pass_ccp, true /* nonzero_p */);
|
|
|
241 /* After CCP we rewrite no longer addressed locals into SSA
|
|
|
242 form if possible. */
|
|
|
243 NEXT_PASS (pass_cse_sincos);
|
|
|
244 NEXT_PASS (pass_optimize_bswap);
|
|
|
245 NEXT_PASS (pass_laddress);
|
|
|
246 NEXT_PASS (pass_lim);
|
|
|
247 NEXT_PASS (pass_walloca, false);
|
|
|
248 NEXT_PASS (pass_pre);
|
|
|
249 NEXT_PASS (pass_sink_code);
|
|
|
250 NEXT_PASS (pass_sancov);
|
|
|
251 NEXT_PASS (pass_asan);
|
|
|
252 NEXT_PASS (pass_tsan);
|
|
|
253 NEXT_PASS (pass_dce);
|
|
|
254 /* Pass group that runs when 1) enabled, 2) there are loops
|
|
|
255 in the function. Make sure to run pass_fix_loops before
|
|
|
256 to discover/remove loops before running the gate function
|
|
|
257 of pass_tree_loop. */
|
|
|
258 NEXT_PASS (pass_fix_loops);
|
|
|
259 NEXT_PASS (pass_tree_loop);
|
|
|
260 PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
|
|
145
|
261 /* Before loop_init we rewrite no longer addressed locals into SSA
|
|
|
262 form if possible. */
|
|
111
|
263 NEXT_PASS (pass_tree_loop_init);
|
|
|
264 NEXT_PASS (pass_tree_unswitch);
|
|
|
265 NEXT_PASS (pass_scev_cprop);
|
|
|
266 NEXT_PASS (pass_loop_split);
|
|
145
|
267 NEXT_PASS (pass_loop_versioning);
|
|
131
|
268 NEXT_PASS (pass_loop_jam);
|
|
111
|
269 /* All unswitching, final value replacement and splitting can expose
|
|
|
270 empty loops. Remove them now. */
|
|
|
271 NEXT_PASS (pass_cd_dce);
|
|
|
272 NEXT_PASS (pass_iv_canon);
|
|
|
273 NEXT_PASS (pass_loop_distribution);
|
|
131
|
274 NEXT_PASS (pass_linterchange);
|
|
111
|
275 NEXT_PASS (pass_copy_prop);
|
|
|
276 NEXT_PASS (pass_graphite);
|
|
|
277 PUSH_INSERT_PASSES_WITHIN (pass_graphite)
|
|
|
278 NEXT_PASS (pass_graphite_transforms);
|
|
|
279 NEXT_PASS (pass_lim);
|
|
|
280 NEXT_PASS (pass_copy_prop);
|
|
|
281 NEXT_PASS (pass_dce);
|
|
|
282 POP_INSERT_PASSES ()
|
|
|
283 NEXT_PASS (pass_parallelize_loops, false /* oacc_kernels_p */);
|
|
|
284 NEXT_PASS (pass_expand_omp_ssa);
|
|
|
285 NEXT_PASS (pass_ch_vect);
|
|
|
286 NEXT_PASS (pass_if_conversion);
|
|
|
287 /* pass_vectorize must immediately follow pass_if_conversion.
|
|
|
288 Please do not add any other passes in between. */
|
|
|
289 NEXT_PASS (pass_vectorize);
|
|
|
290 PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
|
|
|
291 NEXT_PASS (pass_dce);
|
|
|
292 POP_INSERT_PASSES ()
|
|
|
293 NEXT_PASS (pass_predcom);
|
|
|
294 NEXT_PASS (pass_complete_unroll);
|
|
|
295 NEXT_PASS (pass_slp_vectorize);
|
|
|
296 NEXT_PASS (pass_loop_prefetch);
|
|
|
297 /* Run IVOPTs after the last pass that uses data-reference analysis
|
|
|
298 as that doesn't handle TARGET_MEM_REFs. */
|
|
|
299 NEXT_PASS (pass_iv_optimize);
|
|
|
300 NEXT_PASS (pass_lim);
|
|
|
301 NEXT_PASS (pass_tree_loop_done);
|
|
|
302 POP_INSERT_PASSES ()
|
|
|
303 /* Pass group that runs when pass_tree_loop is disabled or there
|
|
|
304 are no loops in the function. */
|
|
|
305 NEXT_PASS (pass_tree_no_loop);
|
|
|
306 PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop)
|
|
|
307 NEXT_PASS (pass_slp_vectorize);
|
|
|
308 POP_INSERT_PASSES ()
|
|
|
309 NEXT_PASS (pass_simduid_cleanup);
|
|
|
310 NEXT_PASS (pass_lower_vector_ssa);
|
|
131
|
311 NEXT_PASS (pass_lower_switch);
|
|
111
|
312 NEXT_PASS (pass_cse_reciprocals);
|
|
|
313 NEXT_PASS (pass_reassoc, false /* insert_powi_p */);
|
|
|
314 NEXT_PASS (pass_strength_reduction);
|
|
|
315 NEXT_PASS (pass_split_paths);
|
|
|
316 NEXT_PASS (pass_tracer);
|
|
145
|
317 NEXT_PASS (pass_fre, false /* may_iterate */);
|
|
|
318 /* After late FRE we rewrite no longer addressed locals into SSA
|
|
|
319 form if possible. */
|
|
111
|
320 NEXT_PASS (pass_thread_jumps);
|
|
|
321 NEXT_PASS (pass_dominator, false /* may_peel_loop_headers_p */);
|
|
|
322 NEXT_PASS (pass_strlen);
|
|
|
323 NEXT_PASS (pass_thread_jumps);
|
|
|
324 NEXT_PASS (pass_vrp, false /* warn_array_bounds_p */);
|
|
145
|
325 /* Threading can leave many const/copy propagations in the IL.
|
|
|
326 Clean them up. */
|
|
|
327 NEXT_PASS (pass_copy_prop);
|
|
131
|
328 NEXT_PASS (pass_warn_restrict);
|
|
111
|
329 NEXT_PASS (pass_dse);
|
|
|
330 NEXT_PASS (pass_cd_dce);
|
|
|
331 NEXT_PASS (pass_forwprop);
|
|
131
|
332 NEXT_PASS (pass_phiopt, false /* early_p */);
|
|
111
|
333 NEXT_PASS (pass_fold_builtins);
|
|
|
334 NEXT_PASS (pass_optimize_widening_mul);
|
|
|
335 NEXT_PASS (pass_store_merging);
|
|
|
336 NEXT_PASS (pass_tail_calls);
|
|
|
337 /* If DCE is not run before checking for uninitialized uses,
|
|
|
338 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
|
|
|
339 However, this also causes us to misdiagnose cases that should be
|
|
|
340 real warnings (e.g., testsuite/gcc.dg/pr18501.c). */
|
|
|
341 NEXT_PASS (pass_dce);
|
|
|
342 /* Split critical edges before late uninit warning to reduce the
|
|
|
343 number of false positives from it. */
|
|
|
344 NEXT_PASS (pass_split_crit_edges);
|
|
|
345 NEXT_PASS (pass_late_warn_uninitialized);
|
|
|
346 NEXT_PASS (pass_uncprop);
|
|
|
347 NEXT_PASS (pass_local_pure_const);
|
|
|
348 POP_INSERT_PASSES ()
|
|
|
349 NEXT_PASS (pass_all_optimizations_g);
|
|
|
350 PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
|
|
|
351 NEXT_PASS (pass_remove_cgraph_callee_edges);
|
|
131
|
352 NEXT_PASS (pass_strip_predict_hints, false /* early_p */);
|
|
111
|
353 /* Lower remaining pieces of GIMPLE. */
|
|
|
354 NEXT_PASS (pass_lower_complex);
|
|
|
355 NEXT_PASS (pass_lower_vector_ssa);
|
|
131
|
356 NEXT_PASS (pass_lower_switch);
|
|
111
|
357 /* Perform simple scalar cleanup which is constant/copy propagation. */
|
|
|
358 NEXT_PASS (pass_ccp, true /* nonzero_p */);
|
|
|
359 NEXT_PASS (pass_post_ipa_warn);
|
|
|
360 NEXT_PASS (pass_object_sizes);
|
|
|
361 /* Fold remaining builtins. */
|
|
|
362 NEXT_PASS (pass_fold_builtins);
|
|
145
|
363 NEXT_PASS (pass_strlen);
|
|
111
|
364 /* Copy propagation also copy-propagates constants, this is necessary
|
|
|
365 to forward object-size and builtin folding results properly. */
|
|
|
366 NEXT_PASS (pass_copy_prop);
|
|
|
367 NEXT_PASS (pass_dce);
|
|
|
368 NEXT_PASS (pass_sancov);
|
|
|
369 NEXT_PASS (pass_asan);
|
|
|
370 NEXT_PASS (pass_tsan);
|
|
|
371 /* ??? We do want some kind of loop invariant motion, but we possibly
|
|
|
372 need to adjust LIM to be more friendly towards preserving accurate
|
|
|
373 debug information here. */
|
|
|
374 /* Split critical edges before late uninit warning to reduce the
|
|
|
375 number of false positives from it. */
|
|
|
376 NEXT_PASS (pass_split_crit_edges);
|
|
|
377 NEXT_PASS (pass_late_warn_uninitialized);
|
|
|
378 NEXT_PASS (pass_uncprop);
|
|
|
379 NEXT_PASS (pass_local_pure_const);
|
|
|
380 POP_INSERT_PASSES ()
|
|
|
381 NEXT_PASS (pass_tm_init);
|
|
|
382 PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
|
|
|
383 NEXT_PASS (pass_tm_mark);
|
|
|
384 NEXT_PASS (pass_tm_memopt);
|
|
|
385 NEXT_PASS (pass_tm_edges);
|
|
|
386 POP_INSERT_PASSES ()
|
|
|
387 NEXT_PASS (pass_simduid_cleanup);
|
|
|
388 NEXT_PASS (pass_vtable_verify);
|
|
|
389 NEXT_PASS (pass_lower_vaarg);
|
|
|
390 NEXT_PASS (pass_lower_vector);
|
|
|
391 NEXT_PASS (pass_lower_complex_O0);
|
|
|
392 NEXT_PASS (pass_sancov_O0);
|
|
131
|
393 NEXT_PASS (pass_lower_switch_O0);
|
|
111
|
394 NEXT_PASS (pass_asan_O0);
|
|
|
395 NEXT_PASS (pass_tsan_O0);
|
|
|
396 NEXT_PASS (pass_sanopt);
|
|
|
397 NEXT_PASS (pass_cleanup_eh);
|
|
|
398 NEXT_PASS (pass_lower_resx);
|
|
|
399 NEXT_PASS (pass_nrv);
|
|
|
400 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
|
|
|
401 NEXT_PASS (pass_warn_function_noreturn);
|
|
|
402 NEXT_PASS (pass_gen_hsail);
|
|
|
403
|
|
|
404 NEXT_PASS (pass_expand);
|
|
|
405
|
|
|
406 NEXT_PASS (pass_rest_of_compilation);
|
|
|
407 PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
|
|
|
408 NEXT_PASS (pass_instantiate_virtual_regs);
|
|
|
409 NEXT_PASS (pass_into_cfg_layout_mode);
|
|
|
410 NEXT_PASS (pass_jump);
|
|
|
411 NEXT_PASS (pass_lower_subreg);
|
|
|
412 NEXT_PASS (pass_df_initialize_opt);
|
|
|
413 NEXT_PASS (pass_cse);
|
|
|
414 NEXT_PASS (pass_rtl_fwprop);
|
|
|
415 NEXT_PASS (pass_rtl_cprop);
|
|
|
416 NEXT_PASS (pass_rtl_pre);
|
|
|
417 NEXT_PASS (pass_rtl_hoist);
|
|
|
418 NEXT_PASS (pass_rtl_cprop);
|
|
|
419 NEXT_PASS (pass_rtl_store_motion);
|
|
|
420 NEXT_PASS (pass_cse_after_global_opts);
|
|
|
421 NEXT_PASS (pass_rtl_ifcvt);
|
|
|
422 NEXT_PASS (pass_reginfo_init);
|
|
|
423 /* Perform loop optimizations. It might be better to do them a bit
|
|
|
424 sooner, but we want the profile feedback to work more
|
|
|
425 efficiently. */
|
|
|
426 NEXT_PASS (pass_loop2);
|
|
|
427 PUSH_INSERT_PASSES_WITHIN (pass_loop2)
|
|
|
428 NEXT_PASS (pass_rtl_loop_init);
|
|
|
429 NEXT_PASS (pass_rtl_move_loop_invariants);
|
|
|
430 NEXT_PASS (pass_rtl_unroll_loops);
|
|
|
431 NEXT_PASS (pass_rtl_doloop);
|
|
|
432 NEXT_PASS (pass_rtl_loop_done);
|
|
|
433 POP_INSERT_PASSES ()
|
|
145
|
434 NEXT_PASS (pass_lower_subreg2);
|
|
111
|
435 NEXT_PASS (pass_web);
|
|
|
436 NEXT_PASS (pass_rtl_cprop);
|
|
|
437 NEXT_PASS (pass_cse2);
|
|
|
438 NEXT_PASS (pass_rtl_dse1);
|
|
|
439 NEXT_PASS (pass_rtl_fwprop_addr);
|
|
|
440 NEXT_PASS (pass_inc_dec);
|
|
|
441 NEXT_PASS (pass_initialize_regs);
|
|
|
442 NEXT_PASS (pass_ud_rtl_dce);
|
|
|
443 NEXT_PASS (pass_combine);
|
|
|
444 NEXT_PASS (pass_if_after_combine);
|
|
145
|
445 NEXT_PASS (pass_jump_after_combine);
|
|
111
|
446 NEXT_PASS (pass_partition_blocks);
|
|
|
447 NEXT_PASS (pass_outof_cfg_layout_mode);
|
|
|
448 NEXT_PASS (pass_split_all_insns);
|
|
145
|
449 NEXT_PASS (pass_lower_subreg3);
|
|
111
|
450 NEXT_PASS (pass_df_initialize_no_opt);
|
|
|
451 NEXT_PASS (pass_stack_ptr_mod);
|
|
|
452 NEXT_PASS (pass_mode_switching);
|
|
|
453 NEXT_PASS (pass_match_asm_constraints);
|
|
|
454 NEXT_PASS (pass_sms);
|
|
|
455 NEXT_PASS (pass_live_range_shrinkage);
|
|
|
456 NEXT_PASS (pass_sched);
|
|
131
|
457 NEXT_PASS (pass_early_remat);
|
|
111
|
458 NEXT_PASS (pass_ira);
|
|
|
459 NEXT_PASS (pass_reload);
|
|
|
460 NEXT_PASS (pass_postreload);
|
|
|
461 PUSH_INSERT_PASSES_WITHIN (pass_postreload)
|
|
|
462 NEXT_PASS (pass_postreload_cse);
|
|
|
463 NEXT_PASS (pass_gcse2);
|
|
|
464 NEXT_PASS (pass_split_after_reload);
|
|
|
465 NEXT_PASS (pass_ree);
|
|
|
466 NEXT_PASS (pass_compare_elim_after_reload);
|
|
|
467 NEXT_PASS (pass_thread_prologue_and_epilogue);
|
|
|
468 NEXT_PASS (pass_rtl_dse2);
|
|
|
469 NEXT_PASS (pass_stack_adjustments);
|
|
|
470 NEXT_PASS (pass_jump2);
|
|
|
471 NEXT_PASS (pass_duplicate_computed_gotos);
|
|
|
472 NEXT_PASS (pass_sched_fusion);
|
|
|
473 NEXT_PASS (pass_peephole2);
|
|
|
474 NEXT_PASS (pass_if_after_reload);
|
|
|
475 NEXT_PASS (pass_regrename);
|
|
|
476 NEXT_PASS (pass_cprop_hardreg);
|
|
|
477 NEXT_PASS (pass_fast_rtl_dce);
|
|
|
478 NEXT_PASS (pass_reorder_blocks);
|
|
|
479 NEXT_PASS (pass_leaf_regs);
|
|
|
480 NEXT_PASS (pass_split_before_sched2);
|
|
|
481 NEXT_PASS (pass_sched2);
|
|
|
482 NEXT_PASS (pass_stack_regs);
|
|
|
483 PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
|
|
|
484 NEXT_PASS (pass_split_before_regstack);
|
|
|
485 NEXT_PASS (pass_stack_regs_run);
|
|
|
486 POP_INSERT_PASSES ()
|
|
|
487 POP_INSERT_PASSES ()
|
|
|
488 NEXT_PASS (pass_late_compilation);
|
|
|
489 PUSH_INSERT_PASSES_WITHIN (pass_late_compilation)
|
|
|
490 NEXT_PASS (pass_compute_alignments);
|
|
|
491 NEXT_PASS (pass_variable_tracking);
|
|
|
492 NEXT_PASS (pass_free_cfg);
|
|
|
493 NEXT_PASS (pass_machine_reorg);
|
|
|
494 NEXT_PASS (pass_cleanup_barriers);
|
|
|
495 NEXT_PASS (pass_delay_slots);
|
|
|
496 NEXT_PASS (pass_split_for_shorten_branches);
|
|
|
497 NEXT_PASS (pass_convert_to_eh_region_ranges);
|
|
|
498 NEXT_PASS (pass_shorten_branches);
|
|
|
499 NEXT_PASS (pass_set_nothrow_function_flags);
|
|
|
500 NEXT_PASS (pass_dwarf2_frame);
|
|
|
501 NEXT_PASS (pass_final);
|
|
|
502 POP_INSERT_PASSES ()
|
|
|
503 NEXT_PASS (pass_df_finish);
|
|
|
504 POP_INSERT_PASSES ()
|
|
|
505 NEXT_PASS (pass_clean_state);
|
|
|
506 TERMINATE_PASS_LIST (all_passes)
|
