gcc/
[official-gcc.git] / gcc / passes.c
blob04ff04247adc45e2005eb36691bb3220508b1610
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 push_dummy_function (true);
951 create_pass_tab ();
953 dump_pass_list (all_lowering_passes, 1);
954 dump_pass_list (all_small_ipa_passes, 1);
955 dump_pass_list (all_regular_ipa_passes, 1);
956 dump_pass_list (all_late_ipa_passes, 1);
957 dump_pass_list (all_passes, 1);
959 pop_dummy_function ();
962 /* Returns the pass with NAME. */
964 static opt_pass *
965 get_pass_by_name (const char *name)
967 opt_pass **p = name_to_pass_map->get (name);
968 if (p)
969 return *p;
971 return NULL;
975 /* Range [start, last]. */
977 struct uid_range
979 unsigned int start;
980 unsigned int last;
981 const char *assem_name;
982 struct uid_range *next;
985 typedef struct uid_range *uid_range_p;
988 static vec<uid_range_p>
989 enabled_pass_uid_range_tab = vNULL;
990 static vec<uid_range_p>
991 disabled_pass_uid_range_tab = vNULL;
994 /* Parse option string for -fdisable- and -fenable-
995 The syntax of the options:
997 -fenable-<pass_name>
998 -fdisable-<pass_name>
1000 -fenable-<pass_name>=s1:e1,s2:e2,...
1001 -fdisable-<pass_name>=s1:e1,s2:e2,...
1004 static void
1005 enable_disable_pass (const char *arg, bool is_enable)
1007 opt_pass *pass;
1008 char *range_str, *phase_name;
1009 char *argstr = xstrdup (arg);
1010 vec<uid_range_p> *tab = 0;
1012 range_str = strchr (argstr,'=');
1013 if (range_str)
1015 *range_str = '\0';
1016 range_str++;
1019 phase_name = argstr;
1020 if (!*phase_name)
1022 if (is_enable)
1023 error ("unrecognized option -fenable");
1024 else
1025 error ("unrecognized option -fdisable");
1026 free (argstr);
1027 return;
1029 pass = get_pass_by_name (phase_name);
1030 if (!pass || pass->static_pass_number == -1)
1032 if (is_enable)
1033 error ("unknown pass %s specified in -fenable", phase_name);
1034 else
1035 error ("unknown pass %s specified in -fdisable", phase_name);
1036 free (argstr);
1037 return;
1040 if (is_enable)
1041 tab = &enabled_pass_uid_range_tab;
1042 else
1043 tab = &disabled_pass_uid_range_tab;
1045 if ((unsigned) pass->static_pass_number >= tab->length ())
1046 tab->safe_grow_cleared (pass->static_pass_number + 1);
1048 if (!range_str)
1050 uid_range_p slot;
1051 uid_range_p new_range = XCNEW (struct uid_range);
1053 new_range->start = 0;
1054 new_range->last = (unsigned)-1;
1056 slot = (*tab)[pass->static_pass_number];
1057 new_range->next = slot;
1058 (*tab)[pass->static_pass_number] = new_range;
1059 if (is_enable)
1060 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
1061 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1062 else
1063 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
1064 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1066 else
1068 char *next_range = NULL;
1069 char *one_range = range_str;
1070 char *end_val = NULL;
1074 uid_range_p slot;
1075 uid_range_p new_range;
1076 char *invalid = NULL;
1077 long start;
1078 char *func_name = NULL;
1080 next_range = strchr (one_range, ',');
1081 if (next_range)
1083 *next_range = '\0';
1084 next_range++;
1087 end_val = strchr (one_range, ':');
1088 if (end_val)
1090 *end_val = '\0';
1091 end_val++;
1093 start = strtol (one_range, &invalid, 10);
1094 if (*invalid || start < 0)
1096 if (end_val || (one_range[0] >= '0'
1097 && one_range[0] <= '9'))
1099 error ("Invalid range %s in option %s",
1100 one_range,
1101 is_enable ? "-fenable" : "-fdisable");
1102 free (argstr);
1103 return;
1105 func_name = one_range;
1107 if (!end_val)
1109 new_range = XCNEW (struct uid_range);
1110 if (!func_name)
1112 new_range->start = (unsigned) start;
1113 new_range->last = (unsigned) start;
1115 else
1117 new_range->start = (unsigned) -1;
1118 new_range->last = (unsigned) -1;
1119 new_range->assem_name = xstrdup (func_name);
1122 else
1124 long last = strtol (end_val, &invalid, 10);
1125 if (*invalid || last < start)
1127 error ("Invalid range %s in option %s",
1128 end_val,
1129 is_enable ? "-fenable" : "-fdisable");
1130 free (argstr);
1131 return;
1133 new_range = XCNEW (struct uid_range);
1134 new_range->start = (unsigned) start;
1135 new_range->last = (unsigned) last;
1138 slot = (*tab)[pass->static_pass_number];
1139 new_range->next = slot;
1140 (*tab)[pass->static_pass_number] = new_range;
1141 if (is_enable)
1143 if (new_range->assem_name)
1144 inform (UNKNOWN_LOCATION,
1145 "enable pass %s for function %s",
1146 phase_name, new_range->assem_name);
1147 else
1148 inform (UNKNOWN_LOCATION,
1149 "enable pass %s for functions in the range of [%u, %u]",
1150 phase_name, new_range->start, new_range->last);
1152 else
1154 if (new_range->assem_name)
1155 inform (UNKNOWN_LOCATION,
1156 "disable pass %s for function %s",
1157 phase_name, new_range->assem_name);
1158 else
1159 inform (UNKNOWN_LOCATION,
1160 "disable pass %s for functions in the range of [%u, %u]",
1161 phase_name, new_range->start, new_range->last);
1164 one_range = next_range;
1165 } while (next_range);
1168 free (argstr);
1171 /* Enable pass specified by ARG. */
1173 void
1174 enable_pass (const char *arg)
1176 enable_disable_pass (arg, true);
1179 /* Disable pass specified by ARG. */
1181 void
1182 disable_pass (const char *arg)
1184 enable_disable_pass (arg, false);
1187 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1189 static bool
1190 is_pass_explicitly_enabled_or_disabled (opt_pass *pass,
1191 tree func,
1192 vec<uid_range_p> tab)
1194 uid_range_p slot, range;
1195 int cgraph_uid;
1196 const char *aname = NULL;
1198 if (!tab.exists ()
1199 || (unsigned) pass->static_pass_number >= tab.length ()
1200 || pass->static_pass_number == -1)
1201 return false;
1203 slot = tab[pass->static_pass_number];
1204 if (!slot)
1205 return false;
1207 cgraph_uid = func ? cgraph_node::get (func)->uid : 0;
1208 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
1209 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
1211 range = slot;
1212 while (range)
1214 if ((unsigned) cgraph_uid >= range->start
1215 && (unsigned) cgraph_uid <= range->last)
1216 return true;
1217 if (range->assem_name && aname
1218 && !strcmp (range->assem_name, aname))
1219 return true;
1220 range = range->next;
1223 return false;
1227 /* Update static_pass_number for passes (and the flag
1228 TODO_mark_first_instance).
1230 Passes are constructed with static_pass_number preinitialized to 0
1232 This field is used in two different ways: initially as instance numbers
1233 of their kind, and then as ids within the entire pass manager.
1235 Within pass_manager::pass_manager:
1237 * In add_pass_instance(), as called by next_pass_1 in
1238 NEXT_PASS in init_optimization_passes
1240 * When the initial instance of a pass within a pass manager is seen,
1241 it is flagged, and its static_pass_number is set to -1
1243 * On subsequent times that it is seen, the static pass number
1244 is decremented each time, so that if there are e.g. 4 dups,
1245 they have static_pass_number -4, 2, 3, 4 respectively (note
1246 how the initial one is negative and gives the count); these
1247 can be thought of as instance numbers of the specific pass
1249 * Within the register_dump_files () traversal, set_pass_for_id()
1250 is called on each pass, using these instance numbers to create
1251 dumpfile switches, and then overwriting them with a pass id,
1252 which are global to the whole pass manager (based on
1253 (TDI_end + current value of extra_dump_files_in_use) ) */
1255 static void
1256 add_pass_instance (opt_pass *new_pass, bool track_duplicates,
1257 opt_pass *initial_pass)
1259 /* Are we dealing with the first pass of its kind, or a clone? */
1260 if (new_pass != initial_pass)
1262 /* We're dealing with a clone. */
1263 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
1265 /* Indicate to register_dump_files that this pass has duplicates,
1266 and so it should rename the dump file. The first instance will
1267 be -1, and be number of duplicates = -static_pass_number - 1.
1268 Subsequent instances will be > 0 and just the duplicate number. */
1269 if ((new_pass->name && new_pass->name[0] != '*') || track_duplicates)
1271 initial_pass->static_pass_number -= 1;
1272 new_pass->static_pass_number = -initial_pass->static_pass_number;
1275 else
1277 /* We're dealing with the first pass of its kind. */
1278 new_pass->todo_flags_start |= TODO_mark_first_instance;
1279 new_pass->static_pass_number = -1;
1281 invoke_plugin_callbacks (PLUGIN_NEW_PASS, new_pass);
1285 /* Add a pass to the pass list. Duplicate the pass if it's already
1286 in the list. */
1288 static opt_pass **
1289 next_pass_1 (opt_pass **list, opt_pass *pass, opt_pass *initial_pass)
1291 /* Every pass should have a name so that plugins can refer to them. */
1292 gcc_assert (pass->name != NULL);
1294 add_pass_instance (pass, false, initial_pass);
1295 *list = pass;
1297 return &(*list)->next;
1300 /* List node for an inserted pass instance. We need to keep track of all
1301 the newly-added pass instances (with 'added_pass_nodes' defined below)
1302 so that we can register their dump files after pass-positioning is finished.
1303 Registering dumping files needs to be post-processed or the
1304 static_pass_number of the opt_pass object would be modified and mess up
1305 the dump file names of future pass instances to be added. */
1307 struct pass_list_node
1309 opt_pass *pass;
1310 struct pass_list_node *next;
1313 static struct pass_list_node *added_pass_nodes = NULL;
1314 static struct pass_list_node *prev_added_pass_node;
1316 /* Insert the pass at the proper position. Return true if the pass
1317 is successfully added.
1319 NEW_PASS_INFO - new pass to be inserted
1320 PASS_LIST - root of the pass list to insert the new pass to */
1322 static bool
1323 position_pass (struct register_pass_info *new_pass_info, opt_pass **pass_list)
1325 opt_pass *pass = *pass_list, *prev_pass = NULL;
1326 bool success = false;
1328 for ( ; pass; prev_pass = pass, pass = pass->next)
1330 /* Check if the current pass is of the same type as the new pass and
1331 matches the name and the instance number of the reference pass. */
1332 if (pass->type == new_pass_info->pass->type
1333 && pass->name
1334 && !strcmp (pass->name, new_pass_info->reference_pass_name)
1335 && ((new_pass_info->ref_pass_instance_number == 0)
1336 || (new_pass_info->ref_pass_instance_number ==
1337 pass->static_pass_number)
1338 || (new_pass_info->ref_pass_instance_number == 1
1339 && pass->todo_flags_start & TODO_mark_first_instance)))
1341 opt_pass *new_pass;
1342 struct pass_list_node *new_pass_node;
1344 if (new_pass_info->ref_pass_instance_number == 0)
1346 new_pass = new_pass_info->pass->clone ();
1347 add_pass_instance (new_pass, true, new_pass_info->pass);
1349 else
1351 new_pass = new_pass_info->pass;
1352 add_pass_instance (new_pass, true, new_pass);
1355 /* Insert the new pass instance based on the positioning op. */
1356 switch (new_pass_info->pos_op)
1358 case PASS_POS_INSERT_AFTER:
1359 new_pass->next = pass->next;
1360 pass->next = new_pass;
1362 /* Skip newly inserted pass to avoid repeated
1363 insertions in the case where the new pass and the
1364 existing one have the same name. */
1365 pass = new_pass;
1366 break;
1367 case PASS_POS_INSERT_BEFORE:
1368 new_pass->next = pass;
1369 if (prev_pass)
1370 prev_pass->next = new_pass;
1371 else
1372 *pass_list = new_pass;
1373 break;
1374 case PASS_POS_REPLACE:
1375 new_pass->next = pass->next;
1376 if (prev_pass)
1377 prev_pass->next = new_pass;
1378 else
1379 *pass_list = new_pass;
1380 new_pass->sub = pass->sub;
1381 new_pass->tv_id = pass->tv_id;
1382 pass = new_pass;
1383 break;
1384 default:
1385 error ("invalid pass positioning operation");
1386 return false;
1389 /* Save the newly added pass (instance) in the added_pass_nodes
1390 list so that we can register its dump file later. Note that
1391 we cannot register the dump file now because doing so will modify
1392 the static_pass_number of the opt_pass object and therefore
1393 mess up the dump file name of future instances. */
1394 new_pass_node = XCNEW (struct pass_list_node);
1395 new_pass_node->pass = new_pass;
1396 if (!added_pass_nodes)
1397 added_pass_nodes = new_pass_node;
1398 else
1399 prev_added_pass_node->next = new_pass_node;
1400 prev_added_pass_node = new_pass_node;
1402 success = true;
1405 if (pass->sub && position_pass (new_pass_info, &pass->sub))
1406 success = true;
1409 return success;
1412 /* Hooks a new pass into the pass lists.
1414 PASS_INFO - pass information that specifies the opt_pass object,
1415 reference pass, instance number, and how to position
1416 the pass */
1418 void
1419 register_pass (struct register_pass_info *pass_info)
1421 g->get_passes ()->register_pass (pass_info);
1424 void
1425 register_pass (opt_pass* pass, pass_positioning_ops pos,
1426 const char* ref_pass_name, int ref_pass_inst_number)
1428 register_pass_info i;
1429 i.pass = pass;
1430 i.reference_pass_name = ref_pass_name;
1431 i.ref_pass_instance_number = ref_pass_inst_number;
1432 i.pos_op = pos;
1434 g->get_passes ()->register_pass (&i);
1437 void
1438 pass_manager::register_pass (struct register_pass_info *pass_info)
1440 bool all_instances, success;
1441 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
1443 /* The checks below could fail in buggy plugins. Existing GCC
1444 passes should never fail these checks, so we mention plugin in
1445 the messages. */
1446 if (!pass_info->pass)
1447 fatal_error (input_location, "plugin cannot register a missing pass");
1449 if (!pass_info->pass->name)
1450 fatal_error (input_location, "plugin cannot register an unnamed pass");
1452 if (!pass_info->reference_pass_name)
1453 fatal_error
1454 (input_location,
1455 "plugin cannot register pass %qs without reference pass name",
1456 pass_info->pass->name);
1458 /* Try to insert the new pass to the pass lists. We need to check
1459 all five lists as the reference pass could be in one (or all) of
1460 them. */
1461 all_instances = pass_info->ref_pass_instance_number == 0;
1462 success = position_pass (pass_info, &all_lowering_passes);
1463 if (!success || all_instances)
1464 success |= position_pass (pass_info, &all_small_ipa_passes);
1465 if (!success || all_instances)
1466 success |= position_pass (pass_info, &all_regular_ipa_passes);
1467 if (!success || all_instances)
1468 success |= position_pass (pass_info, &all_late_ipa_passes);
1469 if (!success || all_instances)
1470 success |= position_pass (pass_info, &all_passes);
1471 if (!success)
1472 fatal_error
1473 (input_location,
1474 "pass %qs not found but is referenced by new pass %qs",
1475 pass_info->reference_pass_name, pass_info->pass->name);
1477 /* OK, we have successfully inserted the new pass. We need to register
1478 the dump files for the newly added pass and its duplicates (if any).
1479 Because the registration of plugin/backend passes happens after the
1480 command-line options are parsed, the options that specify single
1481 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1482 passes. Therefore we currently can only enable dumping of
1483 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1484 are specified. While doing so, we also delete the pass_list_node
1485 objects created during pass positioning. */
1486 while (added_pass_nodes)
1488 struct pass_list_node *next_node = added_pass_nodes->next;
1489 enum tree_dump_index tdi;
1490 register_one_dump_file (added_pass_nodes->pass);
1491 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
1492 || added_pass_nodes->pass->type == IPA_PASS)
1493 tdi = TDI_ipa_all;
1494 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
1495 tdi = TDI_tree_all;
1496 else
1497 tdi = TDI_rtl_all;
1498 /* Check if dump-all flag is specified. */
1499 if (dumps->get_dump_file_info (tdi)->pstate)
1500 dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1501 ->pstate = dumps->get_dump_file_info (tdi)->pstate;
1502 XDELETE (added_pass_nodes);
1503 added_pass_nodes = next_node;
1507 /* Construct the pass tree. The sequencing of passes is driven by
1508 the cgraph routines:
1510 finalize_compilation_unit ()
1511 for each node N in the cgraph
1512 cgraph_analyze_function (N)
1513 cgraph_lower_function (N) -> all_lowering_passes
1515 If we are optimizing, compile is then invoked:
1517 compile ()
1518 ipa_passes () -> all_small_ipa_passes
1519 -> Analysis of all_regular_ipa_passes
1520 * possible LTO streaming at copmilation time *
1521 -> Execution of all_regular_ipa_passes
1522 * possible LTO streaming at link time *
1523 -> all_late_ipa_passes
1524 expand_all_functions ()
1525 for each node N in the cgraph
1526 expand_function (N) -> Transformation of all_regular_ipa_passes
1527 -> all_passes
1530 void *
1531 pass_manager::operator new (size_t sz)
1533 /* Ensure that all fields of the pass manager are zero-initialized. */
1534 return xcalloc (1, sz);
1537 void
1538 pass_manager::operator delete (void *ptr)
1540 free (ptr);
1543 pass_manager::pass_manager (context *ctxt)
1544 : all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
1545 all_regular_ipa_passes (NULL),
1546 all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
1547 m_ctxt (ctxt)
1549 opt_pass **p;
1551 /* Initialize the pass_lists array. */
1552 #define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1553 GCC_PASS_LISTS
1554 #undef DEF_PASS_LIST
1556 /* Build the tree of passes. */
1558 #define INSERT_PASSES_AFTER(PASS) \
1559 p = &(PASS);
1561 #define PUSH_INSERT_PASSES_WITHIN(PASS) \
1563 opt_pass **p = &(PASS ## _1)->sub;
1565 #define POP_INSERT_PASSES() \
1568 #define NEXT_PASS(PASS, NUM) \
1569 do { \
1570 gcc_assert (NULL == PASS ## _ ## NUM); \
1571 if ((NUM) == 1) \
1572 PASS ## _1 = make_##PASS (m_ctxt); \
1573 else \
1575 gcc_assert (PASS ## _1); \
1576 PASS ## _ ## NUM = PASS ## _1->clone (); \
1578 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1579 } while (0)
1581 #define TERMINATE_PASS_LIST() \
1582 *p = NULL;
1584 #include "pass-instances.def"
1586 #undef INSERT_PASSES_AFTER
1587 #undef PUSH_INSERT_PASSES_WITHIN
1588 #undef POP_INSERT_PASSES
1589 #undef NEXT_PASS
1590 #undef TERMINATE_PASS_LIST
1592 /* Register the passes with the tree dump code. */
1593 register_dump_files (all_lowering_passes);
1594 register_dump_files (all_small_ipa_passes);
1595 register_dump_files (all_regular_ipa_passes);
1596 register_dump_files (all_late_ipa_passes);
1597 register_dump_files (all_passes);
1600 static void
1601 delete_pass_tree (opt_pass *pass)
1603 while (pass)
1605 /* Recurse into child passes. */
1606 delete_pass_tree (pass->sub);
1608 opt_pass *next = pass->next;
1610 /* Delete this pass. */
1611 delete pass;
1613 /* Iterate onto sibling passes. */
1614 pass = next;
1618 pass_manager::~pass_manager ()
1620 XDELETEVEC (passes_by_id);
1622 /* Call delete_pass_tree on each of the pass_lists. */
1623 #define DEF_PASS_LIST(LIST) \
1624 delete_pass_tree (*pass_lists[PASS_LIST_NO_##LIST]);
1625 GCC_PASS_LISTS
1626 #undef DEF_PASS_LIST
1630 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1631 function CALLBACK for every function in the call graph. Otherwise,
1632 call CALLBACK on the current function. */
1634 static void
1635 do_per_function (void (*callback) (function *, void *data), void *data)
1637 if (current_function_decl)
1638 callback (cfun, data);
1639 else
1641 struct cgraph_node *node;
1642 FOR_EACH_DEFINED_FUNCTION (node)
1643 if (node->analyzed && (gimple_has_body_p (node->decl) && !in_lto_p)
1644 && (!node->clone_of || node->decl != node->clone_of->decl))
1645 callback (DECL_STRUCT_FUNCTION (node->decl), data);
1649 /* Because inlining might remove no-longer reachable nodes, we need to
1650 keep the array visible to garbage collector to avoid reading collected
1651 out nodes. */
1652 static int nnodes;
1653 static GTY ((length ("nnodes"))) cgraph_node **order;
1655 /* Hook called when NODE is removed and therefore should be
1656 excluded from order vector. DATA is an array of integers.
1657 DATA[0] holds max index it may be accessed by. For cgraph
1658 node DATA[node->uid + 1] holds index of this node in order
1659 vector. */
1660 static void
1661 remove_cgraph_node_from_order (cgraph_node *node, void *data)
1663 int *order_idx = (int *)data;
1665 if (node->uid >= order_idx[0])
1666 return;
1668 int idx = order_idx[node->uid + 1];
1669 if (idx >= 0 && idx < nnodes && order[idx] == node)
1670 order[idx] = NULL;
1673 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1674 function CALLBACK for every function in the call graph. Otherwise,
1675 call CALLBACK on the current function.
1676 This function is global so that plugins can use it. */
1677 void
1678 do_per_function_toporder (void (*callback) (function *, void *data), void *data)
1680 int i;
1682 if (current_function_decl)
1683 callback (cfun, data);
1684 else
1686 cgraph_node_hook_list *hook;
1687 int *order_idx;
1688 gcc_assert (!order);
1689 order = ggc_vec_alloc<cgraph_node *> (symtab->cgraph_count);
1691 order_idx = XALLOCAVEC (int, symtab->cgraph_max_uid + 1);
1692 memset (order_idx + 1, -1, sizeof (int) * symtab->cgraph_max_uid);
1693 order_idx[0] = symtab->cgraph_max_uid;
1695 nnodes = ipa_reverse_postorder (order);
1696 for (i = nnodes - 1; i >= 0; i--)
1698 order[i]->process = 1;
1699 order_idx[order[i]->uid + 1] = i;
1701 hook = symtab->add_cgraph_removal_hook (remove_cgraph_node_from_order,
1702 order_idx);
1703 for (i = nnodes - 1; i >= 0; i--)
1705 /* Function could be inlined and removed as unreachable. */
1706 if (!order[i])
1707 continue;
1709 struct cgraph_node *node = order[i];
1711 /* Allow possibly removed nodes to be garbage collected. */
1712 order[i] = NULL;
1713 node->process = 0;
1714 if (node->has_gimple_body_p ())
1715 callback (DECL_STRUCT_FUNCTION (node->decl), data);
1717 symtab->remove_cgraph_removal_hook (hook);
1719 ggc_free (order);
1720 order = NULL;
1721 nnodes = 0;
1724 /* Helper function to perform function body dump. */
1726 static void
1727 execute_function_dump (function *fn, void *data)
1729 opt_pass *pass = (opt_pass *)data;
1731 if (dump_file)
1733 push_cfun (fn);
1735 if (fn->curr_properties & PROP_trees)
1736 dump_function_to_file (fn->decl, dump_file, dump_flags);
1737 else
1738 print_rtl_with_bb (dump_file, get_insns (), dump_flags);
1740 /* Flush the file. If verification fails, we won't be able to
1741 close the file before aborting. */
1742 fflush (dump_file);
1744 if ((fn->curr_properties & PROP_cfg)
1745 && (dump_flags & TDF_GRAPH))
1747 if (!pass->graph_dump_initialized)
1749 clean_graph_dump_file (dump_file_name);
1750 pass->graph_dump_initialized = true;
1752 print_graph_cfg (dump_file_name, fn);
1755 pop_cfun ();
1759 static struct profile_record *profile_record;
1761 /* Do profile consistency book-keeping for the pass with static number INDEX.
1762 If SUBPASS is zero, we run _before_ the pass, and if SUBPASS is one, then
1763 we run _after_ the pass. RUN is true if the pass really runs, or FALSE
1764 if we are only book-keeping on passes that may have selectively disabled
1765 themselves on a given function. */
1766 static void
1767 check_profile_consistency (int index, int subpass, bool run)
1769 pass_manager *passes = g->get_passes ();
1770 if (index == -1)
1771 return;
1772 if (!profile_record)
1773 profile_record = XCNEWVEC (struct profile_record,
1774 passes->passes_by_id_size);
1775 gcc_assert (index < passes->passes_by_id_size && index >= 0);
1776 gcc_assert (subpass < 2);
1777 profile_record[index].run |= run;
1778 account_profile_record (&profile_record[index], subpass);
1781 /* Output profile consistency. */
1783 void
1784 dump_profile_report (void)
1786 g->get_passes ()->dump_profile_report ();
1789 void
1790 pass_manager::dump_profile_report () const
1792 int i, j;
1793 int last_freq_in = 0, last_count_in = 0, last_freq_out = 0, last_count_out = 0;
1794 gcov_type last_time = 0, last_size = 0;
1795 double rel_time_change, rel_size_change;
1796 int last_reported = 0;
1798 if (!profile_record)
1799 return;
1800 fprintf (stderr, "\nProfile consistency report:\n\n");
1801 fprintf (stderr, "Pass name |mismatch in |mismated out|Overall\n");
1802 fprintf (stderr, " |freq count |freq count |size time\n");
1804 for (i = 0; i < passes_by_id_size; i++)
1805 for (j = 0 ; j < 2; j++)
1806 if (profile_record[i].run)
1808 if (last_time)
1809 rel_time_change = (profile_record[i].time[j]
1810 - (double)last_time) * 100 / (double)last_time;
1811 else
1812 rel_time_change = 0;
1813 if (last_size)
1814 rel_size_change = (profile_record[i].size[j]
1815 - (double)last_size) * 100 / (double)last_size;
1816 else
1817 rel_size_change = 0;
1819 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in
1820 || profile_record[i].num_mismatched_freq_out[j] != last_freq_out
1821 || profile_record[i].num_mismatched_count_in[j] != last_count_in
1822 || profile_record[i].num_mismatched_count_out[j] != last_count_out
1823 || rel_time_change || rel_size_change)
1825 last_reported = i;
1826 fprintf (stderr, "%-20s %s",
1827 passes_by_id [i]->name,
1828 j ? "(after TODO)" : " ");
1829 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in)
1830 fprintf (stderr, "| %+5i",
1831 profile_record[i].num_mismatched_freq_in[j]
1832 - last_freq_in);
1833 else
1834 fprintf (stderr, "| ");
1835 if (profile_record[i].num_mismatched_count_in[j] != last_count_in)
1836 fprintf (stderr, " %+5i",
1837 profile_record[i].num_mismatched_count_in[j]
1838 - last_count_in);
1839 else
1840 fprintf (stderr, " ");
1841 if (profile_record[i].num_mismatched_freq_out[j] != last_freq_out)
1842 fprintf (stderr, "| %+5i",
1843 profile_record[i].num_mismatched_freq_out[j]
1844 - last_freq_out);
1845 else
1846 fprintf (stderr, "| ");
1847 if (profile_record[i].num_mismatched_count_out[j] != last_count_out)
1848 fprintf (stderr, " %+5i",
1849 profile_record[i].num_mismatched_count_out[j]
1850 - last_count_out);
1851 else
1852 fprintf (stderr, " ");
1854 /* Size/time units change across gimple and RTL. */
1855 if (i == pass_expand_1->static_pass_number)
1856 fprintf (stderr, "|----------");
1857 else
1859 if (rel_size_change)
1860 fprintf (stderr, "| %+8.4f%%", rel_size_change);
1861 else
1862 fprintf (stderr, "| ");
1863 if (rel_time_change)
1864 fprintf (stderr, " %+8.4f%%", rel_time_change);
1866 fprintf (stderr, "\n");
1867 last_freq_in = profile_record[i].num_mismatched_freq_in[j];
1868 last_freq_out = profile_record[i].num_mismatched_freq_out[j];
1869 last_count_in = profile_record[i].num_mismatched_count_in[j];
1870 last_count_out = profile_record[i].num_mismatched_count_out[j];
1872 else if (j && last_reported != i)
1874 last_reported = i;
1875 fprintf (stderr, "%-20s ------------| | |\n",
1876 passes_by_id [i]->name);
1878 last_time = profile_record[i].time[j];
1879 last_size = profile_record[i].size[j];
1883 /* Perform all TODO actions that ought to be done on each function. */
1885 static void
1886 execute_function_todo (function *fn, void *data)
1888 bool from_ipa_pass = (cfun == NULL);
1889 unsigned int flags = (size_t)data;
1890 flags &= ~fn->last_verified;
1891 if (!flags)
1892 return;
1894 push_cfun (fn);
1896 /* Always cleanup the CFG before trying to update SSA. */
1897 if (flags & TODO_cleanup_cfg)
1899 cleanup_tree_cfg ();
1901 /* When cleanup_tree_cfg merges consecutive blocks, it may
1902 perform some simplistic propagation when removing single
1903 valued PHI nodes. This propagation may, in turn, cause the
1904 SSA form to become out-of-date (see PR 22037). So, even
1905 if the parent pass had not scheduled an SSA update, we may
1906 still need to do one. */
1907 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1908 flags |= TODO_update_ssa;
1911 if (flags & TODO_update_ssa_any)
1913 unsigned update_flags = flags & TODO_update_ssa_any;
1914 update_ssa (update_flags);
1917 if (flag_tree_pta && (flags & TODO_rebuild_alias))
1918 compute_may_aliases ();
1920 if (optimize && (flags & TODO_update_address_taken))
1921 execute_update_addresses_taken ();
1923 if (flags & TODO_remove_unused_locals)
1924 remove_unused_locals ();
1926 if (flags & TODO_rebuild_frequencies)
1927 rebuild_frequencies ();
1929 if (flags & TODO_rebuild_cgraph_edges)
1930 cgraph_edge::rebuild_edges ();
1932 /* If we've seen errors do not bother running any verifiers. */
1933 if (!seen_error ())
1935 #if defined ENABLE_CHECKING
1936 dom_state pre_verify_state = dom_info_state (fn, CDI_DOMINATORS);
1937 dom_state pre_verify_pstate = dom_info_state (fn, CDI_POST_DOMINATORS);
1939 if (flags & TODO_verify_il)
1941 if (cfun->curr_properties & PROP_trees)
1943 if (cfun->curr_properties & PROP_cfg)
1944 /* IPA passes leave stmts to be fixed up, so make sure to
1945 not verify stmts really throw. */
1946 verify_gimple_in_cfg (cfun, !from_ipa_pass);
1947 else
1948 verify_gimple_in_seq (gimple_body (cfun->decl));
1950 if (cfun->curr_properties & PROP_ssa)
1951 /* IPA passes leave stmts to be fixed up, so make sure to
1952 not verify SSA operands whose verifier will choke on that. */
1953 verify_ssa (true, !from_ipa_pass);
1954 /* IPA passes leave basic-blocks unsplit, so make sure to
1955 not trip on that. */
1956 if ((cfun->curr_properties & PROP_cfg)
1957 && !from_ipa_pass)
1958 verify_flow_info ();
1959 if (current_loops
1960 && loops_state_satisfies_p (LOOP_CLOSED_SSA))
1961 verify_loop_closed_ssa (false);
1962 if (cfun->curr_properties & PROP_rtl)
1963 verify_rtl_sharing ();
1966 /* Make sure verifiers don't change dominator state. */
1967 gcc_assert (dom_info_state (fn, CDI_DOMINATORS) == pre_verify_state);
1968 gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == pre_verify_pstate);
1969 #endif
1972 fn->last_verified = flags & TODO_verify_all;
1974 pop_cfun ();
1976 /* For IPA passes make sure to release dominator info, it can be
1977 computed by non-verifying TODOs. */
1978 if (from_ipa_pass)
1980 free_dominance_info (fn, CDI_DOMINATORS);
1981 free_dominance_info (fn, CDI_POST_DOMINATORS);
1985 /* Perform all TODO actions. */
1986 static void
1987 execute_todo (unsigned int flags)
1989 #if defined ENABLE_CHECKING
1990 if (cfun
1991 && need_ssa_update_p (cfun))
1992 gcc_assert (flags & TODO_update_ssa_any);
1993 #endif
1995 timevar_push (TV_TODO);
1997 /* Inform the pass whether it is the first time it is run. */
1998 first_pass_instance = (flags & TODO_mark_first_instance) != 0;
2000 statistics_fini_pass ();
2002 if (flags)
2003 do_per_function (execute_function_todo, (void *)(size_t) flags);
2005 /* Always remove functions just as before inlining: IPA passes might be
2006 interested to see bodies of extern inline functions that are not inlined
2007 to analyze side effects. The full removal is done just at the end
2008 of IPA pass queue. */
2009 if (flags & TODO_remove_functions)
2011 gcc_assert (!cfun);
2012 symtab->remove_unreachable_nodes (dump_file);
2015 if ((flags & TODO_dump_symtab) && dump_file && !current_function_decl)
2017 gcc_assert (!cfun);
2018 symtab_node::dump_table (dump_file);
2019 /* Flush the file. If verification fails, we won't be able to
2020 close the file before aborting. */
2021 fflush (dump_file);
2024 /* Now that the dumping has been done, we can get rid of the optional
2025 df problems. */
2026 if (flags & TODO_df_finish)
2027 df_finish_pass ((flags & TODO_df_verify) != 0);
2029 timevar_pop (TV_TODO);
2032 /* Verify invariants that should hold between passes. This is a place
2033 to put simple sanity checks. */
2035 static void
2036 verify_interpass_invariants (void)
2038 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2041 /* Clear the last verified flag. */
2043 static void
2044 clear_last_verified (function *fn, void *data ATTRIBUTE_UNUSED)
2046 fn->last_verified = 0;
2049 /* Helper function. Verify that the properties has been turn into the
2050 properties expected by the pass. */
2052 #ifdef ENABLE_CHECKING
2053 static void
2054 verify_curr_properties (function *fn, void *data)
2056 unsigned int props = (size_t)data;
2057 gcc_assert ((fn->curr_properties & props) == props);
2059 #endif
2061 /* Initialize pass dump file. */
2062 /* This is non-static so that the plugins can use it. */
2064 bool
2065 pass_init_dump_file (opt_pass *pass)
2067 /* If a dump file name is present, open it if enabled. */
2068 if (pass->static_pass_number != -1)
2070 timevar_push (TV_DUMP);
2071 gcc::dump_manager *dumps = g->get_dumps ();
2072 bool initializing_dump =
2073 !dumps->dump_initialized_p (pass->static_pass_number);
2074 dump_file_name = dumps->get_dump_file_name (pass->static_pass_number);
2075 dumps->dump_start (pass->static_pass_number, &dump_flags);
2076 if (dump_file && current_function_decl)
2077 dump_function_header (dump_file, current_function_decl, dump_flags);
2078 if (initializing_dump
2079 && dump_file && (dump_flags & TDF_GRAPH)
2080 && cfun && (cfun->curr_properties & PROP_cfg))
2082 clean_graph_dump_file (dump_file_name);
2083 pass->graph_dump_initialized = true;
2085 timevar_pop (TV_DUMP);
2086 return initializing_dump;
2088 else
2089 return false;
2092 /* Flush PASS dump file. */
2093 /* This is non-static so that plugins can use it. */
2095 void
2096 pass_fini_dump_file (opt_pass *pass)
2098 timevar_push (TV_DUMP);
2100 /* Flush and close dump file. */
2101 if (dump_file_name)
2103 free (CONST_CAST (char *, dump_file_name));
2104 dump_file_name = NULL;
2107 g->get_dumps ()->dump_finish (pass->static_pass_number);
2108 timevar_pop (TV_DUMP);
2111 /* After executing the pass, apply expected changes to the function
2112 properties. */
2114 static void
2115 update_properties_after_pass (function *fn, void *data)
2117 opt_pass *pass = (opt_pass *) data;
2118 fn->curr_properties = (fn->curr_properties | pass->properties_provided)
2119 & ~pass->properties_destroyed;
2122 /* Execute summary generation for all of the passes in IPA_PASS. */
2124 void
2125 execute_ipa_summary_passes (ipa_opt_pass_d *ipa_pass)
2127 while (ipa_pass)
2129 opt_pass *pass = ipa_pass;
2131 /* Execute all of the IPA_PASSes in the list. */
2132 if (ipa_pass->type == IPA_PASS
2133 && pass->gate (cfun)
2134 && ipa_pass->generate_summary)
2136 pass_init_dump_file (pass);
2138 /* If a timevar is present, start it. */
2139 if (pass->tv_id)
2140 timevar_push (pass->tv_id);
2142 current_pass = pass;
2143 ipa_pass->generate_summary ();
2145 /* Stop timevar. */
2146 if (pass->tv_id)
2147 timevar_pop (pass->tv_id);
2149 pass_fini_dump_file (pass);
2151 ipa_pass = (ipa_opt_pass_d *)ipa_pass->next;
2155 /* Execute IPA_PASS function transform on NODE. */
2157 static void
2158 execute_one_ipa_transform_pass (struct cgraph_node *node,
2159 ipa_opt_pass_d *ipa_pass)
2161 opt_pass *pass = ipa_pass;
2162 unsigned int todo_after = 0;
2164 current_pass = pass;
2165 if (!ipa_pass->function_transform)
2166 return;
2168 /* Note that the folders should only create gimple expressions.
2169 This is a hack until the new folder is ready. */
2170 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2172 pass_init_dump_file (pass);
2174 /* Run pre-pass verification. */
2175 execute_todo (ipa_pass->function_transform_todo_flags_start);
2177 /* If a timevar is present, start it. */
2178 if (pass->tv_id != TV_NONE)
2179 timevar_push (pass->tv_id);
2181 /* Do it! */
2182 todo_after = ipa_pass->function_transform (node);
2184 /* Stop timevar. */
2185 if (pass->tv_id != TV_NONE)
2186 timevar_pop (pass->tv_id);
2188 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2189 check_profile_consistency (pass->static_pass_number, 0, true);
2191 /* Run post-pass cleanup and verification. */
2192 execute_todo (todo_after);
2193 verify_interpass_invariants ();
2194 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2195 check_profile_consistency (pass->static_pass_number, 1, true);
2197 if (dump_file)
2198 do_per_function (execute_function_dump, NULL);
2199 pass_fini_dump_file (pass);
2201 current_pass = NULL;
2203 /* Signal this is a suitable GC collection point. */
2204 if (!(todo_after & TODO_do_not_ggc_collect))
2205 ggc_collect ();
2208 /* For the current function, execute all ipa transforms. */
2210 void
2211 execute_all_ipa_transforms (void)
2213 struct cgraph_node *node;
2214 if (!cfun)
2215 return;
2216 node = cgraph_node::get (current_function_decl);
2218 if (node->ipa_transforms_to_apply.exists ())
2220 unsigned int i;
2222 for (i = 0; i < node->ipa_transforms_to_apply.length (); i++)
2223 execute_one_ipa_transform_pass (node, node->ipa_transforms_to_apply[i]);
2224 node->ipa_transforms_to_apply.release ();
2228 /* Check if PASS is explicitly disabled or enabled and return
2229 the gate status. FUNC is the function to be processed, and
2230 GATE_STATUS is the gate status determined by pass manager by
2231 default. */
2233 static bool
2234 override_gate_status (opt_pass *pass, tree func, bool gate_status)
2236 bool explicitly_enabled = false;
2237 bool explicitly_disabled = false;
2239 explicitly_enabled
2240 = is_pass_explicitly_enabled_or_disabled (pass, func,
2241 enabled_pass_uid_range_tab);
2242 explicitly_disabled
2243 = is_pass_explicitly_enabled_or_disabled (pass, func,
2244 disabled_pass_uid_range_tab);
2246 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
2248 return gate_status;
2252 /* Execute PASS. */
2254 bool
2255 execute_one_pass (opt_pass *pass)
2257 unsigned int todo_after = 0;
2259 bool gate_status;
2261 /* IPA passes are executed on whole program, so cfun should be NULL.
2262 Other passes need function context set. */
2263 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2264 gcc_assert (!cfun && !current_function_decl);
2265 else
2266 gcc_assert (cfun && current_function_decl);
2268 current_pass = pass;
2270 /* Check whether gate check should be avoided.
2271 User controls the value of the gate through the parameter "gate_status". */
2272 gate_status = pass->gate (cfun);
2273 gate_status = override_gate_status (pass, current_function_decl, gate_status);
2275 /* Override gate with plugin. */
2276 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
2278 if (!gate_status)
2280 /* Run so passes selectively disabling themselves on a given function
2281 are not miscounted. */
2282 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2284 check_profile_consistency (pass->static_pass_number, 0, false);
2285 check_profile_consistency (pass->static_pass_number, 1, false);
2287 current_pass = NULL;
2288 return false;
2291 /* Pass execution event trigger: useful to identify passes being
2292 executed. */
2293 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
2295 if (!quiet_flag && !cfun)
2296 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
2298 /* Note that the folders should only create gimple expressions.
2299 This is a hack until the new folder is ready. */
2300 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2302 pass_init_dump_file (pass);
2304 /* Run pre-pass verification. */
2305 execute_todo (pass->todo_flags_start);
2307 #ifdef ENABLE_CHECKING
2308 do_per_function (verify_curr_properties,
2309 (void *)(size_t)pass->properties_required);
2310 #endif
2312 /* If a timevar is present, start it. */
2313 if (pass->tv_id != TV_NONE)
2314 timevar_push (pass->tv_id);
2316 /* Do it! */
2317 todo_after = pass->execute (cfun);
2318 do_per_function (clear_last_verified, NULL);
2320 /* Stop timevar. */
2321 if (pass->tv_id != TV_NONE)
2322 timevar_pop (pass->tv_id);
2324 do_per_function (update_properties_after_pass, pass);
2326 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2327 check_profile_consistency (pass->static_pass_number, 0, true);
2329 /* Run post-pass cleanup and verification. */
2330 execute_todo (todo_after | pass->todo_flags_finish | TODO_verify_il);
2331 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2332 check_profile_consistency (pass->static_pass_number, 1, true);
2334 verify_interpass_invariants ();
2335 if (dump_file)
2336 do_per_function (execute_function_dump, pass);
2337 if (pass->type == IPA_PASS)
2339 struct cgraph_node *node;
2340 if (((ipa_opt_pass_d *)pass)->function_transform)
2341 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2342 node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *)pass);
2345 if (!current_function_decl)
2346 symtab->process_new_functions ();
2348 pass_fini_dump_file (pass);
2350 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2351 gcc_assert (!(cfun->curr_properties & PROP_trees)
2352 || pass->type != RTL_PASS);
2354 current_pass = NULL;
2356 /* Signal this is a suitable GC collection point. */
2357 if (!((todo_after | pass->todo_flags_finish) & TODO_do_not_ggc_collect))
2358 ggc_collect ();
2360 return true;
2363 static void
2364 execute_pass_list_1 (opt_pass *pass)
2368 gcc_assert (pass->type == GIMPLE_PASS
2369 || pass->type == RTL_PASS);
2370 if (execute_one_pass (pass) && pass->sub)
2371 execute_pass_list_1 (pass->sub);
2372 pass = pass->next;
2374 while (pass);
2377 void
2378 execute_pass_list (function *fn, opt_pass *pass)
2380 push_cfun (fn);
2381 execute_pass_list_1 (pass);
2382 if (fn->cfg)
2384 free_dominance_info (CDI_DOMINATORS);
2385 free_dominance_info (CDI_POST_DOMINATORS);
2387 pop_cfun ();
2390 /* Write out all LTO data. */
2391 static void
2392 write_lto (void)
2394 timevar_push (TV_IPA_LTO_GIMPLE_OUT);
2395 lto_output ();
2396 timevar_pop (TV_IPA_LTO_GIMPLE_OUT);
2397 timevar_push (TV_IPA_LTO_DECL_OUT);
2398 produce_asm_for_decls ();
2399 timevar_pop (TV_IPA_LTO_DECL_OUT);
2402 /* Same as execute_pass_list but assume that subpasses of IPA passes
2403 are local passes. If SET is not NULL, write out summaries of only
2404 those node in SET. */
2406 static void
2407 ipa_write_summaries_2 (opt_pass *pass, struct lto_out_decl_state *state)
2409 while (pass)
2411 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2412 gcc_assert (!current_function_decl);
2413 gcc_assert (!cfun);
2414 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2415 if (pass->type == IPA_PASS
2416 && ipa_pass->write_summary
2417 && pass->gate (cfun))
2419 /* If a timevar is present, start it. */
2420 if (pass->tv_id)
2421 timevar_push (pass->tv_id);
2423 pass_init_dump_file (pass);
2425 current_pass = pass;
2426 ipa_pass->write_summary ();
2428 pass_fini_dump_file (pass);
2430 /* If a timevar is present, start it. */
2431 if (pass->tv_id)
2432 timevar_pop (pass->tv_id);
2435 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2436 ipa_write_summaries_2 (pass->sub, state);
2438 pass = pass->next;
2442 /* Helper function of ipa_write_summaries. Creates and destroys the
2443 decl state and calls ipa_write_summaries_2 for all passes that have
2444 summaries. SET is the set of nodes to be written. */
2446 static void
2447 ipa_write_summaries_1 (lto_symtab_encoder_t encoder)
2449 pass_manager *passes = g->get_passes ();
2450 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2451 state->symtab_node_encoder = encoder;
2453 lto_output_init_mode_table ();
2454 lto_push_out_decl_state (state);
2456 gcc_assert (!flag_wpa);
2457 ipa_write_summaries_2 (passes->all_regular_ipa_passes, state);
2459 write_lto ();
2461 gcc_assert (lto_get_out_decl_state () == state);
2462 lto_pop_out_decl_state ();
2463 lto_delete_out_decl_state (state);
2466 /* Write out summaries for all the nodes in the callgraph. */
2468 void
2469 ipa_write_summaries (void)
2471 lto_symtab_encoder_t encoder;
2472 int i, order_pos;
2473 varpool_node *vnode;
2474 struct cgraph_node *node;
2475 struct cgraph_node **order;
2477 if ((!flag_generate_lto && !flag_generate_offload) || seen_error ())
2478 return;
2480 select_what_to_stream ();
2482 encoder = lto_symtab_encoder_new (false);
2484 /* Create the callgraph set in the same order used in
2485 cgraph_expand_all_functions. This mostly facilitates debugging,
2486 since it causes the gimple file to be processed in the same order
2487 as the source code. */
2488 order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
2489 order_pos = ipa_reverse_postorder (order);
2490 gcc_assert (order_pos == symtab->cgraph_count);
2492 for (i = order_pos - 1; i >= 0; i--)
2494 struct cgraph_node *node = order[i];
2496 if (node->has_gimple_body_p ())
2498 /* When streaming out references to statements as part of some IPA
2499 pass summary, the statements need to have uids assigned and the
2500 following does that for all the IPA passes here. Naturally, this
2501 ordering then matches the one IPA-passes get in their stmt_fixup
2502 hooks. */
2504 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2505 renumber_gimple_stmt_uids ();
2506 pop_cfun ();
2508 if (node->definition && node->need_lto_streaming)
2509 lto_set_symtab_encoder_in_partition (encoder, node);
2512 FOR_EACH_DEFINED_FUNCTION (node)
2513 if (node->alias && node->need_lto_streaming)
2514 lto_set_symtab_encoder_in_partition (encoder, node);
2515 FOR_EACH_DEFINED_VARIABLE (vnode)
2516 if (vnode->need_lto_streaming)
2517 lto_set_symtab_encoder_in_partition (encoder, vnode);
2519 ipa_write_summaries_1 (compute_ltrans_boundary (encoder));
2521 free (order);
2524 /* Same as execute_pass_list but assume that subpasses of IPA passes
2525 are local passes. If SET is not NULL, write out optimization summaries of
2526 only those node in SET. */
2528 static void
2529 ipa_write_optimization_summaries_1 (opt_pass *pass,
2530 struct lto_out_decl_state *state)
2532 while (pass)
2534 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2535 gcc_assert (!current_function_decl);
2536 gcc_assert (!cfun);
2537 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2538 if (pass->type == IPA_PASS
2539 && ipa_pass->write_optimization_summary
2540 && pass->gate (cfun))
2542 /* If a timevar is present, start it. */
2543 if (pass->tv_id)
2544 timevar_push (pass->tv_id);
2546 pass_init_dump_file (pass);
2548 current_pass = pass;
2549 ipa_pass->write_optimization_summary ();
2551 pass_fini_dump_file (pass);
2553 /* If a timevar is present, start it. */
2554 if (pass->tv_id)
2555 timevar_pop (pass->tv_id);
2558 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2559 ipa_write_optimization_summaries_1 (pass->sub, state);
2561 pass = pass->next;
2565 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2566 NULL, write out all summaries of all nodes. */
2568 void
2569 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder)
2571 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2572 lto_symtab_encoder_iterator lsei;
2573 state->symtab_node_encoder = encoder;
2575 lto_output_init_mode_table ();
2576 lto_push_out_decl_state (state);
2577 for (lsei = lsei_start_function_in_partition (encoder);
2578 !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
2580 struct cgraph_node *node = lsei_cgraph_node (lsei);
2581 /* When streaming out references to statements as part of some IPA
2582 pass summary, the statements need to have uids assigned.
2584 For functions newly born at WPA stage we need to initialize
2585 the uids here. */
2586 if (node->definition
2587 && gimple_has_body_p (node->decl))
2589 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2590 renumber_gimple_stmt_uids ();
2591 pop_cfun ();
2595 gcc_assert (flag_wpa);
2596 pass_manager *passes = g->get_passes ();
2597 ipa_write_optimization_summaries_1 (passes->all_regular_ipa_passes, state);
2599 write_lto ();
2601 gcc_assert (lto_get_out_decl_state () == state);
2602 lto_pop_out_decl_state ();
2603 lto_delete_out_decl_state (state);
2606 /* Same as execute_pass_list but assume that subpasses of IPA passes
2607 are local passes. */
2609 static void
2610 ipa_read_summaries_1 (opt_pass *pass)
2612 while (pass)
2614 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2616 gcc_assert (!current_function_decl);
2617 gcc_assert (!cfun);
2618 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2620 if (pass->gate (cfun))
2622 if (pass->type == IPA_PASS && ipa_pass->read_summary)
2624 /* If a timevar is present, start it. */
2625 if (pass->tv_id)
2626 timevar_push (pass->tv_id);
2628 pass_init_dump_file (pass);
2630 current_pass = pass;
2631 ipa_pass->read_summary ();
2633 pass_fini_dump_file (pass);
2635 /* Stop timevar. */
2636 if (pass->tv_id)
2637 timevar_pop (pass->tv_id);
2640 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2641 ipa_read_summaries_1 (pass->sub);
2643 pass = pass->next;
2648 /* Read all the summaries for all_regular_ipa_passes. */
2650 void
2651 ipa_read_summaries (void)
2653 pass_manager *passes = g->get_passes ();
2654 ipa_read_summaries_1 (passes->all_regular_ipa_passes);
2657 /* Same as execute_pass_list but assume that subpasses of IPA passes
2658 are local passes. */
2660 static void
2661 ipa_read_optimization_summaries_1 (opt_pass *pass)
2663 while (pass)
2665 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2667 gcc_assert (!current_function_decl);
2668 gcc_assert (!cfun);
2669 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2671 if (pass->gate (cfun))
2673 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
2675 /* If a timevar is present, start it. */
2676 if (pass->tv_id)
2677 timevar_push (pass->tv_id);
2679 pass_init_dump_file (pass);
2681 current_pass = pass;
2682 ipa_pass->read_optimization_summary ();
2684 pass_fini_dump_file (pass);
2686 /* Stop timevar. */
2687 if (pass->tv_id)
2688 timevar_pop (pass->tv_id);
2691 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2692 ipa_read_optimization_summaries_1 (pass->sub);
2694 pass = pass->next;
2698 /* Read all the summaries for all_regular_ipa_passes. */
2700 void
2701 ipa_read_optimization_summaries (void)
2703 pass_manager *passes = g->get_passes ();
2704 ipa_read_optimization_summaries_1 (passes->all_regular_ipa_passes);
2707 /* Same as execute_pass_list but assume that subpasses of IPA passes
2708 are local passes. */
2709 void
2710 execute_ipa_pass_list (opt_pass *pass)
2714 gcc_assert (!current_function_decl);
2715 gcc_assert (!cfun);
2716 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2717 if (execute_one_pass (pass) && pass->sub)
2719 if (pass->sub->type == GIMPLE_PASS)
2721 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
2722 do_per_function_toporder ((void (*)(function *, void *))
2723 execute_pass_list,
2724 pass->sub);
2725 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
2727 else if (pass->sub->type == SIMPLE_IPA_PASS
2728 || pass->sub->type == IPA_PASS)
2729 execute_ipa_pass_list (pass->sub);
2730 else
2731 gcc_unreachable ();
2733 gcc_assert (!current_function_decl);
2734 symtab->process_new_functions ();
2735 pass = pass->next;
2737 while (pass);
2740 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2742 static void
2743 execute_ipa_stmt_fixups (opt_pass *pass,
2744 struct cgraph_node *node, gimple *stmts)
2746 while (pass)
2748 /* Execute all of the IPA_PASSes in the list. */
2749 if (pass->type == IPA_PASS
2750 && pass->gate (cfun))
2752 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2754 if (ipa_pass->stmt_fixup)
2756 pass_init_dump_file (pass);
2757 /* If a timevar is present, start it. */
2758 if (pass->tv_id)
2759 timevar_push (pass->tv_id);
2761 current_pass = pass;
2762 ipa_pass->stmt_fixup (node, stmts);
2764 /* Stop timevar. */
2765 if (pass->tv_id)
2766 timevar_pop (pass->tv_id);
2767 pass_fini_dump_file (pass);
2769 if (pass->sub)
2770 execute_ipa_stmt_fixups (pass->sub, node, stmts);
2772 pass = pass->next;
2776 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2778 void
2779 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
2781 pass_manager *passes = g->get_passes ();
2782 execute_ipa_stmt_fixups (passes->all_regular_ipa_passes, node, stmts);
2786 extern void debug_properties (unsigned int);
2787 extern void dump_properties (FILE *, unsigned int);
2789 DEBUG_FUNCTION void
2790 dump_properties (FILE *dump, unsigned int props)
2792 fprintf (dump, "Properties:\n");
2793 if (props & PROP_gimple_any)
2794 fprintf (dump, "PROP_gimple_any\n");
2795 if (props & PROP_gimple_lcf)
2796 fprintf (dump, "PROP_gimple_lcf\n");
2797 if (props & PROP_gimple_leh)
2798 fprintf (dump, "PROP_gimple_leh\n");
2799 if (props & PROP_cfg)
2800 fprintf (dump, "PROP_cfg\n");
2801 if (props & PROP_ssa)
2802 fprintf (dump, "PROP_ssa\n");
2803 if (props & PROP_no_crit_edges)
2804 fprintf (dump, "PROP_no_crit_edges\n");
2805 if (props & PROP_rtl)
2806 fprintf (dump, "PROP_rtl\n");
2807 if (props & PROP_gimple_lomp)
2808 fprintf (dump, "PROP_gimple_lomp\n");
2809 if (props & PROP_gimple_lcx)
2810 fprintf (dump, "PROP_gimple_lcx\n");
2811 if (props & PROP_gimple_lvec)
2812 fprintf (dump, "PROP_gimple_lvec\n");
2813 if (props & PROP_cfglayout)
2814 fprintf (dump, "PROP_cfglayout\n");
2817 DEBUG_FUNCTION void
2818 debug_properties (unsigned int props)
2820 dump_properties (stderr, props);
2823 /* Called by local passes to see if function is called by already processed nodes.
2824 Because we process nodes in topological order, this means that function is
2825 in recursive cycle or we introduced new direct calls. */
2826 bool
2827 function_called_by_processed_nodes_p (void)
2829 struct cgraph_edge *e;
2830 for (e = cgraph_node::get (current_function_decl)->callers;
2832 e = e->next_caller)
2834 if (e->caller->decl == current_function_decl)
2835 continue;
2836 if (!e->caller->has_gimple_body_p ())
2837 continue;
2838 if (TREE_ASM_WRITTEN (e->caller->decl))
2839 continue;
2840 if (!e->caller->process && !e->caller->global.inlined_to)
2841 break;
2843 if (dump_file && e)
2845 fprintf (dump_file, "Already processed call to:\n");
2846 e->caller->dump (dump_file);
2848 return e != NULL;
2851 #include "gt-passes.h"