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