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