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