OSDN Git Service

2006-02-08 Paolo Bonzini <bonzini@gnu.org>
[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, 2006 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 properties)
308 {
309   char *dot_name, *flag_name, *glob_name;
310   const char *prefix;
311   char num[10];
312   int flags;
313
314   /* See below in next_pass_1.  */
315   num[0] = '\0';
316   if (pass->static_pass_number != -1)
317     sprintf (num, "%d", ((int) pass->static_pass_number < 0
318                          ? 1 : pass->static_pass_number));
319
320   dot_name = concat (".", pass->name, num, NULL);
321   if (ipa)
322     prefix = "ipa-", flags = TDF_IPA;
323   else if (properties & PROP_trees)
324     prefix = "tree-", flags = TDF_TREE;
325   else
326     prefix = "rtl-", flags = TDF_RTL;
327
328   flag_name = concat (prefix, pass->name, num, NULL);
329   glob_name = concat (prefix, pass->name, NULL);
330   pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
331                                             flags, pass->letter);
332 }
333
334 /* Recursive worker function for register_dump_files.  */
335
336 static int 
337 register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)
338 {
339   do
340     {
341       int new_properties = (properties | pass->properties_provided)
342                            & ~pass->properties_destroyed;
343
344       if (pass->name)
345         register_one_dump_file (pass, ipa, new_properties);
346
347       if (pass->sub)
348         new_properties = register_dump_files_1 (pass->sub, false,
349                                                 new_properties);
350
351       /* If we have a gate, combine the properties that we could have with
352          and without the pass being examined.  */
353       if (pass->gate)
354         properties &= new_properties;
355       else
356         properties = new_properties;
357
358       pass = pass->next;
359     }
360   while (pass);
361
362   return properties;
363 }
364
365 /* Register the dump files for the pipeline starting at PASS.  IPA is
366    true if the pass is inter-procedural, and PROPERTIES reflects the
367    properties that are guarenteed to be available at the beginning of
368    the pipeline.  */
369
370 static void 
371 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
372 {
373   pass->properties_required |= properties;
374   pass->todo_flags_start |= TODO_set_props;
375   register_dump_files_1 (pass, ipa, properties);
376 }
377
378 /* Add a pass to the pass list. Duplicate the pass if it's already
379    in the list.  */
380
381 static struct tree_opt_pass **
382 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
383 {
384   /* A nonzero static_pass_number indicates that the
385      pass is already in the list.  */
386   if (pass->static_pass_number)
387     {
388       struct tree_opt_pass *new;
389
390       new = xmalloc (sizeof (*new));
391       memcpy (new, pass, sizeof (*new));
392
393       /* Indicate to register_dump_files that this pass has duplicates,
394          and so it should rename the dump file.  The first instance will
395          be -1, and be number of duplicates = -static_pass_number - 1.
396          Subsequent instances will be > 0 and just the duplicate number.  */
397       if (pass->name)
398         {
399           pass->static_pass_number -= 1;
400           new->static_pass_number = -pass->static_pass_number;
401         }
402       
403       *list = new;
404     }
405   else
406     {
407       pass->static_pass_number = -1;
408       *list = pass;
409     }  
410   
411   return &(*list)->next;
412           
413 }
414
415 /* Construct the pass tree.  The sequencing of passes is driven by
416    the cgraph routines:
417
418    cgraph_finalize_compilation_unit ()
419        for each node N in the cgraph
420            cgraph_analyze_function (N)
421                cgraph_lower_function (N) -> all_lowering_passes
422
423    If we are optimizing, cgraph_optimize is then invoked:
424
425    cgraph_optimize ()
426        ipa_passes ()                    -> all_ipa_passes
427        cgraph_expand_all_functions ()
428            for each node N in the cgraph
429                cgraph_expand_function (N)
430                    cgraph_lower_function (N)    -> Now a NOP.
431                    lang_hooks.callgraph.expand_function (DECL (N))
432                         tree_rest_of_compilation (DECL (N))  -> all_passes
433 */
434
435 void
436 init_optimization_passes (void)
437 {
438   struct tree_opt_pass **p;
439
440 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
441   /* Interprocedural optimization passes.  */
442   p = &all_ipa_passes;
443   NEXT_PASS (pass_early_ipa_inline);
444   NEXT_PASS (pass_early_local_passes);
445   NEXT_PASS (pass_ipa_cp);
446   NEXT_PASS (pass_ipa_inline);
447   NEXT_PASS (pass_ipa_reference);
448   NEXT_PASS (pass_ipa_pure_const); 
449   NEXT_PASS (pass_ipa_type_escape);
450   *p = NULL;
451
452   /* All passes needed to lower the function into shape optimizers can
453      operate on.  */
454   p = &all_lowering_passes;
455   NEXT_PASS (pass_remove_useless_stmts);
456   NEXT_PASS (pass_mudflap_1);
457   NEXT_PASS (pass_lower_omp);
458   NEXT_PASS (pass_lower_cf);
459   NEXT_PASS (pass_lower_eh);
460   NEXT_PASS (pass_build_cfg);
461   NEXT_PASS (pass_lower_complex_O0);
462   NEXT_PASS (pass_lower_vector);
463   NEXT_PASS (pass_warn_function_return);
464   NEXT_PASS (pass_early_tree_profile);
465   *p = NULL;
466
467   p = &pass_early_local_passes.sub;
468   NEXT_PASS (pass_tree_profile);
469   NEXT_PASS (pass_cleanup_cfg);
470   NEXT_PASS (pass_rebuild_cgraph_edges);
471   *p = NULL;
472
473   p = &all_passes;
474   NEXT_PASS (pass_fixup_cfg);
475   NEXT_PASS (pass_init_datastructures);
476   NEXT_PASS (pass_expand_omp);
477   NEXT_PASS (pass_all_optimizations);
478   NEXT_PASS (pass_warn_function_noreturn);
479   NEXT_PASS (pass_mudflap_2);
480   NEXT_PASS (pass_free_datastructures);
481   NEXT_PASS (pass_free_cfg_annotations);
482   NEXT_PASS (pass_expand);
483   NEXT_PASS (pass_rest_of_compilation);
484   NEXT_PASS (pass_clean_state);
485   *p = NULL;
486
487   p = &pass_all_optimizations.sub;
488   NEXT_PASS (pass_referenced_vars);
489   NEXT_PASS (pass_create_structure_vars);
490   NEXT_PASS (pass_build_ssa);
491   NEXT_PASS (pass_may_alias);
492   NEXT_PASS (pass_return_slot);
493   NEXT_PASS (pass_rename_ssa_copies);
494   NEXT_PASS (pass_early_warn_uninitialized);
495
496   /* Initial scalar cleanups.  */
497   NEXT_PASS (pass_ccp);
498   NEXT_PASS (pass_fre);
499   NEXT_PASS (pass_dce);
500   NEXT_PASS (pass_forwprop);
501   NEXT_PASS (pass_copy_prop);
502   NEXT_PASS (pass_merge_phi);
503   NEXT_PASS (pass_vrp);
504   NEXT_PASS (pass_dce);
505   NEXT_PASS (pass_dominator);
506
507   /* The only copy propagation opportunities left after DOM
508      should be due to degenerate PHI nodes.  So rather than
509      run the full copy propagator, just discover and copy
510      propagate away the degenerate PHI nodes.  */
511   NEXT_PASS (pass_phi_only_copy_prop);
512
513   NEXT_PASS (pass_phiopt);
514   NEXT_PASS (pass_may_alias);
515   NEXT_PASS (pass_tail_recursion);
516   NEXT_PASS (pass_profile);
517   NEXT_PASS (pass_ch);
518   NEXT_PASS (pass_stdarg);
519   NEXT_PASS (pass_lower_complex);
520   NEXT_PASS (pass_sra);
521   /* FIXME: SRA may generate arbitrary gimple code, exposing new
522      aliased and call-clobbered variables.  As mentioned below,
523      pass_may_alias should be a TODO item.  */
524   NEXT_PASS (pass_may_alias);
525   NEXT_PASS (pass_rename_ssa_copies);
526   NEXT_PASS (pass_dominator);
527
528   /* The only copy propagation opportunities left after DOM
529      should be due to degenerate PHI nodes.  So rather than
530      run the full copy propagator, just discover and copy
531      propagate away the degenerate PHI nodes.  */
532   NEXT_PASS (pass_phi_only_copy_prop);
533
534   NEXT_PASS (pass_reassoc);
535   NEXT_PASS (pass_dce);
536   NEXT_PASS (pass_dse);
537   NEXT_PASS (pass_may_alias);
538   NEXT_PASS (pass_forwprop);
539   NEXT_PASS (pass_phiopt);
540   NEXT_PASS (pass_object_sizes);
541   NEXT_PASS (pass_store_ccp);
542   NEXT_PASS (pass_store_copy_prop);
543   NEXT_PASS (pass_fold_builtins);
544   /* FIXME: May alias should a TODO but for 4.0.0,
545      we add may_alias right after fold builtins
546      which can create arbitrary GIMPLE.  */
547   NEXT_PASS (pass_may_alias);
548   NEXT_PASS (pass_split_crit_edges);
549   NEXT_PASS (pass_pre);
550   NEXT_PASS (pass_may_alias);
551   NEXT_PASS (pass_sink_code);
552   NEXT_PASS (pass_tree_loop);
553   NEXT_PASS (pass_cse_reciprocals);
554   NEXT_PASS (pass_reassoc);
555   NEXT_PASS (pass_vrp);
556   NEXT_PASS (pass_dominator);
557
558   /* The only copy propagation opportunities left after DOM
559      should be due to degenerate PHI nodes.  So rather than
560      run the full copy propagator, just discover and copy
561      propagate away the degenerate PHI nodes.  */
562   NEXT_PASS (pass_phi_only_copy_prop);
563
564   NEXT_PASS (pass_cd_dce);
565
566   /* FIXME: If DCE is not run before checking for uninitialized uses,
567      we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
568      However, this also causes us to misdiagnose cases that should be
569      real warnings (e.g., testsuite/gcc.dg/pr18501.c).
570      
571      To fix the false positives in uninit-5.c, we would have to
572      account for the predicates protecting the set and the use of each
573      variable.  Using a representation like Gated Single Assignment
574      may help.  */
575   NEXT_PASS (pass_late_warn_uninitialized);
576   NEXT_PASS (pass_dse);
577   NEXT_PASS (pass_forwprop);
578   NEXT_PASS (pass_phiopt);
579   NEXT_PASS (pass_tail_calls);
580   NEXT_PASS (pass_rename_ssa_copies);
581   NEXT_PASS (pass_uncprop);
582   NEXT_PASS (pass_del_ssa);
583   NEXT_PASS (pass_nrv);
584   NEXT_PASS (pass_mark_used_blocks);
585   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
586   *p = NULL;
587
588   p = &pass_tree_loop.sub;
589   NEXT_PASS (pass_tree_loop_init);
590   NEXT_PASS (pass_copy_prop);
591   NEXT_PASS (pass_lim);
592   NEXT_PASS (pass_tree_unswitch);
593   NEXT_PASS (pass_scev_cprop);
594   NEXT_PASS (pass_empty_loop);
595   NEXT_PASS (pass_record_bounds);
596   NEXT_PASS (pass_linear_transform);
597   NEXT_PASS (pass_iv_canon);
598   NEXT_PASS (pass_if_conversion);
599   NEXT_PASS (pass_vectorize);
600   /* NEXT_PASS (pass_may_alias) cannot be done again because the
601      vectorizer creates alias relations that are not supported by
602      pass_may_alias.  */
603   NEXT_PASS (pass_complete_unroll);
604   NEXT_PASS (pass_iv_optimize);
605   NEXT_PASS (pass_tree_loop_done);
606   *p = NULL;
607
608   p = &pass_vectorize.sub;
609   NEXT_PASS (pass_lower_vector_ssa);
610   NEXT_PASS (pass_dce_loop);
611   *p = NULL;
612
613   p = &pass_loop2.sub;
614   NEXT_PASS (pass_rtl_loop_init);
615   NEXT_PASS (pass_rtl_move_loop_invariants);
616   NEXT_PASS (pass_rtl_unswitch);
617   NEXT_PASS (pass_rtl_unroll_and_peel_loops);
618   NEXT_PASS (pass_rtl_doloop);
619   NEXT_PASS (pass_rtl_loop_done);
620   *p = NULL;
621   
622   p = &pass_rest_of_compilation.sub;
623   NEXT_PASS (pass_remove_unnecessary_notes);
624   NEXT_PASS (pass_init_function);
625   NEXT_PASS (pass_jump);
626   NEXT_PASS (pass_insn_locators_initialize);
627   NEXT_PASS (pass_rtl_eh);
628   NEXT_PASS (pass_initial_value_sets);
629   NEXT_PASS (pass_unshare_all_rtl);
630   NEXT_PASS (pass_instantiate_virtual_regs);
631   NEXT_PASS (pass_jump2);
632   NEXT_PASS (pass_cse);
633   NEXT_PASS (pass_gcse);
634   NEXT_PASS (pass_loop_optimize);
635   NEXT_PASS (pass_jump_bypass);
636   NEXT_PASS (pass_cfg);
637   NEXT_PASS (pass_branch_prob);
638   NEXT_PASS (pass_rtl_ifcvt);
639   NEXT_PASS (pass_tracer);
640   /* Perform loop optimizations.  It might be better to do them a bit
641      sooner, but we want the profile feedback to work more
642      efficiently.  */
643   NEXT_PASS (pass_loop2);
644   NEXT_PASS (pass_web);
645   NEXT_PASS (pass_cse2);
646   NEXT_PASS (pass_life);
647   NEXT_PASS (pass_combine);
648   NEXT_PASS (pass_if_after_combine);
649   NEXT_PASS (pass_partition_blocks);
650   NEXT_PASS (pass_regmove);
651   NEXT_PASS (pass_split_all_insns);
652   NEXT_PASS (pass_mode_switching);
653   NEXT_PASS (pass_recompute_reg_usage);
654   NEXT_PASS (pass_sms);
655   NEXT_PASS (pass_sched);
656   NEXT_PASS (pass_local_alloc);
657   NEXT_PASS (pass_global_alloc);
658   NEXT_PASS (pass_postreload);
659   *p = NULL;
660
661   p = &pass_postreload.sub;
662   NEXT_PASS (pass_postreload_cse);
663   NEXT_PASS (pass_gcse2);
664   NEXT_PASS (pass_flow2);
665   NEXT_PASS (pass_rtl_seqabstr);
666   NEXT_PASS (pass_stack_adjustments);
667   NEXT_PASS (pass_peephole2);
668   NEXT_PASS (pass_if_after_reload);
669   NEXT_PASS (pass_regrename);
670   NEXT_PASS (pass_reorder_blocks);
671   NEXT_PASS (pass_branch_target_load_optimize);
672   NEXT_PASS (pass_leaf_regs);
673   NEXT_PASS (pass_sched2);
674   NEXT_PASS (pass_split_before_regstack);
675   NEXT_PASS (pass_stack_regs);
676   NEXT_PASS (pass_compute_alignments);
677   NEXT_PASS (pass_duplicate_computed_gotos);
678   NEXT_PASS (pass_variable_tracking);
679   NEXT_PASS (pass_free_cfg);
680   NEXT_PASS (pass_machine_reorg);
681   NEXT_PASS (pass_purge_lineno_notes);
682   NEXT_PASS (pass_cleanup_barriers);
683   NEXT_PASS (pass_delay_slots);
684   NEXT_PASS (pass_split_for_shorten_branches);
685   NEXT_PASS (pass_convert_to_eh_region_ranges);
686   NEXT_PASS (pass_shorten_branches);
687   NEXT_PASS (pass_set_nothrow_function_flags);
688   NEXT_PASS (pass_final);
689   *p = NULL;
690
691 #undef NEXT_PASS
692
693   /* Register the passes with the tree dump code.  */
694   register_dump_files (all_ipa_passes, true,
695                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
696                        | PROP_cfg);
697   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
698   register_dump_files (all_passes, false,
699                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
700                        | PROP_cfg);
701 }
702
703 static unsigned int last_verified;
704 static unsigned int curr_properties;
705
706 static void
707 execute_todo (unsigned int flags)
708 {
709 #if defined ENABLE_CHECKING
710   if (need_ssa_update_p ())
711     gcc_assert (flags & TODO_update_ssa_any);
712 #endif
713
714   if (curr_properties & PROP_ssa)
715     flags |= TODO_verify_ssa;
716   flags &= ~last_verified;
717   if (!flags)
718     return;
719
720   /* Always cleanup the CFG before doing anything else.  */
721   if (flags & TODO_cleanup_cfg)
722     {
723       if (current_loops)
724         cleanup_tree_cfg_loop ();
725       else
726         cleanup_tree_cfg ();
727
728       /* When cleanup_tree_cfg merges consecutive blocks, it may
729          perform some simplistic propagation when removing single
730          valued PHI nodes.  This propagation may, in turn, cause the
731          SSA form to become out-of-date (see PR 22037).  So, even
732          if the parent pass had not scheduled an SSA update, we may
733          still need to do one.  */
734       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
735         flags |= TODO_update_ssa;
736     }
737
738   if (flags & TODO_update_ssa_any)
739     {
740       unsigned update_flags = flags & TODO_update_ssa_any;
741       update_ssa (update_flags);
742       last_verified &= ~TODO_verify_ssa;
743     }
744
745   if (flags & TODO_remove_unused_locals)
746     remove_unused_locals ();
747
748   if ((flags & TODO_dump_func)
749       && dump_file && current_function_decl)
750     {
751       if (curr_properties & PROP_trees)
752         dump_function_to_file (current_function_decl,
753                                dump_file, dump_flags);
754       else
755         {
756           if (dump_flags & TDF_SLIM)
757             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
758           else if (curr_properties & PROP_cfg)
759             print_rtl_with_bb (dump_file, get_insns ());
760           else
761             print_rtl (dump_file, get_insns ());
762
763           if (curr_properties & PROP_cfg
764               && graph_dump_format != no_graph
765               && (dump_flags & TDF_GRAPH))
766             print_rtl_graph_with_bb (dump_file_name, get_insns ());
767         }
768
769       /* Flush the file.  If verification fails, we won't be able to
770          close the file before aborting.  */
771       fflush (dump_file);
772     }
773   if ((flags & TODO_dump_cgraph)
774       && dump_file && !current_function_decl)
775     {
776       dump_cgraph (dump_file);
777       /* Flush the file.  If verification fails, we won't be able to
778          close the file before aborting.  */
779       fflush (dump_file);
780     }
781
782   if (flags & TODO_ggc_collect)
783     {
784       ggc_collect ();
785     }
786
787 #if defined ENABLE_CHECKING
788   if (flags & TODO_verify_ssa)
789     verify_ssa (true);
790   if (flags & TODO_verify_flow)
791     verify_flow_info ();
792   if (flags & TODO_verify_stmts)
793     verify_stmts ();
794   if (flags & TODO_verify_loops)
795     verify_loop_closed_ssa ();
796 #endif
797
798   last_verified = flags & TODO_verify_all;
799 }
800
801 static bool
802 execute_one_pass (struct tree_opt_pass *pass)
803 {
804   bool initializing_dump;
805
806   /* See if we're supposed to run this pass.  */
807   if (pass->gate && !pass->gate ())
808     return false;
809
810   if (pass->todo_flags_start & TODO_set_props)
811     curr_properties = pass->properties_required;
812
813   /* Note that the folders should only create gimple expressions.
814      This is a hack until the new folder is ready.  */
815   in_gimple_form = (curr_properties & PROP_trees) != 0;
816
817   /* Run pre-pass verification.  */
818   execute_todo (pass->todo_flags_start);
819
820   gcc_assert ((curr_properties & pass->properties_required)
821               == pass->properties_required);
822
823   /* If a dump file name is present, open it if enabled.  */
824   if (pass->static_pass_number != -1)
825     {
826       initializing_dump = !dump_initialized_p (pass->static_pass_number);
827       dump_file_name = get_dump_file_name (pass->static_pass_number);
828       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
829       if (dump_file && current_function_decl)
830         {
831           const char *dname, *aname;
832           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
833           aname = (IDENTIFIER_POINTER
834                    (DECL_ASSEMBLER_NAME (current_function_decl)));
835           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
836              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
837              ? " (hot)"
838              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
839              ? " (unlikely executed)"
840              : "");
841         }
842     }
843   else
844     initializing_dump = false;
845
846   /* If a timevar is present, start it.  */
847   if (pass->tv_id)
848     timevar_push (pass->tv_id);
849
850   /* Do it!  */
851   if (pass->execute)
852     {
853       pass->execute ();
854       last_verified = 0;
855     }
856
857   /* Stop timevar.  */
858   if (pass->tv_id)
859     timevar_pop (pass->tv_id);
860
861   curr_properties = (curr_properties | pass->properties_provided)
862                     & ~pass->properties_destroyed;
863
864   if (initializing_dump
865       && dump_file
866       && graph_dump_format != no_graph
867       && (curr_properties & (PROP_cfg | PROP_rtl)) == (PROP_cfg | PROP_rtl))
868     {
869       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
870       dump_flags |= TDF_GRAPH;
871       clean_graph_dump_file (dump_file_name);
872     }
873
874   /* Run post-pass cleanup and verification.  */
875   execute_todo (pass->todo_flags_finish);
876
877   /* Flush and close dump file.  */
878   if (dump_file_name)
879     {
880       free ((char *) dump_file_name);
881       dump_file_name = NULL;
882     }
883   if (dump_file)
884     {
885       dump_end (pass->static_pass_number, dump_file);
886       dump_file = NULL;
887     }
888
889   return true;
890 }
891
892 void
893 execute_pass_list (struct tree_opt_pass *pass)
894 {
895   do
896     {
897       if (execute_one_pass (pass) && pass->sub)
898         execute_pass_list (pass->sub);
899       pass = pass->next;
900     }
901   while (pass);
902 }
903
904 /* Same as execute_pass_list but assume that subpasses of IPA passes
905    are local passes.  */
906 void
907 execute_ipa_pass_list (struct tree_opt_pass *pass)
908 {
909   do
910     {
911       if (execute_one_pass (pass) && pass->sub)
912         {
913           struct cgraph_node *node;
914           for (node = cgraph_nodes; node; node = node->next)
915             if (node->analyzed)
916               {
917                 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
918                 current_function_decl = node->decl;
919                 execute_pass_list (pass->sub);
920                 free_dominance_info (CDI_DOMINATORS);
921                 free_dominance_info (CDI_POST_DOMINATORS);
922                 current_function_decl = NULL;
923                 pop_cfun ();
924                 ggc_collect ();
925               }
926         }
927       pass = pass->next;
928     }
929   while (pass);
930 }