OSDN Git Service

7d43bedd84774f13c978a95ec748232a2f134d9a
[pf3gnuchains/gcc-fork.git] / gcc / passes.c
1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA.  */
21
22 /* This is the top level of cc1/c++.
23    It parses command args, opens files, invokes the various passes
24    in the proper order, and counts the time used by each.
25    Error messages and low-level interface to malloc also handled here.  */
26
27 #include "config.h"
28 #undef FLOAT /* This is for hpux. They should change hpux.  */
29 #undef FFS  /* Some systems define this in param.h.  */
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include <signal.h>
34
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
37 #endif
38
39 #ifdef HAVE_SYS_TIMES_H
40 # include <sys/times.h>
41 #endif
42
43 #include "line-map.h"
44 #include "input.h"
45 #include "tree.h"
46 #include "rtl.h"
47 #include "tm_p.h"
48 #include "flags.h"
49 #include "insn-attr.h"
50 #include "insn-config.h"
51 #include "insn-flags.h"
52 #include "hard-reg-set.h"
53 #include "recog.h"
54 #include "output.h"
55 #include "except.h"
56 #include "function.h"
57 #include "toplev.h"
58 #include "expr.h"
59 #include "basic-block.h"
60 #include "intl.h"
61 #include "ggc.h"
62 #include "graph.h"
63 #include "regs.h"
64 #include "timevar.h"
65 #include "diagnostic.h"
66 #include "params.h"
67 #include "reload.h"
68 #include "dwarf2asm.h"
69 #include "integrate.h"
70 #include "real.h"
71 #include "debug.h"
72 #include "target.h"
73 #include "langhooks.h"
74 #include "cfglayout.h"
75 #include "cfgloop.h"
76 #include "hosthooks.h"
77 #include "cgraph.h"
78 #include "opts.h"
79 #include "coverage.h"
80 #include "value-prof.h"
81 #include "tree-inline.h"
82 #include "tree-flow.h"
83 #include "tree-pass.h"
84 #include "tree-dump.h"
85
86 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
87 #include "dwarf2out.h"
88 #endif
89
90 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
91 #include "dbxout.h"
92 #endif
93
94 #ifdef SDB_DEBUGGING_INFO
95 #include "sdbout.h"
96 #endif
97
98 #ifdef XCOFF_DEBUGGING_INFO
99 #include "xcoffout.h"           /* Needed for external data
100                                    declarations for e.g. AIX 4.x.  */
101 #endif
102
103 /* Global variables used to communicate with passes.  */
104 int dump_flags;
105 bool in_gimple_form;
106
107
108 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
109    and TYPE_DECL nodes.
110
111    This does nothing for local (non-static) variables, unless the
112    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
113    that case, or if the variable is not an automatic, it sets up the
114    RTL and outputs any assembler code (label definition, storage
115    allocation and initialization).
116
117    DECL is the declaration.  TOP_LEVEL is nonzero
118    if this declaration is not within a function.  */
119
120 void
121 rest_of_decl_compilation (tree decl,
122                           int top_level,
123                           int at_end)
124 {
125   /* We deferred calling assemble_alias so that we could collect
126      other attributes such as visibility.  Emit the alias now.  */
127   {
128     tree alias;
129     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
130     if (alias)
131       {
132         alias = TREE_VALUE (TREE_VALUE (alias));
133         alias = get_identifier (TREE_STRING_POINTER (alias));
134         assemble_alias (decl, alias);
135       }
136   }
137
138   /* Can't defer this, because it needs to happen before any
139      later function definitions are processed.  */
140   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
141     make_decl_rtl (decl);
142
143   /* Forward declarations for nested functions are not "external",
144      but we need to treat them as if they were.  */
145   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
146       || TREE_CODE (decl) == FUNCTION_DECL)
147     {
148       timevar_push (TV_VARCONST);
149
150       /* Don't output anything when a tentative file-scope definition
151          is seen.  But at end of compilation, do output code for them.
152
153          We do output all variables when unit-at-a-time is active and rely on
154          callgraph code to defer them except for forward declarations
155          (see gcc.c-torture/compile/920624-1.c) */
156       if ((at_end
157            || !DECL_DEFER_OUTPUT (decl)
158            || DECL_INITIAL (decl))
159           && !DECL_EXTERNAL (decl))
160         {
161           if (TREE_CODE (decl) != FUNCTION_DECL)
162             cgraph_varpool_finalize_decl (decl);
163           else
164             assemble_variable (decl, top_level, at_end, 0);
165         }
166
167 #ifdef ASM_FINISH_DECLARE_OBJECT
168       if (decl == last_assemble_variable_decl)
169         {
170           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
171                                      top_level, at_end);
172         }
173 #endif
174
175       timevar_pop (TV_VARCONST);
176     }
177   else if (TREE_CODE (decl) == TYPE_DECL
178            /* Like in rest_of_type_compilation, avoid confusing the debug
179               information machinery when there are errors.  */
180            && !(sorrycount || errorcount))
181     {
182       timevar_push (TV_SYMOUT);
183       debug_hooks->type_decl (decl, !top_level);
184       timevar_pop (TV_SYMOUT);
185     }
186
187   /* Let cgraph know about the existence of variables.  */
188   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
189     cgraph_varpool_node (decl);
190 }
191
192 /* Called after finishing a record, union or enumeral type.  */
193
194 void
195 rest_of_type_compilation (tree type, int toplev)
196 {
197   /* Avoid confusing the debug information machinery when there are
198      errors.  */
199   if (errorcount != 0 || sorrycount != 0)
200     return;
201
202   timevar_push (TV_SYMOUT);
203   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
204   timevar_pop (TV_SYMOUT);
205 }
206
207 \f
208
209 void
210 finish_optimization_passes (void)
211 {
212   enum tree_dump_index i;
213   struct dump_file_info *dfi;
214   char *name;
215
216   timevar_push (TV_DUMP);
217   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
218     {
219       dump_file = dump_begin (pass_branch_prob.static_pass_number, NULL);
220       end_branch_prob ();
221       if (dump_file)
222         dump_end (pass_branch_prob.static_pass_number, dump_file);
223     }
224
225   if (optimize > 0)
226     {
227       dump_file = dump_begin (pass_combine.static_pass_number, NULL);
228       if (dump_file)
229         {
230           dump_combine_total_stats (dump_file);
231           dump_end (pass_combine.static_pass_number, dump_file);
232         }
233     }
234
235   /* Do whatever is necessary to finish printing the graphs.  */
236   if (graph_dump_format != no_graph)
237     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
238       if (dump_initialized_p (i)
239           && (dfi->flags & TDF_GRAPH) != 0
240           && (name = get_dump_file_name (i)) != NULL)
241         {
242           finish_graph_dump_file (name);
243           free (name);
244         }
245
246   timevar_pop (TV_DUMP);
247 }
248
249 static bool
250 gate_rest_of_compilation (void)
251 {
252   /* Early return if there were errors.  We can run afoul of our
253      consistency checks, and there's not really much point in fixing them.  */
254   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
255 }
256
257 struct tree_opt_pass pass_rest_of_compilation =
258 {
259   NULL,                                 /* name */
260   gate_rest_of_compilation,             /* gate */
261   NULL,                                 /* execute */
262   NULL,                                 /* sub */
263   NULL,                                 /* next */
264   0,                                    /* static_pass_number */
265   TV_REST_OF_COMPILATION,               /* tv_id */
266   PROP_rtl,                             /* properties_required */
267   0,                                    /* properties_provided */
268   0,                                    /* properties_destroyed */
269   0,                                    /* todo_flags_start */
270   TODO_ggc_collect,                     /* todo_flags_finish */
271   0                                     /* letter */
272 };
273
274 static bool
275 gate_postreload (void)
276 {
277   return reload_completed;
278 }
279
280 struct tree_opt_pass pass_postreload =
281 {
282   NULL,                                 /* name */
283   gate_postreload,                      /* gate */
284   NULL,                                 /* execute */
285   NULL,                                 /* sub */
286   NULL,                                 /* next */
287   0,                                    /* static_pass_number */
288   0,                                    /* tv_id */
289   PROP_rtl,                             /* properties_required */
290   0,                                    /* properties_provided */
291   0,                                    /* properties_destroyed */
292   0,                                    /* todo_flags_start */
293   TODO_ggc_collect,                     /* todo_flags_finish */
294   0                                     /* letter */
295 };
296
297
298
299 /* The root of the compilation pass tree, once constructed.  */
300 struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
301
302 /* Iterate over the pass tree allocating dump file numbers.  We want
303    to do this depth first, and independent of whether the pass is
304    enabled or not.  */
305
306 static void
307 register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
308 {
309   char *dot_name, *flag_name, *glob_name;
310   char num[10];
311
312   /* See below in next_pass_1.  */
313   num[0] = '\0';
314   if (pass->static_pass_number != -1)
315     sprintf (num, "%d", ((int) pass->static_pass_number < 0
316                          ? 1 : pass->static_pass_number));
317
318   dot_name = concat (".", pass->name, num, NULL);
319   if (ipa)
320     {
321       flag_name = concat ("ipa-", pass->name, num, NULL);
322       glob_name = concat ("ipa-", pass->name, NULL);
323       /* First IPA dump is cgraph that is dumped via separate channels.  */
324       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
325                                                 TDF_IPA, n + 1, 0);
326     }
327   else if (pass->properties_provided & PROP_trees)
328     {
329       flag_name = concat ("tree-", pass->name, num, NULL);
330       glob_name = concat ("tree-", pass->name, NULL);
331       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
332                                                 TDF_TREE, n + TDI_tree_all, 0);
333     }
334   else
335     {
336       flag_name = concat ("rtl-", pass->name, num, NULL);
337       glob_name = concat ("rtl-", pass->name, NULL);
338       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
339                                                 TDF_RTL, n, pass->letter);
340     }
341 }
342
343 static int 
344 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
345 {
346   static int n = 0;
347   do
348     {
349       int new_properties;
350       int pass_number;
351
352       pass->properties_required = properties;
353       new_properties =
354         (properties | pass->properties_provided) & ~pass->properties_destroyed;
355
356       /* Reset the counter when we reach RTL-based passes.  */
357       if ((new_properties ^ pass->properties_required) & PROP_rtl)
358         n = 0;
359
360       pass_number = n;
361       if (pass->name)
362         n++;
363
364       if (pass->sub)
365         new_properties = register_dump_files (pass->sub, false, new_properties);
366
367       /* If we have a gate, combine the properties that we could have with
368          and without the pass being examined.  */
369       if (pass->gate)
370         properties &= new_properties;
371       else
372         properties = new_properties;
373
374       pass->properties_provided = properties;
375       if (pass->name)
376         register_one_dump_file (pass, ipa, pass_number);
377
378       pass = pass->next;
379     }
380   while (pass);
381
382   return properties;
383 }
384
385 /* Add a pass to the pass list. Duplicate the pass if it's already
386    in the list.  */
387
388 static struct tree_opt_pass **
389 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
390 {
391
392   /* A nonzero static_pass_number indicates that the
393      pass is already in the list.  */
394   if (pass->static_pass_number)
395     {
396       struct tree_opt_pass *new;
397
398       new = xmalloc (sizeof (*new));
399       memcpy (new, pass, sizeof (*new));
400
401       /* Indicate to register_dump_files that this pass has duplicates,
402          and so it should rename the dump file.  The first instance will
403          be -1, and be number of duplicates = -static_pass_number - 1.
404          Subsequent instances will be > 0 and just the duplicate number.  */
405       if (pass->name)
406         {
407           pass->static_pass_number -= 1;
408           new->static_pass_number = -pass->static_pass_number;
409         }
410       
411       *list = new;
412     }
413   else
414     {
415       pass->static_pass_number = -1;
416       *list = pass;
417     }  
418   
419   return &(*list)->next;
420           
421 }
422
423 /* Construct the pass tree.  The sequencing of passes is driven by
424    the cgraph routines:
425
426    cgraph_finalize_compilation_unit ()
427        for each node N in the cgraph
428            cgraph_analyze_function (N)
429                cgraph_lower_function (N) -> all_lowering_passes
430
431    If we are optimizing, cgraph_optimize is then invoked:
432
433    cgraph_optimize ()
434        ipa_passes ()                    -> all_ipa_passes
435        cgraph_expand_all_functions ()
436            for each node N in the cgraph
437                cgraph_expand_function (N)
438                    cgraph_lower_function (N)    -> Now a NOP.
439                    lang_hooks.callgraph.expand_function (DECL (N))
440                         tree_rest_of_compilation (DECL (N))  -> all_passes
441 */
442
443 void
444 init_optimization_passes (void)
445 {
446   struct tree_opt_pass **p;
447
448 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
449   /* Interprocedural optimization passes.  */
450   p = &all_ipa_passes;
451   NEXT_PASS (pass_early_ipa_inline);
452   NEXT_PASS (pass_early_local_passes);
453   NEXT_PASS (pass_ipa_cp);
454   NEXT_PASS (pass_ipa_inline);
455   NEXT_PASS (pass_ipa_reference);
456   NEXT_PASS (pass_ipa_pure_const); 
457   NEXT_PASS (pass_ipa_type_escape);
458   *p = NULL;
459
460   /* All passes needed to lower the function into shape optimizers can
461      operate on.  */
462   p = &all_lowering_passes;
463   NEXT_PASS (pass_remove_useless_stmts);
464   NEXT_PASS (pass_mudflap_1);
465   NEXT_PASS (pass_lower_cf);
466   NEXT_PASS (pass_lower_eh);
467   NEXT_PASS (pass_build_cfg);
468   NEXT_PASS (pass_lower_complex_O0);
469   NEXT_PASS (pass_lower_vector);
470   NEXT_PASS (pass_warn_function_return);
471   NEXT_PASS (pass_early_tree_profile);
472   *p = NULL;
473
474   p = &pass_early_local_passes.sub;
475   NEXT_PASS (pass_tree_profile);
476   NEXT_PASS (pass_cleanup_cfg);
477   NEXT_PASS (pass_rebuild_cgraph_edges);
478   *p = NULL;
479
480   p = &all_passes;
481   NEXT_PASS (pass_fixup_cfg);
482   NEXT_PASS (pass_init_datastructures);
483   NEXT_PASS (pass_all_optimizations);
484   NEXT_PASS (pass_warn_function_noreturn);
485   NEXT_PASS (pass_mudflap_2);
486   NEXT_PASS (pass_free_datastructures);
487   NEXT_PASS (pass_free_cfg_annotations);
488   NEXT_PASS (pass_expand);
489   NEXT_PASS (pass_rest_of_compilation);
490   NEXT_PASS (pass_clean_state);
491   *p = NULL;
492
493   p = &pass_all_optimizations.sub;
494   NEXT_PASS (pass_referenced_vars);
495   NEXT_PASS (pass_create_structure_vars);
496   NEXT_PASS (pass_build_ssa);
497   NEXT_PASS (pass_may_alias);
498   NEXT_PASS (pass_return_slot);
499   NEXT_PASS (pass_rename_ssa_copies);
500   NEXT_PASS (pass_early_warn_uninitialized);
501
502   /* Initial scalar cleanups.  */
503   NEXT_PASS (pass_ccp);
504   NEXT_PASS (pass_fre);
505   NEXT_PASS (pass_dce);
506   NEXT_PASS (pass_forwprop);
507   NEXT_PASS (pass_copy_prop);
508   NEXT_PASS (pass_vrp);
509   NEXT_PASS (pass_dce);
510   NEXT_PASS (pass_merge_phi);
511   NEXT_PASS (pass_dominator);
512
513   /* The only copy propagation opportunities left after DOM
514      should be due to degenerate PHI nodes.  So rather than
515      run the full copy propagator, just discover and copy
516      propagate away the degenerate PHI nodes.  */
517   NEXT_PASS (pass_phi_only_copy_prop);
518
519   NEXT_PASS (pass_phiopt);
520   NEXT_PASS (pass_may_alias);
521   NEXT_PASS (pass_tail_recursion);
522   NEXT_PASS (pass_profile);
523   NEXT_PASS (pass_ch);
524   NEXT_PASS (pass_stdarg);
525   NEXT_PASS (pass_lower_complex);
526   NEXT_PASS (pass_sra);
527   /* FIXME: SRA may generate arbitrary gimple code, exposing new
528      aliased and call-clobbered variables.  As mentioned below,
529      pass_may_alias should be a TODO item.  */
530   NEXT_PASS (pass_may_alias);
531   NEXT_PASS (pass_rename_ssa_copies);
532   NEXT_PASS (pass_dominator);
533
534   /* The only copy propagation opportunities left after DOM
535      should be due to degenerate PHI nodes.  So rather than
536      run the full copy propagator, just discover and copy
537      propagate away the degenerate PHI nodes.  */
538   NEXT_PASS (pass_phi_only_copy_prop);
539
540   NEXT_PASS (pass_reassoc);
541   NEXT_PASS (pass_dce);
542   NEXT_PASS (pass_dse);
543   NEXT_PASS (pass_may_alias);
544   NEXT_PASS (pass_forwprop);
545   NEXT_PASS (pass_phiopt);
546   NEXT_PASS (pass_object_sizes);
547   NEXT_PASS (pass_store_ccp);
548   NEXT_PASS (pass_store_copy_prop);
549   NEXT_PASS (pass_fold_builtins);
550   /* FIXME: May alias should a TODO but for 4.0.0,
551      we add may_alias right after fold builtins
552      which can create arbitrary GIMPLE.  */
553   NEXT_PASS (pass_may_alias);
554   NEXT_PASS (pass_split_crit_edges);
555   NEXT_PASS (pass_pre);
556   NEXT_PASS (pass_may_alias);
557   NEXT_PASS (pass_sink_code);
558   NEXT_PASS (pass_tree_loop);
559   NEXT_PASS (pass_cse_reciprocals);
560   NEXT_PASS (pass_reassoc);
561   NEXT_PASS (pass_dominator);
562
563   /* The only copy propagation opportunities left after DOM
564      should be due to degenerate PHI nodes.  So rather than
565      run the full copy propagator, just discover and copy
566      propagate away the degenerate PHI nodes.  */
567   NEXT_PASS (pass_phi_only_copy_prop);
568
569   NEXT_PASS (pass_cd_dce);
570
571   /* FIXME: If DCE is not run before checking for uninitialized uses,
572      we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
573      However, this also causes us to misdiagnose cases that should be
574      real warnings (e.g., testsuite/gcc.dg/pr18501.c).
575      
576      To fix the false positives in uninit-5.c, we would have to
577      account for the predicates protecting the set and the use of each
578      variable.  Using a representation like Gated Single Assignment
579      may help.  */
580   NEXT_PASS (pass_late_warn_uninitialized);
581   NEXT_PASS (pass_dse);
582   NEXT_PASS (pass_forwprop);
583   NEXT_PASS (pass_phiopt);
584   NEXT_PASS (pass_tail_calls);
585   NEXT_PASS (pass_rename_ssa_copies);
586   NEXT_PASS (pass_uncprop);
587   NEXT_PASS (pass_del_ssa);
588   NEXT_PASS (pass_nrv);
589   NEXT_PASS (pass_mark_used_blocks);
590   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
591   *p = NULL;
592
593   p = &pass_tree_loop.sub;
594   NEXT_PASS (pass_tree_loop_init);
595   NEXT_PASS (pass_copy_prop);
596   NEXT_PASS (pass_lim);
597   NEXT_PASS (pass_tree_unswitch);
598   NEXT_PASS (pass_scev_cprop);
599   NEXT_PASS (pass_empty_loop);
600   NEXT_PASS (pass_record_bounds);
601   NEXT_PASS (pass_linear_transform);
602   NEXT_PASS (pass_iv_canon);
603   NEXT_PASS (pass_if_conversion);
604   NEXT_PASS (pass_vectorize);
605   /* NEXT_PASS (pass_may_alias) cannot be done again because the
606      vectorizer creates alias relations that are not supported by
607      pass_may_alias.  */
608   NEXT_PASS (pass_complete_unroll);
609   NEXT_PASS (pass_iv_optimize);
610   NEXT_PASS (pass_tree_loop_done);
611   *p = NULL;
612
613   p = &pass_vectorize.sub;
614   NEXT_PASS (pass_lower_vector_ssa);
615   NEXT_PASS (pass_dce_loop);
616   *p = NULL;
617
618   p = &pass_loop2.sub;
619   NEXT_PASS (pass_rtl_loop_init);
620   NEXT_PASS (pass_rtl_move_loop_invariants);
621   NEXT_PASS (pass_rtl_unswitch);
622   NEXT_PASS (pass_rtl_unroll_and_peel_loops);
623   NEXT_PASS (pass_rtl_doloop);
624   NEXT_PASS (pass_rtl_loop_done);
625   *p = NULL;
626   
627   p = &pass_rest_of_compilation.sub;
628   NEXT_PASS (pass_remove_unnecessary_notes);
629   NEXT_PASS (pass_init_function);
630   NEXT_PASS (pass_jump);
631   NEXT_PASS (pass_insn_locators_initialize);
632   NEXT_PASS (pass_rtl_eh);
633   NEXT_PASS (pass_initial_value_sets);
634   NEXT_PASS (pass_unshare_all_rtl);
635   NEXT_PASS (pass_instantiate_virtual_regs);
636   NEXT_PASS (pass_jump2);
637   NEXT_PASS (pass_cse);
638   NEXT_PASS (pass_gcse);
639   NEXT_PASS (pass_loop_optimize);
640   NEXT_PASS (pass_jump_bypass);
641   NEXT_PASS (pass_cfg);
642   NEXT_PASS (pass_branch_prob);
643   NEXT_PASS (pass_rtl_ifcvt);
644   NEXT_PASS (pass_tracer);
645   /* Perform loop optimizations.  It might be better to do them a bit
646      sooner, but we want the profile feedback to work more
647      efficiently.  */
648   NEXT_PASS (pass_loop2);
649   NEXT_PASS (pass_web);
650   NEXT_PASS (pass_cse2);
651   NEXT_PASS (pass_life);
652   NEXT_PASS (pass_combine);
653   NEXT_PASS (pass_if_after_combine);
654   NEXT_PASS (pass_partition_blocks);
655   NEXT_PASS (pass_regmove);
656   NEXT_PASS (pass_split_all_insns);
657   NEXT_PASS (pass_mode_switching);
658   NEXT_PASS (pass_recompute_reg_usage);
659   NEXT_PASS (pass_sms);
660   NEXT_PASS (pass_sched);
661   NEXT_PASS (pass_local_alloc);
662   NEXT_PASS (pass_global_alloc);
663   NEXT_PASS (pass_postreload);
664   *p = NULL;
665
666   p = &pass_postreload.sub;
667   NEXT_PASS (pass_postreload_cse);
668   NEXT_PASS (pass_gcse2);
669   NEXT_PASS (pass_flow2);
670   NEXT_PASS (pass_stack_adjustments);
671   NEXT_PASS (pass_peephole2);
672   NEXT_PASS (pass_if_after_reload);
673   NEXT_PASS (pass_regrename);
674   NEXT_PASS (pass_reorder_blocks);
675   NEXT_PASS (pass_branch_target_load_optimize);
676   NEXT_PASS (pass_leaf_regs);
677   NEXT_PASS (pass_sched2);
678   NEXT_PASS (pass_split_before_regstack);
679   NEXT_PASS (pass_stack_regs);
680   NEXT_PASS (pass_compute_alignments);
681   NEXT_PASS (pass_duplicate_computed_gotos);
682   NEXT_PASS (pass_variable_tracking);
683   NEXT_PASS (pass_free_cfg);
684   NEXT_PASS (pass_machine_reorg);
685   NEXT_PASS (pass_purge_lineno_notes);
686   NEXT_PASS (pass_cleanup_barriers);
687   NEXT_PASS (pass_delay_slots);
688   NEXT_PASS (pass_split_for_shorten_branches);
689   NEXT_PASS (pass_convert_to_eh_region_ranges);
690   NEXT_PASS (pass_shorten_branches);
691   NEXT_PASS (pass_set_nothrow_function_flags);
692   NEXT_PASS (pass_final);
693   *p = NULL;
694
695 #undef NEXT_PASS
696
697   /* Register the passes with the tree dump code.  */
698   register_dump_files (all_ipa_passes, true, PROP_gimple_leh | PROP_cfg);
699   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
700   register_dump_files (all_passes, false, PROP_gimple_leh | PROP_cfg);
701 }
702
703 static unsigned int last_verified;
704 static void
705 execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
706 {
707   int properties 
708     = use_required ? pass->properties_required : pass->properties_provided;
709
710 #if defined ENABLE_CHECKING
711   if (need_ssa_update_p ())
712     gcc_assert (flags & TODO_update_ssa_any);
713 #endif
714
715   /* Always cleanup the CFG before doing anything else.  */
716   if (flags & TODO_cleanup_cfg)
717     {
718       if (current_loops)
719         cleanup_tree_cfg_loop ();
720       else
721         cleanup_tree_cfg ();
722
723       /* When cleanup_tree_cfg merges consecutive blocks, it may
724          perform some simplistic propagation when removing single
725          valued PHI nodes.  This propagation may, in turn, cause the
726          SSA form to become out-of-date (see PR 22037).  So, even
727          if the parent pass had not scheduled an SSA update, we may
728          still need to do one.  */
729       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
730         flags |= TODO_update_ssa;
731     }
732
733   if (flags & TODO_update_ssa_any)
734     {
735       unsigned update_flags = flags & TODO_update_ssa_any;
736       update_ssa (update_flags);
737     }
738
739   if (flags & TODO_remove_unused_locals)
740     remove_unused_locals ();
741
742   if ((flags & TODO_dump_func)
743       && dump_file && current_function_decl)
744     {
745       if (properties & PROP_trees)
746         dump_function_to_file (current_function_decl,
747                                dump_file, dump_flags);
748       else if (properties & PROP_cfg)
749         {
750           print_rtl_with_bb (dump_file, get_insns ());
751
752           if (graph_dump_format != no_graph
753               && (dump_flags & TDF_GRAPH))
754             print_rtl_graph_with_bb (dump_file_name, get_insns ());
755         }
756       else
757         print_rtl (dump_file, get_insns ());
758
759       /* Flush the file.  If verification fails, we won't be able to
760          close the file before aborting.  */
761       fflush (dump_file);
762     }
763   if ((flags & TODO_dump_cgraph)
764       && dump_file && !current_function_decl)
765     {
766       dump_cgraph (dump_file);
767       /* Flush the file.  If verification fails, we won't be able to
768          close the file before aborting.  */
769       fflush (dump_file);
770     }
771
772   if (flags & TODO_ggc_collect)
773     {
774       ggc_collect ();
775     }
776
777 #if defined ENABLE_CHECKING
778   if ((pass->properties_required & PROP_ssa)
779       && !(pass->properties_destroyed & PROP_ssa))
780     verify_ssa (true);
781   if (flags & TODO_verify_flow)
782     verify_flow_info ();
783   if (flags & TODO_verify_stmts)
784     verify_stmts ();
785   if (flags & TODO_verify_loops)
786     verify_loop_closed_ssa ();
787 #endif
788 }
789
790 static bool
791 execute_one_pass (struct tree_opt_pass *pass)
792 {
793   unsigned int todo; 
794
795   /* See if we're supposed to run this pass.  */
796   if (pass->gate && !pass->gate ())
797     return false;
798
799   /* Note that the folders should only create gimple expressions.
800      This is a hack until the new folder is ready.  */
801   in_gimple_form = (pass->properties_provided & PROP_trees) != 0;
802
803   /* Run pre-pass verification.  */
804   todo = pass->todo_flags_start & ~last_verified;
805   if (todo)
806     execute_todo (pass, todo, true);
807
808   /* If a dump file name is present, open it if enabled.  */
809   if (pass->static_pass_number != -1)
810     {
811       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
812       dump_file_name = get_dump_file_name (pass->static_pass_number);
813       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
814       if (dump_file && current_function_decl)
815         {
816           const char *dname, *aname;
817           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
818           aname = (IDENTIFIER_POINTER
819                    (DECL_ASSEMBLER_NAME (current_function_decl)));
820           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
821              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
822              ? " (hot)"
823              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
824              ? " (unlikely executed)"
825              : "");
826         }
827
828       if (initializing_dump
829           && dump_file
830           && graph_dump_format != no_graph
831           && (pass->properties_provided & (PROP_cfg | PROP_rtl))
832               == (PROP_cfg | PROP_rtl))
833         {
834           get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
835           dump_flags |= TDF_GRAPH;
836           clean_graph_dump_file (dump_file_name);
837         }
838     }
839
840   /* If a timevar is present, start it.  */
841   if (pass->tv_id)
842     timevar_push (pass->tv_id);
843
844   /* Do it!  */
845   if (pass->execute)
846     pass->execute ();
847
848   /* Stop timevar.  */
849   if (pass->tv_id)
850     timevar_pop (pass->tv_id);
851
852   /* Run post-pass cleanup and verification.  */
853   todo = pass->todo_flags_finish;
854   last_verified = todo & TODO_verify_all;
855   if (todo)
856     execute_todo (pass, todo, false);
857
858   /* Flush and close dump file.  */
859   if (dump_file_name)
860     {
861       free ((char *) dump_file_name);
862       dump_file_name = NULL;
863     }
864   if (dump_file)
865     {
866       dump_end (pass->static_pass_number, dump_file);
867       dump_file = NULL;
868     }
869
870   return true;
871 }
872
873 void
874 execute_pass_list (struct tree_opt_pass *pass)
875 {
876   do
877     {
878       if (execute_one_pass (pass) && pass->sub)
879         execute_pass_list (pass->sub);
880       pass = pass->next;
881     }
882   while (pass);
883 }
884
885 /* Same as execute_pass_list but assume that subpasses of IPA passes
886    are local passes.  */
887 void
888 execute_ipa_pass_list (struct tree_opt_pass *pass)
889 {
890   do
891     {
892       if (execute_one_pass (pass) && pass->sub)
893         {
894           struct cgraph_node *node;
895           for (node = cgraph_nodes; node; node = node->next)
896             if (node->analyzed)
897               {
898                 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
899                 current_function_decl = node->decl;
900                 execute_pass_list (pass->sub);
901                 free_dominance_info (CDI_DOMINATORS);
902                 free_dominance_info (CDI_POST_DOMINATORS);
903                 current_function_decl = NULL;
904                 pop_cfun ();
905                 ggc_collect ();
906               }
907         }
908       pass = pass->next;
909     }
910   while (pass);
911 }