OSDN Git Service

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