OSDN Git Service

* cgraph.c (cgraph_release_function_body): Update use of
[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, 2008, 2009
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 #include "lto-streamer.h"
88
89 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
90 #include "dwarf2out.h"
91 #endif
92
93 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
94 #include "dbxout.h"
95 #endif
96
97 #ifdef SDB_DEBUGGING_INFO
98 #include "sdbout.h"
99 #endif
100
101 #ifdef XCOFF_DEBUGGING_INFO
102 #include "xcoffout.h"           /* Needed for external data
103                                    declarations for e.g. AIX 4.x.  */
104 #endif
105
106 /* This is used for debugging.  It allows the current pass to printed
107    from anywhere in compilation.  */
108 struct opt_pass *current_pass;
109
110 /* Call from anywhere to find out what pass this is.  Useful for
111    printing out debugging information deep inside an service
112    routine.  */
113 void
114 print_current_pass (FILE *file)
115 {
116   if (current_pass)
117     fprintf (file, "current pass = %s (%d)\n", 
118              current_pass->name, current_pass->static_pass_number);
119   else
120     fprintf (file, "no current pass.\n");
121 }
122
123
124 /* Call from the debugger to get the current pass name.  */
125 void
126 debug_pass (void)
127 {
128   print_current_pass (stderr);
129
130
131
132
133 /* Global variables used to communicate with passes.  */
134 int dump_flags;
135 bool in_gimple_form;
136 bool first_pass_instance;
137
138
139 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
140    and TYPE_DECL nodes.
141
142    This does nothing for local (non-static) variables, unless the
143    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
144    that case, or if the variable is not an automatic, it sets up the
145    RTL and outputs any assembler code (label definition, storage
146    allocation and initialization).
147
148    DECL is the declaration.  TOP_LEVEL is nonzero
149    if this declaration is not within a function.  */
150
151 void
152 rest_of_decl_compilation (tree decl,
153                           int top_level,
154                           int at_end)
155 {
156   /* We deferred calling assemble_alias so that we could collect
157      other attributes such as visibility.  Emit the alias now.  */
158   {
159     tree alias;
160     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
161     if (alias)
162       {
163         alias = TREE_VALUE (TREE_VALUE (alias));
164         alias = get_identifier (TREE_STRING_POINTER (alias));
165         assemble_alias (decl, alias);
166       }
167   }
168
169   /* Can't defer this, because it needs to happen before any
170      later function definitions are processed.  */
171   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
172     make_decl_rtl (decl);
173
174   /* Forward declarations for nested functions are not "external",
175      but we need to treat them as if they were.  */
176   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
177       || TREE_CODE (decl) == FUNCTION_DECL)
178     {
179       timevar_push (TV_VARCONST);
180
181       /* Don't output anything when a tentative file-scope definition
182          is seen.  But at end of compilation, do output code for them.
183
184          We do output all variables and rely on
185          callgraph code to defer them except for forward declarations
186          (see gcc.c-torture/compile/920624-1.c) */
187       if ((at_end
188            || !DECL_DEFER_OUTPUT (decl)
189            || DECL_INITIAL (decl))
190           && !DECL_EXTERNAL (decl))
191         {
192           if (TREE_CODE (decl) != FUNCTION_DECL)
193             varpool_finalize_decl (decl);
194           else
195             assemble_variable (decl, top_level, at_end, 0);
196         }
197
198 #ifdef ASM_FINISH_DECLARE_OBJECT
199       if (decl == last_assemble_variable_decl)
200         {
201           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
202                                      top_level, at_end);
203         }
204 #endif
205
206       timevar_pop (TV_VARCONST);
207     }
208   else if (TREE_CODE (decl) == TYPE_DECL
209            /* Like in rest_of_type_compilation, avoid confusing the debug
210               information machinery when there are errors.  */
211            && !(sorrycount || errorcount))
212     {
213       timevar_push (TV_SYMOUT);
214       debug_hooks->type_decl (decl, !top_level);
215       timevar_pop (TV_SYMOUT);
216     }
217
218   /* Let cgraph know about the existence of variables.  */
219   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
220     varpool_node (decl);
221 }
222
223 /* Called after finishing a record, union or enumeral type.  */
224
225 void
226 rest_of_type_compilation (tree type, int toplev)
227 {
228   /* Avoid confusing the debug information machinery when there are
229      errors.  */
230   if (errorcount != 0 || sorrycount != 0)
231     return;
232
233   timevar_push (TV_SYMOUT);
234   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
235   timevar_pop (TV_SYMOUT);
236 }
237
238 \f
239
240 void
241 finish_optimization_passes (void)
242 {
243   int i;
244   struct dump_file_info *dfi;
245   char *name;
246
247   timevar_push (TV_DUMP);
248   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
249     {
250       dump_file = dump_begin (pass_profile.pass.static_pass_number, NULL);
251       end_branch_prob ();
252       if (dump_file)
253         dump_end (pass_profile.pass.static_pass_number, dump_file);
254     }
255
256   if (optimize > 0)
257     {
258       dump_file = dump_begin (pass_combine.pass.static_pass_number, NULL);
259       if (dump_file)
260         {
261           dump_combine_total_stats (dump_file);
262           dump_end (pass_combine.pass.static_pass_number, dump_file);
263         }
264     }
265
266   /* Do whatever is necessary to finish printing the graphs.  */
267   if (graph_dump_format != no_graph)
268     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
269       if (dump_initialized_p (i)
270           && (dfi->flags & TDF_GRAPH) != 0
271           && (name = get_dump_file_name (i)) != NULL)
272         {
273           finish_graph_dump_file (name);
274           free (name);
275         }
276
277   timevar_pop (TV_DUMP);
278 }
279
280 static bool
281 gate_rest_of_compilation (void)
282 {
283   /* Early return if there were errors.  We can run afoul of our
284      consistency checks, and there's not really much point in fixing them.  */
285   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
286 }
287
288 struct gimple_opt_pass pass_rest_of_compilation =
289 {
290  {
291   GIMPLE_PASS,
292   "*rest_of_compilation",               /* name */
293   gate_rest_of_compilation,             /* gate */
294   NULL,                                 /* execute */
295   NULL,                                 /* sub */
296   NULL,                                 /* next */
297   0,                                    /* static_pass_number */
298   TV_REST_OF_COMPILATION,               /* tv_id */
299   PROP_rtl,                             /* properties_required */
300   0,                                    /* properties_provided */
301   0,                                    /* properties_destroyed */
302   0,                                    /* todo_flags_start */
303   TODO_ggc_collect                      /* todo_flags_finish */
304  }
305 };
306
307 static bool
308 gate_postreload (void)
309 {
310   return reload_completed;
311 }
312
313 struct rtl_opt_pass pass_postreload =
314 {
315  {
316   RTL_PASS,
317   "*all-postreload",                        /* name */
318   gate_postreload,                      /* gate */
319   NULL,                                 /* execute */
320   NULL,                                 /* sub */
321   NULL,                                 /* next */
322   0,                                    /* static_pass_number */
323   TV_NONE,                              /* tv_id */
324   PROP_rtl,                             /* properties_required */
325   0,                                    /* properties_provided */
326   0,                                    /* properties_destroyed */
327   0,                                    /* todo_flags_start */
328   TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */
329  }
330 };
331
332
333
334 /* The root of the compilation pass tree, once constructed.  */
335 struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes,
336   *all_regular_ipa_passes, *all_lto_gen_passes;
337
338 /* A map from static pass id to optimization pass.  */
339 struct opt_pass **passes_by_id;
340 int passes_by_id_size;
341
342 /* Set the static pass number of pass PASS to ID and record that
343    in the mapping from static pass number to pass.  */
344
345 static void
346 set_pass_for_id (int id, struct opt_pass *pass)
347 {
348   pass->static_pass_number = id;
349   if (passes_by_id_size <= id)
350     {
351       passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1);
352       memset (passes_by_id + passes_by_id_size, 0,
353               (id + 1 - passes_by_id_size) * sizeof (void *));
354       passes_by_id_size = id + 1;
355     }
356   passes_by_id[id] = pass;
357 }
358
359 /* Return the pass with the static pass number ID.  */
360
361 struct opt_pass *
362 get_pass_for_id (int id)
363 {
364   if (id >= passes_by_id_size)
365     return NULL;
366   return passes_by_id[id];
367 }
368
369 /* Iterate over the pass tree allocating dump file numbers.  We want
370    to do this depth first, and independent of whether the pass is
371    enabled or not.  */
372
373 void
374 register_one_dump_file (struct opt_pass *pass)
375 {
376   char *dot_name, *flag_name, *glob_name;
377   const char *name, *prefix;
378   char num[10];
379   int flags, id;
380
381   /* See below in next_pass_1.  */
382   num[0] = '\0';
383   if (pass->static_pass_number != -1)
384     sprintf (num, "%d", ((int) pass->static_pass_number < 0
385                          ? 1 : pass->static_pass_number));
386
387   /* The name is both used to identify the pass for the purposes of plugins,
388      and to specify dump file name and option.
389      The latter two might want something short which is not quite unique; for
390      that reason, we may have a disambiguating prefix, followed by a space
391      to mark the start of the following dump file name / option string.  */
392   name = strchr (pass->name, ' ');
393   name = name ? name + 1 : pass->name;
394   dot_name = concat (".", name, num, NULL);
395   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
396     prefix = "ipa-", flags = TDF_IPA;
397   else if (pass->type == GIMPLE_PASS)
398     prefix = "tree-", flags = TDF_TREE;
399   else
400     prefix = "rtl-", flags = TDF_RTL;
401
402   flag_name = concat (prefix, name, num, NULL);
403   glob_name = concat (prefix, name, NULL);
404   id = dump_register (dot_name, flag_name, glob_name, flags);
405   set_pass_for_id (id, pass);
406 }
407
408 /* Recursive worker function for register_dump_files.  */
409
410 static int 
411 register_dump_files_1 (struct opt_pass *pass, int properties)
412 {
413   do
414     {
415       int new_properties = (properties | pass->properties_provided)
416                            & ~pass->properties_destroyed;
417
418       if (pass->name && pass->name[0] != '*')
419         register_one_dump_file (pass);
420
421       if (pass->sub)
422         new_properties = register_dump_files_1 (pass->sub, new_properties);
423
424       /* If we have a gate, combine the properties that we could have with
425          and without the pass being examined.  */
426       if (pass->gate)
427         properties &= new_properties;
428       else
429         properties = new_properties;
430
431       pass = pass->next;
432     }
433   while (pass);
434
435   return properties;
436 }
437
438 /* Register the dump files for the pipeline starting at PASS. 
439    PROPERTIES reflects the properties that are guaranteed to be available at
440    the beginning of the pipeline.  */
441
442 static void 
443 register_dump_files (struct opt_pass *pass,int properties)
444 {
445   pass->properties_required |= properties;
446   register_dump_files_1 (pass, properties);
447 }
448
449 /* Look at the static_pass_number and duplicate the pass
450    if it is already added to a list. */
451
452 static struct opt_pass *
453 make_pass_instance (struct opt_pass *pass, bool track_duplicates)
454 {
455   /* A nonzero static_pass_number indicates that the
456      pass is already in the list.  */
457   if (pass->static_pass_number)
458     {
459       struct opt_pass *new_pass;
460
461       new_pass = XNEW (struct opt_pass);
462       memcpy (new_pass, pass, sizeof (*new_pass));
463       new_pass->next = NULL;
464
465       new_pass->todo_flags_start &= ~TODO_mark_first_instance;
466
467       /* Indicate to register_dump_files that this pass has duplicates,
468          and so it should rename the dump file.  The first instance will
469          be -1, and be number of duplicates = -static_pass_number - 1.
470          Subsequent instances will be > 0 and just the duplicate number.  */
471       if ((pass->name && pass->name[0] != '*') || track_duplicates)
472         {
473           pass->static_pass_number -= 1;
474           new_pass->static_pass_number = -pass->static_pass_number;
475         }
476       return new_pass;
477     }
478   else
479     {
480       pass->todo_flags_start |= TODO_mark_first_instance;
481       pass->static_pass_number = -1;
482     } 
483   return pass; 
484 }
485
486 /* Add a pass to the pass list. Duplicate the pass if it's already
487    in the list.  */
488
489 static struct opt_pass **
490 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
491 {
492   /* Every pass should have a name so that plugins can refer to them.  */
493   gcc_assert (pass->name != NULL);
494
495   *list = make_pass_instance (pass, false);
496   
497   return &(*list)->next;
498 }
499
500 /* List node for an inserted pass instance. We need to keep track of all
501    the newly-added pass instances (with 'added_pass_nodes' defined below)
502    so that we can register their dump files after pass-positioning is finished.
503    Registering dumping files needs to be post-processed or the
504    static_pass_number of the opt_pass object would be modified and mess up
505    the dump file names of future pass instances to be added.  */
506
507 struct pass_list_node
508 {
509   struct opt_pass *pass;
510   struct pass_list_node *next;
511 };
512
513 static struct pass_list_node *added_pass_nodes = NULL;
514 static struct pass_list_node *prev_added_pass_node;
515
516 /* Insert the pass at the proper position. Return true if the pass 
517    is successfully added.
518
519    NEW_PASS_INFO - new pass to be inserted
520    PASS_LIST - root of the pass list to insert the new pass to  */
521
522 static bool
523 position_pass (struct register_pass_info *new_pass_info,
524                struct opt_pass **pass_list)
525 {
526   struct opt_pass *pass = *pass_list, *prev_pass = NULL;
527   bool success = false;
528
529   for ( ; pass; prev_pass = pass, pass = pass->next)
530     {
531       /* Check if the current pass is of the same type as the new pass and
532          matches the name and the instance number of the reference pass.  */
533       if (pass->type == new_pass_info->pass->type
534           && pass->name
535           && !strcmp (pass->name, new_pass_info->reference_pass_name)
536           && ((new_pass_info->ref_pass_instance_number == 0)
537               || (new_pass_info->ref_pass_instance_number ==
538                   pass->static_pass_number)
539               || (new_pass_info->ref_pass_instance_number == 1
540                   && pass->todo_flags_start & TODO_mark_first_instance)))
541         {
542           struct opt_pass *new_pass;
543           struct pass_list_node *new_pass_node;
544
545           new_pass = make_pass_instance (new_pass_info->pass, true);
546   
547           /* Insert the new pass instance based on the positioning op.  */
548           switch (new_pass_info->pos_op)
549             {
550               case PASS_POS_INSERT_AFTER:
551                 new_pass->next = pass->next;
552                 pass->next = new_pass;
553
554                 /* Skip newly inserted pass to avoid repeated
555                    insertions in the case where the new pass and the
556                    existing one have the same name.  */
557                 pass = new_pass; 
558                 break;
559               case PASS_POS_INSERT_BEFORE:
560                 new_pass->next = pass;
561                 if (prev_pass)
562                   prev_pass->next = new_pass;
563                 else
564                   *pass_list = new_pass;
565                 break;
566               case PASS_POS_REPLACE:
567                 new_pass->next = pass->next;
568                 if (prev_pass)
569                   prev_pass->next = new_pass;
570                 else
571                   *pass_list = new_pass;
572                 new_pass->sub = pass->sub;
573                 new_pass->tv_id = pass->tv_id;
574                 pass = new_pass;
575                 break;
576               default:
577                 error ("Invalid pass positioning operation");
578                 return false;
579             }
580
581           /* Save the newly added pass (instance) in the added_pass_nodes
582              list so that we can register its dump file later. Note that
583              we cannot register the dump file now because doing so will modify
584              the static_pass_number of the opt_pass object and therefore
585              mess up the dump file name of future instances.  */
586           new_pass_node = XCNEW (struct pass_list_node);
587           new_pass_node->pass = new_pass;
588           if (!added_pass_nodes)
589             added_pass_nodes = new_pass_node;
590           else
591             prev_added_pass_node->next = new_pass_node;
592           prev_added_pass_node = new_pass_node;
593
594           success = true;
595         }
596
597       if (pass->sub && position_pass (new_pass_info, &pass->sub))
598         success = true;
599     }
600
601   return success;
602 }
603
604 /* Hooks a new pass into the pass lists.
605
606    PASS_INFO   - pass information that specifies the opt_pass object,
607                  reference pass, instance number, and how to position
608                  the pass  */
609
610 void
611 register_pass (struct register_pass_info *pass_info)
612 {
613   /* The checks below could fail in buggy plugins.  Existing GCC
614      passes should never fail these checks, so we mention plugin in
615      the messages.  */
616   if (!pass_info->pass)
617       fatal_error ("plugin cannot register a missing pass");
618
619   if (!pass_info->pass->name)
620       fatal_error ("plugin cannot register an unnamed pass");
621
622   if (!pass_info->reference_pass_name)
623       fatal_error
624         ("plugin cannot register pass %qs without reference pass name",
625          pass_info->pass->name);
626
627   /* Try to insert the new pass to the pass lists.  We need to check
628      all three lists as the reference pass could be in one (or all) of
629      them.  */
630   if (!position_pass (pass_info, &all_lowering_passes)
631       && !position_pass (pass_info, &all_small_ipa_passes)
632       && !position_pass (pass_info, &all_regular_ipa_passes)
633       && !position_pass (pass_info, &all_lto_gen_passes)
634       && !position_pass (pass_info, &all_passes))
635     fatal_error
636       ("pass %qs not found but is referenced by new pass %qs",
637        pass_info->reference_pass_name, pass_info->pass->name);
638   else
639     {
640       /* OK, we have successfully inserted the new pass. We need to register
641          the dump files for the newly added pass and its duplicates (if any).
642          Because the registration of plugin/backend passes happens after the
643          command-line options are parsed, the options that specify single
644          pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
645          passes. Therefore we currently can only enable dumping of
646          new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
647          are specified. While doing so, we also delete the pass_list_node
648          objects created during pass positioning.  */
649       while (added_pass_nodes)
650         {
651           struct pass_list_node *next_node = added_pass_nodes->next;
652           enum tree_dump_index tdi;
653           register_one_dump_file (added_pass_nodes->pass);
654           if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
655               || added_pass_nodes->pass->type == IPA_PASS)
656             tdi = TDI_ipa_all;
657           else if (added_pass_nodes->pass->type == GIMPLE_PASS)
658             tdi = TDI_tree_all;
659           else
660             tdi = TDI_rtl_all;
661           /* Check if dump-all flag is specified.  */
662           if (get_dump_file_info (tdi)->state)
663             get_dump_file_info (added_pass_nodes->pass->static_pass_number)
664                 ->state = get_dump_file_info (tdi)->state;
665           XDELETE (added_pass_nodes);
666           added_pass_nodes = next_node;
667         }
668     }
669 }
670
671 /* Construct the pass tree.  The sequencing of passes is driven by
672    the cgraph routines:
673
674    cgraph_finalize_compilation_unit ()
675        for each node N in the cgraph
676            cgraph_analyze_function (N)
677                cgraph_lower_function (N) -> all_lowering_passes
678
679    If we are optimizing, cgraph_optimize is then invoked:
680
681    cgraph_optimize ()
682        ipa_passes ()                    -> all_small_ipa_passes
683        cgraph_expand_all_functions ()
684            for each node N in the cgraph
685                cgraph_expand_function (N)
686                   tree_rest_of_compilation (DECL (N))  -> all_passes
687 */
688
689 void
690 init_optimization_passes (void)
691 {
692   struct opt_pass **p;
693
694 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &((PASS).pass)))
695
696  /* All passes needed to lower the function into shape optimizers can
697     operate on.  These passes are always run first on the function, but
698     backend might produce already lowered functions that are not processed
699     by these passes.  */
700   p = &all_lowering_passes;
701   NEXT_PASS (pass_warn_unused_result);
702   NEXT_PASS (pass_diagnose_omp_blocks);
703   NEXT_PASS (pass_mudflap_1);
704   NEXT_PASS (pass_lower_omp);
705   NEXT_PASS (pass_lower_cf);
706   NEXT_PASS (pass_refactor_eh);
707   NEXT_PASS (pass_lower_eh);
708   NEXT_PASS (pass_build_cfg);
709   NEXT_PASS (pass_lower_complex_O0);
710   NEXT_PASS (pass_lower_vector);
711   NEXT_PASS (pass_warn_function_return);
712   NEXT_PASS (pass_build_cgraph_edges);
713   NEXT_PASS (pass_inline_parameters);
714   *p = NULL;
715
716   /* Interprocedural optimization passes.  */
717   p = &all_small_ipa_passes;
718   NEXT_PASS (pass_ipa_function_and_variable_visibility);
719   NEXT_PASS (pass_ipa_early_inline);
720     {
721       struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
722       NEXT_PASS (pass_early_inline);
723       NEXT_PASS (pass_inline_parameters);
724       NEXT_PASS (pass_rebuild_cgraph_edges);
725     }
726   NEXT_PASS (pass_ipa_free_lang_data);
727   NEXT_PASS (pass_early_local_passes);
728     {
729       struct opt_pass **p = &pass_early_local_passes.pass.sub;
730       NEXT_PASS (pass_fixup_cfg);
731       NEXT_PASS (pass_tree_profile);
732       NEXT_PASS (pass_cleanup_cfg);
733       NEXT_PASS (pass_init_datastructures);
734       NEXT_PASS (pass_expand_omp);
735
736       NEXT_PASS (pass_referenced_vars);
737       NEXT_PASS (pass_build_ssa);
738       NEXT_PASS (pass_early_warn_uninitialized);
739       /* Note that it is not strictly necessary to schedule an early
740          inline pass here.  However, some test cases (e.g.,
741          g++.dg/other/p334435.C g++.dg/other/i386-1.C) expect extern
742          inline functions to be inlined even at -O0.  This does not
743          happen during the first early inline pass.  */
744       NEXT_PASS (pass_rebuild_cgraph_edges);
745       NEXT_PASS (pass_early_inline);
746       NEXT_PASS (pass_all_early_optimizations);
747         {
748           struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
749           NEXT_PASS (pass_remove_cgraph_callee_edges);
750           NEXT_PASS (pass_rename_ssa_copies);
751           NEXT_PASS (pass_ccp);
752           NEXT_PASS (pass_forwprop);
753           /* pass_build_ealias is a dummy pass that ensures that we
754              execute TODO_rebuild_alias at this point.  Re-building
755              alias information also rewrites no longer addressed
756              locals into SSA form if possible.  */
757           NEXT_PASS (pass_build_ealias);
758           NEXT_PASS (pass_sra_early);
759           NEXT_PASS (pass_copy_prop);
760           NEXT_PASS (pass_merge_phi);
761           NEXT_PASS (pass_cd_dce);
762           NEXT_PASS (pass_early_ipa_sra);
763           NEXT_PASS (pass_tail_recursion);
764           NEXT_PASS (pass_convert_switch);
765           NEXT_PASS (pass_cleanup_eh);
766           NEXT_PASS (pass_profile);
767           NEXT_PASS (pass_local_pure_const);
768         }
769       NEXT_PASS (pass_release_ssa_names);
770       NEXT_PASS (pass_rebuild_cgraph_edges);
771       NEXT_PASS (pass_inline_parameters);
772     }
773   NEXT_PASS (pass_ipa_increase_alignment);
774   NEXT_PASS (pass_ipa_matrix_reorg);
775   *p = NULL;
776
777   p = &all_regular_ipa_passes;
778   NEXT_PASS (pass_ipa_whole_program_visibility);
779   NEXT_PASS (pass_ipa_cp);
780   NEXT_PASS (pass_ipa_inline);
781   NEXT_PASS (pass_ipa_reference);
782   NEXT_PASS (pass_ipa_pure_const); 
783   NEXT_PASS (pass_ipa_type_escape);
784   NEXT_PASS (pass_ipa_pta);
785   NEXT_PASS (pass_ipa_struct_reorg);
786   *p = NULL;
787
788   p = &all_lto_gen_passes;
789   NEXT_PASS (pass_ipa_lto_gimple_out);
790   NEXT_PASS (pass_ipa_lto_wpa_fixup);
791   NEXT_PASS (pass_ipa_lto_finish_out);  /* This must be the last LTO pass.  */
792   *p = NULL;
793
794   /* These passes are run after IPA passes on every function that is being
795      output to the assembler file.  */
796   p = &all_passes;
797   NEXT_PASS (pass_lower_eh_dispatch);
798   NEXT_PASS (pass_all_optimizations);
799     {
800       struct opt_pass **p = &pass_all_optimizations.pass.sub;
801       NEXT_PASS (pass_remove_cgraph_callee_edges);
802       /* Initial scalar cleanups before alias computation.
803          They ensure memory accesses are not indirect wherever possible.  */
804       NEXT_PASS (pass_strip_predict_hints);
805       NEXT_PASS (pass_update_address_taken);
806       NEXT_PASS (pass_rename_ssa_copies);
807       NEXT_PASS (pass_complete_unrolli);
808       NEXT_PASS (pass_ccp);
809       NEXT_PASS (pass_forwprop);
810       NEXT_PASS (pass_call_cdce);
811       /* pass_build_alias is a dummy pass that ensures that we
812          execute TODO_rebuild_alias at this point.  Re-building
813          alias information also rewrites no longer addressed
814          locals into SSA form if possible.  */
815       NEXT_PASS (pass_build_alias);
816       NEXT_PASS (pass_return_slot);
817       NEXT_PASS (pass_phiprop);
818       NEXT_PASS (pass_fre);
819       NEXT_PASS (pass_copy_prop);
820       NEXT_PASS (pass_merge_phi);
821       NEXT_PASS (pass_vrp);
822       NEXT_PASS (pass_dce);
823       NEXT_PASS (pass_cselim);
824       NEXT_PASS (pass_tree_ifcombine);
825       NEXT_PASS (pass_phiopt);
826       NEXT_PASS (pass_tail_recursion);
827       NEXT_PASS (pass_ch);
828       NEXT_PASS (pass_stdarg);
829       NEXT_PASS (pass_lower_complex);
830       NEXT_PASS (pass_sra);
831       NEXT_PASS (pass_rename_ssa_copies);
832       /* The dom pass will also resolve all __builtin_constant_p calls
833          that are still there to 0.  This has to be done after some
834          propagations have already run, but before some more dead code
835          is removed, and this place fits nicely.  Remember this when
836          trying to move or duplicate pass_dominator somewhere earlier.  */
837       NEXT_PASS (pass_dominator);
838       /* The only const/copy propagation opportunities left after
839          DOM should be due to degenerate PHI nodes.  So rather than
840          run the full propagators, run a specialized pass which
841          only examines PHIs to discover const/copy propagation
842          opportunities.  */
843       NEXT_PASS (pass_phi_only_cprop);
844       NEXT_PASS (pass_dse);
845       NEXT_PASS (pass_reassoc);
846       NEXT_PASS (pass_dce);
847       NEXT_PASS (pass_forwprop);
848       NEXT_PASS (pass_phiopt);
849       NEXT_PASS (pass_object_sizes);
850       NEXT_PASS (pass_ccp);
851       NEXT_PASS (pass_copy_prop);
852       NEXT_PASS (pass_cse_sincos);
853       NEXT_PASS (pass_optimize_bswap);
854       NEXT_PASS (pass_split_crit_edges);
855       NEXT_PASS (pass_pre);
856       NEXT_PASS (pass_sink_code);
857       NEXT_PASS (pass_tree_loop);
858         {
859           struct opt_pass **p = &pass_tree_loop.pass.sub;
860           NEXT_PASS (pass_tree_loop_init);
861           NEXT_PASS (pass_copy_prop);
862           NEXT_PASS (pass_dce_loop);
863           NEXT_PASS (pass_lim);
864           NEXT_PASS (pass_tree_unswitch);
865           NEXT_PASS (pass_scev_cprop);
866           NEXT_PASS (pass_record_bounds);
867           NEXT_PASS (pass_check_data_deps);
868           NEXT_PASS (pass_loop_distribution);
869           NEXT_PASS (pass_linear_transform);
870           NEXT_PASS (pass_graphite_transforms);
871             {
872               struct opt_pass **p = &pass_graphite_transforms.pass.sub;
873               NEXT_PASS (pass_dce_loop);
874               NEXT_PASS (pass_lim);
875             }
876           NEXT_PASS (pass_iv_canon);
877           NEXT_PASS (pass_if_conversion);
878           NEXT_PASS (pass_vectorize);
879             {
880               struct opt_pass **p = &pass_vectorize.pass.sub;
881               NEXT_PASS (pass_lower_vector_ssa);
882               NEXT_PASS (pass_dce_loop);
883             }
884           NEXT_PASS (pass_predcom);
885           NEXT_PASS (pass_complete_unroll);
886           NEXT_PASS (pass_slp_vectorize);
887           NEXT_PASS (pass_parallelize_loops);
888           NEXT_PASS (pass_loop_prefetch);
889           NEXT_PASS (pass_iv_optimize);
890           NEXT_PASS (pass_tree_loop_done);
891         }
892       NEXT_PASS (pass_cse_reciprocals);
893       NEXT_PASS (pass_reassoc);
894       NEXT_PASS (pass_vrp);
895       NEXT_PASS (pass_dominator);
896       /* The only const/copy propagation opportunities left after
897          DOM should be due to degenerate PHI nodes.  So rather than
898          run the full propagators, run a specialized pass which
899          only examines PHIs to discover const/copy propagation
900          opportunities.  */
901       NEXT_PASS (pass_phi_only_cprop);
902       NEXT_PASS (pass_cd_dce);
903       NEXT_PASS (pass_tracer);
904
905       /* FIXME: If DCE is not run before checking for uninitialized uses,
906          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
907          However, this also causes us to misdiagnose cases that should be
908          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
909          
910          To fix the false positives in uninit-5.c, we would have to
911          account for the predicates protecting the set and the use of each
912          variable.  Using a representation like Gated Single Assignment
913          may help.  */
914       NEXT_PASS (pass_late_warn_uninitialized);
915       NEXT_PASS (pass_dse);
916       NEXT_PASS (pass_forwprop);
917       NEXT_PASS (pass_phiopt);
918       NEXT_PASS (pass_fold_builtins);
919       NEXT_PASS (pass_tail_calls);
920       NEXT_PASS (pass_rename_ssa_copies);
921       NEXT_PASS (pass_uncprop);
922       NEXT_PASS (pass_local_pure_const);
923     }
924   NEXT_PASS (pass_cleanup_eh);
925   NEXT_PASS (pass_lower_resx);
926   NEXT_PASS (pass_nrv);
927   NEXT_PASS (pass_mudflap_2);
928   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
929   NEXT_PASS (pass_warn_function_noreturn);
930
931   NEXT_PASS (pass_expand);
932
933   NEXT_PASS (pass_rest_of_compilation);
934     {
935       struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
936       NEXT_PASS (pass_init_function);
937       NEXT_PASS (pass_jump);
938       NEXT_PASS (pass_rtl_eh);
939       NEXT_PASS (pass_initial_value_sets);
940       NEXT_PASS (pass_unshare_all_rtl);
941       NEXT_PASS (pass_instantiate_virtual_regs);
942       NEXT_PASS (pass_into_cfg_layout_mode);
943       NEXT_PASS (pass_jump2);
944       NEXT_PASS (pass_lower_subreg);
945       NEXT_PASS (pass_df_initialize_opt);
946       NEXT_PASS (pass_cse);
947       NEXT_PASS (pass_rtl_fwprop);
948       NEXT_PASS (pass_rtl_cprop);
949       NEXT_PASS (pass_rtl_pre);
950       NEXT_PASS (pass_rtl_hoist);
951       NEXT_PASS (pass_rtl_cprop);
952       NEXT_PASS (pass_rtl_store_motion);
953       NEXT_PASS (pass_cse_after_global_opts);
954       NEXT_PASS (pass_rtl_ifcvt);
955       NEXT_PASS (pass_reginfo_init);
956       /* Perform loop optimizations.  It might be better to do them a bit
957          sooner, but we want the profile feedback to work more
958          efficiently.  */
959       NEXT_PASS (pass_loop2);
960         {
961           struct opt_pass **p = &pass_loop2.pass.sub;
962           NEXT_PASS (pass_rtl_loop_init);
963           NEXT_PASS (pass_rtl_move_loop_invariants);
964           NEXT_PASS (pass_rtl_unswitch);
965           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
966           NEXT_PASS (pass_rtl_doloop);
967           NEXT_PASS (pass_rtl_loop_done);
968           *p = NULL;
969         }
970       NEXT_PASS (pass_web);
971       NEXT_PASS (pass_rtl_cprop);
972       NEXT_PASS (pass_cse2);
973       NEXT_PASS (pass_rtl_dse1);
974       NEXT_PASS (pass_rtl_fwprop_addr);
975       NEXT_PASS (pass_inc_dec);
976       NEXT_PASS (pass_initialize_regs);
977       NEXT_PASS (pass_ud_rtl_dce);
978       NEXT_PASS (pass_combine);
979       NEXT_PASS (pass_if_after_combine);
980       NEXT_PASS (pass_partition_blocks);
981       NEXT_PASS (pass_regmove);
982       NEXT_PASS (pass_outof_cfg_layout_mode);
983       NEXT_PASS (pass_split_all_insns);
984       NEXT_PASS (pass_lower_subreg2);
985       NEXT_PASS (pass_df_initialize_no_opt);
986       NEXT_PASS (pass_stack_ptr_mod);
987       NEXT_PASS (pass_mode_switching);
988       NEXT_PASS (pass_match_asm_constraints);
989       NEXT_PASS (pass_sms);
990       NEXT_PASS (pass_sched);
991       NEXT_PASS (pass_ira);
992       NEXT_PASS (pass_postreload);
993         {
994           struct opt_pass **p = &pass_postreload.pass.sub;
995           NEXT_PASS (pass_postreload_cse);
996           NEXT_PASS (pass_gcse2);
997           NEXT_PASS (pass_split_after_reload);
998           NEXT_PASS (pass_branch_target_load_optimize1);
999           NEXT_PASS (pass_thread_prologue_and_epilogue);
1000           NEXT_PASS (pass_rtl_dse2);
1001           NEXT_PASS (pass_stack_adjustments);
1002           NEXT_PASS (pass_peephole2);
1003           NEXT_PASS (pass_if_after_reload);
1004           NEXT_PASS (pass_regrename);
1005           NEXT_PASS (pass_cprop_hardreg);
1006           NEXT_PASS (pass_fast_rtl_dce);
1007           NEXT_PASS (pass_reorder_blocks);
1008           NEXT_PASS (pass_branch_target_load_optimize2);
1009           NEXT_PASS (pass_leaf_regs);
1010           NEXT_PASS (pass_split_before_sched2);
1011           NEXT_PASS (pass_sched2);
1012           NEXT_PASS (pass_stack_regs);
1013             {
1014               struct opt_pass **p = &pass_stack_regs.pass.sub;
1015               NEXT_PASS (pass_split_before_regstack);
1016               NEXT_PASS (pass_stack_regs_run);
1017             }
1018           NEXT_PASS (pass_compute_alignments);
1019           NEXT_PASS (pass_duplicate_computed_gotos);
1020           NEXT_PASS (pass_variable_tracking);
1021           NEXT_PASS (pass_free_cfg);
1022           NEXT_PASS (pass_machine_reorg);
1023           NEXT_PASS (pass_cleanup_barriers);
1024           NEXT_PASS (pass_delay_slots);
1025           NEXT_PASS (pass_split_for_shorten_branches);
1026           NEXT_PASS (pass_convert_to_eh_region_ranges);
1027           NEXT_PASS (pass_shorten_branches);
1028           NEXT_PASS (pass_set_nothrow_function_flags);
1029           NEXT_PASS (pass_final);
1030         }
1031       NEXT_PASS (pass_df_finish);
1032     }
1033   NEXT_PASS (pass_clean_state);
1034   *p = NULL;
1035
1036 #undef NEXT_PASS
1037
1038   /* Register the passes with the tree dump code.  */
1039   register_dump_files (all_lowering_passes, PROP_gimple_any);
1040   register_dump_files (all_small_ipa_passes, 
1041                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1042                        | PROP_cfg);
1043   register_dump_files (all_regular_ipa_passes, 
1044                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1045                        | PROP_cfg);
1046   register_dump_files (all_lto_gen_passes, 
1047                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1048                        | PROP_cfg);
1049   register_dump_files (all_passes, 
1050                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1051                        | PROP_cfg);
1052 }
1053
1054 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1055    function CALLBACK for every function in the call graph.  Otherwise,
1056    call CALLBACK on the current function.  */ 
1057
1058 static void
1059 do_per_function (void (*callback) (void *data), void *data)
1060 {
1061   if (current_function_decl)
1062     callback (data);
1063   else
1064     {
1065       struct cgraph_node *node;
1066       for (node = cgraph_nodes; node; node = node->next)
1067         if (node->analyzed && gimple_has_body_p (node->decl)
1068             && (!node->clone_of || node->decl != node->clone_of->decl))
1069           {
1070             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1071             current_function_decl = node->decl;
1072             callback (data);
1073             if (!flag_wpa)
1074               {
1075                 free_dominance_info (CDI_DOMINATORS);
1076                 free_dominance_info (CDI_POST_DOMINATORS);
1077               }
1078             current_function_decl = NULL;
1079             pop_cfun ();
1080             ggc_collect ();
1081           }
1082     }
1083 }
1084
1085 /* Because inlining might remove no-longer reachable nodes, we need to
1086    keep the array visible to garbage collector to avoid reading collected
1087    out nodes.  */
1088 static int nnodes;
1089 static GTY ((length ("nnodes"))) struct cgraph_node **order;
1090
1091 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1092    function CALLBACK for every function in the call graph.  Otherwise,
1093    call CALLBACK on the current function.  */ 
1094
1095 static void
1096 do_per_function_toporder (void (*callback) (void *data), void *data)
1097 {
1098   int i;
1099
1100   if (current_function_decl)
1101     callback (data);
1102   else
1103     {
1104       gcc_assert (!order);
1105       order = GGC_NEWVEC (struct cgraph_node *, cgraph_n_nodes);
1106       nnodes = cgraph_postorder (order);
1107       for (i = nnodes - 1; i >= 0; i--)
1108         order[i]->process = 1;
1109       for (i = nnodes - 1; i >= 0; i--)
1110         {
1111           struct cgraph_node *node = order[i];
1112
1113           /* Allow possibly removed nodes to be garbage collected.  */
1114           order[i] = NULL;
1115           node->process = 0;
1116           if (node->analyzed)
1117             {
1118               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1119               current_function_decl = node->decl;
1120               callback (data);
1121               free_dominance_info (CDI_DOMINATORS);
1122               free_dominance_info (CDI_POST_DOMINATORS);
1123               current_function_decl = NULL;
1124               pop_cfun ();
1125               ggc_collect ();
1126             }
1127         }
1128     }
1129   ggc_free (order);
1130   order = NULL;
1131   nnodes = 0;
1132 }
1133
1134 /* Perform all TODO actions that ought to be done on each function.  */
1135
1136 static void
1137 execute_function_todo (void *data)
1138 {
1139   unsigned int flags = (size_t)data;
1140   if (cfun->curr_properties & PROP_ssa)
1141     flags |= TODO_verify_ssa;
1142   flags &= ~cfun->last_verified;
1143   if (!flags)
1144     return;
1145
1146   statistics_fini_pass ();
1147
1148   /* Always cleanup the CFG before trying to update SSA.  */
1149   if (flags & TODO_cleanup_cfg)
1150     {
1151       bool cleanup = cleanup_tree_cfg ();
1152
1153       if (cleanup && (cfun->curr_properties & PROP_ssa))
1154         flags |= TODO_remove_unused_locals;
1155         
1156       /* When cleanup_tree_cfg merges consecutive blocks, it may
1157          perform some simplistic propagation when removing single
1158          valued PHI nodes.  This propagation may, in turn, cause the
1159          SSA form to become out-of-date (see PR 22037).  So, even
1160          if the parent pass had not scheduled an SSA update, we may
1161          still need to do one.  */
1162       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1163         flags |= TODO_update_ssa;
1164     }
1165
1166   if (flags & TODO_update_ssa_any)
1167     {
1168       unsigned update_flags = flags & TODO_update_ssa_any;
1169       update_ssa (update_flags);
1170       cfun->last_verified &= ~TODO_verify_ssa;
1171     }
1172   
1173   if (flags & TODO_update_address_taken)
1174     execute_update_addresses_taken (true);
1175
1176   if (flags & TODO_rebuild_alias)
1177     {
1178       if (!(flags & TODO_update_address_taken))
1179         execute_update_addresses_taken (true);
1180       compute_may_aliases ();
1181     }
1182   
1183   if (flags & TODO_remove_unused_locals)
1184     remove_unused_locals ();
1185
1186   if ((flags & TODO_dump_func) && dump_file && current_function_decl)
1187     {
1188       if (cfun->curr_properties & PROP_trees)
1189         dump_function_to_file (current_function_decl, dump_file, dump_flags);
1190       else
1191         {
1192           if (dump_flags & TDF_SLIM)
1193             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
1194           else if ((cfun->curr_properties & PROP_cfg)
1195                    && (dump_flags & TDF_BLOCKS))
1196             print_rtl_with_bb (dump_file, get_insns ());
1197           else
1198             print_rtl (dump_file, get_insns ());
1199
1200           if ((cfun->curr_properties & PROP_cfg)
1201               && graph_dump_format != no_graph
1202               && (dump_flags & TDF_GRAPH))
1203             print_rtl_graph_with_bb (dump_file_name, get_insns ());
1204         }
1205
1206       /* Flush the file.  If verification fails, we won't be able to
1207          close the file before aborting.  */
1208       fflush (dump_file);
1209     }
1210
1211   if (flags & TODO_rebuild_frequencies)
1212     {
1213       if (profile_status == PROFILE_GUESSED)
1214         {
1215           loop_optimizer_init (0);
1216           add_noreturn_fake_exit_edges ();
1217           mark_irreducible_loops ();
1218           connect_infinite_loops_to_exit ();
1219           estimate_bb_frequencies ();
1220           remove_fake_exit_edges ();
1221           loop_optimizer_finalize ();
1222         }
1223       else if (profile_status == PROFILE_READ)
1224         counts_to_freqs ();
1225       else
1226         gcc_unreachable ();
1227     }
1228
1229 #if defined ENABLE_CHECKING
1230   if (flags & TODO_verify_ssa)
1231     verify_ssa (true);
1232   if (flags & TODO_verify_flow)
1233     verify_flow_info ();
1234   if (flags & TODO_verify_stmts)
1235     verify_stmts ();
1236   if (flags & TODO_verify_loops)
1237     verify_loop_closed_ssa ();
1238   if (flags & TODO_verify_rtl_sharing)
1239     verify_rtl_sharing ();
1240 #endif
1241
1242   cfun->last_verified = flags & TODO_verify_all;
1243 }
1244
1245 /* Perform all TODO actions.  */
1246 static void
1247 execute_todo (unsigned int flags)
1248 {
1249 #if defined ENABLE_CHECKING
1250   if (cfun
1251       && need_ssa_update_p (cfun))
1252     gcc_assert (flags & TODO_update_ssa_any);
1253 #endif
1254
1255   /* Inform the pass whether it is the first time it is run.  */
1256   first_pass_instance = (flags & TODO_mark_first_instance) != 0;
1257
1258   do_per_function (execute_function_todo, (void *)(size_t) flags);
1259
1260   /* Always remove functions just as before inlining: IPA passes might be
1261      interested to see bodies of extern inline functions that are not inlined
1262      to analyze side effects.  The full removal is done just at the end
1263      of IPA pass queue.  */
1264   if (flags & TODO_remove_functions)
1265     {
1266       gcc_assert (!cfun);
1267       cgraph_remove_unreachable_nodes (true, dump_file);
1268     }
1269
1270   if ((flags & TODO_dump_cgraph) && dump_file && !current_function_decl)
1271     {
1272       gcc_assert (!cfun);
1273       dump_cgraph (dump_file);
1274       /* Flush the file.  If verification fails, we won't be able to
1275          close the file before aborting.  */
1276       fflush (dump_file);
1277     }
1278
1279   if (flags & TODO_ggc_collect)
1280     ggc_collect ();
1281
1282   /* Now that the dumping has been done, we can get rid of the optional 
1283      df problems.  */
1284   if (flags & TODO_df_finish)
1285     df_finish_pass ((flags & TODO_df_verify) != 0);
1286 }
1287
1288 /* Verify invariants that should hold between passes.  This is a place
1289    to put simple sanity checks.  */
1290
1291 static void
1292 verify_interpass_invariants (void)
1293 {
1294 #ifdef ENABLE_CHECKING
1295   gcc_assert (!fold_deferring_overflow_warnings_p ());
1296 #endif
1297 }
1298
1299 /* Clear the last verified flag.  */
1300
1301 static void
1302 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1303 {
1304   cfun->last_verified = 0;
1305 }
1306
1307 /* Helper function. Verify that the properties has been turn into the
1308    properties expected by the pass.  */
1309
1310 #ifdef ENABLE_CHECKING
1311 static void
1312 verify_curr_properties (void *data)
1313 {
1314   unsigned int props = (size_t)data;
1315   gcc_assert ((cfun->curr_properties & props) == props);
1316 }
1317 #endif
1318
1319 /* Initialize pass dump file.  */
1320
1321 static bool
1322 pass_init_dump_file (struct opt_pass *pass)
1323 {
1324   /* If a dump file name is present, open it if enabled.  */
1325   if (pass->static_pass_number != -1)
1326     {
1327       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
1328       dump_file_name = get_dump_file_name (pass->static_pass_number);
1329       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1330       if (dump_file && current_function_decl)
1331         {
1332           const char *dname, *aname;
1333           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1334           aname = (IDENTIFIER_POINTER
1335                    (DECL_ASSEMBLER_NAME (current_function_decl)));
1336           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1337              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1338              ? " (hot)"
1339              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1340              ? " (unlikely executed)"
1341              : "");
1342         }
1343       return initializing_dump;
1344     }
1345   else
1346     return false;
1347 }
1348
1349 /* Flush PASS dump file.  */
1350
1351 static void
1352 pass_fini_dump_file (struct opt_pass *pass)
1353 {
1354   /* Flush and close dump file.  */
1355   if (dump_file_name)
1356     {
1357       free (CONST_CAST (char *, dump_file_name));
1358       dump_file_name = NULL;
1359     }
1360
1361   if (dump_file)
1362     {
1363       dump_end (pass->static_pass_number, dump_file);
1364       dump_file = NULL;
1365     }
1366 }
1367
1368 /* After executing the pass, apply expected changes to the function
1369    properties. */
1370
1371 static void
1372 update_properties_after_pass (void *data)
1373 {
1374   struct opt_pass *pass = (struct opt_pass *) data;
1375   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1376                            & ~pass->properties_destroyed;
1377 }
1378
1379 /* Execute summary generation for all of the passes in IPA_PASS.  */
1380
1381 void
1382 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
1383 {
1384   while (ipa_pass)
1385     {
1386       struct opt_pass *pass = &ipa_pass->pass;
1387
1388       /* Execute all of the IPA_PASSes in the list.  */
1389       if (ipa_pass->pass.type == IPA_PASS 
1390           && (!pass->gate || pass->gate ())
1391           && ipa_pass->generate_summary)
1392         {
1393           pass_init_dump_file (pass);
1394
1395           /* If a timevar is present, start it.  */
1396           if (pass->tv_id)
1397             timevar_push (pass->tv_id);
1398
1399           ipa_pass->generate_summary ();
1400
1401           /* Stop timevar.  */
1402           if (pass->tv_id)
1403             timevar_pop (pass->tv_id);
1404
1405           pass_fini_dump_file (pass);
1406         }
1407       ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
1408     }
1409 }
1410
1411 /* Execute IPA_PASS function transform on NODE.  */
1412
1413 static void
1414 execute_one_ipa_transform_pass (struct cgraph_node *node,
1415                                 struct ipa_opt_pass_d *ipa_pass)
1416 {
1417   struct opt_pass *pass = &ipa_pass->pass;
1418   unsigned int todo_after = 0;
1419
1420   current_pass = pass;
1421   if (!ipa_pass->function_transform)
1422     return;
1423
1424   /* Note that the folders should only create gimple expressions.
1425      This is a hack until the new folder is ready.  */
1426   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1427
1428   pass_init_dump_file (pass);
1429
1430   /* Run pre-pass verification.  */
1431   execute_todo (ipa_pass->function_transform_todo_flags_start);
1432
1433   /* If a timevar is present, start it.  */
1434   if (pass->tv_id != TV_NONE)
1435     timevar_push (pass->tv_id);
1436
1437   /* Do it!  */
1438   todo_after = ipa_pass->function_transform (node);
1439
1440   /* Stop timevar.  */
1441   if (pass->tv_id != TV_NONE)
1442     timevar_pop (pass->tv_id);
1443
1444   /* Run post-pass cleanup and verification.  */
1445   execute_todo (todo_after);
1446   verify_interpass_invariants ();
1447
1448   pass_fini_dump_file (pass);
1449
1450   current_pass = NULL;
1451 }
1452
1453 /* For the current function, execute all ipa transforms. */
1454
1455 void
1456 execute_all_ipa_transforms (void)
1457 {
1458   struct cgraph_node *node;
1459   if (!cfun)
1460     return;
1461   node = cgraph_node (current_function_decl);
1462   if (node->ipa_transforms_to_apply)
1463     {
1464       unsigned int i;
1465
1466       for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply);
1467            i++)
1468         execute_one_ipa_transform_pass (node,
1469                                         VEC_index (ipa_opt_pass,
1470                                                    node->ipa_transforms_to_apply,
1471                                                    i));
1472       VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply);
1473       node->ipa_transforms_to_apply = NULL;
1474     }
1475 }
1476
1477 /* Execute PASS. */
1478
1479 static bool
1480 execute_one_pass (struct opt_pass *pass)
1481 {
1482   bool initializing_dump;
1483   unsigned int todo_after = 0;
1484
1485   /* IPA passes are executed on whole program, so cfun should be NULL.
1486      Other passes need function context set.  */
1487   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
1488     gcc_assert (!cfun && !current_function_decl);
1489   else
1490     gcc_assert (cfun && current_function_decl);
1491
1492   current_pass = pass;
1493
1494   /* See if we're supposed to run this pass.  */
1495   if (pass->gate && !pass->gate ())
1496     return false;
1497
1498   if (!quiet_flag && !cfun)
1499     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1500
1501   /* Note that the folders should only create gimple expressions.
1502      This is a hack until the new folder is ready.  */
1503   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1504
1505   initializing_dump = pass_init_dump_file (pass);
1506
1507   /* Run pre-pass verification.  */
1508   execute_todo (pass->todo_flags_start);
1509
1510 #ifdef ENABLE_CHECKING
1511   do_per_function (verify_curr_properties,
1512                    (void *)(size_t)pass->properties_required);
1513 #endif
1514
1515   /* If a timevar is present, start it.  */
1516   if (pass->tv_id != TV_NONE)
1517     timevar_push (pass->tv_id);
1518
1519   /* Do it!  */
1520   if (pass->execute)
1521     {
1522       todo_after = pass->execute ();
1523       do_per_function (clear_last_verified, NULL);
1524     }
1525
1526   /* Stop timevar.  */
1527   if (pass->tv_id != TV_NONE)
1528     timevar_pop (pass->tv_id);
1529
1530   do_per_function (update_properties_after_pass, pass);
1531
1532   if (initializing_dump
1533       && dump_file
1534       && graph_dump_format != no_graph
1535       && cfun
1536       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1537           == (PROP_cfg | PROP_rtl))
1538     {
1539       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1540       dump_flags |= TDF_GRAPH;
1541       clean_graph_dump_file (dump_file_name);
1542     }
1543
1544   /* Run post-pass cleanup and verification.  */
1545   execute_todo (todo_after | pass->todo_flags_finish);
1546   verify_interpass_invariants ();
1547   if (pass->type == IPA_PASS)
1548     {
1549       struct cgraph_node *node;
1550       for (node = cgraph_nodes; node; node = node->next)
1551         if (node->analyzed)
1552           VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
1553                          (struct ipa_opt_pass_d *)pass);
1554     }
1555
1556   if (!current_function_decl)
1557     cgraph_process_new_functions ();
1558
1559   pass_fini_dump_file (pass);
1560
1561   if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
1562     gcc_assert (!(cfun->curr_properties & PROP_trees)
1563                 || pass->type != RTL_PASS);
1564
1565   current_pass = NULL;
1566
1567   return true;
1568 }
1569
1570 void
1571 execute_pass_list (struct opt_pass *pass)
1572 {
1573   do
1574     {
1575       gcc_assert (pass->type == GIMPLE_PASS
1576                   || pass->type == RTL_PASS);
1577       if (execute_one_pass (pass) && pass->sub)
1578         execute_pass_list (pass->sub);
1579       pass = pass->next;
1580     }
1581   while (pass);
1582 }
1583
1584 /* Same as execute_pass_list but assume that subpasses of IPA passes
1585    are local passes. If SET is not NULL, write out summaries of only
1586    those node in SET. */
1587
1588 static void
1589 ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
1590                        struct lto_out_decl_state *state)
1591 {
1592   while (pass)
1593     {
1594       struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
1595       gcc_assert (!current_function_decl);
1596       gcc_assert (!cfun);
1597       gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1598       if (pass->type == IPA_PASS
1599           && ipa_pass->write_summary
1600           && (!pass->gate || pass->gate ()))
1601         {
1602           /* If a timevar is present, start it.  */
1603           if (pass->tv_id)
1604             timevar_push (pass->tv_id);
1605
1606           ipa_pass->write_summary (set);
1607
1608           /* If a timevar is present, start it.  */
1609           if (pass->tv_id)
1610             timevar_pop (pass->tv_id);
1611         }
1612
1613       if (pass->sub && pass->sub->type != GIMPLE_PASS)
1614         ipa_write_summaries_2 (pass->sub, set, state);
1615
1616       pass = pass->next;
1617     }
1618 }
1619
1620 /* Helper function of ipa_write_summaries. Creates and destroys the
1621    decl state and calls ipa_write_summaries_2 for all passes that have
1622    summaries.  SET is the set of nodes to be written.  */
1623
1624 static void
1625 ipa_write_summaries_1 (cgraph_node_set set)
1626 {
1627   struct lto_out_decl_state *state = lto_new_out_decl_state ();
1628   lto_push_out_decl_state (state);
1629
1630   if (!flag_wpa)
1631     ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
1632   ipa_write_summaries_2 (all_lto_gen_passes, set, state);
1633
1634   gcc_assert (lto_get_out_decl_state () == state);
1635   lto_pop_out_decl_state ();
1636   lto_delete_out_decl_state (state);
1637 }
1638
1639 /* Write out summaries for all the nodes in the callgraph.  */
1640
1641 void
1642 ipa_write_summaries (void)
1643 {
1644   cgraph_node_set set;
1645   struct cgraph_node **order;
1646   int i, order_pos;
1647  
1648   if (!flag_generate_lto || errorcount || sorrycount)
1649     return;
1650
1651   lto_new_extern_inline_states ();
1652   set = cgraph_node_set_new ();
1653
1654   /* Create the callgraph set in the same order used in
1655      cgraph_expand_all_functions.  This mostly facilitates debugging,
1656      since it causes the gimple file to be processed in the same order
1657      as the source code.  */
1658   order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1659   order_pos = cgraph_postorder (order);
1660   gcc_assert (order_pos == cgraph_n_nodes);
1661
1662   for (i = order_pos - 1; i >= 0; i--)
1663     cgraph_node_set_add (set, order[i]);
1664
1665   ipa_write_summaries_1 (set);
1666   lto_delete_extern_inline_states ();
1667
1668   free (order);
1669   ggc_free (set);
1670 }
1671
1672
1673 /* Write all the summaries for the cgraph nodes in SET.  If SET is
1674    NULL, write out all summaries of all nodes. */
1675
1676 void
1677 ipa_write_summaries_of_cgraph_node_set (cgraph_node_set set)
1678 {
1679   if (flag_generate_lto && !(errorcount || sorrycount))
1680     ipa_write_summaries_1 (set);
1681 }
1682
1683 /* Same as execute_pass_list but assume that subpasses of IPA passes
1684    are local passes.  */
1685
1686 static void
1687 ipa_read_summaries_1 (struct opt_pass *pass)
1688 {
1689   while (pass)
1690     {
1691       struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
1692
1693       gcc_assert (!current_function_decl);
1694       gcc_assert (!cfun);
1695       gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1696
1697       if (pass->gate == NULL || pass->gate ())
1698         {
1699           if (pass->type == IPA_PASS && ipa_pass->read_summary)
1700             {
1701               /* If a timevar is present, start it.  */
1702               if (pass->tv_id)
1703                 timevar_push (pass->tv_id);
1704
1705               ipa_pass->read_summary ();
1706
1707               /* Stop timevar.  */
1708               if (pass->tv_id)
1709                 timevar_pop (pass->tv_id);
1710             }
1711
1712           if (pass->sub && pass->sub->type != GIMPLE_PASS)
1713             ipa_read_summaries_1 (pass->sub);
1714         }
1715       pass = pass->next;
1716     }
1717 }
1718
1719
1720 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes.  */
1721
1722 void
1723 ipa_read_summaries (void)
1724 {
1725   if (!flag_ltrans)
1726     ipa_read_summaries_1 (all_regular_ipa_passes);
1727   ipa_read_summaries_1 (all_lto_gen_passes);
1728 }
1729
1730 /* Same as execute_pass_list but assume that subpasses of IPA passes
1731    are local passes.  */
1732 void
1733 execute_ipa_pass_list (struct opt_pass *pass)
1734 {
1735   do
1736     {
1737       gcc_assert (!current_function_decl);
1738       gcc_assert (!cfun);
1739       gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1740       if (execute_one_pass (pass) && pass->sub)
1741         {
1742           if (pass->sub->type == GIMPLE_PASS)
1743             do_per_function_toporder ((void (*)(void *))execute_pass_list,
1744                                       pass->sub);
1745           else if (pass->sub->type == SIMPLE_IPA_PASS
1746                    || pass->sub->type == IPA_PASS)
1747             execute_ipa_pass_list (pass->sub);
1748           else
1749             gcc_unreachable ();
1750         }
1751       gcc_assert (!current_function_decl);
1752       cgraph_process_new_functions ();
1753       pass = pass->next;
1754     }
1755   while (pass);
1756 }
1757
1758 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS.  */
1759
1760 static void
1761 execute_ipa_stmt_fixups (struct opt_pass *pass,
1762                           struct cgraph_node *node, gimple *stmts)
1763 {
1764   while (pass)
1765     {
1766       /* Execute all of the IPA_PASSes in the list.  */
1767       if (pass->type == IPA_PASS
1768           && (!pass->gate || pass->gate ()))
1769         {
1770           struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
1771
1772           if (ipa_pass->stmt_fixup)
1773             {
1774               pass_init_dump_file (pass);
1775               /* If a timevar is present, start it.  */
1776               if (pass->tv_id)
1777                 timevar_push (pass->tv_id);
1778
1779               ipa_pass->stmt_fixup (node, stmts);
1780
1781               /* Stop timevar.  */
1782               if (pass->tv_id)
1783                 timevar_pop (pass->tv_id);
1784               pass_fini_dump_file (pass);
1785             }
1786           if (pass->sub)
1787             execute_ipa_stmt_fixups (pass->sub, node, stmts);
1788         }
1789       pass = pass->next;
1790     }
1791 }
1792
1793 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS.  */
1794
1795 void
1796 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
1797 {
1798   execute_ipa_stmt_fixups (all_regular_ipa_passes, node, stmts);
1799 }
1800
1801
1802 extern void debug_properties (unsigned int);
1803 extern void dump_properties (FILE *, unsigned int);
1804
1805 void
1806 dump_properties (FILE *dump, unsigned int props)
1807 {
1808   fprintf (dump, "Properties:\n");
1809   if (props & PROP_gimple_any)
1810     fprintf (dump, "PROP_gimple_any\n");
1811   if (props & PROP_gimple_lcf)
1812     fprintf (dump, "PROP_gimple_lcf\n");
1813   if (props & PROP_gimple_leh)
1814     fprintf (dump, "PROP_gimple_leh\n");
1815   if (props & PROP_cfg)
1816     fprintf (dump, "PROP_cfg\n");
1817   if (props & PROP_referenced_vars)
1818     fprintf (dump, "PROP_referenced_vars\n");
1819   if (props & PROP_ssa)
1820     fprintf (dump, "PROP_ssa\n");
1821   if (props & PROP_no_crit_edges)
1822     fprintf (dump, "PROP_no_crit_edges\n");
1823   if (props & PROP_rtl)
1824     fprintf (dump, "PROP_rtl\n");
1825   if (props & PROP_gimple_lomp)
1826     fprintf (dump, "PROP_gimple_lomp\n");
1827 }
1828
1829 void
1830 debug_properties (unsigned int props)
1831 {
1832   dump_properties (stderr, props);
1833 }
1834
1835 /* Called by local passes to see if function is called by already processed nodes.
1836    Because we process nodes in topological order, this means that function is
1837    in recursive cycle or we introduced new direct calls.  */
1838 bool
1839 function_called_by_processed_nodes_p (void)
1840 {
1841   struct cgraph_edge *e;
1842   for (e = cgraph_node (current_function_decl)->callers; e; e = e->next_caller)
1843     {
1844       if (e->caller->decl == current_function_decl)
1845         continue;
1846       if (!e->caller->analyzed)
1847         continue;
1848       if (TREE_ASM_WRITTEN (e->caller->decl))
1849         continue;
1850       if (!e->caller->process && !e->caller->global.inlined_to)
1851         break;
1852     }
1853   if (dump_file && e)
1854     {
1855       fprintf (dump_file, "Already processed call to:\n");
1856       dump_cgraph_node (dump_file, e->caller);
1857     }
1858   return e != NULL;
1859 }
1860
1861 #include "gt-passes.h"