OSDN Git Service

48f78b42be8d2b8748d8f1750eb5fb661e60c186
[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, 2007
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
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 #include "df.h"
86 #include "predict.h"
87
88 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
89 #include "dwarf2out.h"
90 #endif
91
92 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
93 #include "dbxout.h"
94 #endif
95
96 #ifdef SDB_DEBUGGING_INFO
97 #include "sdbout.h"
98 #endif
99
100 #ifdef XCOFF_DEBUGGING_INFO
101 #include "xcoffout.h"           /* Needed for external data
102                                    declarations for e.g. AIX 4.x.  */
103 #endif
104
105 /* This is used for debugging.  It allows the current pass to printed
106    from anywhere in compilation.  */
107 struct tree_opt_pass *current_pass;
108
109 /* Call from anywhere to find out what pass this is.  Useful for
110    printing out debugging information deep inside an service
111    routine.  */
112 void
113 print_current_pass (FILE *file)
114 {
115   if (current_pass)
116     fprintf (file, "current pass = %s (%d)\n", 
117              current_pass->name, current_pass->static_pass_number);
118   else
119     fprintf (file, "no current pass.\n");
120 }
121
122
123 /* Call from the debugger to get the current pass name.  */
124 void
125 debug_pass (void)
126 {
127   print_current_pass (stderr);
128
129
130
131
132 /* Global variables used to communicate with passes.  */
133 int dump_flags;
134 bool in_gimple_form;
135 bool first_pass_instance;
136
137
138 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
139    and TYPE_DECL nodes.
140
141    This does nothing for local (non-static) variables, unless the
142    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
143    that case, or if the variable is not an automatic, it sets up the
144    RTL and outputs any assembler code (label definition, storage
145    allocation and initialization).
146
147    DECL is the declaration.  TOP_LEVEL is nonzero
148    if this declaration is not within a function.  */
149
150 void
151 rest_of_decl_compilation (tree decl,
152                           int top_level,
153                           int at_end)
154 {
155   /* We deferred calling assemble_alias so that we could collect
156      other attributes such as visibility.  Emit the alias now.  */
157   {
158     tree alias;
159     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
160     if (alias)
161       {
162         alias = TREE_VALUE (TREE_VALUE (alias));
163         alias = get_identifier (TREE_STRING_POINTER (alias));
164         assemble_alias (decl, alias);
165       }
166   }
167
168   /* Can't defer this, because it needs to happen before any
169      later function definitions are processed.  */
170   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
171     make_decl_rtl (decl);
172
173   /* Forward declarations for nested functions are not "external",
174      but we need to treat them as if they were.  */
175   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
176       || TREE_CODE (decl) == FUNCTION_DECL)
177     {
178       timevar_push (TV_VARCONST);
179
180       /* Don't output anything when a tentative file-scope definition
181          is seen.  But at end of compilation, do output code for them.
182
183          We do output all variables when unit-at-a-time is active and rely on
184          callgraph code to defer them except for forward declarations
185          (see gcc.c-torture/compile/920624-1.c) */
186       if ((at_end
187            || !DECL_DEFER_OUTPUT (decl)
188            || DECL_INITIAL (decl))
189           && !DECL_EXTERNAL (decl))
190         {
191           if (TREE_CODE (decl) != FUNCTION_DECL)
192             varpool_finalize_decl (decl);
193           else
194             assemble_variable (decl, top_level, at_end, 0);
195         }
196
197 #ifdef ASM_FINISH_DECLARE_OBJECT
198       if (decl == last_assemble_variable_decl)
199         {
200           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
201                                      top_level, at_end);
202         }
203 #endif
204
205       timevar_pop (TV_VARCONST);
206     }
207   else if (TREE_CODE (decl) == TYPE_DECL
208            /* Like in rest_of_type_compilation, avoid confusing the debug
209               information machinery when there are errors.  */
210            && !(sorrycount || errorcount))
211     {
212       timevar_push (TV_SYMOUT);
213       debug_hooks->type_decl (decl, !top_level);
214       timevar_pop (TV_SYMOUT);
215     }
216
217   /* Let cgraph know about the existence of variables.  */
218   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
219     varpool_node (decl);
220 }
221
222 /* Called after finishing a record, union or enumeral type.  */
223
224 void
225 rest_of_type_compilation (tree type, int toplev)
226 {
227   /* Avoid confusing the debug information machinery when there are
228      errors.  */
229   if (errorcount != 0 || sorrycount != 0)
230     return;
231
232   timevar_push (TV_SYMOUT);
233   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
234   timevar_pop (TV_SYMOUT);
235 }
236
237 \f
238
239 void
240 finish_optimization_passes (void)
241 {
242   enum tree_dump_index i;
243   struct dump_file_info *dfi;
244   char *name;
245
246   timevar_push (TV_DUMP);
247   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
248     {
249       dump_file = dump_begin (pass_profile.static_pass_number, NULL);
250       end_branch_prob ();
251       if (dump_file)
252         dump_end (pass_profile.static_pass_number, dump_file);
253     }
254
255   if (optimize > 0)
256     {
257       dump_file = dump_begin (pass_combine.static_pass_number, NULL);
258       if (dump_file)
259         {
260           dump_combine_total_stats (dump_file);
261           dump_end (pass_combine.static_pass_number, dump_file);
262         }
263     }
264
265   /* Do whatever is necessary to finish printing the graphs.  */
266   if (graph_dump_format != no_graph)
267     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
268       if (dump_initialized_p (i)
269           && (dfi->flags & TDF_GRAPH) != 0
270           && (name = get_dump_file_name (i)) != NULL)
271         {
272           finish_graph_dump_file (name);
273           free (name);
274         }
275
276   timevar_pop (TV_DUMP);
277 }
278
279 static bool
280 gate_rest_of_compilation (void)
281 {
282   /* Early return if there were errors.  We can run afoul of our
283      consistency checks, and there's not really much point in fixing them.  */
284   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
285 }
286
287 struct tree_opt_pass pass_rest_of_compilation =
288 {
289   NULL,                                 /* name */
290   gate_rest_of_compilation,             /* gate */
291   NULL,                                 /* execute */
292   NULL,                                 /* sub */
293   NULL,                                 /* next */
294   0,                                    /* static_pass_number */
295   TV_REST_OF_COMPILATION,               /* tv_id */
296   PROP_rtl,                             /* properties_required */
297   0,                                    /* properties_provided */
298   0,                                    /* properties_destroyed */
299   0,                                    /* todo_flags_start */
300   TODO_ggc_collect,                     /* todo_flags_finish */
301   0                                     /* letter */
302 };
303
304 static bool
305 gate_postreload (void)
306 {
307   return reload_completed;
308 }
309
310 struct tree_opt_pass pass_postreload =
311 {
312   NULL,                                 /* name */
313   gate_postreload,                      /* gate */
314   NULL,                                 /* execute */
315   NULL,                                 /* sub */
316   NULL,                                 /* next */
317   0,                                    /* static_pass_number */
318   0,                                    /* tv_id */
319   PROP_rtl,                             /* properties_required */
320   0,                                    /* properties_provided */
321   0,                                    /* properties_destroyed */
322   0,                                    /* todo_flags_start */
323   TODO_ggc_collect | TODO_verify_rtl_sharing, /* todo_flags_finish */
324   0                                     /* letter */
325 };
326
327
328
329 /* The root of the compilation pass tree, once constructed.  */
330 struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
331
332 /* Iterate over the pass tree allocating dump file numbers.  We want
333    to do this depth first, and independent of whether the pass is
334    enabled or not.  */
335
336 static void
337 register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int properties)
338 {
339   char *dot_name, *flag_name, *glob_name;
340   const char *prefix;
341   char num[10];
342   int flags;
343
344   /* See below in next_pass_1.  */
345   num[0] = '\0';
346   if (pass->static_pass_number != -1)
347     sprintf (num, "%d", ((int) pass->static_pass_number < 0
348                          ? 1 : pass->static_pass_number));
349
350   dot_name = concat (".", pass->name, num, NULL);
351   if (ipa)
352     prefix = "ipa-", flags = TDF_IPA;
353   else if (properties & PROP_trees)
354     prefix = "tree-", flags = TDF_TREE;
355   else
356     prefix = "rtl-", flags = TDF_RTL;
357
358   flag_name = concat (prefix, pass->name, num, NULL);
359   glob_name = concat (prefix, pass->name, NULL);
360   pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
361                                             flags, pass->letter);
362 }
363
364 /* Recursive worker function for register_dump_files.  */
365
366 static int 
367 register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)
368 {
369   do
370     {
371       int new_properties = (properties | pass->properties_provided)
372                            & ~pass->properties_destroyed;
373
374       if (pass->name)
375         register_one_dump_file (pass, ipa, new_properties);
376
377       if (pass->sub)
378         new_properties = register_dump_files_1 (pass->sub, false,
379                                                 new_properties);
380
381       /* If we have a gate, combine the properties that we could have with
382          and without the pass being examined.  */
383       if (pass->gate)
384         properties &= new_properties;
385       else
386         properties = new_properties;
387
388       pass = pass->next;
389     }
390   while (pass);
391
392   return properties;
393 }
394
395 /* Register the dump files for the pipeline starting at PASS.  IPA is
396    true if the pass is inter-procedural, and PROPERTIES reflects the
397    properties that are guaranteed to be available at the beginning of
398    the pipeline.  */
399
400 static void 
401 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
402 {
403   pass->properties_required |= properties;
404   register_dump_files_1 (pass, ipa, properties);
405 }
406
407 /* Add a pass to the pass list. Duplicate the pass if it's already
408    in the list.  */
409
410 static struct tree_opt_pass **
411 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
412 {
413   /* A nonzero static_pass_number indicates that the
414      pass is already in the list.  */
415   if (pass->static_pass_number)
416     {
417       struct tree_opt_pass *new;
418
419       new = xmalloc (sizeof (*new));
420       memcpy (new, pass, sizeof (*new));
421       new->next = NULL;
422
423       new->todo_flags_start &= ~TODO_mark_first_instance;
424
425       /* Indicate to register_dump_files that this pass has duplicates,
426          and so it should rename the dump file.  The first instance will
427          be -1, and be number of duplicates = -static_pass_number - 1.
428          Subsequent instances will be > 0 and just the duplicate number.  */
429       if (pass->name)
430         {
431           pass->static_pass_number -= 1;
432           new->static_pass_number = -pass->static_pass_number;
433         }
434       
435       *list = new;
436     }
437   else
438     {
439       pass->todo_flags_start |= TODO_mark_first_instance;
440       pass->static_pass_number = -1;
441       *list = pass;
442     }  
443   
444   return &(*list)->next;
445           
446 }
447
448
449 /* Construct the pass tree.  The sequencing of passes is driven by
450    the cgraph routines:
451
452    cgraph_finalize_compilation_unit ()
453        for each node N in the cgraph
454            cgraph_analyze_function (N)
455                cgraph_lower_function (N) -> all_lowering_passes
456
457    If we are optimizing, cgraph_optimize is then invoked:
458
459    cgraph_optimize ()
460        ipa_passes ()                    -> all_ipa_passes
461        cgraph_expand_all_functions ()
462            for each node N in the cgraph
463                cgraph_expand_function (N)
464                   tree_rest_of_compilation (DECL (N))  -> all_passes
465 */
466
467 void
468 init_optimization_passes (void)
469 {
470   struct tree_opt_pass **p;
471
472 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
473
474  /* All passes needed to lower the function into shape optimizers can
475     operate on.  These passes are always run first on the function, but
476     backend might produce already lowered functions that are not processed
477     by these passes.  */
478   p = &all_lowering_passes;
479   NEXT_PASS (pass_remove_useless_stmts);
480   NEXT_PASS (pass_mudflap_1);
481   NEXT_PASS (pass_lower_omp);
482   NEXT_PASS (pass_lower_cf);
483   NEXT_PASS (pass_refactor_eh);
484   NEXT_PASS (pass_lower_eh);
485   NEXT_PASS (pass_build_cfg);
486   NEXT_PASS (pass_lower_complex_O0);
487   NEXT_PASS (pass_lower_vector);
488   NEXT_PASS (pass_warn_function_return);
489   NEXT_PASS (pass_build_cgraph_edges);
490   NEXT_PASS (pass_inline_parameters);
491   *p = NULL;
492
493   /* Interprocedural optimization passes. 
494      All these passes are ignored in -fno-unit-at-a-time
495      except for subpasses of early_local_passes.  */
496   p = &all_ipa_passes;
497   NEXT_PASS (pass_ipa_function_and_variable_visibility);
498   NEXT_PASS (pass_ipa_early_inline);
499     {
500       struct tree_opt_pass **p = &pass_ipa_early_inline.sub;
501       NEXT_PASS (pass_early_inline);
502       NEXT_PASS (pass_inline_parameters);
503       NEXT_PASS (pass_rebuild_cgraph_edges);
504     }
505   NEXT_PASS (pass_early_local_passes);
506     {
507       struct tree_opt_pass **p = &pass_early_local_passes.sub;
508       NEXT_PASS (pass_tree_profile);
509       NEXT_PASS (pass_cleanup_cfg);
510       NEXT_PASS (pass_init_datastructures);
511       NEXT_PASS (pass_expand_omp);
512       NEXT_PASS (pass_all_early_optimizations);
513         {
514           struct tree_opt_pass **p = &pass_all_early_optimizations.sub;
515           NEXT_PASS (pass_referenced_vars);
516           NEXT_PASS (pass_reset_cc_flags);
517           NEXT_PASS (pass_build_ssa);
518           NEXT_PASS (pass_expand_omp_ssa);
519           NEXT_PASS (pass_early_warn_uninitialized);
520           NEXT_PASS (pass_rebuild_cgraph_edges);
521           NEXT_PASS (pass_early_inline);
522           NEXT_PASS (pass_cleanup_cfg);
523           NEXT_PASS (pass_rename_ssa_copies);
524           NEXT_PASS (pass_ccp);
525           NEXT_PASS (pass_forwprop);
526           NEXT_PASS (pass_update_address_taken);
527           NEXT_PASS (pass_simple_dse);
528           NEXT_PASS (pass_sra_early);
529           NEXT_PASS (pass_copy_prop);
530           NEXT_PASS (pass_merge_phi);
531           NEXT_PASS (pass_dce);
532           NEXT_PASS (pass_update_address_taken);
533           NEXT_PASS (pass_simple_dse);
534           NEXT_PASS (pass_tail_recursion);
535           NEXT_PASS (pass_profile);
536           NEXT_PASS (pass_release_ssa_names);
537         }
538       NEXT_PASS (pass_rebuild_cgraph_edges);
539       NEXT_PASS (pass_inline_parameters);
540     }
541   NEXT_PASS (pass_ipa_increase_alignment);
542   NEXT_PASS (pass_ipa_matrix_reorg);
543   NEXT_PASS (pass_ipa_cp);
544   NEXT_PASS (pass_ipa_inline);
545   NEXT_PASS (pass_ipa_reference);
546   NEXT_PASS (pass_ipa_pure_const); 
547   NEXT_PASS (pass_ipa_type_escape);
548   NEXT_PASS (pass_ipa_pta);
549   NEXT_PASS (pass_ipa_struct_reorg);  
550   *p = NULL;
551
552   /* These passes are run after IPA passes on every function that is being
553      output to the assembler file.  */
554   p = &all_passes;
555   NEXT_PASS (pass_apply_inline);
556   NEXT_PASS (pass_all_optimizations);
557     {
558       struct tree_opt_pass **p = &pass_all_optimizations.sub;
559       NEXT_PASS (pass_create_structure_vars);
560       NEXT_PASS (pass_return_slot);
561       NEXT_PASS (pass_rename_ssa_copies);
562
563       /* Initial scalar cleanups.  */
564       NEXT_PASS (pass_ccp);
565       NEXT_PASS (pass_phiprop);
566       NEXT_PASS (pass_fre);
567       NEXT_PASS (pass_dce);
568       NEXT_PASS (pass_forwprop);
569       NEXT_PASS (pass_copy_prop);
570       NEXT_PASS (pass_merge_phi);
571       NEXT_PASS (pass_vrp);
572       NEXT_PASS (pass_dce);
573       NEXT_PASS (pass_cselim);
574       NEXT_PASS (pass_dominator);
575       /* The only const/copy propagation opportunities left after
576          DOM should be due to degenerate PHI nodes.  So rather than
577          run the full propagators, run a specialized pass which
578          only examines PHIs to discover const/copy propagation
579          opportunities.  */
580       NEXT_PASS (pass_phi_only_cprop);
581       NEXT_PASS (pass_tree_ifcombine);
582       NEXT_PASS (pass_phiopt);
583       NEXT_PASS (pass_tail_recursion);
584       NEXT_PASS (pass_ch);
585       NEXT_PASS (pass_stdarg);
586       NEXT_PASS (pass_lower_complex);
587       NEXT_PASS (pass_sra);
588       NEXT_PASS (pass_rename_ssa_copies);
589       NEXT_PASS (pass_dominator);
590
591       /* The only const/copy propagation opportunities left after
592          DOM should be due to degenerate PHI nodes.  So rather than
593          run the full propagators, run a specialized pass which
594          only examines PHIs to discover const/copy propagation
595          opportunities.  */
596       NEXT_PASS (pass_phi_only_cprop);
597
598       NEXT_PASS (pass_reassoc);
599       NEXT_PASS (pass_dce);
600       NEXT_PASS (pass_dse);
601       NEXT_PASS (pass_forwprop);
602       NEXT_PASS (pass_phiopt);
603       NEXT_PASS (pass_object_sizes);
604       NEXT_PASS (pass_store_ccp);
605       NEXT_PASS (pass_copy_prop);
606       NEXT_PASS (pass_fold_builtins);
607       NEXT_PASS (pass_cse_sincos);
608       NEXT_PASS (pass_split_crit_edges);
609       NEXT_PASS (pass_pre);
610       NEXT_PASS (pass_sink_code);
611       NEXT_PASS (pass_tree_loop);
612         {
613           struct tree_opt_pass **p = &pass_tree_loop.sub;
614           NEXT_PASS (pass_tree_loop_init);
615           NEXT_PASS (pass_copy_prop);
616           NEXT_PASS (pass_dce_loop);
617           NEXT_PASS (pass_lim);
618           NEXT_PASS (pass_predcom);
619           NEXT_PASS (pass_tree_unswitch);
620           NEXT_PASS (pass_scev_cprop);
621           NEXT_PASS (pass_empty_loop);
622           NEXT_PASS (pass_record_bounds);
623           NEXT_PASS (pass_check_data_deps);
624           NEXT_PASS (pass_linear_transform);
625           NEXT_PASS (pass_iv_canon);
626           NEXT_PASS (pass_if_conversion);
627           NEXT_PASS (pass_vectorize);
628             {
629               struct tree_opt_pass **p = &pass_vectorize.sub;
630               NEXT_PASS (pass_lower_vector_ssa);
631               NEXT_PASS (pass_dce_loop);
632             }
633           NEXT_PASS (pass_complete_unroll);
634           NEXT_PASS (pass_parallelize_loops);
635           NEXT_PASS (pass_loop_prefetch);
636           NEXT_PASS (pass_iv_optimize);
637           NEXT_PASS (pass_tree_loop_done);
638         }
639       NEXT_PASS (pass_cse_reciprocals);
640       NEXT_PASS (pass_convert_to_rsqrt);
641       NEXT_PASS (pass_reassoc);
642       NEXT_PASS (pass_vrp);
643       NEXT_PASS (pass_dominator);
644       
645       /* The only const/copy propagation opportunities left after
646          DOM should be due to degenerate PHI nodes.  So rather than
647          run the full propagators, run a specialized pass which
648          only examines PHIs to discover const/copy propagation
649          opportunities.  */
650       NEXT_PASS (pass_phi_only_cprop);
651
652       NEXT_PASS (pass_cd_dce);
653       NEXT_PASS (pass_tracer);
654
655       /* FIXME: If DCE is not run before checking for uninitialized uses,
656          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
657          However, this also causes us to misdiagnose cases that should be
658          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
659          
660          To fix the false positives in uninit-5.c, we would have to
661          account for the predicates protecting the set and the use of each
662          variable.  Using a representation like Gated Single Assignment
663          may help.  */
664       NEXT_PASS (pass_late_warn_uninitialized);
665       NEXT_PASS (pass_dse);
666       NEXT_PASS (pass_forwprop);
667       NEXT_PASS (pass_phiopt);
668       NEXT_PASS (pass_tail_calls);
669       NEXT_PASS (pass_rename_ssa_copies);
670       NEXT_PASS (pass_uncprop);
671       NEXT_PASS (pass_del_ssa);
672       NEXT_PASS (pass_nrv);
673       NEXT_PASS (pass_mark_used_blocks);
674       NEXT_PASS (pass_cleanup_cfg_post_optimizing);
675     }
676   NEXT_PASS (pass_warn_function_noreturn);
677   NEXT_PASS (pass_free_datastructures);
678   NEXT_PASS (pass_mudflap_2);
679   NEXT_PASS (pass_free_cfg_annotations);
680   NEXT_PASS (pass_expand);
681   NEXT_PASS (pass_rest_of_compilation);
682     {
683       struct tree_opt_pass **p = &pass_rest_of_compilation.sub;
684       NEXT_PASS (pass_init_function);
685       NEXT_PASS (pass_jump);
686       NEXT_PASS (pass_rtl_eh);
687       NEXT_PASS (pass_initial_value_sets);
688       NEXT_PASS (pass_unshare_all_rtl);
689       NEXT_PASS (pass_instantiate_virtual_regs);
690       NEXT_PASS (pass_into_cfg_layout_mode);
691       NEXT_PASS (pass_jump2);
692       NEXT_PASS (pass_lower_subreg);
693       NEXT_PASS (pass_df_initialize_opt);
694       NEXT_PASS (pass_cse);
695       NEXT_PASS (pass_rtl_fwprop);
696       NEXT_PASS (pass_gcse);
697       NEXT_PASS (pass_rtl_ifcvt);
698       /* Perform loop optimizations.  It might be better to do them a bit
699          sooner, but we want the profile feedback to work more
700          efficiently.  */
701       NEXT_PASS (pass_loop2);
702         {
703           struct tree_opt_pass **p = &pass_loop2.sub;
704           NEXT_PASS (pass_rtl_loop_init);
705           NEXT_PASS (pass_rtl_move_loop_invariants);
706           NEXT_PASS (pass_rtl_unswitch);
707           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
708           NEXT_PASS (pass_rtl_doloop);
709           NEXT_PASS (pass_rtl_loop_done);
710           *p = NULL;
711         }
712       NEXT_PASS (pass_web);
713       NEXT_PASS (pass_jump_bypass);
714       NEXT_PASS (pass_cse2);
715       NEXT_PASS (pass_rtl_dse1);
716       NEXT_PASS (pass_rtl_fwprop_addr);
717       NEXT_PASS (pass_regclass_init);
718       NEXT_PASS (pass_inc_dec);
719       NEXT_PASS (pass_initialize_regs);
720       NEXT_PASS (pass_outof_cfg_layout_mode);
721       NEXT_PASS (pass_ud_rtl_dce);
722       NEXT_PASS (pass_combine);
723       NEXT_PASS (pass_if_after_combine);
724       NEXT_PASS (pass_partition_blocks);
725       NEXT_PASS (pass_regmove);
726       NEXT_PASS (pass_split_all_insns);
727       NEXT_PASS (pass_lower_subreg2);
728       NEXT_PASS (pass_df_initialize_no_opt);
729       NEXT_PASS (pass_stack_ptr_mod);
730       NEXT_PASS (pass_mode_switching);
731       NEXT_PASS (pass_see);
732       NEXT_PASS (pass_match_asm_constraints);
733       NEXT_PASS (pass_sms);
734       NEXT_PASS (pass_sched);
735       NEXT_PASS (pass_subregs_of_mode_init);
736       NEXT_PASS (pass_local_alloc);
737       NEXT_PASS (pass_global_alloc);
738       NEXT_PASS (pass_subregs_of_mode_finish);
739       NEXT_PASS (pass_postreload);
740         {
741           struct tree_opt_pass **p = &pass_postreload.sub;
742           NEXT_PASS (pass_postreload_cse);
743           NEXT_PASS (pass_gcse2);
744           NEXT_PASS (pass_split_after_reload);
745           NEXT_PASS (pass_branch_target_load_optimize1);
746           NEXT_PASS (pass_thread_prologue_and_epilogue);
747           NEXT_PASS (pass_rtl_dse2);
748           NEXT_PASS (pass_rtl_seqabstr);
749           NEXT_PASS (pass_stack_adjustments);
750           NEXT_PASS (pass_peephole2);
751           NEXT_PASS (pass_if_after_reload);
752           NEXT_PASS (pass_regrename);
753           NEXT_PASS (pass_cprop_hardreg);
754           NEXT_PASS (pass_fast_rtl_dce);
755           NEXT_PASS (pass_reorder_blocks);
756           NEXT_PASS (pass_branch_target_load_optimize2);
757           NEXT_PASS (pass_leaf_regs);
758           NEXT_PASS (pass_split_before_sched2);
759           NEXT_PASS (pass_sched2);
760           NEXT_PASS (pass_stack_regs);
761             {
762               struct tree_opt_pass **p = &pass_stack_regs.sub;
763               NEXT_PASS (pass_split_before_regstack);
764               NEXT_PASS (pass_stack_regs_run);
765             }
766           NEXT_PASS (pass_compute_alignments);
767           NEXT_PASS (pass_duplicate_computed_gotos);
768           NEXT_PASS (pass_variable_tracking);
769           NEXT_PASS (pass_free_cfg);
770           NEXT_PASS (pass_machine_reorg);
771           NEXT_PASS (pass_cleanup_barriers);
772           NEXT_PASS (pass_delay_slots);
773           NEXT_PASS (pass_split_for_shorten_branches);
774           NEXT_PASS (pass_convert_to_eh_region_ranges);
775           NEXT_PASS (pass_shorten_branches);
776           NEXT_PASS (pass_set_nothrow_function_flags);
777           NEXT_PASS (pass_final);
778         }
779       NEXT_PASS (pass_df_finish);
780     }
781   NEXT_PASS (pass_clean_state);
782   *p = NULL;
783
784 #undef NEXT_PASS
785
786   /* Register the passes with the tree dump code.  */
787   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
788   all_lowering_passes->todo_flags_start |= TODO_set_props;
789   register_dump_files (all_ipa_passes, true,
790                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
791                        | PROP_cfg);
792   register_dump_files (all_passes, false,
793                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
794                        | PROP_cfg);
795 }
796
797 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
798    function CALLBACK for every function in the call graph.  Otherwise,
799    call CALLBACK on the current function.  */ 
800
801 static void
802 do_per_function (void (*callback) (void *data), void *data)
803 {
804   if (current_function_decl)
805     callback (data);
806   else
807     {
808       struct cgraph_node *node;
809       for (node = cgraph_nodes; node; node = node->next)
810         if (node->analyzed)
811           {
812             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
813             current_function_decl = node->decl;
814             callback (data);
815             free_dominance_info (CDI_DOMINATORS);
816             free_dominance_info (CDI_POST_DOMINATORS);
817             current_function_decl = NULL;
818             pop_cfun ();
819             ggc_collect ();
820           }
821     }
822 }
823
824 /* Because inlining might remove no-longer reachable nodes, we need to
825    keep the array visible to garbage collector to avoid reading collected
826    out nodes.  */
827 static int nnodes;
828 static GTY ((length ("nnodes"))) struct cgraph_node **order;
829
830 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
831    function CALLBACK for every function in the call graph.  Otherwise,
832    call CALLBACK on the current function.  */ 
833
834 static void
835 do_per_function_toporder (void (*callback) (void *data), void *data)
836 {
837   int i;
838
839   if (current_function_decl)
840     callback (data);
841   else
842     {
843       gcc_assert (!order);
844       order = ggc_alloc (sizeof (*order) * cgraph_n_nodes);
845       nnodes = cgraph_postorder (order);
846       for (i = nnodes - 1; i >= 0; i--)
847         {
848           struct cgraph_node *node = order[i];
849
850           /* Allow possibly removed nodes to be garbage collected.  */
851           order[i] = NULL;
852           if (node->analyzed && (node->needed || node->reachable))
853             {
854               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
855               current_function_decl = node->decl;
856               callback (data);
857               free_dominance_info (CDI_DOMINATORS);
858               free_dominance_info (CDI_POST_DOMINATORS);
859               current_function_decl = NULL;
860               pop_cfun ();
861               ggc_collect ();
862             }
863         }
864     }
865   ggc_free (order);
866   order = NULL;
867   nnodes = 0;
868 }
869
870 /* Perform all TODO actions that ought to be done on each function.  */
871
872 static void
873 execute_function_todo (void *data)
874 {
875   unsigned int flags = (size_t)data;
876   if (cfun->curr_properties & PROP_ssa)
877     flags |= TODO_verify_ssa;
878   flags &= ~cfun->last_verified;
879   if (!flags)
880     return;
881   
882   /* Always cleanup the CFG before trying to update SSA.  */
883   if (flags & TODO_cleanup_cfg)
884     {
885       bool cleanup = cleanup_tree_cfg ();
886
887       if (cleanup && (cfun->curr_properties & PROP_ssa))
888         flags |= TODO_remove_unused_locals;
889         
890       /* When cleanup_tree_cfg merges consecutive blocks, it may
891          perform some simplistic propagation when removing single
892          valued PHI nodes.  This propagation may, in turn, cause the
893          SSA form to become out-of-date (see PR 22037).  So, even
894          if the parent pass had not scheduled an SSA update, we may
895          still need to do one.  */
896       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
897         flags |= TODO_update_ssa;
898     }
899
900   if (flags & TODO_update_ssa_any)
901     {
902       unsigned update_flags = flags & TODO_update_ssa_any;
903       update_ssa (update_flags);
904       cfun->last_verified &= ~TODO_verify_ssa;
905     }
906   
907   if (flags & TODO_rebuild_alias)
908     {
909       compute_may_aliases ();
910       cfun->curr_properties |= PROP_alias;
911     }
912   
913   if (flags & TODO_remove_unused_locals)
914     remove_unused_locals ();
915
916   if ((flags & TODO_dump_func)
917       && dump_file && current_function_decl)
918     {
919       if (cfun->curr_properties & PROP_trees)
920         dump_function_to_file (current_function_decl,
921                                dump_file, dump_flags);
922       else
923         {
924           if (dump_flags & TDF_SLIM)
925             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
926           else if ((cfun->curr_properties & PROP_cfg)
927                    && (dump_flags & TDF_BLOCKS))
928             print_rtl_with_bb (dump_file, get_insns ());
929           else
930             print_rtl (dump_file, get_insns ());
931
932           if (cfun->curr_properties & PROP_cfg
933               && graph_dump_format != no_graph
934               && (dump_flags & TDF_GRAPH))
935             print_rtl_graph_with_bb (dump_file_name, get_insns ());
936         }
937
938       /* Flush the file.  If verification fails, we won't be able to
939          close the file before aborting.  */
940       fflush (dump_file);
941     }
942
943   if (flags & TODO_rebuild_frequencies)
944     {
945       if (profile_status == PROFILE_GUESSED)
946         {
947           loop_optimizer_init (0);
948           add_noreturn_fake_exit_edges ();
949           mark_irreducible_loops ();
950           connect_infinite_loops_to_exit ();
951           estimate_bb_frequencies ();
952           remove_fake_exit_edges ();
953           loop_optimizer_finalize ();
954         }
955       else if (profile_status == PROFILE_READ)
956         counts_to_freqs ();
957       else
958         gcc_unreachable ();
959     }
960
961 #if defined ENABLE_CHECKING
962   if (flags & TODO_verify_ssa)
963     verify_ssa (true);
964   if (flags & TODO_verify_flow)
965     verify_flow_info ();
966   if (flags & TODO_verify_stmts)
967     verify_stmts ();
968   if (flags & TODO_verify_loops)
969     verify_loop_closed_ssa ();
970   if (flags & TODO_verify_rtl_sharing)
971     verify_rtl_sharing ();
972 #endif
973
974   cfun->last_verified = flags & TODO_verify_all;
975 }
976
977 /* Perform all TODO actions.  */
978 static void
979 execute_todo (unsigned int flags)
980 {
981 #if defined ENABLE_CHECKING
982   if (need_ssa_update_p ())
983     gcc_assert (flags & TODO_update_ssa_any);
984 #endif
985
986   /* Inform the pass whether it is the first time it is run.  */
987   first_pass_instance = (flags & TODO_mark_first_instance) != 0;
988
989   do_per_function (execute_function_todo, (void *)(size_t) flags);
990
991   /* Always remove functions just as before inlining: IPA passes might be
992      interested to see bodies of extern inline functions that are not inlined
993      to analyze side effects.  The full removal is done just at the end
994      of IPA pass queue.  */
995   if (flags & TODO_remove_functions)
996     cgraph_remove_unreachable_nodes (true, dump_file);
997
998   if ((flags & TODO_dump_cgraph)
999       && dump_file && !current_function_decl)
1000     {
1001       dump_cgraph (dump_file);
1002       /* Flush the file.  If verification fails, we won't be able to
1003          close the file before aborting.  */
1004       fflush (dump_file);
1005     }
1006
1007   if (flags & TODO_ggc_collect)
1008     {
1009       ggc_collect ();
1010     }
1011
1012   /* Now that the dumping has been done, we can get rid of the optional 
1013      df problems.  */
1014   if (flags & TODO_df_finish)
1015     df_finish_pass ((flags & TODO_df_verify) != 0);
1016 }
1017
1018 /* Verify invariants that should hold between passes.  This is a place
1019    to put simple sanity checks.  */
1020
1021 static void
1022 verify_interpass_invariants (void)
1023 {
1024 #ifdef ENABLE_CHECKING
1025   gcc_assert (!fold_deferring_overflow_warnings_p ());
1026 #endif
1027 }
1028
1029 /* Clear the last verified flag.  */
1030
1031 static void
1032 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1033 {
1034   cfun->last_verified = 0;
1035 }
1036
1037 /* Helper function. Verify that the properties has been turn into the
1038    properties expected by the pass.  */
1039
1040 #ifdef ENABLE_CHECKING
1041 static void
1042 verify_curr_properties (void *data)
1043 {
1044   unsigned int props = (size_t)data;
1045   gcc_assert ((cfun->curr_properties & props) == props);
1046 }
1047 #endif
1048
1049 /* After executing the pass, apply expected changes to the function
1050    properties. */
1051 static void
1052 update_properties_after_pass (void *data)
1053 {
1054   struct tree_opt_pass *pass = data;
1055   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1056                            & ~pass->properties_destroyed;
1057 }
1058
1059 static bool
1060 execute_one_pass (struct tree_opt_pass *pass)
1061 {
1062   bool initializing_dump;
1063   unsigned int todo_after = 0;
1064
1065   current_pass = pass;
1066   /* See if we're supposed to run this pass.  */
1067   if (pass->gate && !pass->gate ())
1068     return false;
1069
1070   if (!quiet_flag && !cfun)
1071     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1072
1073   if (pass->todo_flags_start & TODO_set_props)
1074     cfun->curr_properties = pass->properties_required;
1075
1076   /* Note that the folders should only create gimple expressions.
1077      This is a hack until the new folder is ready.  */
1078   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1079
1080   /* Run pre-pass verification.  */
1081   execute_todo (pass->todo_flags_start);
1082
1083 #ifdef ENABLE_CHECKING
1084   do_per_function (verify_curr_properties,
1085                    (void *)(size_t)pass->properties_required);
1086 #endif
1087
1088   /* If a dump file name is present, open it if enabled.  */
1089   if (pass->static_pass_number != -1)
1090     {
1091       initializing_dump = !dump_initialized_p (pass->static_pass_number);
1092       dump_file_name = get_dump_file_name (pass->static_pass_number);
1093       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1094       if (dump_file && current_function_decl)
1095         {
1096           const char *dname, *aname;
1097           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1098           aname = (IDENTIFIER_POINTER
1099                    (DECL_ASSEMBLER_NAME (current_function_decl)));
1100           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1101              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1102              ? " (hot)"
1103              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1104              ? " (unlikely executed)"
1105              : "");
1106         }
1107     }
1108   else
1109     initializing_dump = false;
1110
1111   /* If a timevar is present, start it.  */
1112   if (pass->tv_id)
1113     timevar_push (pass->tv_id);
1114
1115   /* Do it!  */
1116   if (pass->execute)
1117     {
1118       todo_after = pass->execute ();
1119       do_per_function (clear_last_verified, NULL);
1120     }
1121
1122   /* Stop timevar.  */
1123   if (pass->tv_id)
1124     timevar_pop (pass->tv_id);
1125
1126   do_per_function (update_properties_after_pass, pass);
1127
1128   if (initializing_dump
1129       && dump_file
1130       && graph_dump_format != no_graph
1131       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1132           == (PROP_cfg | PROP_rtl))
1133     {
1134       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1135       dump_flags |= TDF_GRAPH;
1136       clean_graph_dump_file (dump_file_name);
1137     }
1138
1139   /* Run post-pass cleanup and verification.  */
1140   execute_todo (todo_after | pass->todo_flags_finish);
1141   verify_interpass_invariants ();
1142
1143   if (!current_function_decl)
1144     cgraph_process_new_functions ();
1145
1146   /* Flush and close dump file.  */
1147   if (dump_file_name)
1148     {
1149       free (CONST_CAST (char *, dump_file_name));
1150       dump_file_name = NULL;
1151     }
1152
1153   if (dump_file)
1154     {
1155       dump_end (pass->static_pass_number, dump_file);
1156       dump_file = NULL;
1157     }
1158
1159   current_pass = NULL;
1160   /* Reset in_gimple_form to not break non-unit-at-a-time mode.  */
1161   in_gimple_form = false;
1162
1163   return true;
1164 }
1165
1166 void
1167 execute_pass_list (struct tree_opt_pass *pass)
1168 {
1169   do
1170     {
1171       if (execute_one_pass (pass) && pass->sub)
1172         execute_pass_list (pass->sub);
1173       pass = pass->next;
1174     }
1175   while (pass);
1176 }
1177
1178 /* Same as execute_pass_list but assume that subpasses of IPA passes
1179    are local passes.  */
1180 void
1181 execute_ipa_pass_list (struct tree_opt_pass *pass)
1182 {
1183   do
1184     {
1185       gcc_assert (!current_function_decl);
1186       gcc_assert (!cfun);
1187       if (execute_one_pass (pass) && pass->sub)
1188         do_per_function_toporder ((void (*)(void *))execute_pass_list,
1189                                   pass->sub);
1190       if (!current_function_decl)
1191         cgraph_process_new_functions ();
1192       pass = pass->next;
1193     }
1194   while (pass);
1195 }
1196 #include "gt-passes.h"