]>
Commit | Line | Data |
---|---|---|
0f9cdef4 | 1 | /* Description of pass structure |
a945c346 | 2 | Copyright (C) 1987-2024 Free Software Foundation, Inc. |
0f9cdef4 DM |
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 | ||
38500484 TS |
20 | /* Note that this file is processed by a simple parser: |
21 | 'gen-pass-instances.awk', so carefully verify the generated | |
22 | 'pass-instances.def' if you deviate from the syntax otherwise used in | |
23 | here. */ | |
24 | ||
0f9cdef4 DM |
25 | |
26 | /* All passes needed to lower the function into shape optimizers can | |
27 | operate on. These passes are always run first on the function, but | |
28 | backend might produce already lowered functions that are not processed | |
29 | by these passes. */ | |
30 | INSERT_PASSES_AFTER (all_lowering_passes) | |
31 | NEXT_PASS (pass_warn_unused_result); | |
32 | NEXT_PASS (pass_diagnose_omp_blocks); | |
33 | NEXT_PASS (pass_diagnose_tm_blocks); | |
e898ce79 | 34 | NEXT_PASS (pass_omp_oacc_kernels_decompose); |
0f9cdef4 DM |
35 | NEXT_PASS (pass_lower_omp); |
36 | NEXT_PASS (pass_lower_cf); | |
37 | NEXT_PASS (pass_lower_tm); | |
38 | NEXT_PASS (pass_refactor_eh); | |
39 | NEXT_PASS (pass_lower_eh); | |
49789fd0 | 40 | NEXT_PASS (pass_coroutine_lower_builtins); |
0f9cdef4 DM |
41 | NEXT_PASS (pass_build_cfg); |
42 | NEXT_PASS (pass_warn_function_return); | |
49789fd0 | 43 | NEXT_PASS (pass_coroutine_early_expand_ifns); |
0f9cdef4 | 44 | NEXT_PASS (pass_expand_omp); |
6ba856d4 | 45 | NEXT_PASS (pass_build_cgraph_edges); |
17e7ab87 | 46 | TERMINATE_PASS_LIST (all_lowering_passes) |
0f9cdef4 DM |
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); | |
f0a90c7d | 52 | NEXT_PASS (pass_ipa_strub_mode); |
d5e254e1 IE |
53 | NEXT_PASS (pass_build_ssa_passes); |
54 | PUSH_INSERT_PASSES_WITHIN (pass_build_ssa_passes) | |
0f9cdef4 | 55 | NEXT_PASS (pass_fixup_cfg); |
0f9cdef4 | 56 | NEXT_PASS (pass_build_ssa); |
e68f5c90 | 57 | NEXT_PASS (pass_walloca, /*strict_mode_p=*/true); |
2254b323 | 58 | NEXT_PASS (pass_warn_printf); |
bf14eba2 | 59 | NEXT_PASS (pass_warn_nonnull_compare); |
0f9cdef4 | 60 | NEXT_PASS (pass_early_warn_uninitialized); |
5a668ec0 | 61 | NEXT_PASS (pass_warn_access, /*early=*/true); |
31de5e4d | 62 | NEXT_PASS (pass_ubsan); |
38147a2a | 63 | NEXT_PASS (pass_nothrow); |
8a87dced | 64 | NEXT_PASS (pass_rebuild_cgraph_edges); |
d5e254e1 IE |
65 | POP_INSERT_PASSES () |
66 | ||
d5e254e1 IE |
67 | NEXT_PASS (pass_local_optimization_passes); |
68 | PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes) | |
69 | NEXT_PASS (pass_fixup_cfg); | |
0f9cdef4 | 70 | NEXT_PASS (pass_rebuild_cgraph_edges); |
d2db2e6b | 71 | NEXT_PASS (pass_local_fn_summary); |
0f9cdef4 | 72 | NEXT_PASS (pass_early_inline); |
30ba058f | 73 | NEXT_PASS (pass_warn_recursion); |
0f9cdef4 DM |
74 | NEXT_PASS (pass_all_early_optimizations); |
75 | PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations) | |
76 | NEXT_PASS (pass_remove_cgraph_callee_edges); | |
dddb6ffd | 77 | NEXT_PASS (pass_early_object_sizes); |
c06883ac TV |
78 | /* Don't record nonzero bits before IPA to avoid |
79 | using too much memory. */ | |
80 | NEXT_PASS (pass_ccp, false /* nonzero_p */); | |
0f9cdef4 DM |
81 | /* After CCP we rewrite no longer addressed locals into SSA |
82 | form if possible. */ | |
83 | NEXT_PASS (pass_forwprop); | |
bc5baac5 | 84 | NEXT_PASS (pass_early_thread_jumps, /*first=*/true); |
a9e4c82f | 85 | NEXT_PASS (pass_sra_early); |
0f9cdef4 DM |
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); | |
7b34cacc JH |
89 | /* Do phiprop before FRE so we optimize std::min and std::max well. */ |
90 | NEXT_PASS (pass_phiprop); | |
744fd446 | 91 | NEXT_PASS (pass_fre, true /* may_iterate */); |
973625a0 | 92 | NEXT_PASS (pass_early_vrp); |
0f9cdef4 | 93 | NEXT_PASS (pass_merge_phi); |
5a33401e | 94 | NEXT_PASS (pass_dse); |
b673e754 | 95 | NEXT_PASS (pass_cd_dce, false /* update_address_taken_p */); |
1cab645d | 96 | NEXT_PASS (pass_phiopt, true /* early_p */); |
0f9cdef4 | 97 | NEXT_PASS (pass_tail_recursion); |
03eb0929 | 98 | NEXT_PASS (pass_if_to_switch); |
0f9cdef4 | 99 | NEXT_PASS (pass_convert_switch); |
d5e254e1 | 100 | NEXT_PASS (pass_cleanup_eh); |
cd794c39 | 101 | NEXT_PASS (pass_sccopy); |
d5e254e1 IE |
102 | NEXT_PASS (pass_profile); |
103 | NEXT_PASS (pass_local_pure_const); | |
494bdadf | 104 | NEXT_PASS (pass_modref); |
0f9cdef4 DM |
105 | /* Split functions creates parts that are not run through |
106 | early optimizations again. It is thus good idea to do this | |
d5e254e1 IE |
107 | late. */ |
108 | NEXT_PASS (pass_split_functions); | |
7a096965 | 109 | NEXT_PASS (pass_strip_predict_hints, true /* early_p */); |
0f9cdef4 DM |
110 | POP_INSERT_PASSES () |
111 | NEXT_PASS (pass_release_ssa_names); | |
112 | NEXT_PASS (pass_rebuild_cgraph_edges); | |
d2db2e6b | 113 | NEXT_PASS (pass_local_fn_summary); |
0f9cdef4 | 114 | POP_INSERT_PASSES () |
597a8ab9 | 115 | |
12485662 | 116 | NEXT_PASS (pass_ipa_remove_symbols); |
f0a90c7d | 117 | NEXT_PASS (pass_ipa_strub); |
597a8ab9 TV |
118 | NEXT_PASS (pass_ipa_oacc); |
119 | PUSH_INSERT_PASSES_WITHIN (pass_ipa_oacc) | |
120 | NEXT_PASS (pass_ipa_pta); | |
121 | /* Pass group that runs when the function is an offloaded function | |
122 | containing oacc kernels loops. */ | |
123 | NEXT_PASS (pass_ipa_oacc_kernels); | |
124 | PUSH_INSERT_PASSES_WITHIN (pass_ipa_oacc_kernels) | |
125 | NEXT_PASS (pass_oacc_kernels); | |
126 | PUSH_INSERT_PASSES_WITHIN (pass_oacc_kernels) | |
127 | NEXT_PASS (pass_ch); | |
744fd446 | 128 | NEXT_PASS (pass_fre, true /* may_iterate */); |
597a8ab9 TV |
129 | /* We use pass_lim to rewrite in-memory iteration and reduction |
130 | variable accesses in loops into local variables accesses. */ | |
131 | NEXT_PASS (pass_lim); | |
132 | NEXT_PASS (pass_dominator, false /* may_peel_loop_headers_p */); | |
133 | NEXT_PASS (pass_dce); | |
a98d4647 | 134 | NEXT_PASS (pass_parallelize_loops, true /* oacc_kernels_p */); |
597a8ab9 TV |
135 | NEXT_PASS (pass_expand_omp_ssa); |
136 | NEXT_PASS (pass_rebuild_cgraph_edges); | |
137 | POP_INSERT_PASSES () | |
138 | POP_INSERT_PASSES () | |
139 | POP_INSERT_PASSES () | |
140 | ||
46a2ab58 | 141 | NEXT_PASS (pass_target_clone); |
be3c16c4 | 142 | NEXT_PASS (pass_ipa_auto_profile); |
0f9cdef4 DM |
143 | NEXT_PASS (pass_ipa_tree_profile); |
144 | PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile) | |
145 | NEXT_PASS (pass_feedback_split_functions); | |
146 | POP_INSERT_PASSES () | |
442db276 | 147 | NEXT_PASS (pass_ipa_free_fn_summary, true /* small_p */); |
0f9cdef4 DM |
148 | NEXT_PASS (pass_ipa_increase_alignment); |
149 | NEXT_PASS (pass_ipa_tm); | |
150 | NEXT_PASS (pass_ipa_lower_emutls); | |
17e7ab87 | 151 | TERMINATE_PASS_LIST (all_small_ipa_passes) |
0f9cdef4 DM |
152 | |
153 | INSERT_PASSES_AFTER (all_regular_ipa_passes) | |
757bf1df | 154 | NEXT_PASS (pass_analyzer); |
3fb68f2e | 155 | NEXT_PASS (pass_ipa_odr); |
0f9cdef4 DM |
156 | NEXT_PASS (pass_ipa_whole_program_visibility); |
157 | NEXT_PASS (pass_ipa_profile); | |
b84d4347 | 158 | NEXT_PASS (pass_ipa_icf); |
bbc9396b | 159 | NEXT_PASS (pass_ipa_devirt); |
db0fa0b3 | 160 | NEXT_PASS (pass_ipa_cdtor_merge); |
0f9cdef4 | 161 | NEXT_PASS (pass_ipa_cp); |
ff6686d2 | 162 | NEXT_PASS (pass_ipa_sra); |
d2db2e6b | 163 | NEXT_PASS (pass_ipa_fn_summary); |
0f9cdef4 DM |
164 | NEXT_PASS (pass_ipa_inline); |
165 | NEXT_PASS (pass_ipa_pure_const); | |
d119f34c | 166 | NEXT_PASS (pass_ipa_modref); |
442db276 | 167 | NEXT_PASS (pass_ipa_free_fn_summary, false /* small_p */); |
0f9cdef4 | 168 | NEXT_PASS (pass_ipa_reference); |
eb6a09a7 JH |
169 | /* This pass needs to be scheduled after any IP code duplication. */ |
170 | NEXT_PASS (pass_ipa_single_use); | |
a04d9035 JH |
171 | /* Comdat privatization come last, as direct references to comdat local |
172 | symbols are not allowed outside of the comdat group. Privatizing early | |
173 | would result in missed optimizations due to this restriction. */ | |
174 | NEXT_PASS (pass_ipa_comdats); | |
17e7ab87 | 175 | TERMINATE_PASS_LIST (all_regular_ipa_passes) |
0f9cdef4 | 176 | |
0f9cdef4 DM |
177 | /* Simple IPA passes executed after the regular passes. In WHOPR mode the |
178 | passes are executed after partitioning and thus see just parts of the | |
179 | compiled unit. */ | |
180 | INSERT_PASSES_AFTER (all_late_ipa_passes) | |
181 | NEXT_PASS (pass_ipa_pta); | |
0136f8f0 | 182 | NEXT_PASS (pass_omp_simd_clone); |
17e7ab87 | 183 | TERMINATE_PASS_LIST (all_late_ipa_passes) |
0f9cdef4 DM |
184 | |
185 | /* These passes are run after IPA passes on every function that is being | |
186 | output to the assembler file. */ | |
187 | INSERT_PASSES_AFTER (all_passes) | |
9c39fca1 | 188 | NEXT_PASS (pass_fixup_cfg); |
0f9cdef4 | 189 | NEXT_PASS (pass_lower_eh_dispatch); |
0829ab79 | 190 | NEXT_PASS (pass_oacc_loop_designation); |
e2a58ed6 | 191 | NEXT_PASS (pass_omp_oacc_neuter_broadcast); |
94829f87 | 192 | NEXT_PASS (pass_oacc_device_lower); |
9669b00b | 193 | NEXT_PASS (pass_omp_device_lower); |
4a38b02b | 194 | NEXT_PASS (pass_omp_target_link); |
dfa4fcdb | 195 | NEXT_PASS (pass_adjust_alignment); |
551935d1 | 196 | NEXT_PASS (pass_harden_control_flow_redundancy); |
0f9cdef4 DM |
197 | NEXT_PASS (pass_all_optimizations); |
198 | PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations) | |
199 | NEXT_PASS (pass_remove_cgraph_callee_edges); | |
200 | /* Initial scalar cleanups before alias computation. | |
201 | They ensure memory accesses are not indirect wherever possible. */ | |
7a096965 | 202 | NEXT_PASS (pass_strip_predict_hints, false /* early_p */); |
c06883ac | 203 | NEXT_PASS (pass_ccp, true /* nonzero_p */); |
0f9cdef4 DM |
204 | /* After CCP we rewrite no longer addressed locals into SSA |
205 | form if possible. */ | |
dddb6ffd JJ |
206 | NEXT_PASS (pass_object_sizes); |
207 | NEXT_PASS (pass_post_ipa_warn); | |
9d6a0f38 MS |
208 | /* Must run before loop unrolling. */ |
209 | NEXT_PASS (pass_warn_access, /*early=*/true); | |
aa6741ef JH |
210 | /* Profile count may overflow as a result of inlinining very large |
211 | loop nests. This pass should run before any late pass that makes | |
212 | use of profile. */ | |
213 | NEXT_PASS (pass_rebuild_frequencies); | |
4ee5c752 | 214 | NEXT_PASS (pass_complete_unrolli); |
6a75d560 | 215 | NEXT_PASS (pass_backprop); |
0f9cdef4 DM |
216 | NEXT_PASS (pass_phiprop); |
217 | NEXT_PASS (pass_forwprop); | |
218 | /* pass_build_alias is a dummy pass that ensures that we | |
219 | execute TODO_rebuild_alias at this point. */ | |
220 | NEXT_PASS (pass_build_alias); | |
221 | NEXT_PASS (pass_return_slot); | |
744fd446 | 222 | NEXT_PASS (pass_fre, true /* may_iterate */); |
0f9cdef4 | 223 | NEXT_PASS (pass_merge_phi); |
bc5baac5 | 224 | NEXT_PASS (pass_thread_jumps_full, /*first=*/true); |
7eb5ce7f | 225 | NEXT_PASS (pass_vrp, false /* final_p*/); |
74ee12ff | 226 | NEXT_PASS (pass_array_bounds); |
d8e1f1d2 | 227 | NEXT_PASS (pass_dse); |
0f9cdef4 | 228 | NEXT_PASS (pass_dce); |
8d4c374c RB |
229 | /* pass_stdarg is always run and at this point we execute |
230 | TODO_remove_unused_locals to prune CLOBBERs of dead | |
231 | variables which are otherwise a churn on alias walkings. */ | |
32966af8 | 232 | NEXT_PASS (pass_stdarg); |
0f9cdef4 DM |
233 | NEXT_PASS (pass_call_cdce); |
234 | NEXT_PASS (pass_cselim); | |
9e4f27ef | 235 | NEXT_PASS (pass_copy_prop); |
0f9cdef4 | 236 | NEXT_PASS (pass_tree_ifcombine); |
465770e4 | 237 | NEXT_PASS (pass_merge_phi); |
1cab645d | 238 | NEXT_PASS (pass_phiopt, false /* early_p */); |
0f9cdef4 DM |
239 | NEXT_PASS (pass_tail_recursion); |
240 | NEXT_PASS (pass_ch); | |
0f9cdef4 | 241 | NEXT_PASS (pass_lower_complex); |
a9d6c7fb | 242 | NEXT_PASS (pass_lower_bitint); |
0f9cdef4 | 243 | NEXT_PASS (pass_sra); |
0f9cdef4 DM |
244 | /* The dom pass will also resolve all __builtin_constant_p calls |
245 | that are still there to 0. This has to be done after some | |
246 | propagations have already run, but before some more dead code | |
247 | is removed, and this place fits nicely. Remember this when | |
248 | trying to move or duplicate pass_dominator somewhere earlier. */ | |
bc5baac5 | 249 | NEXT_PASS (pass_thread_jumps, /*first=*/true); |
5ce8d99a | 250 | NEXT_PASS (pass_dominator, true /* may_peel_loop_headers_p */); |
33579b59 JL |
251 | /* Threading can leave many const/copy propagations in the IL. |
252 | Clean them up. Failure to do so well can lead to false | |
253 | positives from warnings for erroneous code. */ | |
254 | NEXT_PASS (pass_copy_prop); | |
255 | /* Identify paths that should never be executed in a conforming | |
256 | program and isolate those paths. */ | |
8fdc414d | 257 | NEXT_PASS (pass_isolate_erroneous_paths); |
99c106e6 | 258 | NEXT_PASS (pass_reassoc, true /* early_p */); |
0f9cdef4 DM |
259 | NEXT_PASS (pass_dce); |
260 | NEXT_PASS (pass_forwprop); | |
1cab645d | 261 | NEXT_PASS (pass_phiopt, false /* early_p */); |
c06883ac | 262 | NEXT_PASS (pass_ccp, true /* nonzero_p */); |
0f9cdef4 DM |
263 | /* After CCP we rewrite no longer addressed locals into SSA |
264 | form if possible. */ | |
36852a18 | 265 | NEXT_PASS (pass_expand_pow); |
0f9cdef4 | 266 | NEXT_PASS (pass_optimize_bswap); |
ca87c493 | 267 | NEXT_PASS (pass_laddress); |
43c0068e | 268 | NEXT_PASS (pass_lim); |
adc577c5 | 269 | NEXT_PASS (pass_walloca, false); |
0f9cdef4 | 270 | NEXT_PASS (pass_pre); |
3a7ba8fd | 271 | NEXT_PASS (pass_sink_code, false /* unsplit edges */); |
95e7bbb8 | 272 | NEXT_PASS (pass_sancov); |
0f9cdef4 DM |
273 | NEXT_PASS (pass_asan); |
274 | NEXT_PASS (pass_tsan); | |
4bdf739f | 275 | NEXT_PASS (pass_dse, true /* use DR analysis */); |
43c0068e | 276 | NEXT_PASS (pass_dce); |
e5d8bd8c | 277 | /* Pass group that runs when 1) enabled, 2) there are loops |
7d39012c RB |
278 | in the function. Make sure to run pass_fix_loops before |
279 | to discover/remove loops before running the gate function | |
280 | of pass_tree_loop. */ | |
281 | NEXT_PASS (pass_fix_loops); | |
0f9cdef4 DM |
282 | NEXT_PASS (pass_tree_loop); |
283 | PUSH_INSERT_PASSES_WITHIN (pass_tree_loop) | |
8964432a RB |
284 | /* Before loop_init we rewrite no longer addressed locals into SSA |
285 | form if possible. */ | |
0f9cdef4 | 286 | NEXT_PASS (pass_tree_loop_init); |
0f9cdef4 | 287 | NEXT_PASS (pass_tree_unswitch); |
28df8730 | 288 | NEXT_PASS (pass_loop_split); |
3d48c11a | 289 | NEXT_PASS (pass_scev_cprop); |
13e08dc9 | 290 | NEXT_PASS (pass_loop_versioning); |
1cc521f1 | 291 | NEXT_PASS (pass_loop_jam); |
59ec925b RB |
292 | /* All unswitching, final value replacement and splitting can expose |
293 | empty loops. Remove them now. */ | |
b673e754 | 294 | NEXT_PASS (pass_cd_dce, false /* update_address_taken_p */); |
09a939a0 | 295 | NEXT_PASS (pass_iv_canon); |
0f9cdef4 | 296 | NEXT_PASS (pass_loop_distribution); |
fbdec14e | 297 | NEXT_PASS (pass_linterchange); |
0f9cdef4 DM |
298 | NEXT_PASS (pass_copy_prop); |
299 | NEXT_PASS (pass_graphite); | |
300 | PUSH_INSERT_PASSES_WITHIN (pass_graphite) | |
301 | NEXT_PASS (pass_graphite_transforms); | |
302 | NEXT_PASS (pass_lim); | |
303 | NEXT_PASS (pass_copy_prop); | |
30866dc9 | 304 | NEXT_PASS (pass_dce); |
0f9cdef4 | 305 | POP_INSERT_PASSES () |
61d9c527 | 306 | NEXT_PASS (pass_parallelize_loops, false /* oacc_kernels_p */); |
2d73a9d2 | 307 | NEXT_PASS (pass_expand_omp_ssa); |
4f9a2b4e | 308 | NEXT_PASS (pass_ch_vect); |
0f9cdef4 | 309 | NEXT_PASS (pass_if_conversion); |
5ce9450f JJ |
310 | /* pass_vectorize must immediately follow pass_if_conversion. |
311 | Please do not add any other passes in between. */ | |
0f9cdef4 | 312 | NEXT_PASS (pass_vectorize); |
f5e18dd9 | 313 | PUSH_INSERT_PASSES_WITHIN (pass_vectorize) |
30866dc9 | 314 | NEXT_PASS (pass_dce); |
f5e18dd9 KL |
315 | POP_INSERT_PASSES () |
316 | NEXT_PASS (pass_predcom); | |
0f9cdef4 | 317 | NEXT_PASS (pass_complete_unroll); |
f5e18dd9 KL |
318 | NEXT_PASS (pass_pre_slp_scalar_cleanup); |
319 | PUSH_INSERT_PASSES_WITHIN (pass_pre_slp_scalar_cleanup) | |
320 | NEXT_PASS (pass_fre, false /* may_iterate */); | |
321 | NEXT_PASS (pass_dse); | |
322 | POP_INSERT_PASSES () | |
0f9cdef4 DM |
323 | NEXT_PASS (pass_slp_vectorize); |
324 | NEXT_PASS (pass_loop_prefetch); | |
e5d8bd8c RB |
325 | /* Run IVOPTs after the last pass that uses data-reference analysis |
326 | as that doesn't handle TARGET_MEM_REFs. */ | |
0f9cdef4 DM |
327 | NEXT_PASS (pass_iv_optimize); |
328 | NEXT_PASS (pass_lim); | |
329 | NEXT_PASS (pass_tree_loop_done); | |
330 | POP_INSERT_PASSES () | |
e5d8bd8c RB |
331 | /* Pass group that runs when pass_tree_loop is disabled or there |
332 | are no loops in the function. */ | |
333 | NEXT_PASS (pass_tree_no_loop); | |
334 | PUSH_INSERT_PASSES_WITHIN (pass_tree_no_loop) | |
335 | NEXT_PASS (pass_slp_vectorize); | |
336 | POP_INSERT_PASSES () | |
8c8b9f32 | 337 | NEXT_PASS (pass_simduid_cleanup); |
0f9cdef4 | 338 | NEXT_PASS (pass_lower_vector_ssa); |
eb63c01f | 339 | NEXT_PASS (pass_lower_switch); |
78d5e125 | 340 | NEXT_PASS (pass_cse_sincos); |
0f9cdef4 | 341 | NEXT_PASS (pass_cse_reciprocals); |
99c106e6 | 342 | NEXT_PASS (pass_reassoc, false /* early_p */); |
0f9cdef4 | 343 | NEXT_PASS (pass_strength_reduction); |
45fbe8e9 | 344 | NEXT_PASS (pass_split_paths); |
8cce4dbf | 345 | NEXT_PASS (pass_tracer); |
744fd446 | 346 | NEXT_PASS (pass_fre, false /* may_iterate */); |
bf05a3bb RB |
347 | /* After late FRE we rewrite no longer addressed locals into SSA |
348 | form if possible. */ | |
bc5baac5 | 349 | NEXT_PASS (pass_thread_jumps, /*first=*/false); |
5ce8d99a | 350 | NEXT_PASS (pass_dominator, false /* may_peel_loop_headers_p */); |
24314386 | 351 | NEXT_PASS (pass_strlen); |
bc5baac5 | 352 | NEXT_PASS (pass_thread_jumps_full, /*first=*/false); |
7eb5ce7f | 353 | NEXT_PASS (pass_vrp, true /* final_p */); |
d2161caf | 354 | /* Run CCP to compute alignment and nonzero bits. */ |
da9e6e63 | 355 | NEXT_PASS (pass_ccp, true /* nonzero_p */); |
7fb1d021 | 356 | NEXT_PASS (pass_warn_restrict); |
154c9188 | 357 | NEXT_PASS (pass_dse); |
be2c74fd RB |
358 | NEXT_PASS (pass_dce, true /* update_address_taken_p */); |
359 | /* After late DCE we rewrite no longer addressed locals into SSA | |
b673e754 | 360 | form if possible. */ |
154c9188 | 361 | NEXT_PASS (pass_forwprop); |
3a7ba8fd | 362 | NEXT_PASS (pass_sink_code, true /* unsplit edges */); |
1cab645d | 363 | NEXT_PASS (pass_phiopt, false /* early_p */); |
154c9188 RB |
364 | NEXT_PASS (pass_fold_builtins); |
365 | NEXT_PASS (pass_optimize_widening_mul); | |
f663d9ad | 366 | NEXT_PASS (pass_store_merging); |
24a179f8 | 367 | /* If DCE is not run before checking for uninitialized uses, |
0f9cdef4 DM |
368 | we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c). |
369 | However, this also causes us to misdiagnose cases that should be | |
24a179f8 | 370 | real warnings (e.g., testsuite/gcc.dg/pr18501.c). */ |
be2c74fd | 371 | NEXT_PASS (pass_cd_dce, false /* update_address_taken_p */); |
cd794c39 | 372 | NEXT_PASS (pass_sccopy); |
be2c74fd | 373 | NEXT_PASS (pass_tail_calls); |
5c2961cf RB |
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); | |
0f9cdef4 | 377 | NEXT_PASS (pass_late_warn_uninitialized); |
0f9cdef4 | 378 | NEXT_PASS (pass_local_pure_const); |
d119f34c | 379 | NEXT_PASS (pass_modref); |
666d7804 JH |
380 | /* uncprop replaces constants by SSA names. This makes analysis harder |
381 | and thus it should be run last. */ | |
382 | NEXT_PASS (pass_uncprop); | |
0f9cdef4 DM |
383 | POP_INSERT_PASSES () |
384 | NEXT_PASS (pass_all_optimizations_g); | |
385 | PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g) | |
e89b2a27 RB |
386 | /* The idea is that with -Og we do not perform any IPA optimization |
387 | so post-IPA work should be restricted to semantically required | |
388 | passes and all optimization work is done early. */ | |
0f9cdef4 | 389 | NEXT_PASS (pass_remove_cgraph_callee_edges); |
7a096965 | 390 | NEXT_PASS (pass_strip_predict_hints, false /* early_p */); |
0f9cdef4 DM |
391 | /* Lower remaining pieces of GIMPLE. */ |
392 | NEXT_PASS (pass_lower_complex); | |
a9d6c7fb | 393 | NEXT_PASS (pass_lower_bitint); |
0f9cdef4 | 394 | NEXT_PASS (pass_lower_vector_ssa); |
eb63c01f | 395 | NEXT_PASS (pass_lower_switch); |
0f9cdef4 | 396 | /* Perform simple scalar cleanup which is constant/copy propagation. */ |
c06883ac | 397 | NEXT_PASS (pass_ccp, true /* nonzero_p */); |
0dba7960 | 398 | NEXT_PASS (pass_post_ipa_warn); |
0f9cdef4 DM |
399 | NEXT_PASS (pass_object_sizes); |
400 | /* Fold remaining builtins. */ | |
401 | NEXT_PASS (pass_fold_builtins); | |
22fca489 | 402 | NEXT_PASS (pass_strlen); |
0f9cdef4 DM |
403 | /* Copy propagation also copy-propagates constants, this is necessary |
404 | to forward object-size and builtin folding results properly. */ | |
405 | NEXT_PASS (pass_copy_prop); | |
406 | NEXT_PASS (pass_dce); | |
aa6741ef JH |
407 | /* Profile count may overflow as a result of inlinining very large |
408 | loop nests. This pass should run before any late pass that makes | |
409 | use of profile. */ | |
410 | NEXT_PASS (pass_rebuild_frequencies); | |
95e7bbb8 | 411 | NEXT_PASS (pass_sancov); |
0f9cdef4 DM |
412 | NEXT_PASS (pass_asan); |
413 | NEXT_PASS (pass_tsan); | |
0f9cdef4 DM |
414 | /* ??? We do want some kind of loop invariant motion, but we possibly |
415 | need to adjust LIM to be more friendly towards preserving accurate | |
416 | debug information here. */ | |
5c2961cf RB |
417 | /* Split critical edges before late uninit warning to reduce the |
418 | number of false positives from it. */ | |
419 | NEXT_PASS (pass_split_crit_edges); | |
0f9cdef4 | 420 | NEXT_PASS (pass_late_warn_uninitialized); |
666d7804 JH |
421 | /* uncprop replaces constants by SSA names. This makes analysis harder |
422 | and thus it should be run last. */ | |
423 | NEXT_PASS (pass_uncprop); | |
0f9cdef4 | 424 | POP_INSERT_PASSES () |
4dda30e9 | 425 | NEXT_PASS (pass_assumptions); |
0f9cdef4 DM |
426 | NEXT_PASS (pass_tm_init); |
427 | PUSH_INSERT_PASSES_WITHIN (pass_tm_init) | |
428 | NEXT_PASS (pass_tm_mark); | |
429 | NEXT_PASS (pass_tm_memopt); | |
430 | NEXT_PASS (pass_tm_edges); | |
431 | POP_INSERT_PASSES () | |
d9a6bd32 | 432 | NEXT_PASS (pass_simduid_cleanup); |
2077db1b | 433 | NEXT_PASS (pass_vtable_verify); |
f8e89441 | 434 | NEXT_PASS (pass_lower_vaarg); |
0f9cdef4 DM |
435 | NEXT_PASS (pass_lower_vector); |
436 | NEXT_PASS (pass_lower_complex_O0); | |
a9d6c7fb | 437 | NEXT_PASS (pass_lower_bitint_O0); |
95e7bbb8 | 438 | NEXT_PASS (pass_sancov_O0); |
b4c9a058 | 439 | NEXT_PASS (pass_lower_switch_O0); |
0f9cdef4 DM |
440 | NEXT_PASS (pass_asan_O0); |
441 | NEXT_PASS (pass_tsan_O0); | |
b9a55b13 | 442 | NEXT_PASS (pass_sanopt); |
0f9cdef4 | 443 | NEXT_PASS (pass_cleanup_eh); |
b738a63e | 444 | NEXT_PASS (pass_musttail); |
0f9cdef4 DM |
445 | NEXT_PASS (pass_lower_resx); |
446 | NEXT_PASS (pass_nrv); | |
502d63b6 | 447 | NEXT_PASS (pass_gimple_isel); |
95bb87b2 AO |
448 | NEXT_PASS (pass_harden_conditional_branches); |
449 | NEXT_PASS (pass_harden_compares); | |
5a668ec0 | 450 | NEXT_PASS (pass_warn_access, /*early=*/false); |
0f9cdef4 DM |
451 | NEXT_PASS (pass_cleanup_cfg_post_optimizing); |
452 | NEXT_PASS (pass_warn_function_noreturn); | |
453 | ||
454 | NEXT_PASS (pass_expand); | |
455 | ||
456 | NEXT_PASS (pass_rest_of_compilation); | |
457 | PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation) | |
458 | NEXT_PASS (pass_instantiate_virtual_regs); | |
459 | NEXT_PASS (pass_into_cfg_layout_mode); | |
460 | NEXT_PASS (pass_jump); | |
461 | NEXT_PASS (pass_lower_subreg); | |
462 | NEXT_PASS (pass_df_initialize_opt); | |
463 | NEXT_PASS (pass_cse); | |
464 | NEXT_PASS (pass_rtl_fwprop); | |
465 | NEXT_PASS (pass_rtl_cprop); | |
466 | NEXT_PASS (pass_rtl_pre); | |
467 | NEXT_PASS (pass_rtl_hoist); | |
468 | NEXT_PASS (pass_rtl_cprop); | |
469 | NEXT_PASS (pass_rtl_store_motion); | |
470 | NEXT_PASS (pass_cse_after_global_opts); | |
471 | NEXT_PASS (pass_rtl_ifcvt); | |
472 | NEXT_PASS (pass_reginfo_init); | |
473 | /* Perform loop optimizations. It might be better to do them a bit | |
474 | sooner, but we want the profile feedback to work more | |
475 | efficiently. */ | |
476 | NEXT_PASS (pass_loop2); | |
477 | PUSH_INSERT_PASSES_WITHIN (pass_loop2) | |
478 | NEXT_PASS (pass_rtl_loop_init); | |
479 | NEXT_PASS (pass_rtl_move_loop_invariants); | |
f8934be7 | 480 | NEXT_PASS (pass_rtl_unroll_loops); |
0f9cdef4 DM |
481 | NEXT_PASS (pass_rtl_doloop); |
482 | NEXT_PASS (pass_rtl_loop_done); | |
0f9cdef4 | 483 | POP_INSERT_PASSES () |
b18081df | 484 | NEXT_PASS (pass_lower_subreg2); |
0f9cdef4 DM |
485 | NEXT_PASS (pass_web); |
486 | NEXT_PASS (pass_rtl_cprop); | |
487 | NEXT_PASS (pass_cse2); | |
488 | NEXT_PASS (pass_rtl_dse1); | |
489 | NEXT_PASS (pass_rtl_fwprop_addr); | |
490 | NEXT_PASS (pass_inc_dec); | |
491 | NEXT_PASS (pass_initialize_regs); | |
492 | NEXT_PASS (pass_ud_rtl_dce); | |
98914f9e | 493 | NEXT_PASS (pass_ext_dce); |
0f9cdef4 | 494 | NEXT_PASS (pass_combine); |
792f97b4 | 495 | NEXT_PASS (pass_late_combine); |
0f9cdef4 | 496 | NEXT_PASS (pass_if_after_combine); |
216779db | 497 | NEXT_PASS (pass_jump_after_combine); |
0f9cdef4 | 498 | NEXT_PASS (pass_partition_blocks); |
0f9cdef4 DM |
499 | NEXT_PASS (pass_outof_cfg_layout_mode); |
500 | NEXT_PASS (pass_split_all_insns); | |
b18081df | 501 | NEXT_PASS (pass_lower_subreg3); |
0f9cdef4 DM |
502 | NEXT_PASS (pass_df_initialize_no_opt); |
503 | NEXT_PASS (pass_stack_ptr_mod); | |
504 | NEXT_PASS (pass_mode_switching); | |
505 | NEXT_PASS (pass_match_asm_constraints); | |
506 | NEXT_PASS (pass_sms); | |
f20f2613 | 507 | NEXT_PASS (pass_live_range_shrinkage); |
0f9cdef4 | 508 | NEXT_PASS (pass_sched); |
5cce8171 | 509 | NEXT_PASS (pass_early_remat); |
0f9cdef4 DM |
510 | NEXT_PASS (pass_ira); |
511 | NEXT_PASS (pass_reload); | |
438381ef TS |
512 | /* In the following, some passes are tied to 'pass_postreload' and others |
513 | to 'pass_late_compilation'. The difference is that the latter also | |
514 | run for 'targetm.no_register_allocation' targets. */ | |
0f9cdef4 DM |
515 | NEXT_PASS (pass_postreload); |
516 | PUSH_INSERT_PASSES_WITHIN (pass_postreload) | |
517 | NEXT_PASS (pass_postreload_cse); | |
792f97b4 | 518 | NEXT_PASS (pass_late_combine); |
0f9cdef4 DM |
519 | NEXT_PASS (pass_gcse2); |
520 | NEXT_PASS (pass_split_after_reload); | |
521 | NEXT_PASS (pass_ree); | |
522 | NEXT_PASS (pass_compare_elim_after_reload); | |
0f9cdef4 DM |
523 | NEXT_PASS (pass_thread_prologue_and_epilogue); |
524 | NEXT_PASS (pass_rtl_dse2); | |
525 | NEXT_PASS (pass_stack_adjustments); | |
526 | NEXT_PASS (pass_jump2); | |
fc56f9d2 | 527 | NEXT_PASS (pass_duplicate_computed_gotos); |
b16abbcb | 528 | NEXT_PASS (pass_sched_fusion); |
fc56f9d2 | 529 | NEXT_PASS (pass_peephole2); |
0f9cdef4 DM |
530 | NEXT_PASS (pass_if_after_reload); |
531 | NEXT_PASS (pass_regrename); | |
04c9cf5c | 532 | NEXT_PASS (pass_fold_mem_offsets); |
0f9cdef4 DM |
533 | NEXT_PASS (pass_cprop_hardreg); |
534 | NEXT_PASS (pass_fast_rtl_dce); | |
535 | NEXT_PASS (pass_reorder_blocks); | |
0f9cdef4 DM |
536 | NEXT_PASS (pass_leaf_regs); |
537 | NEXT_PASS (pass_split_before_sched2); | |
538 | NEXT_PASS (pass_sched2); | |
539 | NEXT_PASS (pass_stack_regs); | |
540 | PUSH_INSERT_PASSES_WITHIN (pass_stack_regs) | |
541 | NEXT_PASS (pass_split_before_regstack); | |
542 | NEXT_PASS (pass_stack_regs_run); | |
543 | POP_INSERT_PASSES () | |
433e4164 | 544 | POP_INSERT_PASSES () |
e9d2ae6b RS |
545 | NEXT_PASS (pass_late_thread_prologue_and_epilogue); |
546 | /* No target-independent code motion is allowed beyond this point, | |
547 | excepting the legacy delayed-branch pass. */ | |
433e4164 BS |
548 | NEXT_PASS (pass_late_compilation); |
549 | PUSH_INSERT_PASSES_WITHIN (pass_late_compilation) | |
d10f3e90 | 550 | NEXT_PASS (pass_zero_call_used_regs); |
0f9cdef4 | 551 | NEXT_PASS (pass_compute_alignments); |
0f9cdef4 DM |
552 | NEXT_PASS (pass_variable_tracking); |
553 | NEXT_PASS (pass_free_cfg); | |
554 | NEXT_PASS (pass_machine_reorg); | |
555 | NEXT_PASS (pass_cleanup_barriers); | |
556 | NEXT_PASS (pass_delay_slots); | |
557 | NEXT_PASS (pass_split_for_shorten_branches); | |
558 | NEXT_PASS (pass_convert_to_eh_region_ranges); | |
559 | NEXT_PASS (pass_shorten_branches); | |
560 | NEXT_PASS (pass_set_nothrow_function_flags); | |
561 | NEXT_PASS (pass_dwarf2_frame); | |
562 | NEXT_PASS (pass_final); | |
563 | POP_INSERT_PASSES () | |
564 | NEXT_PASS (pass_df_finish); | |
565 | POP_INSERT_PASSES () | |
566 | NEXT_PASS (pass_clean_state); | |
17e7ab87 | 567 | TERMINATE_PASS_LIST (all_passes) |