Daily bump.
[official-gcc.git] / gcc / passes.c
blob062ae4f0d1b40c0dddfafefc1e79e85d7926c706
1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This is the top level of cc1/c++.
21 It parses command args, opens files, invokes the various passes
22 in the proper order, and counts the time used by each.
23 Error messages and low-level interface to malloc also handled here. */
25 #include "config.h"
26 #include "system.h"
27 #include "coretypes.h"
28 #include "tm.h"
29 #include "line-map.h"
30 #include "input.h"
31 #include "hash-set.h"
32 #include "machmode.h"
33 #include "vec.h"
34 #include "double-int.h"
35 #include "alias.h"
36 #include "symtab.h"
37 #include "wide-int.h"
38 #include "inchash.h"
39 #include "tree.h"
40 #include "fold-const.h"
41 #include "varasm.h"
42 #include "rtl.h"
43 #include "tm_p.h"
44 #include "flags.h"
45 #include "insn-attr.h"
46 #include "insn-config.h"
47 #include "insn-flags.h"
48 #include "hard-reg-set.h"
49 #include "recog.h"
50 #include "output.h"
51 #include "except.h"
52 #include "function.h"
53 #include "toplev.h"
54 #include "hashtab.h"
55 #include "statistics.h"
56 #include "real.h"
57 #include "fixed-value.h"
58 #include "expmed.h"
59 #include "dojump.h"
60 #include "explow.h"
61 #include "calls.h"
62 #include "emit-rtl.h"
63 #include "stmt.h"
64 #include "expr.h"
65 #include "predict.h"
66 #include "basic-block.h"
67 #include "intl.h"
68 #include "graph.h"
69 #include "regs.h"
70 #include "diagnostic-core.h"
71 #include "params.h"
72 #include "reload.h"
73 #include "debug.h"
74 #include "target.h"
75 #include "langhooks.h"
76 #include "cfgloop.h"
77 #include "hosthooks.h"
78 #include "opts.h"
79 #include "coverage.h"
80 #include "value-prof.h"
81 #include "tree-inline.h"
82 #include "tree-ssa-alias.h"
83 #include "internal-fn.h"
84 #include "gimple-expr.h"
85 #include "is-a.h"
86 #include "gimple.h"
87 #include "gimple-ssa.h"
88 #include "tree-cfg.h"
89 #include "stringpool.h"
90 #include "tree-ssanames.h"
91 #include "tree-ssa-loop-manip.h"
92 #include "tree-into-ssa.h"
93 #include "tree-dfa.h"
94 #include "tree-ssa.h"
95 #include "tree-pass.h"
96 #include "tree-dump.h"
97 #include "df.h"
98 #include "hash-map.h"
99 #include "plugin-api.h"
100 #include "ipa-ref.h"
101 #include "cgraph.h"
102 #include "lto-streamer.h"
103 #include "plugin.h"
104 #include "ipa-utils.h"
105 #include "tree-pretty-print.h" /* for dump_function_header */
106 #include "context.h"
107 #include "pass_manager.h"
108 #include "tree-ssa-live.h" /* For remove_unused_locals. */
109 #include "tree-cfgcleanup.h"
111 using namespace gcc;
113 /* This is used for debugging. It allows the current pass to printed
114 from anywhere in compilation.
115 The variable current_pass is also used for statistics and plugins. */
116 opt_pass *current_pass;
118 static void register_pass_name (opt_pass *, const char *);
120 /* Most passes are single-instance (within their context) and thus don't
121 need to implement cloning, but passes that support multiple instances
122 *must* provide their own implementation of the clone method.
124 Handle this by providing a default implemenation, but make it a fatal
125 error to call it. */
127 opt_pass *
128 opt_pass::clone ()
130 internal_error ("pass %s does not support cloning", name);
133 bool
134 opt_pass::gate (function *)
136 return true;
139 unsigned int
140 opt_pass::execute (function *)
142 return 0;
145 opt_pass::opt_pass (const pass_data &data, context *ctxt)
146 : pass_data (data),
147 sub (NULL),
148 next (NULL),
149 static_pass_number (0),
150 m_ctxt (ctxt)
155 void
156 pass_manager::execute_early_local_passes ()
158 execute_pass_list (cfun, pass_build_ssa_passes_1->sub);
159 if (flag_check_pointer_bounds)
160 execute_pass_list (cfun, pass_chkp_instrumentation_passes_1->sub);
161 execute_pass_list (cfun, pass_local_optimization_passes_1->sub);
164 unsigned int
165 pass_manager::execute_pass_mode_switching ()
167 return pass_mode_switching_1->execute (cfun);
171 /* Call from anywhere to find out what pass this is. Useful for
172 printing out debugging information deep inside an service
173 routine. */
174 void
175 print_current_pass (FILE *file)
177 if (current_pass)
178 fprintf (file, "current pass = %s (%d)\n",
179 current_pass->name, current_pass->static_pass_number);
180 else
181 fprintf (file, "no current pass.\n");
185 /* Call from the debugger to get the current pass name. */
186 DEBUG_FUNCTION void
187 debug_pass (void)
189 print_current_pass (stderr);
194 /* Global variables used to communicate with passes. */
195 bool in_gimple_form;
196 bool first_pass_instance;
199 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
200 and TYPE_DECL nodes.
202 This does nothing for local (non-static) variables, unless the
203 variable is a register variable with DECL_ASSEMBLER_NAME set. In
204 that case, or if the variable is not an automatic, it sets up the
205 RTL and outputs any assembler code (label definition, storage
206 allocation and initialization).
208 DECL is the declaration. TOP_LEVEL is nonzero
209 if this declaration is not within a function. */
211 void
212 rest_of_decl_compilation (tree decl,
213 int top_level,
214 int at_end)
216 bool finalize = true;
218 /* We deferred calling assemble_alias so that we could collect
219 other attributes such as visibility. Emit the alias now. */
220 if (!in_lto_p)
222 tree alias;
223 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
224 if (alias)
226 alias = TREE_VALUE (TREE_VALUE (alias));
227 alias = get_identifier (TREE_STRING_POINTER (alias));
228 /* A quirk of the initial implementation of aliases required that the
229 user add "extern" to all of them. Which is silly, but now
230 historical. Do note that the symbol is in fact locally defined. */
231 DECL_EXTERNAL (decl) = 0;
232 TREE_STATIC (decl) = 1;
233 assemble_alias (decl, alias);
234 finalize = false;
238 /* Can't defer this, because it needs to happen before any
239 later function definitions are processed. */
240 if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
241 make_decl_rtl (decl);
243 /* Forward declarations for nested functions are not "external",
244 but we need to treat them as if they were. */
245 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
246 || TREE_CODE (decl) == FUNCTION_DECL)
248 timevar_push (TV_VARCONST);
250 /* Don't output anything when a tentative file-scope definition
251 is seen. But at end of compilation, do output code for them.
253 We do output all variables and rely on
254 callgraph code to defer them except for forward declarations
255 (see gcc.c-torture/compile/920624-1.c) */
256 if ((at_end
257 || !DECL_DEFER_OUTPUT (decl)
258 || DECL_INITIAL (decl))
259 && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl))
260 && !DECL_EXTERNAL (decl))
262 /* When reading LTO unit, we also read varpool, so do not
263 rebuild it. */
264 if (in_lto_p && !at_end)
266 else if (finalize && TREE_CODE (decl) != FUNCTION_DECL)
267 varpool_node::finalize_decl (decl);
270 #ifdef ASM_FINISH_DECLARE_OBJECT
271 if (decl == last_assemble_variable_decl)
273 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
274 top_level, at_end);
276 #endif
278 timevar_pop (TV_VARCONST);
280 else if (TREE_CODE (decl) == TYPE_DECL
281 /* Like in rest_of_type_compilation, avoid confusing the debug
282 information machinery when there are errors. */
283 && !seen_error ())
285 timevar_push (TV_SYMOUT);
286 debug_hooks->type_decl (decl, !top_level);
287 timevar_pop (TV_SYMOUT);
290 /* Let cgraph know about the existence of variables. */
291 if (in_lto_p && !at_end)
293 else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
294 && TREE_STATIC (decl))
295 varpool_node::get_create (decl);
298 /* Called after finishing a record, union or enumeral type. */
300 void
301 rest_of_type_compilation (tree type, int toplev)
303 /* Avoid confusing the debug information machinery when there are
304 errors. */
305 if (seen_error ())
306 return;
308 timevar_push (TV_SYMOUT);
309 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
310 timevar_pop (TV_SYMOUT);
315 void
316 pass_manager::
317 finish_optimization_passes (void)
319 int i;
320 struct dump_file_info *dfi;
321 char *name;
322 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
324 timevar_push (TV_DUMP);
325 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
327 dumps->dump_start (pass_profile_1->static_pass_number, NULL);
328 end_branch_prob ();
329 dumps->dump_finish (pass_profile_1->static_pass_number);
332 if (optimize > 0)
334 dumps->dump_start (pass_profile_1->static_pass_number, NULL);
335 print_combine_total_stats ();
336 dumps->dump_finish (pass_profile_1->static_pass_number);
339 /* Do whatever is necessary to finish printing the graphs. */
340 for (i = TDI_end; (dfi = dumps->get_dump_file_info (i)) != NULL; ++i)
341 if (dumps->dump_initialized_p (i)
342 && (dfi->pflags & TDF_GRAPH) != 0
343 && (name = dumps->get_dump_file_name (i)) != NULL)
345 finish_graph_dump_file (name);
346 free (name);
349 timevar_pop (TV_DUMP);
352 static unsigned int
353 execute_build_ssa_passes (void)
355 /* Once this pass (and its sub-passes) are complete, all functions
356 will be in SSA form. Technically this state change is happening
357 a tad early, since the sub-passes have not yet run, but since
358 none of the sub-passes are IPA passes and do not create new
359 functions, this is ok. We're setting this value for the benefit
360 of IPA passes that follow. */
361 if (symtab->state < IPA_SSA)
362 symtab->state = IPA_SSA;
363 return 0;
366 namespace {
368 const pass_data pass_data_build_ssa_passes =
370 SIMPLE_IPA_PASS, /* type */
371 "build_ssa_passes", /* name */
372 OPTGROUP_NONE, /* optinfo_flags */
373 TV_EARLY_LOCAL, /* tv_id */
374 0, /* properties_required */
375 0, /* properties_provided */
376 0, /* properties_destroyed */
377 0, /* todo_flags_start */
378 /* todo_flags_finish is executed before subpases. For this reason
379 it makes no sense to remove unreachable functions here. */
380 0, /* todo_flags_finish */
383 class pass_build_ssa_passes : public simple_ipa_opt_pass
385 public:
386 pass_build_ssa_passes (gcc::context *ctxt)
387 : simple_ipa_opt_pass (pass_data_build_ssa_passes, ctxt)
390 /* opt_pass methods: */
391 virtual bool gate (function *)
393 /* Don't bother doing anything if the program has errors. */
394 return (!seen_error () && !in_lto_p);
397 virtual unsigned int execute (function *)
399 return execute_build_ssa_passes ();
402 }; // class pass_build_ssa_passes
404 const pass_data pass_data_chkp_instrumentation_passes =
406 SIMPLE_IPA_PASS, /* type */
407 "chkp_passes", /* name */
408 OPTGROUP_NONE, /* optinfo_flags */
409 TV_NONE, /* tv_id */
410 0, /* properties_required */
411 0, /* properties_provided */
412 0, /* properties_destroyed */
413 0, /* todo_flags_start */
414 0, /* todo_flags_finish */
417 class pass_chkp_instrumentation_passes : public simple_ipa_opt_pass
419 public:
420 pass_chkp_instrumentation_passes (gcc::context *ctxt)
421 : simple_ipa_opt_pass (pass_data_chkp_instrumentation_passes, ctxt)
424 /* opt_pass methods: */
425 virtual bool gate (function *)
427 /* Don't bother doing anything if the program has errors. */
428 return (flag_check_pointer_bounds
429 && !seen_error () && !in_lto_p);
432 }; // class pass_chkp_instrumentation_passes
434 const pass_data pass_data_local_optimization_passes =
436 SIMPLE_IPA_PASS, /* type */
437 "opt_local_passes", /* name */
438 OPTGROUP_NONE, /* optinfo_flags */
439 TV_NONE, /* tv_id */
440 0, /* properties_required */
441 0, /* properties_provided */
442 0, /* properties_destroyed */
443 0, /* todo_flags_start */
444 0, /* todo_flags_finish */
447 class pass_local_optimization_passes : public simple_ipa_opt_pass
449 public:
450 pass_local_optimization_passes (gcc::context *ctxt)
451 : simple_ipa_opt_pass (pass_data_local_optimization_passes, ctxt)
454 /* opt_pass methods: */
455 virtual bool gate (function *)
457 /* Don't bother doing anything if the program has errors. */
458 return (!seen_error () && !in_lto_p);
461 }; // class pass_local_optimization_passes
463 } // anon namespace
465 simple_ipa_opt_pass *
466 make_pass_build_ssa_passes (gcc::context *ctxt)
468 return new pass_build_ssa_passes (ctxt);
471 simple_ipa_opt_pass *
472 make_pass_chkp_instrumentation_passes (gcc::context *ctxt)
474 return new pass_chkp_instrumentation_passes (ctxt);
477 simple_ipa_opt_pass *
478 make_pass_local_optimization_passes (gcc::context *ctxt)
480 return new pass_local_optimization_passes (ctxt);
483 namespace {
485 const pass_data pass_data_all_early_optimizations =
487 GIMPLE_PASS, /* type */
488 "early_optimizations", /* name */
489 OPTGROUP_NONE, /* optinfo_flags */
490 TV_NONE, /* tv_id */
491 0, /* properties_required */
492 0, /* properties_provided */
493 0, /* properties_destroyed */
494 0, /* todo_flags_start */
495 0, /* todo_flags_finish */
498 class pass_all_early_optimizations : public gimple_opt_pass
500 public:
501 pass_all_early_optimizations (gcc::context *ctxt)
502 : gimple_opt_pass (pass_data_all_early_optimizations, ctxt)
505 /* opt_pass methods: */
506 virtual bool gate (function *)
508 return (optimize >= 1
509 /* Don't bother doing anything if the program has errors. */
510 && !seen_error ());
513 }; // class pass_all_early_optimizations
515 } // anon namespace
517 static gimple_opt_pass *
518 make_pass_all_early_optimizations (gcc::context *ctxt)
520 return new pass_all_early_optimizations (ctxt);
523 namespace {
525 const pass_data pass_data_all_optimizations =
527 GIMPLE_PASS, /* type */
528 "*all_optimizations", /* name */
529 OPTGROUP_NONE, /* optinfo_flags */
530 TV_OPTIMIZE, /* tv_id */
531 0, /* properties_required */
532 0, /* properties_provided */
533 0, /* properties_destroyed */
534 0, /* todo_flags_start */
535 0, /* todo_flags_finish */
538 class pass_all_optimizations : public gimple_opt_pass
540 public:
541 pass_all_optimizations (gcc::context *ctxt)
542 : gimple_opt_pass (pass_data_all_optimizations, ctxt)
545 /* opt_pass methods: */
546 virtual bool gate (function *) { return optimize >= 1 && !optimize_debug; }
548 }; // class pass_all_optimizations
550 } // anon namespace
552 static gimple_opt_pass *
553 make_pass_all_optimizations (gcc::context *ctxt)
555 return new pass_all_optimizations (ctxt);
558 namespace {
560 const pass_data pass_data_all_optimizations_g =
562 GIMPLE_PASS, /* type */
563 "*all_optimizations_g", /* name */
564 OPTGROUP_NONE, /* optinfo_flags */
565 TV_OPTIMIZE, /* tv_id */
566 0, /* properties_required */
567 0, /* properties_provided */
568 0, /* properties_destroyed */
569 0, /* todo_flags_start */
570 0, /* todo_flags_finish */
573 class pass_all_optimizations_g : public gimple_opt_pass
575 public:
576 pass_all_optimizations_g (gcc::context *ctxt)
577 : gimple_opt_pass (pass_data_all_optimizations_g, ctxt)
580 /* opt_pass methods: */
581 virtual bool gate (function *) { return optimize >= 1 && optimize_debug; }
583 }; // class pass_all_optimizations_g
585 } // anon namespace
587 static gimple_opt_pass *
588 make_pass_all_optimizations_g (gcc::context *ctxt)
590 return new pass_all_optimizations_g (ctxt);
593 namespace {
595 const pass_data pass_data_rest_of_compilation =
597 RTL_PASS, /* type */
598 "*rest_of_compilation", /* name */
599 OPTGROUP_NONE, /* optinfo_flags */
600 TV_REST_OF_COMPILATION, /* tv_id */
601 PROP_rtl, /* properties_required */
602 0, /* properties_provided */
603 0, /* properties_destroyed */
604 0, /* todo_flags_start */
605 0, /* todo_flags_finish */
608 class pass_rest_of_compilation : public rtl_opt_pass
610 public:
611 pass_rest_of_compilation (gcc::context *ctxt)
612 : rtl_opt_pass (pass_data_rest_of_compilation, ctxt)
615 /* opt_pass methods: */
616 virtual bool gate (function *)
618 /* Early return if there were errors. We can run afoul of our
619 consistency checks, and there's not really much point in fixing them. */
620 return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
623 }; // class pass_rest_of_compilation
625 } // anon namespace
627 static rtl_opt_pass *
628 make_pass_rest_of_compilation (gcc::context *ctxt)
630 return new pass_rest_of_compilation (ctxt);
633 namespace {
635 const pass_data pass_data_postreload =
637 RTL_PASS, /* type */
638 "*all-postreload", /* name */
639 OPTGROUP_NONE, /* optinfo_flags */
640 TV_POSTRELOAD, /* tv_id */
641 PROP_rtl, /* properties_required */
642 0, /* properties_provided */
643 0, /* properties_destroyed */
644 0, /* todo_flags_start */
645 0, /* todo_flags_finish */
648 class pass_postreload : public rtl_opt_pass
650 public:
651 pass_postreload (gcc::context *ctxt)
652 : rtl_opt_pass (pass_data_postreload, ctxt)
655 /* opt_pass methods: */
656 virtual bool gate (function *) { return reload_completed; }
658 }; // class pass_postreload
660 } // anon namespace
662 static rtl_opt_pass *
663 make_pass_postreload (gcc::context *ctxt)
665 return new pass_postreload (ctxt);
668 namespace {
670 const pass_data pass_data_late_compilation =
672 RTL_PASS, /* type */
673 "*all-late_compilation", /* name */
674 OPTGROUP_NONE, /* optinfo_flags */
675 TV_LATE_COMPILATION, /* tv_id */
676 PROP_rtl, /* properties_required */
677 0, /* properties_provided */
678 0, /* properties_destroyed */
679 0, /* todo_flags_start */
680 0, /* todo_flags_finish */
683 class pass_late_compilation : public rtl_opt_pass
685 public:
686 pass_late_compilation (gcc::context *ctxt)
687 : rtl_opt_pass (pass_data_late_compilation, ctxt)
690 /* opt_pass methods: */
691 virtual bool gate (function *)
693 return reload_completed || targetm.no_register_allocation;
696 }; // class pass_late_compilation
698 } // anon namespace
700 static rtl_opt_pass *
701 make_pass_late_compilation (gcc::context *ctxt)
703 return new pass_late_compilation (ctxt);
708 /* Set the static pass number of pass PASS to ID and record that
709 in the mapping from static pass number to pass. */
711 void
712 pass_manager::
713 set_pass_for_id (int id, opt_pass *pass)
715 pass->static_pass_number = id;
716 if (passes_by_id_size <= id)
718 passes_by_id = XRESIZEVEC (opt_pass *, passes_by_id, id + 1);
719 memset (passes_by_id + passes_by_id_size, 0,
720 (id + 1 - passes_by_id_size) * sizeof (void *));
721 passes_by_id_size = id + 1;
723 passes_by_id[id] = pass;
726 /* Return the pass with the static pass number ID. */
728 opt_pass *
729 pass_manager::get_pass_for_id (int id) const
731 if (id >= passes_by_id_size)
732 return NULL;
733 return passes_by_id[id];
736 /* Iterate over the pass tree allocating dump file numbers. We want
737 to do this depth first, and independent of whether the pass is
738 enabled or not. */
740 void
741 register_one_dump_file (opt_pass *pass)
743 g->get_passes ()->register_one_dump_file (pass);
746 void
747 pass_manager::register_one_dump_file (opt_pass *pass)
749 char *dot_name, *flag_name, *glob_name;
750 const char *name, *full_name, *prefix;
751 char num[10];
752 int flags, id;
753 int optgroup_flags = OPTGROUP_NONE;
754 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
756 /* See below in next_pass_1. */
757 num[0] = '\0';
758 if (pass->static_pass_number != -1)
759 sprintf (num, "%d", ((int) pass->static_pass_number < 0
760 ? 1 : pass->static_pass_number));
762 /* The name is both used to identify the pass for the purposes of plugins,
763 and to specify dump file name and option.
764 The latter two might want something short which is not quite unique; for
765 that reason, we may have a disambiguating prefix, followed by a space
766 to mark the start of the following dump file name / option string. */
767 name = strchr (pass->name, ' ');
768 name = name ? name + 1 : pass->name;
769 dot_name = concat (".", name, num, NULL);
770 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
772 prefix = "ipa-";
773 flags = TDF_IPA;
774 optgroup_flags |= OPTGROUP_IPA;
776 else if (pass->type == GIMPLE_PASS)
778 prefix = "tree-";
779 flags = TDF_TREE;
781 else
783 prefix = "rtl-";
784 flags = TDF_RTL;
787 flag_name = concat (prefix, name, num, NULL);
788 glob_name = concat (prefix, name, NULL);
789 optgroup_flags |= pass->optinfo_flags;
790 /* For any passes that do not have an optgroup set, and which are not
791 IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
792 any dump messages are emitted properly under -fopt-info(-optall). */
793 if (optgroup_flags == OPTGROUP_NONE)
794 optgroup_flags = OPTGROUP_OTHER;
795 id = dumps->dump_register (dot_name, flag_name, glob_name, flags,
796 optgroup_flags,
797 true);
798 set_pass_for_id (id, pass);
799 full_name = concat (prefix, pass->name, num, NULL);
800 register_pass_name (pass, full_name);
801 free (CONST_CAST (char *, full_name));
804 /* Register the dump files for the pass_manager starting at PASS. */
806 void
807 pass_manager::register_dump_files (opt_pass *pass)
811 if (pass->name && pass->name[0] != '*')
812 register_one_dump_file (pass);
814 if (pass->sub)
815 register_dump_files (pass->sub);
817 pass = pass->next;
819 while (pass);
822 /* Helper for pass_registry hash table. */
824 struct pass_registry_hasher : default_hashmap_traits
826 static inline hashval_t hash (const char *);
827 static inline bool equal_keys (const char *, const char *);
830 /* Pass registry hash function. */
832 inline hashval_t
833 pass_registry_hasher::hash (const char *name)
835 return htab_hash_string (name);
838 /* Hash equal function */
840 inline bool
841 pass_registry_hasher::equal_keys (const char *s1, const char *s2)
843 return !strcmp (s1, s2);
846 static hash_map<const char *, opt_pass *, pass_registry_hasher>
847 *name_to_pass_map;
849 /* Register PASS with NAME. */
851 static void
852 register_pass_name (opt_pass *pass, const char *name)
854 if (!name_to_pass_map)
855 name_to_pass_map
856 = new hash_map<const char *, opt_pass *, pass_registry_hasher> (256);
858 if (name_to_pass_map->get (name))
859 return; /* Ignore plugin passes. */
861 const char *unique_name = xstrdup (name);
862 name_to_pass_map->put (unique_name, pass);
865 /* Map from pass id to canonicalized pass name. */
867 typedef const char *char_ptr;
868 static vec<char_ptr> pass_tab = vNULL;
870 /* Callback function for traversing NAME_TO_PASS_MAP. */
872 bool
873 passes_pass_traverse (const char *const &name, opt_pass *const &pass, void *)
875 gcc_assert (pass->static_pass_number > 0);
876 gcc_assert (pass_tab.exists ());
878 pass_tab[pass->static_pass_number] = name;
880 return 1;
883 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
884 table for dumping purpose. */
886 static void
887 create_pass_tab (void)
889 if (!flag_dump_passes)
890 return;
892 pass_tab.safe_grow_cleared (g->get_passes ()->passes_by_id_size + 1);
893 name_to_pass_map->traverse <void *, passes_pass_traverse> (NULL);
896 static bool override_gate_status (opt_pass *, tree, bool);
898 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
899 is turned on or not. */
901 static void
902 dump_one_pass (opt_pass *pass, int pass_indent)
904 int indent = 3 * pass_indent;
905 const char *pn;
906 bool is_on, is_really_on;
908 is_on = pass->gate (cfun);
909 is_really_on = override_gate_status (pass, current_function_decl, is_on);
911 if (pass->static_pass_number <= 0)
912 pn = pass->name;
913 else
914 pn = pass_tab[pass->static_pass_number];
916 fprintf (stderr, "%*s%-40s%*s:%s%s\n", indent, " ", pn,
917 (15 - indent < 0 ? 0 : 15 - indent), " ",
918 is_on ? " ON" : " OFF",
919 ((!is_on) == (!is_really_on) ? ""
920 : (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)")));
923 /* Dump pass list PASS with indentation INDENT. */
925 static void
926 dump_pass_list (opt_pass *pass, int indent)
930 dump_one_pass (pass, indent);
931 if (pass->sub)
932 dump_pass_list (pass->sub, indent + 1);
933 pass = pass->next;
935 while (pass);
938 /* Dump all optimization passes. */
940 void
941 dump_passes (void)
943 g->get_passes ()->dump_passes ();
946 void
947 pass_manager::dump_passes () const
949 struct cgraph_node *n, *node = NULL;
951 create_pass_tab ();
953 FOR_EACH_FUNCTION (n)
954 if (DECL_STRUCT_FUNCTION (n->decl))
956 node = n;
957 break;
960 if (!node)
961 return;
963 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
965 dump_pass_list (all_lowering_passes, 1);
966 dump_pass_list (all_small_ipa_passes, 1);
967 dump_pass_list (all_regular_ipa_passes, 1);
968 dump_pass_list (all_late_ipa_passes, 1);
969 dump_pass_list (all_passes, 1);
971 pop_cfun ();
975 /* Returns the pass with NAME. */
977 static opt_pass *
978 get_pass_by_name (const char *name)
980 opt_pass **p = name_to_pass_map->get (name);
981 if (p)
982 return *p;
984 return NULL;
988 /* Range [start, last]. */
990 struct uid_range
992 unsigned int start;
993 unsigned int last;
994 const char *assem_name;
995 struct uid_range *next;
998 typedef struct uid_range *uid_range_p;
1001 static vec<uid_range_p>
1002 enabled_pass_uid_range_tab = vNULL;
1003 static vec<uid_range_p>
1004 disabled_pass_uid_range_tab = vNULL;
1007 /* Parse option string for -fdisable- and -fenable-
1008 The syntax of the options:
1010 -fenable-<pass_name>
1011 -fdisable-<pass_name>
1013 -fenable-<pass_name>=s1:e1,s2:e2,...
1014 -fdisable-<pass_name>=s1:e1,s2:e2,...
1017 static void
1018 enable_disable_pass (const char *arg, bool is_enable)
1020 opt_pass *pass;
1021 char *range_str, *phase_name;
1022 char *argstr = xstrdup (arg);
1023 vec<uid_range_p> *tab = 0;
1025 range_str = strchr (argstr,'=');
1026 if (range_str)
1028 *range_str = '\0';
1029 range_str++;
1032 phase_name = argstr;
1033 if (!*phase_name)
1035 if (is_enable)
1036 error ("unrecognized option -fenable");
1037 else
1038 error ("unrecognized option -fdisable");
1039 free (argstr);
1040 return;
1042 pass = get_pass_by_name (phase_name);
1043 if (!pass || pass->static_pass_number == -1)
1045 if (is_enable)
1046 error ("unknown pass %s specified in -fenable", phase_name);
1047 else
1048 error ("unknown pass %s specified in -fdisable", phase_name);
1049 free (argstr);
1050 return;
1053 if (is_enable)
1054 tab = &enabled_pass_uid_range_tab;
1055 else
1056 tab = &disabled_pass_uid_range_tab;
1058 if ((unsigned) pass->static_pass_number >= tab->length ())
1059 tab->safe_grow_cleared (pass->static_pass_number + 1);
1061 if (!range_str)
1063 uid_range_p slot;
1064 uid_range_p new_range = XCNEW (struct uid_range);
1066 new_range->start = 0;
1067 new_range->last = (unsigned)-1;
1069 slot = (*tab)[pass->static_pass_number];
1070 new_range->next = slot;
1071 (*tab)[pass->static_pass_number] = new_range;
1072 if (is_enable)
1073 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
1074 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1075 else
1076 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
1077 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1079 else
1081 char *next_range = NULL;
1082 char *one_range = range_str;
1083 char *end_val = NULL;
1087 uid_range_p slot;
1088 uid_range_p new_range;
1089 char *invalid = NULL;
1090 long start;
1091 char *func_name = NULL;
1093 next_range = strchr (one_range, ',');
1094 if (next_range)
1096 *next_range = '\0';
1097 next_range++;
1100 end_val = strchr (one_range, ':');
1101 if (end_val)
1103 *end_val = '\0';
1104 end_val++;
1106 start = strtol (one_range, &invalid, 10);
1107 if (*invalid || start < 0)
1109 if (end_val || (one_range[0] >= '0'
1110 && one_range[0] <= '9'))
1112 error ("Invalid range %s in option %s",
1113 one_range,
1114 is_enable ? "-fenable" : "-fdisable");
1115 free (argstr);
1116 return;
1118 func_name = one_range;
1120 if (!end_val)
1122 new_range = XCNEW (struct uid_range);
1123 if (!func_name)
1125 new_range->start = (unsigned) start;
1126 new_range->last = (unsigned) start;
1128 else
1130 new_range->start = (unsigned) -1;
1131 new_range->last = (unsigned) -1;
1132 new_range->assem_name = xstrdup (func_name);
1135 else
1137 long last = strtol (end_val, &invalid, 10);
1138 if (*invalid || last < start)
1140 error ("Invalid range %s in option %s",
1141 end_val,
1142 is_enable ? "-fenable" : "-fdisable");
1143 free (argstr);
1144 return;
1146 new_range = XCNEW (struct uid_range);
1147 new_range->start = (unsigned) start;
1148 new_range->last = (unsigned) last;
1151 slot = (*tab)[pass->static_pass_number];
1152 new_range->next = slot;
1153 (*tab)[pass->static_pass_number] = new_range;
1154 if (is_enable)
1156 if (new_range->assem_name)
1157 inform (UNKNOWN_LOCATION,
1158 "enable pass %s for function %s",
1159 phase_name, new_range->assem_name);
1160 else
1161 inform (UNKNOWN_LOCATION,
1162 "enable pass %s for functions in the range of [%u, %u]",
1163 phase_name, new_range->start, new_range->last);
1165 else
1167 if (new_range->assem_name)
1168 inform (UNKNOWN_LOCATION,
1169 "disable pass %s for function %s",
1170 phase_name, new_range->assem_name);
1171 else
1172 inform (UNKNOWN_LOCATION,
1173 "disable pass %s for functions in the range of [%u, %u]",
1174 phase_name, new_range->start, new_range->last);
1177 one_range = next_range;
1178 } while (next_range);
1181 free (argstr);
1184 /* Enable pass specified by ARG. */
1186 void
1187 enable_pass (const char *arg)
1189 enable_disable_pass (arg, true);
1192 /* Disable pass specified by ARG. */
1194 void
1195 disable_pass (const char *arg)
1197 enable_disable_pass (arg, false);
1200 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1202 static bool
1203 is_pass_explicitly_enabled_or_disabled (opt_pass *pass,
1204 tree func,
1205 vec<uid_range_p> tab)
1207 uid_range_p slot, range;
1208 int cgraph_uid;
1209 const char *aname = NULL;
1211 if (!tab.exists ()
1212 || (unsigned) pass->static_pass_number >= tab.length ()
1213 || pass->static_pass_number == -1)
1214 return false;
1216 slot = tab[pass->static_pass_number];
1217 if (!slot)
1218 return false;
1220 cgraph_uid = func ? cgraph_node::get (func)->uid : 0;
1221 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
1222 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
1224 range = slot;
1225 while (range)
1227 if ((unsigned) cgraph_uid >= range->start
1228 && (unsigned) cgraph_uid <= range->last)
1229 return true;
1230 if (range->assem_name && aname
1231 && !strcmp (range->assem_name, aname))
1232 return true;
1233 range = range->next;
1236 return false;
1240 /* Update static_pass_number for passes (and the flag
1241 TODO_mark_first_instance).
1243 Passes are constructed with static_pass_number preinitialized to 0
1245 This field is used in two different ways: initially as instance numbers
1246 of their kind, and then as ids within the entire pass manager.
1248 Within pass_manager::pass_manager:
1250 * In add_pass_instance(), as called by next_pass_1 in
1251 NEXT_PASS in init_optimization_passes
1253 * When the initial instance of a pass within a pass manager is seen,
1254 it is flagged, and its static_pass_number is set to -1
1256 * On subsequent times that it is seen, the static pass number
1257 is decremented each time, so that if there are e.g. 4 dups,
1258 they have static_pass_number -4, 2, 3, 4 respectively (note
1259 how the initial one is negative and gives the count); these
1260 can be thought of as instance numbers of the specific pass
1262 * Within the register_dump_files () traversal, set_pass_for_id()
1263 is called on each pass, using these instance numbers to create
1264 dumpfile switches, and then overwriting them with a pass id,
1265 which are global to the whole pass manager (based on
1266 (TDI_end + current value of extra_dump_files_in_use) ) */
1268 static void
1269 add_pass_instance (opt_pass *new_pass, bool track_duplicates,
1270 opt_pass *initial_pass)
1272 /* Are we dealing with the first pass of its kind, or a clone? */
1273 if (new_pass != initial_pass)
1275 /* We're dealing with a clone. */
1276 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
1278 /* Indicate to register_dump_files that this pass has duplicates,
1279 and so it should rename the dump file. The first instance will
1280 be -1, and be number of duplicates = -static_pass_number - 1.
1281 Subsequent instances will be > 0 and just the duplicate number. */
1282 if ((new_pass->name && new_pass->name[0] != '*') || track_duplicates)
1284 initial_pass->static_pass_number -= 1;
1285 new_pass->static_pass_number = -initial_pass->static_pass_number;
1288 else
1290 /* We're dealing with the first pass of its kind. */
1291 new_pass->todo_flags_start |= TODO_mark_first_instance;
1292 new_pass->static_pass_number = -1;
1294 invoke_plugin_callbacks (PLUGIN_NEW_PASS, new_pass);
1298 /* Add a pass to the pass list. Duplicate the pass if it's already
1299 in the list. */
1301 static opt_pass **
1302 next_pass_1 (opt_pass **list, opt_pass *pass, opt_pass *initial_pass)
1304 /* Every pass should have a name so that plugins can refer to them. */
1305 gcc_assert (pass->name != NULL);
1307 add_pass_instance (pass, false, initial_pass);
1308 *list = pass;
1310 return &(*list)->next;
1313 /* List node for an inserted pass instance. We need to keep track of all
1314 the newly-added pass instances (with 'added_pass_nodes' defined below)
1315 so that we can register their dump files after pass-positioning is finished.
1316 Registering dumping files needs to be post-processed or the
1317 static_pass_number of the opt_pass object would be modified and mess up
1318 the dump file names of future pass instances to be added. */
1320 struct pass_list_node
1322 opt_pass *pass;
1323 struct pass_list_node *next;
1326 static struct pass_list_node *added_pass_nodes = NULL;
1327 static struct pass_list_node *prev_added_pass_node;
1329 /* Insert the pass at the proper position. Return true if the pass
1330 is successfully added.
1332 NEW_PASS_INFO - new pass to be inserted
1333 PASS_LIST - root of the pass list to insert the new pass to */
1335 static bool
1336 position_pass (struct register_pass_info *new_pass_info, opt_pass **pass_list)
1338 opt_pass *pass = *pass_list, *prev_pass = NULL;
1339 bool success = false;
1341 for ( ; pass; prev_pass = pass, pass = pass->next)
1343 /* Check if the current pass is of the same type as the new pass and
1344 matches the name and the instance number of the reference pass. */
1345 if (pass->type == new_pass_info->pass->type
1346 && pass->name
1347 && !strcmp (pass->name, new_pass_info->reference_pass_name)
1348 && ((new_pass_info->ref_pass_instance_number == 0)
1349 || (new_pass_info->ref_pass_instance_number ==
1350 pass->static_pass_number)
1351 || (new_pass_info->ref_pass_instance_number == 1
1352 && pass->todo_flags_start & TODO_mark_first_instance)))
1354 opt_pass *new_pass;
1355 struct pass_list_node *new_pass_node;
1357 if (new_pass_info->ref_pass_instance_number == 0)
1359 new_pass = new_pass_info->pass->clone ();
1360 add_pass_instance (new_pass, true, new_pass_info->pass);
1362 else
1364 new_pass = new_pass_info->pass;
1365 add_pass_instance (new_pass, true, new_pass);
1368 /* Insert the new pass instance based on the positioning op. */
1369 switch (new_pass_info->pos_op)
1371 case PASS_POS_INSERT_AFTER:
1372 new_pass->next = pass->next;
1373 pass->next = new_pass;
1375 /* Skip newly inserted pass to avoid repeated
1376 insertions in the case where the new pass and the
1377 existing one have the same name. */
1378 pass = new_pass;
1379 break;
1380 case PASS_POS_INSERT_BEFORE:
1381 new_pass->next = pass;
1382 if (prev_pass)
1383 prev_pass->next = new_pass;
1384 else
1385 *pass_list = new_pass;
1386 break;
1387 case PASS_POS_REPLACE:
1388 new_pass->next = pass->next;
1389 if (prev_pass)
1390 prev_pass->next = new_pass;
1391 else
1392 *pass_list = new_pass;
1393 new_pass->sub = pass->sub;
1394 new_pass->tv_id = pass->tv_id;
1395 pass = new_pass;
1396 break;
1397 default:
1398 error ("invalid pass positioning operation");
1399 return false;
1402 /* Save the newly added pass (instance) in the added_pass_nodes
1403 list so that we can register its dump file later. Note that
1404 we cannot register the dump file now because doing so will modify
1405 the static_pass_number of the opt_pass object and therefore
1406 mess up the dump file name of future instances. */
1407 new_pass_node = XCNEW (struct pass_list_node);
1408 new_pass_node->pass = new_pass;
1409 if (!added_pass_nodes)
1410 added_pass_nodes = new_pass_node;
1411 else
1412 prev_added_pass_node->next = new_pass_node;
1413 prev_added_pass_node = new_pass_node;
1415 success = true;
1418 if (pass->sub && position_pass (new_pass_info, &pass->sub))
1419 success = true;
1422 return success;
1425 /* Hooks a new pass into the pass lists.
1427 PASS_INFO - pass information that specifies the opt_pass object,
1428 reference pass, instance number, and how to position
1429 the pass */
1431 void
1432 register_pass (struct register_pass_info *pass_info)
1434 g->get_passes ()->register_pass (pass_info);
1437 void
1438 register_pass (opt_pass* pass, pass_positioning_ops pos,
1439 const char* ref_pass_name, int ref_pass_inst_number)
1441 register_pass_info i;
1442 i.pass = pass;
1443 i.reference_pass_name = ref_pass_name;
1444 i.ref_pass_instance_number = ref_pass_inst_number;
1445 i.pos_op = pos;
1447 g->get_passes ()->register_pass (&i);
1450 void
1451 pass_manager::register_pass (struct register_pass_info *pass_info)
1453 bool all_instances, success;
1454 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
1456 /* The checks below could fail in buggy plugins. Existing GCC
1457 passes should never fail these checks, so we mention plugin in
1458 the messages. */
1459 if (!pass_info->pass)
1460 fatal_error (input_location, "plugin cannot register a missing pass");
1462 if (!pass_info->pass->name)
1463 fatal_error (input_location, "plugin cannot register an unnamed pass");
1465 if (!pass_info->reference_pass_name)
1466 fatal_error
1467 (input_location,
1468 "plugin cannot register pass %qs without reference pass name",
1469 pass_info->pass->name);
1471 /* Try to insert the new pass to the pass lists. We need to check
1472 all five lists as the reference pass could be in one (or all) of
1473 them. */
1474 all_instances = pass_info->ref_pass_instance_number == 0;
1475 success = position_pass (pass_info, &all_lowering_passes);
1476 if (!success || all_instances)
1477 success |= position_pass (pass_info, &all_small_ipa_passes);
1478 if (!success || all_instances)
1479 success |= position_pass (pass_info, &all_regular_ipa_passes);
1480 if (!success || all_instances)
1481 success |= position_pass (pass_info, &all_late_ipa_passes);
1482 if (!success || all_instances)
1483 success |= position_pass (pass_info, &all_passes);
1484 if (!success)
1485 fatal_error
1486 (input_location,
1487 "pass %qs not found but is referenced by new pass %qs",
1488 pass_info->reference_pass_name, pass_info->pass->name);
1490 /* OK, we have successfully inserted the new pass. We need to register
1491 the dump files for the newly added pass and its duplicates (if any).
1492 Because the registration of plugin/backend passes happens after the
1493 command-line options are parsed, the options that specify single
1494 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1495 passes. Therefore we currently can only enable dumping of
1496 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1497 are specified. While doing so, we also delete the pass_list_node
1498 objects created during pass positioning. */
1499 while (added_pass_nodes)
1501 struct pass_list_node *next_node = added_pass_nodes->next;
1502 enum tree_dump_index tdi;
1503 register_one_dump_file (added_pass_nodes->pass);
1504 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
1505 || added_pass_nodes->pass->type == IPA_PASS)
1506 tdi = TDI_ipa_all;
1507 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
1508 tdi = TDI_tree_all;
1509 else
1510 tdi = TDI_rtl_all;
1511 /* Check if dump-all flag is specified. */
1512 if (dumps->get_dump_file_info (tdi)->pstate)
1513 dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1514 ->pstate = dumps->get_dump_file_info (tdi)->pstate;
1515 XDELETE (added_pass_nodes);
1516 added_pass_nodes = next_node;
1520 /* Construct the pass tree. The sequencing of passes is driven by
1521 the cgraph routines:
1523 finalize_compilation_unit ()
1524 for each node N in the cgraph
1525 cgraph_analyze_function (N)
1526 cgraph_lower_function (N) -> all_lowering_passes
1528 If we are optimizing, compile is then invoked:
1530 compile ()
1531 ipa_passes () -> all_small_ipa_passes
1532 -> Analysis of all_regular_ipa_passes
1533 * possible LTO streaming at copmilation time *
1534 -> Execution of all_regular_ipa_passes
1535 * possible LTO streaming at link time *
1536 -> all_late_ipa_passes
1537 expand_all_functions ()
1538 for each node N in the cgraph
1539 expand_function (N) -> Transformation of all_regular_ipa_passes
1540 -> all_passes
1543 void *
1544 pass_manager::operator new (size_t sz)
1546 /* Ensure that all fields of the pass manager are zero-initialized. */
1547 return xcalloc (1, sz);
1550 void
1551 pass_manager::operator delete (void *ptr)
1553 free (ptr);
1556 pass_manager::pass_manager (context *ctxt)
1557 : all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
1558 all_regular_ipa_passes (NULL),
1559 all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
1560 m_ctxt (ctxt)
1562 opt_pass **p;
1564 /* Initialize the pass_lists array. */
1565 #define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1566 GCC_PASS_LISTS
1567 #undef DEF_PASS_LIST
1569 /* Build the tree of passes. */
1571 #define INSERT_PASSES_AFTER(PASS) \
1572 p = &(PASS);
1574 #define PUSH_INSERT_PASSES_WITHIN(PASS) \
1576 opt_pass **p = &(PASS ## _1)->sub;
1578 #define POP_INSERT_PASSES() \
1581 #define NEXT_PASS(PASS, NUM) \
1582 do { \
1583 gcc_assert (NULL == PASS ## _ ## NUM); \
1584 if ((NUM) == 1) \
1585 PASS ## _1 = make_##PASS (m_ctxt); \
1586 else \
1588 gcc_assert (PASS ## _1); \
1589 PASS ## _ ## NUM = PASS ## _1->clone (); \
1591 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1592 } while (0)
1594 #define TERMINATE_PASS_LIST() \
1595 *p = NULL;
1597 #include "pass-instances.def"
1599 #undef INSERT_PASSES_AFTER
1600 #undef PUSH_INSERT_PASSES_WITHIN
1601 #undef POP_INSERT_PASSES
1602 #undef NEXT_PASS
1603 #undef TERMINATE_PASS_LIST
1605 /* Register the passes with the tree dump code. */
1606 register_dump_files (all_lowering_passes);
1607 register_dump_files (all_small_ipa_passes);
1608 register_dump_files (all_regular_ipa_passes);
1609 register_dump_files (all_late_ipa_passes);
1610 register_dump_files (all_passes);
1613 static void
1614 delete_pass_tree (opt_pass *pass)
1616 while (pass)
1618 /* Recurse into child passes. */
1619 delete_pass_tree (pass->sub);
1621 opt_pass *next = pass->next;
1623 /* Delete this pass. */
1624 delete pass;
1626 /* Iterate onto sibling passes. */
1627 pass = next;
1631 pass_manager::~pass_manager ()
1633 XDELETEVEC (passes_by_id);
1635 /* Call delete_pass_tree on each of the pass_lists. */
1636 #define DEF_PASS_LIST(LIST) \
1637 delete_pass_tree (*pass_lists[PASS_LIST_NO_##LIST]);
1638 GCC_PASS_LISTS
1639 #undef DEF_PASS_LIST
1643 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1644 function CALLBACK for every function in the call graph. Otherwise,
1645 call CALLBACK on the current function. */
1647 static void
1648 do_per_function (void (*callback) (function *, void *data), void *data)
1650 if (current_function_decl)
1651 callback (cfun, data);
1652 else
1654 struct cgraph_node *node;
1655 FOR_EACH_DEFINED_FUNCTION (node)
1656 if (node->analyzed && (gimple_has_body_p (node->decl) && !in_lto_p)
1657 && (!node->clone_of || node->decl != node->clone_of->decl))
1658 callback (DECL_STRUCT_FUNCTION (node->decl), data);
1662 /* Because inlining might remove no-longer reachable nodes, we need to
1663 keep the array visible to garbage collector to avoid reading collected
1664 out nodes. */
1665 static int nnodes;
1666 static GTY ((length ("nnodes"))) cgraph_node **order;
1668 /* Hook called when NODE is removed and therefore should be
1669 excluded from order vector. DATA is an array of integers.
1670 DATA[0] holds max index it may be accessed by. For cgraph
1671 node DATA[node->uid + 1] holds index of this node in order
1672 vector. */
1673 static void
1674 remove_cgraph_node_from_order (cgraph_node *node, void *data)
1676 int *order_idx = (int *)data;
1678 if (node->uid >= order_idx[0])
1679 return;
1681 int idx = order_idx[node->uid + 1];
1682 if (idx >= 0 && idx < nnodes && order[idx] == node)
1683 order[idx] = NULL;
1686 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1687 function CALLBACK for every function in the call graph. Otherwise,
1688 call CALLBACK on the current function.
1689 This function is global so that plugins can use it. */
1690 void
1691 do_per_function_toporder (void (*callback) (function *, void *data), void *data)
1693 int i;
1695 if (current_function_decl)
1696 callback (cfun, data);
1697 else
1699 cgraph_node_hook_list *hook;
1700 int *order_idx;
1701 gcc_assert (!order);
1702 order = ggc_vec_alloc<cgraph_node *> (symtab->cgraph_count);
1704 order_idx = XALLOCAVEC (int, symtab->cgraph_max_uid + 1);
1705 memset (order_idx + 1, -1, sizeof (int) * symtab->cgraph_max_uid);
1706 order_idx[0] = symtab->cgraph_max_uid;
1708 nnodes = ipa_reverse_postorder (order);
1709 for (i = nnodes - 1; i >= 0; i--)
1711 order[i]->process = 1;
1712 order_idx[order[i]->uid + 1] = i;
1714 hook = symtab->add_cgraph_removal_hook (remove_cgraph_node_from_order,
1715 order_idx);
1716 for (i = nnodes - 1; i >= 0; i--)
1718 /* Function could be inlined and removed as unreachable. */
1719 if (!order[i])
1720 continue;
1722 struct cgraph_node *node = order[i];
1724 /* Allow possibly removed nodes to be garbage collected. */
1725 order[i] = NULL;
1726 node->process = 0;
1727 if (node->has_gimple_body_p ())
1728 callback (DECL_STRUCT_FUNCTION (node->decl), data);
1730 symtab->remove_cgraph_removal_hook (hook);
1732 ggc_free (order);
1733 order = NULL;
1734 nnodes = 0;
1737 /* Helper function to perform function body dump. */
1739 static void
1740 execute_function_dump (function *fn, void *data)
1742 opt_pass *pass = (opt_pass *)data;
1744 if (dump_file)
1746 push_cfun (fn);
1748 if (fn->curr_properties & PROP_trees)
1749 dump_function_to_file (fn->decl, dump_file, dump_flags);
1750 else
1751 print_rtl_with_bb (dump_file, get_insns (), dump_flags);
1753 /* Flush the file. If verification fails, we won't be able to
1754 close the file before aborting. */
1755 fflush (dump_file);
1757 if ((fn->curr_properties & PROP_cfg)
1758 && (dump_flags & TDF_GRAPH))
1760 if (!pass->graph_dump_initialized)
1762 clean_graph_dump_file (dump_file_name);
1763 pass->graph_dump_initialized = true;
1765 print_graph_cfg (dump_file_name, fn);
1768 pop_cfun ();
1772 static struct profile_record *profile_record;
1774 /* Do profile consistency book-keeping for the pass with static number INDEX.
1775 If SUBPASS is zero, we run _before_ the pass, and if SUBPASS is one, then
1776 we run _after_ the pass. RUN is true if the pass really runs, or FALSE
1777 if we are only book-keeping on passes that may have selectively disabled
1778 themselves on a given function. */
1779 static void
1780 check_profile_consistency (int index, int subpass, bool run)
1782 pass_manager *passes = g->get_passes ();
1783 if (index == -1)
1784 return;
1785 if (!profile_record)
1786 profile_record = XCNEWVEC (struct profile_record,
1787 passes->passes_by_id_size);
1788 gcc_assert (index < passes->passes_by_id_size && index >= 0);
1789 gcc_assert (subpass < 2);
1790 profile_record[index].run |= run;
1791 account_profile_record (&profile_record[index], subpass);
1794 /* Output profile consistency. */
1796 void
1797 dump_profile_report (void)
1799 g->get_passes ()->dump_profile_report ();
1802 void
1803 pass_manager::dump_profile_report () const
1805 int i, j;
1806 int last_freq_in = 0, last_count_in = 0, last_freq_out = 0, last_count_out = 0;
1807 gcov_type last_time = 0, last_size = 0;
1808 double rel_time_change, rel_size_change;
1809 int last_reported = 0;
1811 if (!profile_record)
1812 return;
1813 fprintf (stderr, "\nProfile consistency report:\n\n");
1814 fprintf (stderr, "Pass name |mismatch in |mismated out|Overall\n");
1815 fprintf (stderr, " |freq count |freq count |size time\n");
1817 for (i = 0; i < passes_by_id_size; i++)
1818 for (j = 0 ; j < 2; j++)
1819 if (profile_record[i].run)
1821 if (last_time)
1822 rel_time_change = (profile_record[i].time[j]
1823 - (double)last_time) * 100 / (double)last_time;
1824 else
1825 rel_time_change = 0;
1826 if (last_size)
1827 rel_size_change = (profile_record[i].size[j]
1828 - (double)last_size) * 100 / (double)last_size;
1829 else
1830 rel_size_change = 0;
1832 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in
1833 || profile_record[i].num_mismatched_freq_out[j] != last_freq_out
1834 || profile_record[i].num_mismatched_count_in[j] != last_count_in
1835 || profile_record[i].num_mismatched_count_out[j] != last_count_out
1836 || rel_time_change || rel_size_change)
1838 last_reported = i;
1839 fprintf (stderr, "%-20s %s",
1840 passes_by_id [i]->name,
1841 j ? "(after TODO)" : " ");
1842 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in)
1843 fprintf (stderr, "| %+5i",
1844 profile_record[i].num_mismatched_freq_in[j]
1845 - last_freq_in);
1846 else
1847 fprintf (stderr, "| ");
1848 if (profile_record[i].num_mismatched_count_in[j] != last_count_in)
1849 fprintf (stderr, " %+5i",
1850 profile_record[i].num_mismatched_count_in[j]
1851 - last_count_in);
1852 else
1853 fprintf (stderr, " ");
1854 if (profile_record[i].num_mismatched_freq_out[j] != last_freq_out)
1855 fprintf (stderr, "| %+5i",
1856 profile_record[i].num_mismatched_freq_out[j]
1857 - last_freq_out);
1858 else
1859 fprintf (stderr, "| ");
1860 if (profile_record[i].num_mismatched_count_out[j] != last_count_out)
1861 fprintf (stderr, " %+5i",
1862 profile_record[i].num_mismatched_count_out[j]
1863 - last_count_out);
1864 else
1865 fprintf (stderr, " ");
1867 /* Size/time units change across gimple and RTL. */
1868 if (i == pass_expand_1->static_pass_number)
1869 fprintf (stderr, "|----------");
1870 else
1872 if (rel_size_change)
1873 fprintf (stderr, "| %+8.4f%%", rel_size_change);
1874 else
1875 fprintf (stderr, "| ");
1876 if (rel_time_change)
1877 fprintf (stderr, " %+8.4f%%", rel_time_change);
1879 fprintf (stderr, "\n");
1880 last_freq_in = profile_record[i].num_mismatched_freq_in[j];
1881 last_freq_out = profile_record[i].num_mismatched_freq_out[j];
1882 last_count_in = profile_record[i].num_mismatched_count_in[j];
1883 last_count_out = profile_record[i].num_mismatched_count_out[j];
1885 else if (j && last_reported != i)
1887 last_reported = i;
1888 fprintf (stderr, "%-20s ------------| | |\n",
1889 passes_by_id [i]->name);
1891 last_time = profile_record[i].time[j];
1892 last_size = profile_record[i].size[j];
1896 /* Perform all TODO actions that ought to be done on each function. */
1898 static void
1899 execute_function_todo (function *fn, void *data)
1901 bool from_ipa_pass = (cfun == NULL);
1902 unsigned int flags = (size_t)data;
1903 flags &= ~fn->last_verified;
1904 if (!flags)
1905 return;
1907 push_cfun (fn);
1909 /* Always cleanup the CFG before trying to update SSA. */
1910 if (flags & TODO_cleanup_cfg)
1912 cleanup_tree_cfg ();
1914 /* When cleanup_tree_cfg merges consecutive blocks, it may
1915 perform some simplistic propagation when removing single
1916 valued PHI nodes. This propagation may, in turn, cause the
1917 SSA form to become out-of-date (see PR 22037). So, even
1918 if the parent pass had not scheduled an SSA update, we may
1919 still need to do one. */
1920 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1921 flags |= TODO_update_ssa;
1924 if (flags & TODO_update_ssa_any)
1926 unsigned update_flags = flags & TODO_update_ssa_any;
1927 update_ssa (update_flags);
1930 if (flag_tree_pta && (flags & TODO_rebuild_alias))
1931 compute_may_aliases ();
1933 if (optimize && (flags & TODO_update_address_taken))
1934 execute_update_addresses_taken ();
1936 if (flags & TODO_remove_unused_locals)
1937 remove_unused_locals ();
1939 if (flags & TODO_rebuild_frequencies)
1940 rebuild_frequencies ();
1942 if (flags & TODO_rebuild_cgraph_edges)
1943 cgraph_edge::rebuild_edges ();
1945 /* If we've seen errors do not bother running any verifiers. */
1946 if (!seen_error ())
1948 #if defined ENABLE_CHECKING
1949 dom_state pre_verify_state = dom_info_state (fn, CDI_DOMINATORS);
1950 dom_state pre_verify_pstate = dom_info_state (fn, CDI_POST_DOMINATORS);
1952 if (flags & TODO_verify_il)
1954 if (cfun->curr_properties & PROP_trees)
1956 if (cfun->curr_properties & PROP_cfg)
1957 /* IPA passes leave stmts to be fixed up, so make sure to
1958 not verify stmts really throw. */
1959 verify_gimple_in_cfg (cfun, !from_ipa_pass);
1960 else
1961 verify_gimple_in_seq (gimple_body (cfun->decl));
1963 if (cfun->curr_properties & PROP_ssa)
1964 /* IPA passes leave stmts to be fixed up, so make sure to
1965 not verify SSA operands whose verifier will choke on that. */
1966 verify_ssa (true, !from_ipa_pass);
1967 /* IPA passes leave basic-blocks unsplit, so make sure to
1968 not trip on that. */
1969 if ((cfun->curr_properties & PROP_cfg)
1970 && !from_ipa_pass)
1971 verify_flow_info ();
1972 if (current_loops
1973 && loops_state_satisfies_p (LOOP_CLOSED_SSA))
1974 verify_loop_closed_ssa (false);
1975 if (cfun->curr_properties & PROP_rtl)
1976 verify_rtl_sharing ();
1979 /* Make sure verifiers don't change dominator state. */
1980 gcc_assert (dom_info_state (fn, CDI_DOMINATORS) == pre_verify_state);
1981 gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == pre_verify_pstate);
1982 #endif
1985 fn->last_verified = flags & TODO_verify_all;
1987 pop_cfun ();
1989 /* For IPA passes make sure to release dominator info, it can be
1990 computed by non-verifying TODOs. */
1991 if (from_ipa_pass)
1993 free_dominance_info (fn, CDI_DOMINATORS);
1994 free_dominance_info (fn, CDI_POST_DOMINATORS);
1998 /* Perform all TODO actions. */
1999 static void
2000 execute_todo (unsigned int flags)
2002 #if defined ENABLE_CHECKING
2003 if (cfun
2004 && need_ssa_update_p (cfun))
2005 gcc_assert (flags & TODO_update_ssa_any);
2006 #endif
2008 timevar_push (TV_TODO);
2010 /* Inform the pass whether it is the first time it is run. */
2011 first_pass_instance = (flags & TODO_mark_first_instance) != 0;
2013 statistics_fini_pass ();
2015 if (flags)
2016 do_per_function (execute_function_todo, (void *)(size_t) flags);
2018 /* Always remove functions just as before inlining: IPA passes might be
2019 interested to see bodies of extern inline functions that are not inlined
2020 to analyze side effects. The full removal is done just at the end
2021 of IPA pass queue. */
2022 if (flags & TODO_remove_functions)
2024 gcc_assert (!cfun);
2025 symtab->remove_unreachable_nodes (dump_file);
2028 if ((flags & TODO_dump_symtab) && dump_file && !current_function_decl)
2030 gcc_assert (!cfun);
2031 symtab_node::dump_table (dump_file);
2032 /* Flush the file. If verification fails, we won't be able to
2033 close the file before aborting. */
2034 fflush (dump_file);
2037 /* Now that the dumping has been done, we can get rid of the optional
2038 df problems. */
2039 if (flags & TODO_df_finish)
2040 df_finish_pass ((flags & TODO_df_verify) != 0);
2042 timevar_pop (TV_TODO);
2045 /* Verify invariants that should hold between passes. This is a place
2046 to put simple sanity checks. */
2048 static void
2049 verify_interpass_invariants (void)
2051 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2054 /* Clear the last verified flag. */
2056 static void
2057 clear_last_verified (function *fn, void *data ATTRIBUTE_UNUSED)
2059 fn->last_verified = 0;
2062 /* Helper function. Verify that the properties has been turn into the
2063 properties expected by the pass. */
2065 #ifdef ENABLE_CHECKING
2066 static void
2067 verify_curr_properties (function *fn, void *data)
2069 unsigned int props = (size_t)data;
2070 gcc_assert ((fn->curr_properties & props) == props);
2072 #endif
2074 /* Initialize pass dump file. */
2075 /* This is non-static so that the plugins can use it. */
2077 bool
2078 pass_init_dump_file (opt_pass *pass)
2080 /* If a dump file name is present, open it if enabled. */
2081 if (pass->static_pass_number != -1)
2083 timevar_push (TV_DUMP);
2084 gcc::dump_manager *dumps = g->get_dumps ();
2085 bool initializing_dump =
2086 !dumps->dump_initialized_p (pass->static_pass_number);
2087 dump_file_name = dumps->get_dump_file_name (pass->static_pass_number);
2088 dumps->dump_start (pass->static_pass_number, &dump_flags);
2089 if (dump_file && current_function_decl)
2090 dump_function_header (dump_file, current_function_decl, dump_flags);
2091 if (initializing_dump
2092 && dump_file && (dump_flags & TDF_GRAPH)
2093 && cfun && (cfun->curr_properties & PROP_cfg))
2095 clean_graph_dump_file (dump_file_name);
2096 pass->graph_dump_initialized = true;
2098 timevar_pop (TV_DUMP);
2099 return initializing_dump;
2101 else
2102 return false;
2105 /* Flush PASS dump file. */
2106 /* This is non-static so that plugins can use it. */
2108 void
2109 pass_fini_dump_file (opt_pass *pass)
2111 timevar_push (TV_DUMP);
2113 /* Flush and close dump file. */
2114 if (dump_file_name)
2116 free (CONST_CAST (char *, dump_file_name));
2117 dump_file_name = NULL;
2120 g->get_dumps ()->dump_finish (pass->static_pass_number);
2121 timevar_pop (TV_DUMP);
2124 /* After executing the pass, apply expected changes to the function
2125 properties. */
2127 static void
2128 update_properties_after_pass (function *fn, void *data)
2130 opt_pass *pass = (opt_pass *) data;
2131 fn->curr_properties = (fn->curr_properties | pass->properties_provided)
2132 & ~pass->properties_destroyed;
2135 /* Execute summary generation for all of the passes in IPA_PASS. */
2137 void
2138 execute_ipa_summary_passes (ipa_opt_pass_d *ipa_pass)
2140 while (ipa_pass)
2142 opt_pass *pass = ipa_pass;
2144 /* Execute all of the IPA_PASSes in the list. */
2145 if (ipa_pass->type == IPA_PASS
2146 && pass->gate (cfun)
2147 && ipa_pass->generate_summary)
2149 pass_init_dump_file (pass);
2151 /* If a timevar is present, start it. */
2152 if (pass->tv_id)
2153 timevar_push (pass->tv_id);
2155 current_pass = pass;
2156 ipa_pass->generate_summary ();
2158 /* Stop timevar. */
2159 if (pass->tv_id)
2160 timevar_pop (pass->tv_id);
2162 pass_fini_dump_file (pass);
2164 ipa_pass = (ipa_opt_pass_d *)ipa_pass->next;
2168 /* Execute IPA_PASS function transform on NODE. */
2170 static void
2171 execute_one_ipa_transform_pass (struct cgraph_node *node,
2172 ipa_opt_pass_d *ipa_pass)
2174 opt_pass *pass = ipa_pass;
2175 unsigned int todo_after = 0;
2177 current_pass = pass;
2178 if (!ipa_pass->function_transform)
2179 return;
2181 /* Note that the folders should only create gimple expressions.
2182 This is a hack until the new folder is ready. */
2183 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2185 pass_init_dump_file (pass);
2187 /* Run pre-pass verification. */
2188 execute_todo (ipa_pass->function_transform_todo_flags_start);
2190 /* If a timevar is present, start it. */
2191 if (pass->tv_id != TV_NONE)
2192 timevar_push (pass->tv_id);
2194 /* Do it! */
2195 todo_after = ipa_pass->function_transform (node);
2197 /* Stop timevar. */
2198 if (pass->tv_id != TV_NONE)
2199 timevar_pop (pass->tv_id);
2201 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2202 check_profile_consistency (pass->static_pass_number, 0, true);
2204 /* Run post-pass cleanup and verification. */
2205 execute_todo (todo_after);
2206 verify_interpass_invariants ();
2207 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2208 check_profile_consistency (pass->static_pass_number, 1, true);
2210 if (dump_file)
2211 do_per_function (execute_function_dump, NULL);
2212 pass_fini_dump_file (pass);
2214 current_pass = NULL;
2216 /* Signal this is a suitable GC collection point. */
2217 if (!(todo_after & TODO_do_not_ggc_collect))
2218 ggc_collect ();
2221 /* For the current function, execute all ipa transforms. */
2223 void
2224 execute_all_ipa_transforms (void)
2226 struct cgraph_node *node;
2227 if (!cfun)
2228 return;
2229 node = cgraph_node::get (current_function_decl);
2231 if (node->ipa_transforms_to_apply.exists ())
2233 unsigned int i;
2235 for (i = 0; i < node->ipa_transforms_to_apply.length (); i++)
2236 execute_one_ipa_transform_pass (node, node->ipa_transforms_to_apply[i]);
2237 node->ipa_transforms_to_apply.release ();
2241 /* Check if PASS is explicitly disabled or enabled and return
2242 the gate status. FUNC is the function to be processed, and
2243 GATE_STATUS is the gate status determined by pass manager by
2244 default. */
2246 static bool
2247 override_gate_status (opt_pass *pass, tree func, bool gate_status)
2249 bool explicitly_enabled = false;
2250 bool explicitly_disabled = false;
2252 explicitly_enabled
2253 = is_pass_explicitly_enabled_or_disabled (pass, func,
2254 enabled_pass_uid_range_tab);
2255 explicitly_disabled
2256 = is_pass_explicitly_enabled_or_disabled (pass, func,
2257 disabled_pass_uid_range_tab);
2259 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
2261 return gate_status;
2265 /* Execute PASS. */
2267 bool
2268 execute_one_pass (opt_pass *pass)
2270 unsigned int todo_after = 0;
2272 bool gate_status;
2274 /* IPA passes are executed on whole program, so cfun should be NULL.
2275 Other passes need function context set. */
2276 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2277 gcc_assert (!cfun && !current_function_decl);
2278 else
2279 gcc_assert (cfun && current_function_decl);
2281 current_pass = pass;
2283 /* Check whether gate check should be avoided.
2284 User controls the value of the gate through the parameter "gate_status". */
2285 gate_status = pass->gate (cfun);
2286 gate_status = override_gate_status (pass, current_function_decl, gate_status);
2288 /* Override gate with plugin. */
2289 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
2291 if (!gate_status)
2293 /* Run so passes selectively disabling themselves on a given function
2294 are not miscounted. */
2295 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2297 check_profile_consistency (pass->static_pass_number, 0, false);
2298 check_profile_consistency (pass->static_pass_number, 1, false);
2300 current_pass = NULL;
2301 return false;
2304 /* Pass execution event trigger: useful to identify passes being
2305 executed. */
2306 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
2308 if (!quiet_flag && !cfun)
2309 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
2311 /* Note that the folders should only create gimple expressions.
2312 This is a hack until the new folder is ready. */
2313 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2315 pass_init_dump_file (pass);
2317 /* Run pre-pass verification. */
2318 execute_todo (pass->todo_flags_start);
2320 #ifdef ENABLE_CHECKING
2321 do_per_function (verify_curr_properties,
2322 (void *)(size_t)pass->properties_required);
2323 #endif
2325 /* If a timevar is present, start it. */
2326 if (pass->tv_id != TV_NONE)
2327 timevar_push (pass->tv_id);
2329 /* Do it! */
2330 todo_after = pass->execute (cfun);
2331 do_per_function (clear_last_verified, NULL);
2333 /* Stop timevar. */
2334 if (pass->tv_id != TV_NONE)
2335 timevar_pop (pass->tv_id);
2337 do_per_function (update_properties_after_pass, pass);
2339 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2340 check_profile_consistency (pass->static_pass_number, 0, true);
2342 /* Run post-pass cleanup and verification. */
2343 execute_todo (todo_after | pass->todo_flags_finish | TODO_verify_il);
2344 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2345 check_profile_consistency (pass->static_pass_number, 1, true);
2347 verify_interpass_invariants ();
2348 if (dump_file)
2349 do_per_function (execute_function_dump, pass);
2350 if (pass->type == IPA_PASS)
2352 struct cgraph_node *node;
2353 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2354 node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *)pass);
2357 if (!current_function_decl)
2358 symtab->process_new_functions ();
2360 pass_fini_dump_file (pass);
2362 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2363 gcc_assert (!(cfun->curr_properties & PROP_trees)
2364 || pass->type != RTL_PASS);
2366 current_pass = NULL;
2368 /* Signal this is a suitable GC collection point. */
2369 if (!((todo_after | pass->todo_flags_finish) & TODO_do_not_ggc_collect))
2370 ggc_collect ();
2372 return true;
2375 static void
2376 execute_pass_list_1 (opt_pass *pass)
2380 gcc_assert (pass->type == GIMPLE_PASS
2381 || pass->type == RTL_PASS);
2382 if (execute_one_pass (pass) && pass->sub)
2383 execute_pass_list_1 (pass->sub);
2384 pass = pass->next;
2386 while (pass);
2389 void
2390 execute_pass_list (function *fn, opt_pass *pass)
2392 push_cfun (fn);
2393 execute_pass_list_1 (pass);
2394 if (fn->cfg)
2396 free_dominance_info (CDI_DOMINATORS);
2397 free_dominance_info (CDI_POST_DOMINATORS);
2399 pop_cfun ();
2402 /* Write out all LTO data. */
2403 static void
2404 write_lto (void)
2406 timevar_push (TV_IPA_LTO_GIMPLE_OUT);
2407 lto_output ();
2408 timevar_pop (TV_IPA_LTO_GIMPLE_OUT);
2409 timevar_push (TV_IPA_LTO_DECL_OUT);
2410 produce_asm_for_decls ();
2411 timevar_pop (TV_IPA_LTO_DECL_OUT);
2414 /* Same as execute_pass_list but assume that subpasses of IPA passes
2415 are local passes. If SET is not NULL, write out summaries of only
2416 those node in SET. */
2418 static void
2419 ipa_write_summaries_2 (opt_pass *pass, struct lto_out_decl_state *state)
2421 while (pass)
2423 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2424 gcc_assert (!current_function_decl);
2425 gcc_assert (!cfun);
2426 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2427 if (pass->type == IPA_PASS
2428 && ipa_pass->write_summary
2429 && pass->gate (cfun))
2431 /* If a timevar is present, start it. */
2432 if (pass->tv_id)
2433 timevar_push (pass->tv_id);
2435 pass_init_dump_file (pass);
2437 current_pass = pass;
2438 ipa_pass->write_summary ();
2440 pass_fini_dump_file (pass);
2442 /* If a timevar is present, start it. */
2443 if (pass->tv_id)
2444 timevar_pop (pass->tv_id);
2447 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2448 ipa_write_summaries_2 (pass->sub, state);
2450 pass = pass->next;
2454 /* Helper function of ipa_write_summaries. Creates and destroys the
2455 decl state and calls ipa_write_summaries_2 for all passes that have
2456 summaries. SET is the set of nodes to be written. */
2458 static void
2459 ipa_write_summaries_1 (lto_symtab_encoder_t encoder)
2461 pass_manager *passes = g->get_passes ();
2462 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2463 state->symtab_node_encoder = encoder;
2465 lto_output_init_mode_table ();
2466 lto_push_out_decl_state (state);
2468 gcc_assert (!flag_wpa);
2469 ipa_write_summaries_2 (passes->all_regular_ipa_passes, state);
2471 write_lto ();
2473 gcc_assert (lto_get_out_decl_state () == state);
2474 lto_pop_out_decl_state ();
2475 lto_delete_out_decl_state (state);
2478 /* Write out summaries for all the nodes in the callgraph. */
2480 void
2481 ipa_write_summaries (void)
2483 lto_symtab_encoder_t encoder;
2484 int i, order_pos;
2485 varpool_node *vnode;
2486 struct cgraph_node *node;
2487 struct cgraph_node **order;
2489 if ((!flag_generate_lto && !flag_generate_offload) || seen_error ())
2490 return;
2492 select_what_to_stream ();
2494 encoder = lto_symtab_encoder_new (false);
2496 /* Create the callgraph set in the same order used in
2497 cgraph_expand_all_functions. This mostly facilitates debugging,
2498 since it causes the gimple file to be processed in the same order
2499 as the source code. */
2500 order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
2501 order_pos = ipa_reverse_postorder (order);
2502 gcc_assert (order_pos == symtab->cgraph_count);
2504 for (i = order_pos - 1; i >= 0; i--)
2506 struct cgraph_node *node = order[i];
2508 if (node->has_gimple_body_p ())
2510 /* When streaming out references to statements as part of some IPA
2511 pass summary, the statements need to have uids assigned and the
2512 following does that for all the IPA passes here. Naturally, this
2513 ordering then matches the one IPA-passes get in their stmt_fixup
2514 hooks. */
2516 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2517 renumber_gimple_stmt_uids ();
2518 pop_cfun ();
2520 if (node->definition && node->need_lto_streaming)
2521 lto_set_symtab_encoder_in_partition (encoder, node);
2524 FOR_EACH_DEFINED_FUNCTION (node)
2525 if (node->alias && node->need_lto_streaming)
2526 lto_set_symtab_encoder_in_partition (encoder, node);
2527 FOR_EACH_DEFINED_VARIABLE (vnode)
2528 if (vnode->need_lto_streaming)
2529 lto_set_symtab_encoder_in_partition (encoder, vnode);
2531 ipa_write_summaries_1 (compute_ltrans_boundary (encoder));
2533 free (order);
2536 /* Same as execute_pass_list but assume that subpasses of IPA passes
2537 are local passes. If SET is not NULL, write out optimization summaries of
2538 only those node in SET. */
2540 static void
2541 ipa_write_optimization_summaries_1 (opt_pass *pass,
2542 struct lto_out_decl_state *state)
2544 while (pass)
2546 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2547 gcc_assert (!current_function_decl);
2548 gcc_assert (!cfun);
2549 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2550 if (pass->type == IPA_PASS
2551 && ipa_pass->write_optimization_summary
2552 && pass->gate (cfun))
2554 /* If a timevar is present, start it. */
2555 if (pass->tv_id)
2556 timevar_push (pass->tv_id);
2558 pass_init_dump_file (pass);
2560 current_pass = pass;
2561 ipa_pass->write_optimization_summary ();
2563 pass_fini_dump_file (pass);
2565 /* If a timevar is present, start it. */
2566 if (pass->tv_id)
2567 timevar_pop (pass->tv_id);
2570 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2571 ipa_write_optimization_summaries_1 (pass->sub, state);
2573 pass = pass->next;
2577 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2578 NULL, write out all summaries of all nodes. */
2580 void
2581 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder)
2583 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2584 lto_symtab_encoder_iterator lsei;
2585 state->symtab_node_encoder = encoder;
2587 lto_output_init_mode_table ();
2588 lto_push_out_decl_state (state);
2589 for (lsei = lsei_start_function_in_partition (encoder);
2590 !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
2592 struct cgraph_node *node = lsei_cgraph_node (lsei);
2593 /* When streaming out references to statements as part of some IPA
2594 pass summary, the statements need to have uids assigned.
2596 For functions newly born at WPA stage we need to initialize
2597 the uids here. */
2598 if (node->definition
2599 && gimple_has_body_p (node->decl))
2601 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2602 renumber_gimple_stmt_uids ();
2603 pop_cfun ();
2607 gcc_assert (flag_wpa);
2608 pass_manager *passes = g->get_passes ();
2609 ipa_write_optimization_summaries_1 (passes->all_regular_ipa_passes, state);
2611 write_lto ();
2613 gcc_assert (lto_get_out_decl_state () == state);
2614 lto_pop_out_decl_state ();
2615 lto_delete_out_decl_state (state);
2618 /* Same as execute_pass_list but assume that subpasses of IPA passes
2619 are local passes. */
2621 static void
2622 ipa_read_summaries_1 (opt_pass *pass)
2624 while (pass)
2626 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2628 gcc_assert (!current_function_decl);
2629 gcc_assert (!cfun);
2630 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2632 if (pass->gate (cfun))
2634 if (pass->type == IPA_PASS && ipa_pass->read_summary)
2636 /* If a timevar is present, start it. */
2637 if (pass->tv_id)
2638 timevar_push (pass->tv_id);
2640 pass_init_dump_file (pass);
2642 current_pass = pass;
2643 ipa_pass->read_summary ();
2645 pass_fini_dump_file (pass);
2647 /* Stop timevar. */
2648 if (pass->tv_id)
2649 timevar_pop (pass->tv_id);
2652 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2653 ipa_read_summaries_1 (pass->sub);
2655 pass = pass->next;
2660 /* Read all the summaries for all_regular_ipa_passes. */
2662 void
2663 ipa_read_summaries (void)
2665 pass_manager *passes = g->get_passes ();
2666 ipa_read_summaries_1 (passes->all_regular_ipa_passes);
2669 /* Same as execute_pass_list but assume that subpasses of IPA passes
2670 are local passes. */
2672 static void
2673 ipa_read_optimization_summaries_1 (opt_pass *pass)
2675 while (pass)
2677 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2679 gcc_assert (!current_function_decl);
2680 gcc_assert (!cfun);
2681 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2683 if (pass->gate (cfun))
2685 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
2687 /* If a timevar is present, start it. */
2688 if (pass->tv_id)
2689 timevar_push (pass->tv_id);
2691 pass_init_dump_file (pass);
2693 current_pass = pass;
2694 ipa_pass->read_optimization_summary ();
2696 pass_fini_dump_file (pass);
2698 /* Stop timevar. */
2699 if (pass->tv_id)
2700 timevar_pop (pass->tv_id);
2703 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2704 ipa_read_optimization_summaries_1 (pass->sub);
2706 pass = pass->next;
2710 /* Read all the summaries for all_regular_ipa_passes. */
2712 void
2713 ipa_read_optimization_summaries (void)
2715 pass_manager *passes = g->get_passes ();
2716 ipa_read_optimization_summaries_1 (passes->all_regular_ipa_passes);
2719 /* Same as execute_pass_list but assume that subpasses of IPA passes
2720 are local passes. */
2721 void
2722 execute_ipa_pass_list (opt_pass *pass)
2726 gcc_assert (!current_function_decl);
2727 gcc_assert (!cfun);
2728 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2729 if (execute_one_pass (pass) && pass->sub)
2731 if (pass->sub->type == GIMPLE_PASS)
2733 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
2734 do_per_function_toporder ((void (*)(function *, void *))
2735 execute_pass_list,
2736 pass->sub);
2737 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
2739 else if (pass->sub->type == SIMPLE_IPA_PASS
2740 || pass->sub->type == IPA_PASS)
2741 execute_ipa_pass_list (pass->sub);
2742 else
2743 gcc_unreachable ();
2745 gcc_assert (!current_function_decl);
2746 symtab->process_new_functions ();
2747 pass = pass->next;
2749 while (pass);
2752 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2754 static void
2755 execute_ipa_stmt_fixups (opt_pass *pass,
2756 struct cgraph_node *node, gimple *stmts)
2758 while (pass)
2760 /* Execute all of the IPA_PASSes in the list. */
2761 if (pass->type == IPA_PASS
2762 && pass->gate (cfun))
2764 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2766 if (ipa_pass->stmt_fixup)
2768 pass_init_dump_file (pass);
2769 /* If a timevar is present, start it. */
2770 if (pass->tv_id)
2771 timevar_push (pass->tv_id);
2773 current_pass = pass;
2774 ipa_pass->stmt_fixup (node, stmts);
2776 /* Stop timevar. */
2777 if (pass->tv_id)
2778 timevar_pop (pass->tv_id);
2779 pass_fini_dump_file (pass);
2781 if (pass->sub)
2782 execute_ipa_stmt_fixups (pass->sub, node, stmts);
2784 pass = pass->next;
2788 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2790 void
2791 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
2793 pass_manager *passes = g->get_passes ();
2794 execute_ipa_stmt_fixups (passes->all_regular_ipa_passes, node, stmts);
2798 extern void debug_properties (unsigned int);
2799 extern void dump_properties (FILE *, unsigned int);
2801 DEBUG_FUNCTION void
2802 dump_properties (FILE *dump, unsigned int props)
2804 fprintf (dump, "Properties:\n");
2805 if (props & PROP_gimple_any)
2806 fprintf (dump, "PROP_gimple_any\n");
2807 if (props & PROP_gimple_lcf)
2808 fprintf (dump, "PROP_gimple_lcf\n");
2809 if (props & PROP_gimple_leh)
2810 fprintf (dump, "PROP_gimple_leh\n");
2811 if (props & PROP_cfg)
2812 fprintf (dump, "PROP_cfg\n");
2813 if (props & PROP_ssa)
2814 fprintf (dump, "PROP_ssa\n");
2815 if (props & PROP_no_crit_edges)
2816 fprintf (dump, "PROP_no_crit_edges\n");
2817 if (props & PROP_rtl)
2818 fprintf (dump, "PROP_rtl\n");
2819 if (props & PROP_gimple_lomp)
2820 fprintf (dump, "PROP_gimple_lomp\n");
2821 if (props & PROP_gimple_lcx)
2822 fprintf (dump, "PROP_gimple_lcx\n");
2823 if (props & PROP_gimple_lvec)
2824 fprintf (dump, "PROP_gimple_lvec\n");
2825 if (props & PROP_cfglayout)
2826 fprintf (dump, "PROP_cfglayout\n");
2829 DEBUG_FUNCTION void
2830 debug_properties (unsigned int props)
2832 dump_properties (stderr, props);
2835 /* Called by local passes to see if function is called by already processed nodes.
2836 Because we process nodes in topological order, this means that function is
2837 in recursive cycle or we introduced new direct calls. */
2838 bool
2839 function_called_by_processed_nodes_p (void)
2841 struct cgraph_edge *e;
2842 for (e = cgraph_node::get (current_function_decl)->callers;
2844 e = e->next_caller)
2846 if (e->caller->decl == current_function_decl)
2847 continue;
2848 if (!e->caller->has_gimple_body_p ())
2849 continue;
2850 if (TREE_ASM_WRITTEN (e->caller->decl))
2851 continue;
2852 if (!e->caller->process && !e->caller->global.inlined_to)
2853 break;
2855 if (dump_file && e)
2857 fprintf (dump_file, "Already processed call to:\n");
2858 e->caller->dump (dump_file);
2860 return e != NULL;
2863 #include "gt-passes.h"