1/* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
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. */
24
25#include "config.h"
26#include "system.h"
27#include "coretypes.h"
28#include "backend.h"
29#include "target.h"
30#include "rtl.h"
31#include "tree.h"
32#include "gimple.h"
33#include "cfghooks.h"
34#include "df.h"
35#include "memmodel.h"
36#include "tm_p.h"
37#include "ssa.h"
38#include "emit-rtl.h"
39#include "cgraph.h"
40#include "lto-streamer.h"
41#include "fold-const.h"
42#include "varasm.h"
43#include "output.h"
44#include "graph.h"
45#include "debug.h"
46#include "cfgloop.h"
47#include "value-prof.h"
48#include "tree-cfg.h"
49#include "tree-ssa-loop-manip.h"
50#include "tree-into-ssa.h"
51#include "tree-dfa.h"
52#include "tree-ssa.h"
53#include "tree-pass.h"
54#include "plugin.h"
55#include "ipa-utils.h"
56#include "tree-pretty-print.h" /* for dump_function_header */
57#include "context.h"
58#include "pass_manager.h"
59#include "cfgrtl.h"
60#include "tree-ssa-live.h" /* For remove_unused_locals. */
61#include "tree-cfgcleanup.h"
62#include "insn-addr.h" /* for INSN_ADDRESSES_ALLOC. */
63#include "diagnostic-core.h" /* for fnotice */
64#include "stringpool.h"
65#include "attribs.h"
66
67using namespace gcc;
68
69/* This is used for debugging. It allows the current pass to printed
70 from anywhere in compilation.
71 The variable current_pass is also used for statistics and plugins. */
72opt_pass *current_pass;
73
74/* Most passes are single-instance (within their context) and thus don't
75 need to implement cloning, but passes that support multiple instances
76 *must* provide their own implementation of the clone method.
77
78 Handle this by providing a default implemenation, but make it a fatal
79 error to call it. */
80
81opt_pass *
82opt_pass::clone ()
83{
84 internal_error ("pass %s does not support cloning", name);
85}
86
87void
88opt_pass::set_pass_param (unsigned int, bool)
89{
90 internal_error ("pass %s needs a set_pass_param implementation to handle the"
91 " extra argument in NEXT_PASS", name);
92}
93
94bool
95opt_pass::gate (function *)
96{
97 return true;
98}
99
100unsigned int
101opt_pass::execute (function *)
102{
103 return 0;
104}
105
106opt_pass::opt_pass (const pass_data &data, context *ctxt)
107 : pass_data (data),
108 sub (NULL),
109 next (NULL),
110 static_pass_number (0),
111 m_ctxt (ctxt)
112{
113}
114
115
116void
117pass_manager::execute_early_local_passes ()
118{
119 execute_pass_list (cfun, pass_build_ssa_passes_1->sub);
120 if (flag_check_pointer_bounds)
121 execute_pass_list (cfun, pass_chkp_instrumentation_passes_1->sub);
122 execute_pass_list (cfun, pass_local_optimization_passes_1->sub);
123}
124
125unsigned int
126pass_manager::execute_pass_mode_switching ()
127{
128 return pass_mode_switching_1->execute (cfun);
129}
130
131
132/* Call from anywhere to find out what pass this is. Useful for
133 printing out debugging information deep inside an service
134 routine. */
135void
136print_current_pass (FILE *file)
137{
138 if (current_pass)
139 fprintf (file, "current pass = %s (%d)\n",
140 current_pass->name, current_pass->static_pass_number);
141 else
142 fprintf (file, "no current pass.\n");
143}
144
145
146/* Call from the debugger to get the current pass name. */
147DEBUG_FUNCTION void
148debug_pass (void)
149{
150 print_current_pass (stderr);
151}
152
153
154
155/* Global variables used to communicate with passes. */
156bool in_gimple_form;
157
158
159/* This is called from various places for FUNCTION_DECL, VAR_DECL,
160 and TYPE_DECL nodes.
161
162 This does nothing for local (non-static) variables, unless the
163 variable is a register variable with DECL_ASSEMBLER_NAME set. In
164 that case, or if the variable is not an automatic, it sets up the
165 RTL and outputs any assembler code (label definition, storage
166 allocation and initialization).
167
168 DECL is the declaration. TOP_LEVEL is nonzero
169 if this declaration is not within a function. */
170
171void
172rest_of_decl_compilation (tree decl,
173 int top_level,
174 int at_end)
175{
176 bool finalize = true;
177
178 /* We deferred calling assemble_alias so that we could collect
179 other attributes such as visibility. Emit the alias now. */
180 if (!in_lto_p)
181 {
182 tree alias;
183 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
184 if (alias)
185 {
186 alias = TREE_VALUE (TREE_VALUE (alias));
187 alias = get_identifier (TREE_STRING_POINTER (alias));
188 /* A quirk of the initial implementation of aliases required that the
189 user add "extern" to all of them. Which is silly, but now
190 historical. Do note that the symbol is in fact locally defined. */
191 DECL_EXTERNAL (decl) = 0;
192 TREE_STATIC (decl) = 1;
193 assemble_alias (decl, alias);
194 finalize = false;
195 }
196 }
197
198 /* Can't defer this, because it needs to happen before any
199 later function definitions are processed. */
200 if (HAS_DECL_ASSEMBLER_NAME_P (decl)
201 && DECL_ASSEMBLER_NAME_SET_P (decl)
202 && DECL_REGISTER (decl))
203 make_decl_rtl (decl);
204
205 /* Forward declarations for nested functions are not "external",
206 but we need to treat them as if they were. */
207 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
208 || TREE_CODE (decl) == FUNCTION_DECL)
209 {
210 timevar_push (TV_VARCONST);
211
212 /* Don't output anything when a tentative file-scope definition
213 is seen. But at end of compilation, do output code for them.
214
215 We do output all variables and rely on
216 callgraph code to defer them except for forward declarations
217 (see gcc.c-torture/compile/920624-1.c) */
218 if ((at_end
219 || !DECL_DEFER_OUTPUT (decl)
220 || DECL_INITIAL (decl))
221 && (!VAR_P (decl) || !DECL_HAS_VALUE_EXPR_P (decl))
222 && !DECL_EXTERNAL (decl))
223 {
224 /* When reading LTO unit, we also read varpool, so do not
225 rebuild it. */
226 if (in_lto_p && !at_end)
227 ;
228 else if (finalize && TREE_CODE (decl) != FUNCTION_DECL)
229 varpool_node::finalize_decl (decl);
230 }
231
232#ifdef ASM_FINISH_DECLARE_OBJECT
233 if (decl == last_assemble_variable_decl)
234 {
235 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
236 top_level, at_end);
237 }
238#endif
239
240 /* Now that we have activated any function-specific attributes
241 that might affect function decl, particularly align, relayout it. */
242 if (TREE_CODE (decl) == FUNCTION_DECL)
243 targetm.target_option.relayout_function (decl);
244
245 timevar_pop (TV_VARCONST);
246 }
247 else if (TREE_CODE (decl) == TYPE_DECL
248 /* Like in rest_of_type_compilation, avoid confusing the debug
249 information machinery when there are errors. */
250 && !seen_error ())
251 {
252 timevar_push (TV_SYMOUT);
253 debug_hooks->type_decl (decl, !top_level);
254 timevar_pop (TV_SYMOUT);
255 }
256
257 /* Let cgraph know about the existence of variables. */
258 if (in_lto_p && !at_end)
259 ;
260 else if (VAR_P (decl) && !DECL_EXTERNAL (decl)
261 && TREE_STATIC (decl))
262 varpool_node::get_create (decl);
263
264 /* Generate early debug for global variables. Any local variables will
265 be handled by either handling reachable functions from
266 finalize_compilation_unit (and by consequence, locally scoped
267 symbols), or by rest_of_type_compilation below.
268
269 For Go's hijack of the debug_hooks to implement -fdump-go-spec, pick up
270 function prototypes. Go's debug_hooks will not forward them to the
271 wrapped hooks. */
272 if (!in_lto_p
273 && (TREE_CODE (decl) != FUNCTION_DECL
274 /* This will pick up function prototypes with no bodies,
275 which are not visible in finalize_compilation_unit()
276 while iterating with FOR_EACH_*_FUNCTION through the
277 symbol table. */
278 || (flag_dump_go_spec != NULL
279 && !DECL_SAVED_TREE (decl)
280 && DECL_STRUCT_FUNCTION (decl) == NULL))
281
282 /* We need to check both decl_function_context and
283 current_function_decl here to make sure local extern
284 declarations end up with the correct context.
285
286 For local extern declarations, decl_function_context is
287 empty, but current_function_decl is set to the function where
288 the extern was declared . Without the check for
289 !current_function_decl below, the local extern ends up
290 incorrectly with a top-level context.
291
292 For example:
293
294 namespace S
295 {
296 int
297 f()
298 {
299 {
300 int i = 42;
301 {
302 extern int i; // Local extern declaration.
303 return i;
304 }
305 }
306 }
307 }
308 */
309 && !decl_function_context (decl)
310 && !current_function_decl
311 && DECL_SOURCE_LOCATION (decl) != BUILTINS_LOCATION
312 && (!decl_type_context (decl)
313 /* If we created a varpool node for the decl make sure to
314 call early_global_decl. Otherwise we miss changes
315 introduced by member definitions like
316 struct A { static int staticdatamember; };
317 int A::staticdatamember;
318 and thus have incomplete early debug and late debug
319 called from varpool node removal fails to handle it
320 properly. */
321 || (finalize
322 && VAR_P (decl)
323 && TREE_STATIC (decl) && !DECL_EXTERNAL (decl)))
324 /* Avoid confusing the debug information machinery when there are
325 errors. */
326 && !seen_error ())
327 (*debug_hooks->early_global_decl) (decl);
328}
329
330/* Called after finishing a record, union or enumeral type. */
331
332void
333rest_of_type_compilation (tree type, int toplev)
334{
335 /* Avoid confusing the debug information machinery when there are
336 errors. */
337 if (seen_error ())
338 return;
339
340 timevar_push (TV_SYMOUT);
341 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
342 timevar_pop (TV_SYMOUT);
343}
344
345
346
347void
348pass_manager::
349finish_optimization_passes (void)
350{
351 int i;
352 struct dump_file_info *dfi;
353 char *name;
354 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
355
356 timevar_push (TV_DUMP);
357 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
358 {
359 dumps->dump_start (pass_profile_1->static_pass_number, NULL);
360 end_branch_prob ();
361 dumps->dump_finish (pass_profile_1->static_pass_number);
362 }
363
364 if (optimize > 0)
365 {
366 dumps->dump_start (pass_profile_1->static_pass_number, NULL);
367 print_combine_total_stats ();
368 dumps->dump_finish (pass_profile_1->static_pass_number);
369 }
370
371 /* Do whatever is necessary to finish printing the graphs. */
372 for (i = TDI_end; (dfi = dumps->get_dump_file_info (i)) != NULL; ++i)
373 if (dfi->graph_dump_initialized)
374 {
375 name = dumps->get_dump_file_name (dfi);
376 finish_graph_dump_file (name);
377 free (name);
378 }
379
380 timevar_pop (TV_DUMP);
381}
382
383static unsigned int
384execute_build_ssa_passes (void)
385{
386 /* Once this pass (and its sub-passes) are complete, all functions
387 will be in SSA form. Technically this state change is happening
388 a tad early, since the sub-passes have not yet run, but since
389 none of the sub-passes are IPA passes and do not create new
390 functions, this is ok. We're setting this value for the benefit
391 of IPA passes that follow. */
392 if (symtab->state < IPA_SSA)
393 symtab->state = IPA_SSA;
394 return 0;
395}
396
397namespace {
398
399const pass_data pass_data_build_ssa_passes =
400{
401 SIMPLE_IPA_PASS, /* type */
402 "build_ssa_passes", /* name */
403 OPTGROUP_NONE, /* optinfo_flags */
404 TV_EARLY_LOCAL, /* tv_id */
405 0, /* properties_required */
406 0, /* properties_provided */
407 0, /* properties_destroyed */
408 0, /* todo_flags_start */
409 /* todo_flags_finish is executed before subpases. For this reason
410 it makes no sense to remove unreachable functions here. */
411 0, /* todo_flags_finish */
412};
413
414class pass_build_ssa_passes : public simple_ipa_opt_pass
415{
416public:
417 pass_build_ssa_passes (gcc::context *ctxt)
418 : simple_ipa_opt_pass (pass_data_build_ssa_passes, ctxt)
419 {}
420
421 /* opt_pass methods: */
422 virtual bool gate (function *)
423 {
424 /* Don't bother doing anything if the program has errors. */
425 return (!seen_error () && !in_lto_p);
426 }
427
428 virtual unsigned int execute (function *)
429 {
430 return execute_build_ssa_passes ();
431 }
432
433}; // class pass_build_ssa_passes
434
435const pass_data pass_data_chkp_instrumentation_passes =
436{
437 SIMPLE_IPA_PASS, /* type */
438 "chkp_passes", /* name */
439 OPTGROUP_NONE, /* optinfo_flags */
440 TV_NONE, /* tv_id */
441 0, /* properties_required */
442 0, /* properties_provided */
443 0, /* properties_destroyed */
444 0, /* todo_flags_start */
445 0, /* todo_flags_finish */
446};
447
448class pass_chkp_instrumentation_passes : public simple_ipa_opt_pass
449{
450public:
451 pass_chkp_instrumentation_passes (gcc::context *ctxt)
452 : simple_ipa_opt_pass (pass_data_chkp_instrumentation_passes, ctxt)
453 {}
454
455 /* opt_pass methods: */
456 virtual bool gate (function *)
457 {
458 /* Don't bother doing anything if the program has errors. */
459 return (flag_check_pointer_bounds
460 && !seen_error () && !in_lto_p);
461 }
462
463}; // class pass_chkp_instrumentation_passes
464
465const pass_data pass_data_local_optimization_passes =
466{
467 SIMPLE_IPA_PASS, /* type */
468 "opt_local_passes", /* name */
469 OPTGROUP_NONE, /* optinfo_flags */
470 TV_NONE, /* tv_id */
471 0, /* properties_required */
472 0, /* properties_provided */
473 0, /* properties_destroyed */
474 0, /* todo_flags_start */
475 0, /* todo_flags_finish */
476};
477
478class pass_local_optimization_passes : public simple_ipa_opt_pass
479{
480public:
481 pass_local_optimization_passes (gcc::context *ctxt)
482 : simple_ipa_opt_pass (pass_data_local_optimization_passes, ctxt)
483 {}
484
485 /* opt_pass methods: */
486 virtual bool gate (function *)
487 {
488 /* Don't bother doing anything if the program has errors. */
489 return (!seen_error () && !in_lto_p);
490 }
491
492}; // class pass_local_optimization_passes
493
494} // anon namespace
495
496simple_ipa_opt_pass *
497make_pass_build_ssa_passes (gcc::context *ctxt)
498{
499 return new pass_build_ssa_passes (ctxt);
500}
501
502simple_ipa_opt_pass *
503make_pass_chkp_instrumentation_passes (gcc::context *ctxt)
504{
505 return new pass_chkp_instrumentation_passes (ctxt);
506}
507
508simple_ipa_opt_pass *
509make_pass_local_optimization_passes (gcc::context *ctxt)
510{
511 return new pass_local_optimization_passes (ctxt);
512}
513
514namespace {
515
516const pass_data pass_data_all_early_optimizations =
517{
518 GIMPLE_PASS, /* type */
519 "early_optimizations", /* name */
520 OPTGROUP_NONE, /* optinfo_flags */
521 TV_NONE, /* tv_id */
522 0, /* properties_required */
523 0, /* properties_provided */
524 0, /* properties_destroyed */
525 0, /* todo_flags_start */
526 0, /* todo_flags_finish */
527};
528
529class pass_all_early_optimizations : public gimple_opt_pass
530{
531public:
532 pass_all_early_optimizations (gcc::context *ctxt)
533 : gimple_opt_pass (pass_data_all_early_optimizations, ctxt)
534 {}
535
536 /* opt_pass methods: */
537 virtual bool gate (function *)
538 {
539 return (optimize >= 1
540 /* Don't bother doing anything if the program has errors. */
541 && !seen_error ());
542 }
543
544}; // class pass_all_early_optimizations
545
546} // anon namespace
547
548static gimple_opt_pass *
549make_pass_all_early_optimizations (gcc::context *ctxt)
550{
551 return new pass_all_early_optimizations (ctxt);
552}
553
554namespace {
555
556const pass_data pass_data_all_optimizations =
557{
558 GIMPLE_PASS, /* type */
559 "*all_optimizations", /* name */
560 OPTGROUP_NONE, /* optinfo_flags */
561 TV_OPTIMIZE, /* tv_id */
562 0, /* properties_required */
563 0, /* properties_provided */
564 0, /* properties_destroyed */
565 0, /* todo_flags_start */
566 0, /* todo_flags_finish */
567};
568
569class pass_all_optimizations : public gimple_opt_pass
570{
571public:
572 pass_all_optimizations (gcc::context *ctxt)
573 : gimple_opt_pass (pass_data_all_optimizations, ctxt)
574 {}
575
576 /* opt_pass methods: */
577 virtual bool gate (function *) { return optimize >= 1 && !optimize_debug; }
578
579}; // class pass_all_optimizations
580
581} // anon namespace
582
583static gimple_opt_pass *
584make_pass_all_optimizations (gcc::context *ctxt)
585{
586 return new pass_all_optimizations (ctxt);
587}
588
589namespace {
590
591const pass_data pass_data_all_optimizations_g =
592{
593 GIMPLE_PASS, /* type */
594 "*all_optimizations_g", /* name */
595 OPTGROUP_NONE, /* optinfo_flags */
596 TV_OPTIMIZE, /* tv_id */
597 0, /* properties_required */
598 0, /* properties_provided */
599 0, /* properties_destroyed */
600 0, /* todo_flags_start */
601 0, /* todo_flags_finish */
602};
603
604class pass_all_optimizations_g : public gimple_opt_pass
605{
606public:
607 pass_all_optimizations_g (gcc::context *ctxt)
608 : gimple_opt_pass (pass_data_all_optimizations_g, ctxt)
609 {}
610
611 /* opt_pass methods: */
612 virtual bool gate (function *) { return optimize >= 1 && optimize_debug; }
613
614}; // class pass_all_optimizations_g
615
616} // anon namespace
617
618static gimple_opt_pass *
619make_pass_all_optimizations_g (gcc::context *ctxt)
620{
621 return new pass_all_optimizations_g (ctxt);
622}
623
624namespace {
625
626const pass_data pass_data_rest_of_compilation =
627{
628 RTL_PASS, /* type */
629 "*rest_of_compilation", /* name */
630 OPTGROUP_NONE, /* optinfo_flags */
631 TV_REST_OF_COMPILATION, /* tv_id */
632 PROP_rtl, /* properties_required */
633 0, /* properties_provided */
634 0, /* properties_destroyed */
635 0, /* todo_flags_start */
636 0, /* todo_flags_finish */
637};
638
639class pass_rest_of_compilation : public rtl_opt_pass
640{
641public:
642 pass_rest_of_compilation (gcc::context *ctxt)
643 : rtl_opt_pass (pass_data_rest_of_compilation, ctxt)
644 {}
645
646 /* opt_pass methods: */
647 virtual bool gate (function *)
648 {
649 /* Early return if there were errors. We can run afoul of our
650 consistency checks, and there's not really much point in fixing them. */
651 return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
652 }
653
654}; // class pass_rest_of_compilation
655
656} // anon namespace
657
658static rtl_opt_pass *
659make_pass_rest_of_compilation (gcc::context *ctxt)
660{
661 return new pass_rest_of_compilation (ctxt);
662}
663
664namespace {
665
666const pass_data pass_data_postreload =
667{
668 RTL_PASS, /* type */
669 "*all-postreload", /* name */
670 OPTGROUP_NONE, /* optinfo_flags */
671 TV_POSTRELOAD, /* tv_id */
672 PROP_rtl, /* properties_required */
673 0, /* properties_provided */
674 0, /* properties_destroyed */
675 0, /* todo_flags_start */
676 0, /* todo_flags_finish */
677};
678
679class pass_postreload : public rtl_opt_pass
680{
681public:
682 pass_postreload (gcc::context *ctxt)
683 : rtl_opt_pass (pass_data_postreload, ctxt)
684 {}
685
686 /* opt_pass methods: */
687 virtual bool gate (function *) { return reload_completed; }
688
689}; // class pass_postreload
690
691} // anon namespace
692
693static rtl_opt_pass *
694make_pass_postreload (gcc::context *ctxt)
695{
696 return new pass_postreload (ctxt);
697}
698
699namespace {
700
701const pass_data pass_data_late_compilation =
702{
703 RTL_PASS, /* type */
704 "*all-late_compilation", /* name */
705 OPTGROUP_NONE, /* optinfo_flags */
706 TV_LATE_COMPILATION, /* tv_id */
707 PROP_rtl, /* properties_required */
708 0, /* properties_provided */
709 0, /* properties_destroyed */
710 0, /* todo_flags_start */
711 0, /* todo_flags_finish */
712};
713
714class pass_late_compilation : public rtl_opt_pass
715{
716public:
717 pass_late_compilation (gcc::context *ctxt)
718 : rtl_opt_pass (pass_data_late_compilation, ctxt)
719 {}
720
721 /* opt_pass methods: */
722 virtual bool gate (function *)
723 {
724 return reload_completed || targetm.no_register_allocation;
725 }
726
727}; // class pass_late_compilation
728
729} // anon namespace
730
731static rtl_opt_pass *
732make_pass_late_compilation (gcc::context *ctxt)
733{
734 return new pass_late_compilation (ctxt);
735}
736
737
738
739/* Set the static pass number of pass PASS to ID and record that
740 in the mapping from static pass number to pass. */
741
742void
743pass_manager::
744set_pass_for_id (int id, opt_pass *pass)
745{
746 pass->static_pass_number = id;
747 if (passes_by_id_size <= id)
748 {
749 passes_by_id = XRESIZEVEC (opt_pass *, passes_by_id, id + 1);
750 memset (passes_by_id + passes_by_id_size, 0,
751 (id + 1 - passes_by_id_size) * sizeof (void *));
752 passes_by_id_size = id + 1;
753 }
754 passes_by_id[id] = pass;
755}
756
757/* Return the pass with the static pass number ID. */
758
759opt_pass *
760pass_manager::get_pass_for_id (int id) const
761{
762 if (id >= passes_by_id_size)
763 return NULL;
764 return passes_by_id[id];
765}
766
767/* Iterate over the pass tree allocating dump file numbers. We want
768 to do this depth first, and independent of whether the pass is
769 enabled or not. */
770
771void
772register_one_dump_file (opt_pass *pass)
773{
774 g->get_passes ()->register_one_dump_file (pass);
775}
776
777void
778pass_manager::register_one_dump_file (opt_pass *pass)
779{
780 char *dot_name, *flag_name, *glob_name;
781 const char *name, *full_name, *prefix;
782
783 /* Buffer big enough to format a 32-bit UINT_MAX into. */
784 char num[11];
785 dump_kind dkind;
786 int id;
787 int optgroup_flags = OPTGROUP_NONE;
788 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
789
790 /* See below in next_pass_1. */
791 num[0] = '\0';
792 if (pass->static_pass_number != -1)
793 sprintf (num, "%u", ((int) pass->static_pass_number < 0
794 ? 1 : pass->static_pass_number));
795
796 /* The name is both used to identify the pass for the purposes of plugins,
797 and to specify dump file name and option.
798 The latter two might want something short which is not quite unique; for
799 that reason, we may have a disambiguating prefix, followed by a space
800 to mark the start of the following dump file name / option string. */
801 name = strchr (pass->name, ' ');
802 name = name ? name + 1 : pass->name;
803 dot_name = concat (".", name, num, NULL);
804 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
805 {
806 prefix = "ipa-";
807 dkind = DK_ipa;
808 optgroup_flags |= OPTGROUP_IPA;
809 }
810 else if (pass->type == GIMPLE_PASS)
811 {
812 prefix = "tree-";
813 dkind = DK_tree;
814 }
815 else
816 {
817 prefix = "rtl-";
818 dkind = DK_rtl;
819 }
820
821 flag_name = concat (prefix, name, num, NULL);
822 glob_name = concat (prefix, name, NULL);
823 optgroup_flags |= pass->optinfo_flags;
824 /* For any passes that do not have an optgroup set, and which are not
825 IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
826 any dump messages are emitted properly under -fopt-info(-optall). */
827 if (optgroup_flags == OPTGROUP_NONE)
828 optgroup_flags = OPTGROUP_OTHER;
829 id = dumps->dump_register (dot_name, flag_name, glob_name, dkind,
830 optgroup_flags,
831 true);
832 set_pass_for_id (id, pass);
833 full_name = concat (prefix, pass->name, num, NULL);
834 register_pass_name (pass, full_name);
835 free (CONST_CAST (char *, full_name));
836}
837
838/* Register the dump files for the pass_manager starting at PASS. */
839
840void
841pass_manager::register_dump_files (opt_pass *pass)
842{
843 do
844 {
845 if (pass->name && pass->name[0] != '*')
846 register_one_dump_file (pass);
847
848 if (pass->sub)
849 register_dump_files (pass->sub);
850
851 pass = pass->next;
852 }
853 while (pass);
854}
855
856/* Register PASS with NAME. */
857
858void
859pass_manager::register_pass_name (opt_pass *pass, const char *name)
860{
861 if (!m_name_to_pass_map)
862 m_name_to_pass_map = new hash_map<nofree_string_hash, opt_pass *> (256);
863
864 if (m_name_to_pass_map->get (name))
865 return; /* Ignore plugin passes. */
866
867 const char *unique_name = xstrdup (name);
868 m_name_to_pass_map->put (unique_name, pass);
869}
870
871/* Map from pass id to canonicalized pass name. */
872
873typedef const char *char_ptr;
874static vec<char_ptr> pass_tab;
875
876/* Callback function for traversing NAME_TO_PASS_MAP. */
877
878bool
879passes_pass_traverse (const char *const &name, opt_pass *const &pass, void *)
880{
881 gcc_assert (pass->static_pass_number > 0);
882 gcc_assert (pass_tab.exists ());
883
884 pass_tab[pass->static_pass_number] = name;
885
886 return 1;
887}
888
889/* The function traverses NAME_TO_PASS_MAP and creates a pass info
890 table for dumping purpose. */
891
892void
893pass_manager::create_pass_tab (void) const
894{
895 if (!flag_dump_passes)
896 return;
897
898 pass_tab.safe_grow_cleared (passes_by_id_size + 1);
899 m_name_to_pass_map->traverse <void *, passes_pass_traverse> (NULL);
900}
901
902static bool override_gate_status (opt_pass *, tree, bool);
903
904/* Dump the instantiated name for PASS. IS_ON indicates if PASS
905 is turned on or not. */
906
907static void
908dump_one_pass (opt_pass *pass, int pass_indent)
909{
910 int indent = 3 * pass_indent;
911 const char *pn;
912 bool is_on, is_really_on;
913
914 is_on = pass->gate (cfun);
915 is_really_on = override_gate_status (pass, current_function_decl, is_on);
916
917 if (pass->static_pass_number <= 0)
918 pn = pass->name;
919 else
920 pn = pass_tab[pass->static_pass_number];
921
922 fprintf (stderr, "%*s%-40s%*s:%s%s\n", indent, " ", pn,
923 (15 - indent < 0 ? 0 : 15 - indent), " ",
924 is_on ? " ON" : " OFF",
925 ((!is_on) == (!is_really_on) ? ""
926 : (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)")));
927}
928
929/* Dump pass list PASS with indentation INDENT. */
930
931static void
932dump_pass_list (opt_pass *pass, int indent)
933{
934 do
935 {
936 dump_one_pass (pass, indent);
937 if (pass->sub)
938 dump_pass_list (pass->sub, indent + 1);
939 pass = pass->next;
940 }
941 while (pass);
942}
943
944/* Dump all optimization passes. */
945
946void
947dump_passes (void)
948{
949 g->get_passes ()->dump_passes ();
950}
951
952void
953pass_manager::dump_passes () const
954{
955 push_dummy_function (true);
956
957 create_pass_tab ();
958
959 dump_pass_list (all_lowering_passes, 1);
960 dump_pass_list (all_small_ipa_passes, 1);
961 dump_pass_list (all_regular_ipa_passes, 1);
962 dump_pass_list (all_late_ipa_passes, 1);
963 dump_pass_list (all_passes, 1);
964
965 pop_dummy_function ();
966}
967
968/* Returns the pass with NAME. */
969
970opt_pass *
971pass_manager::get_pass_by_name (const char *name)
972{
973 opt_pass **p = m_name_to_pass_map->get (name);
974 if (p)
975 return *p;
976
977 return NULL;
978}
979
980
981/* Range [start, last]. */
982
983struct uid_range
984{
985 unsigned int start;
986 unsigned int last;
987 const char *assem_name;
988 struct uid_range *next;
989};
990
991typedef struct uid_range *uid_range_p;
992
993
994static vec<uid_range_p> enabled_pass_uid_range_tab;
995static vec<uid_range_p> disabled_pass_uid_range_tab;
996
997
998/* Parse option string for -fdisable- and -fenable-
999 The syntax of the options:
1000
1001 -fenable-<pass_name>
1002 -fdisable-<pass_name>
1003
1004 -fenable-<pass_name>=s1:e1,s2:e2,...
1005 -fdisable-<pass_name>=s1:e1,s2:e2,...
1006*/
1007
1008static void
1009enable_disable_pass (const char *arg, bool is_enable)
1010{
1011 opt_pass *pass;
1012 char *range_str, *phase_name;
1013 char *argstr = xstrdup (arg);
1014 vec<uid_range_p> *tab = 0;
1015
1016 range_str = strchr (argstr,'=');
1017 if (range_str)
1018 {
1019 *range_str = '\0';
1020 range_str++;
1021 }
1022
1023 phase_name = argstr;
1024 if (!*phase_name)
1025 {
1026 if (is_enable)
1027 error ("unrecognized option -fenable");
1028 else
1029 error ("unrecognized option -fdisable");
1030 free (argstr);
1031 return;
1032 }
1033 pass = g->get_passes ()->get_pass_by_name (phase_name);
1034 if (!pass || pass->static_pass_number == -1)
1035 {
1036 if (is_enable)
1037 error ("unknown pass %s specified in -fenable", phase_name);
1038 else
1039 error ("unknown pass %s specified in -fdisable", phase_name);
1040 free (argstr);
1041 return;
1042 }
1043
1044 if (is_enable)
1045 tab = &enabled_pass_uid_range_tab;
1046 else
1047 tab = &disabled_pass_uid_range_tab;
1048
1049 if ((unsigned) pass->static_pass_number >= tab->length ())
1050 tab->safe_grow_cleared (pass->static_pass_number + 1);
1051
1052 if (!range_str)
1053 {
1054 uid_range_p slot;
1055 uid_range_p new_range = XCNEW (struct uid_range);
1056
1057 new_range->start = 0;
1058 new_range->last = (unsigned)-1;
1059
1060 slot = (*tab)[pass->static_pass_number];
1061 new_range->next = slot;
1062 (*tab)[pass->static_pass_number] = new_range;
1063 if (is_enable)
1064 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
1065 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1066 else
1067 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
1068 "of [%u, %u]", phase_name, new_range->start, new_range->last);
1069 }
1070 else
1071 {
1072 char *next_range = NULL;
1073 char *one_range = range_str;
1074 char *end_val = NULL;
1075
1076 do
1077 {
1078 uid_range_p slot;
1079 uid_range_p new_range;
1080 char *invalid = NULL;
1081 long start;
1082 char *func_name = NULL;
1083
1084 next_range = strchr (one_range, ',');
1085 if (next_range)
1086 {
1087 *next_range = '\0';
1088 next_range++;
1089 }
1090
1091 end_val = strchr (one_range, ':');
1092 if (end_val)
1093 {
1094 *end_val = '\0';
1095 end_val++;
1096 }
1097 start = strtol (one_range, &invalid, 10);
1098 if (*invalid || start < 0)
1099 {
1100 if (end_val || (one_range[0] >= '0'
1101 && one_range[0] <= '9'))
1102 {
1103 error ("Invalid range %s in option %s",
1104 one_range,
1105 is_enable ? "-fenable" : "-fdisable");
1106 free (argstr);
1107 return;
1108 }
1109 func_name = one_range;
1110 }
1111 if (!end_val)
1112 {
1113 new_range = XCNEW (struct uid_range);
1114 if (!func_name)
1115 {
1116 new_range->start = (unsigned) start;
1117 new_range->last = (unsigned) start;
1118 }
1119 else
1120 {
1121 new_range->start = (unsigned) -1;
1122 new_range->last = (unsigned) -1;
1123 new_range->assem_name = xstrdup (func_name);
1124 }
1125 }
1126 else
1127 {
1128 long last = strtol (end_val, &invalid, 10);
1129 if (*invalid || last < start)
1130 {
1131 error ("Invalid range %s in option %s",
1132 end_val,
1133 is_enable ? "-fenable" : "-fdisable");
1134 free (argstr);
1135 return;
1136 }
1137 new_range = XCNEW (struct uid_range);
1138 new_range->start = (unsigned) start;
1139 new_range->last = (unsigned) last;
1140 }
1141
1142 slot = (*tab)[pass->static_pass_number];
1143 new_range->next = slot;
1144 (*tab)[pass->static_pass_number] = new_range;
1145 if (is_enable)
1146 {
1147 if (new_range->assem_name)
1148 inform (UNKNOWN_LOCATION,
1149 "enable pass %s for function %s",
1150 phase_name, new_range->assem_name);
1151 else
1152 inform (UNKNOWN_LOCATION,
1153 "enable pass %s for functions in the range of [%u, %u]",
1154 phase_name, new_range->start, new_range->last);
1155 }
1156 else
1157 {
1158 if (new_range->assem_name)
1159 inform (UNKNOWN_LOCATION,
1160 "disable pass %s for function %s",
1161 phase_name, new_range->assem_name);
1162 else
1163 inform (UNKNOWN_LOCATION,
1164 "disable pass %s for functions in the range of [%u, %u]",
1165 phase_name, new_range->start, new_range->last);
1166 }
1167
1168 one_range = next_range;
1169 } while (next_range);
1170 }
1171
1172 free (argstr);
1173}
1174
1175/* Enable pass specified by ARG. */
1176
1177void
1178enable_pass (const char *arg)
1179{
1180 enable_disable_pass (arg, true);
1181}
1182
1183/* Disable pass specified by ARG. */
1184
1185void
1186disable_pass (const char *arg)
1187{
1188 enable_disable_pass (arg, false);
1189}
1190
1191/* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1192
1193static bool
1194is_pass_explicitly_enabled_or_disabled (opt_pass *pass,
1195 tree func,
1196 vec<uid_range_p> tab)
1197{
1198 uid_range_p slot, range;
1199 int cgraph_uid;
1200 const char *aname = NULL;
1201
1202 if (!tab.exists ()
1203 || (unsigned) pass->static_pass_number >= tab.length ()
1204 || pass->static_pass_number == -1)
1205 return false;
1206
1207 slot = tab[pass->static_pass_number];
1208 if (!slot)
1209 return false;
1210
1211 cgraph_uid = func ? cgraph_node::get (func)->uid : 0;
1212 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
1213 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
1214
1215 range = slot;
1216 while (range)
1217 {
1218 if ((unsigned) cgraph_uid >= range->start
1219 && (unsigned) cgraph_uid <= range->last)
1220 return true;
1221 if (range->assem_name && aname
1222 && !strcmp (range->assem_name, aname))
1223 return true;
1224 range = range->next;
1225 }
1226
1227 return false;
1228}
1229
1230
1231/* Update static_pass_number for passes (and the flag
1232 TODO_mark_first_instance).
1233
1234 Passes are constructed with static_pass_number preinitialized to 0
1235
1236 This field is used in two different ways: initially as instance numbers
1237 of their kind, and then as ids within the entire pass manager.
1238
1239 Within pass_manager::pass_manager:
1240
1241 * In add_pass_instance(), as called by next_pass_1 in
1242 NEXT_PASS in init_optimization_passes
1243
1244 * When the initial instance of a pass within a pass manager is seen,
1245 it is flagged, and its static_pass_number is set to -1
1246
1247 * On subsequent times that it is seen, the static pass number
1248 is decremented each time, so that if there are e.g. 4 dups,
1249 they have static_pass_number -4, 2, 3, 4 respectively (note
1250 how the initial one is negative and gives the count); these
1251 can be thought of as instance numbers of the specific pass
1252
1253 * Within the register_dump_files () traversal, set_pass_for_id()
1254 is called on each pass, using these instance numbers to create
1255 dumpfile switches, and then overwriting them with a pass id,
1256 which are global to the whole pass manager (based on
1257 (TDI_end + current value of extra_dump_files_in_use) ) */
1258
1259static void
1260add_pass_instance (opt_pass *new_pass, bool track_duplicates,
1261 opt_pass *initial_pass)
1262{
1263 /* Are we dealing with the first pass of its kind, or a clone? */
1264 if (new_pass != initial_pass)
1265 {
1266 /* We're dealing with a clone. */
1267 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
1268
1269 /* Indicate to register_dump_files that this pass has duplicates,
1270 and so it should rename the dump file. The first instance will
1271 be -1, and be number of duplicates = -static_pass_number - 1.
1272 Subsequent instances will be > 0 and just the duplicate number. */
1273 if ((new_pass->name && new_pass->name[0] != '*') || track_duplicates)
1274 {
1275 initial_pass->static_pass_number -= 1;
1276 new_pass->static_pass_number = -initial_pass->static_pass_number;
1277 }
1278 }
1279 else
1280 {
1281 /* We're dealing with the first pass of its kind. */
1282 new_pass->todo_flags_start |= TODO_mark_first_instance;
1283 new_pass->static_pass_number = -1;
1284
1285 invoke_plugin_callbacks (PLUGIN_NEW_PASS, new_pass);
1286 }
1287}
1288
1289/* Add a pass to the pass list. Duplicate the pass if it's already
1290 in the list. */
1291
1292static opt_pass **
1293next_pass_1 (opt_pass **list, opt_pass *pass, opt_pass *initial_pass)
1294{
1295 /* Every pass should have a name so that plugins can refer to them. */
1296 gcc_assert (pass->name != NULL);
1297
1298 add_pass_instance (pass, false, initial_pass);
1299 *list = pass;
1300
1301 return &(*list)->next;
1302}
1303
1304/* List node for an inserted pass instance. We need to keep track of all
1305 the newly-added pass instances (with 'added_pass_nodes' defined below)
1306 so that we can register their dump files after pass-positioning is finished.
1307 Registering dumping files needs to be post-processed or the
1308 static_pass_number of the opt_pass object would be modified and mess up
1309 the dump file names of future pass instances to be added. */
1310
1311struct pass_list_node
1312{
1313 opt_pass *pass;
1314 struct pass_list_node *next;
1315};
1316
1317static struct pass_list_node *added_pass_nodes = NULL;
1318static struct pass_list_node *prev_added_pass_node;
1319
1320/* Insert the pass at the proper position. Return true if the pass
1321 is successfully added.
1322
1323 NEW_PASS_INFO - new pass to be inserted
1324 PASS_LIST - root of the pass list to insert the new pass to */
1325
1326static bool
1327position_pass (struct register_pass_info *new_pass_info, opt_pass **pass_list)
1328{
1329 opt_pass *pass = *pass_list, *prev_pass = NULL;
1330 bool success = false;
1331
1332 for ( ; pass; prev_pass = pass, pass = pass->next)
1333 {
1334 /* Check if the current pass is of the same type as the new pass and
1335 matches the name and the instance number of the reference pass. */
1336 if (pass->type == new_pass_info->pass->type
1337 && pass->name
1338 && !strcmp (pass->name, new_pass_info->reference_pass_name)
1339 && ((new_pass_info->ref_pass_instance_number == 0)
1340 || (new_pass_info->ref_pass_instance_number ==
1341 pass->static_pass_number)
1342 || (new_pass_info->ref_pass_instance_number == 1
1343 && pass->todo_flags_start & TODO_mark_first_instance)))
1344 {
1345 opt_pass *new_pass;
1346 struct pass_list_node *new_pass_node;
1347
1348 if (new_pass_info->ref_pass_instance_number == 0)
1349 {
1350 new_pass = new_pass_info->pass->clone ();
1351 add_pass_instance (new_pass, true, new_pass_info->pass);
1352 }
1353 else
1354 {
1355 new_pass = new_pass_info->pass;
1356 add_pass_instance (new_pass, true, new_pass);
1357 }
1358
1359 /* Insert the new pass instance based on the positioning op. */
1360 switch (new_pass_info->pos_op)
1361 {
1362 case PASS_POS_INSERT_AFTER:
1363 new_pass->next = pass->next;
1364 pass->next = new_pass;
1365
1366 /* Skip newly inserted pass to avoid repeated
1367 insertions in the case where the new pass and the
1368 existing one have the same name. */
1369 pass = new_pass;
1370 break;
1371 case PASS_POS_INSERT_BEFORE:
1372 new_pass->next = pass;
1373 if (prev_pass)
1374 prev_pass->next = new_pass;
1375 else
1376 *pass_list = new_pass;
1377 break;
1378 case PASS_POS_REPLACE:
1379 new_pass->next = pass->next;
1380 if (prev_pass)
1381 prev_pass->next = new_pass;
1382 else
1383 *pass_list = new_pass;
1384 new_pass->sub = pass->sub;
1385 new_pass->tv_id = pass->tv_id;
1386 pass = new_pass;
1387 break;
1388 default:
1389 error ("invalid pass positioning operation");
1390 return false;
1391 }
1392
1393 /* Save the newly added pass (instance) in the added_pass_nodes
1394 list so that we can register its dump file later. Note that
1395 we cannot register the dump file now because doing so will modify
1396 the static_pass_number of the opt_pass object and therefore
1397 mess up the dump file name of future instances. */
1398 new_pass_node = XCNEW (struct pass_list_node);
1399 new_pass_node->pass = new_pass;
1400 if (!added_pass_nodes)
1401 added_pass_nodes = new_pass_node;
1402 else
1403 prev_added_pass_node->next = new_pass_node;
1404 prev_added_pass_node = new_pass_node;
1405
1406 success = true;
1407 }
1408
1409 if (pass->sub && position_pass (new_pass_info, &pass->sub))
1410 success = true;
1411 }
1412
1413 return success;
1414}
1415
1416/* Hooks a new pass into the pass lists.
1417
1418 PASS_INFO - pass information that specifies the opt_pass object,
1419 reference pass, instance number, and how to position
1420 the pass */
1421
1422void
1423register_pass (struct register_pass_info *pass_info)
1424{
1425 g->get_passes ()->register_pass (pass_info);
1426}
1427
1428void
1429register_pass (opt_pass* pass, pass_positioning_ops pos,
1430 const char* ref_pass_name, int ref_pass_inst_number)
1431{
1432 register_pass_info i;
1433 i.pass = pass;
1434 i.reference_pass_name = ref_pass_name;
1435 i.ref_pass_instance_number = ref_pass_inst_number;
1436 i.pos_op = pos;
1437
1438 g->get_passes ()->register_pass (&i);
1439}
1440
1441void
1442pass_manager::register_pass (struct register_pass_info *pass_info)
1443{
1444 bool all_instances, success;
1445 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
1446
1447 /* The checks below could fail in buggy plugins. Existing GCC
1448 passes should never fail these checks, so we mention plugin in
1449 the messages. */
1450 if (!pass_info->pass)
1451 fatal_error (input_location, "plugin cannot register a missing pass");
1452
1453 if (!pass_info->pass->name)
1454 fatal_error (input_location, "plugin cannot register an unnamed pass");
1455
1456 if (!pass_info->reference_pass_name)
1457 fatal_error
1458 (input_location,
1459 "plugin cannot register pass %qs without reference pass name",
1460 pass_info->pass->name);
1461
1462 /* Try to insert the new pass to the pass lists. We need to check
1463 all five lists as the reference pass could be in one (or all) of
1464 them. */
1465 all_instances = pass_info->ref_pass_instance_number == 0;
1466 success = position_pass (pass_info, &all_lowering_passes);
1467 if (!success || all_instances)
1468 success |= position_pass (pass_info, &all_small_ipa_passes);
1469 if (!success || all_instances)
1470 success |= position_pass (pass_info, &all_regular_ipa_passes);
1471 if (!success || all_instances)
1472 success |= position_pass (pass_info, &all_late_ipa_passes);
1473 if (!success || all_instances)
1474 success |= position_pass (pass_info, &all_passes);
1475 if (!success)
1476 fatal_error
1477 (input_location,
1478 "pass %qs not found but is referenced by new pass %qs",
1479 pass_info->reference_pass_name, pass_info->pass->name);
1480
1481 /* OK, we have successfully inserted the new pass. We need to register
1482 the dump files for the newly added pass and its duplicates (if any).
1483 Because the registration of plugin/backend passes happens after the
1484 command-line options are parsed, the options that specify single
1485 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1486 passes. Therefore we currently can only enable dumping of
1487 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1488 are specified. While doing so, we also delete the pass_list_node
1489 objects created during pass positioning. */
1490 while (added_pass_nodes)
1491 {
1492 struct pass_list_node *next_node = added_pass_nodes->next;
1493 enum tree_dump_index tdi;
1494 register_one_dump_file (added_pass_nodes->pass);
1495 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
1496 || added_pass_nodes->pass->type == IPA_PASS)
1497 tdi = TDI_ipa_all;
1498 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
1499 tdi = TDI_tree_all;
1500 else
1501 tdi = TDI_rtl_all;
1502 /* Check if dump-all flag is specified. */
1503 if (dumps->get_dump_file_info (tdi)->pstate)
1504 {
1505 dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1506 ->pstate = dumps->get_dump_file_info (tdi)->pstate;
1507 dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1508 ->pflags = dumps->get_dump_file_info (tdi)->pflags;
1509 }
1510 XDELETE (added_pass_nodes);
1511 added_pass_nodes = next_node;
1512 }
1513}
1514
1515/* Construct the pass tree. The sequencing of passes is driven by
1516 the cgraph routines:
1517
1518 finalize_compilation_unit ()
1519 for each node N in the cgraph
1520 cgraph_analyze_function (N)
1521 cgraph_lower_function (N) -> all_lowering_passes
1522
1523 If we are optimizing, compile is then invoked:
1524
1525 compile ()
1526 ipa_passes () -> all_small_ipa_passes
1527 -> Analysis of all_regular_ipa_passes
1528 * possible LTO streaming at copmilation time *
1529 -> Execution of all_regular_ipa_passes
1530 * possible LTO streaming at link time *
1531 -> all_late_ipa_passes
1532 expand_all_functions ()
1533 for each node N in the cgraph
1534 expand_function (N) -> Transformation of all_regular_ipa_passes
1535 -> all_passes
1536*/
1537
1538pass_manager::pass_manager (context *ctxt)
1539: all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
1540 all_regular_ipa_passes (NULL),
1541 all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
1542 m_ctxt (ctxt), m_name_to_pass_map (NULL)
1543{
1544 opt_pass **p;
1545
1546 /* Zero-initialize pass members. */
1547#define INSERT_PASSES_AFTER(PASS)
1548#define PUSH_INSERT_PASSES_WITHIN(PASS)
1549#define POP_INSERT_PASSES()
1550#define NEXT_PASS(PASS, NUM) PASS ## _ ## NUM = NULL
1551#define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) NEXT_PASS (PASS, NUM)
1552#define TERMINATE_PASS_LIST(PASS)
1553#include "pass-instances.def"
1554#undef INSERT_PASSES_AFTER
1555#undef PUSH_INSERT_PASSES_WITHIN
1556#undef POP_INSERT_PASSES
1557#undef NEXT_PASS
1558#undef NEXT_PASS_WITH_ARG
1559#undef TERMINATE_PASS_LIST
1560
1561 /* Initialize the pass_lists array. */
1562#define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1563 GCC_PASS_LISTS
1564#undef DEF_PASS_LIST
1565
1566 /* Build the tree of passes. */
1567
1568#define INSERT_PASSES_AFTER(PASS) \
1569 { \
1570 opt_pass **p_start; \
1571 p_start = p = &(PASS);
1572
1573#define TERMINATE_PASS_LIST(PASS) \
1574 gcc_assert (p_start == &PASS); \
1575 *p = NULL; \
1576 }
1577
1578#define PUSH_INSERT_PASSES_WITHIN(PASS) \
1579 { \
1580 opt_pass **p = &(PASS ## _1)->sub;
1581
1582#define POP_INSERT_PASSES() \
1583 }
1584
1585#define NEXT_PASS(PASS, NUM) \
1586 do { \
1587 gcc_assert (NULL == PASS ## _ ## NUM); \
1588 if ((NUM) == 1) \
1589 PASS ## _1 = make_##PASS (m_ctxt); \
1590 else \
1591 { \
1592 gcc_assert (PASS ## _1); \
1593 PASS ## _ ## NUM = PASS ## _1->clone (); \
1594 } \
1595 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1596 } while (0)
1597
1598#define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) \
1599 do { \
1600 NEXT_PASS (PASS, NUM); \
1601 PASS ## _ ## NUM->set_pass_param (0, ARG); \
1602 } while (0)
1603
1604#include "pass-instances.def"
1605
1606#undef INSERT_PASSES_AFTER
1607#undef PUSH_INSERT_PASSES_WITHIN
1608#undef POP_INSERT_PASSES
1609#undef NEXT_PASS
1610#undef NEXT_PASS_WITH_ARG
1611#undef TERMINATE_PASS_LIST
1612
1613 /* Register the passes with the tree dump code. */
1614 register_dump_files (all_lowering_passes);
1615 register_dump_files (all_small_ipa_passes);
1616 register_dump_files (all_regular_ipa_passes);
1617 register_dump_files (all_late_ipa_passes);
1618 register_dump_files (all_passes);
1619}
1620
1621static void
1622delete_pass_tree (opt_pass *pass)
1623{
1624 while (pass)
1625 {
1626 /* Recurse into child passes. */
1627 delete_pass_tree (pass->sub);
1628
1629 opt_pass *next = pass->next;
1630
1631 /* Delete this pass. */
1632 delete pass;
1633
1634 /* Iterate onto sibling passes. */
1635 pass = next;
1636 }
1637}
1638
1639pass_manager::~pass_manager ()
1640{
1641 XDELETEVEC (passes_by_id);
1642
1643 /* Call delete_pass_tree on each of the pass_lists. */
1644#define DEF_PASS_LIST(LIST) \
1645 delete_pass_tree (*pass_lists[PASS_LIST_NO_##LIST]);
1646 GCC_PASS_LISTS
1647#undef DEF_PASS_LIST
1648
1649}
1650
1651/* If we are in IPA mode (i.e., current_function_decl is NULL), call
1652 function CALLBACK for every function in the call graph. Otherwise,
1653 call CALLBACK on the current function. */
1654
1655static void
1656do_per_function (void (*callback) (function *, void *data), void *data)
1657{
1658 if (current_function_decl)
1659 callback (cfun, data);
1660 else
1661 {
1662 struct cgraph_node *node;
1663 FOR_EACH_DEFINED_FUNCTION (node)
1664 if (node->analyzed && (gimple_has_body_p (node->decl) && !in_lto_p)
1665 && (!node->clone_of || node->decl != node->clone_of->decl))
1666 callback (DECL_STRUCT_FUNCTION (node->decl), data);
1667 }
1668}
1669
1670/* Because inlining might remove no-longer reachable nodes, we need to
1671 keep the array visible to garbage collector to avoid reading collected
1672 out nodes. */
1673static int nnodes;
1674static GTY ((length ("nnodes"))) cgraph_node **order;
1675
1676/* Hook called when NODE is removed and therefore should be
1677 excluded from order vector. DATA is an array of integers.
1678 DATA[0] holds max index it may be accessed by. For cgraph
1679 node DATA[node->uid + 1] holds index of this node in order
1680 vector. */
1681static void
1682remove_cgraph_node_from_order (cgraph_node *node, void *data)
1683{
1684 int *order_idx = (int *)data;
1685
1686 if (node->uid >= order_idx[0])
1687 return;
1688
1689 int idx = order_idx[node->uid + 1];
1690 if (idx >= 0 && idx < nnodes && order[idx] == node)
1691 order[idx] = NULL;
1692}
1693
1694/* If we are in IPA mode (i.e., current_function_decl is NULL), call
1695 function CALLBACK for every function in the call graph. Otherwise,
1696 call CALLBACK on the current function.
1697 This function is global so that plugins can use it. */
1698void
1699do_per_function_toporder (void (*callback) (function *, void *data), void *data)
1700{
1701 int i;
1702
1703 if (current_function_decl)
1704 callback (cfun, data);
1705 else
1706 {
1707 cgraph_node_hook_list *hook;
1708 int *order_idx;
1709 gcc_assert (!order);
1710 order = ggc_vec_alloc<cgraph_node *> (symtab->cgraph_count);
1711
1712 order_idx = XALLOCAVEC (int, symtab->cgraph_max_uid + 1);
1713 memset (order_idx + 1, -1, sizeof (int) * symtab->cgraph_max_uid);
1714 order_idx[0] = symtab->cgraph_max_uid;
1715
1716 nnodes = ipa_reverse_postorder (order);
1717 for (i = nnodes - 1; i >= 0; i--)
1718 {
1719 order[i]->process = 1;
1720 order_idx[order[i]->uid + 1] = i;
1721 }
1722 hook = symtab->add_cgraph_removal_hook (remove_cgraph_node_from_order,
1723 order_idx);
1724 for (i = nnodes - 1; i >= 0; i--)
1725 {
1726 /* Function could be inlined and removed as unreachable. */
1727 if (!order[i])
1728 continue;
1729
1730 struct cgraph_node *node = order[i];
1731
1732 /* Allow possibly removed nodes to be garbage collected. */
1733 order[i] = NULL;
1734 node->process = 0;
1735 if (node->has_gimple_body_p ())
1736 {
1737 struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1738 push_cfun (fn);
1739 callback (fn, data);
1740 pop_cfun ();
1741 }
1742 }
1743 symtab->remove_cgraph_removal_hook (hook);
1744 }
1745 ggc_free (order);
1746 order = NULL;
1747 nnodes = 0;
1748}
1749
1750/* Helper function to perform function body dump. */
1751
1752static void
1753execute_function_dump (function *fn, void *data)
1754{
1755 opt_pass *pass = (opt_pass *)data;
1756
1757 if (dump_file)
1758 {
1759 push_cfun (fn);
1760
1761 if (fn->curr_properties & PROP_trees)
1762 dump_function_to_file (fn->decl, dump_file, dump_flags);
1763 else
1764 print_rtl_with_bb (dump_file, get_insns (), dump_flags);
1765
1766 /* Flush the file. If verification fails, we won't be able to
1767 close the file before aborting. */
1768 fflush (dump_file);
1769
1770 if ((fn->curr_properties & PROP_cfg)
1771 && (dump_flags & TDF_GRAPH))
1772 {
1773 gcc::dump_manager *dumps = g->get_dumps ();
1774 struct dump_file_info *dfi
1775 = dumps->get_dump_file_info (pass->static_pass_number);
1776 if (!dfi->graph_dump_initialized)
1777 {
1778 clean_graph_dump_file (dump_file_name);
1779 dfi->graph_dump_initialized = true;
1780 }
1781 print_graph_cfg (dump_file_name, fn);
1782 }
1783
1784 pop_cfun ();
1785 }
1786}
1787
1788/* This function is called when an internal compiler error is encountered.
1789 Ensure that function dump is made available before compiler is aborted. */
1790
1791void
1792emergency_dump_function ()
1793{
1794 if (!current_pass)
1795 return;
1796 enum opt_pass_type pt = current_pass->type;
1797 fnotice (stderr, "during %s pass: %s\n",
1798 pt == GIMPLE_PASS ? "GIMPLE" : pt == RTL_PASS ? "RTL" : "IPA",
1799 current_pass->name);
1800 if (!dump_file || !cfun)
1801 return;
1802 fnotice (stderr, "dump file: %s\n", dump_file_name);
1803 fprintf (dump_file, "\n\n\nEMERGENCY DUMP:\n\n");
1804 execute_function_dump (cfun, current_pass);
1805}
1806
1807static struct profile_record *profile_record;
1808
1809/* Do profile consistency book-keeping for the pass with static number INDEX.
1810 If SUBPASS is zero, we run _before_ the pass, and if SUBPASS is one, then
1811 we run _after_ the pass. RUN is true if the pass really runs, or FALSE
1812 if we are only book-keeping on passes that may have selectively disabled
1813 themselves on a given function. */
1814static void
1815check_profile_consistency (int index, int subpass, bool run)
1816{
1817 pass_manager *passes = g->get_passes ();
1818 if (index == -1)
1819 return;
1820 if (!profile_record)
1821 profile_record = XCNEWVEC (struct profile_record,
1822 passes->passes_by_id_size);
1823 gcc_assert (index < passes->passes_by_id_size && index >= 0);
1824 gcc_assert (subpass < 2);
1825 profile_record[index].run |= run;
1826 account_profile_record (&profile_record[index], subpass);
1827}
1828
1829/* Output profile consistency. */
1830
1831void
1832dump_profile_report (void)
1833{
1834 g->get_passes ()->dump_profile_report ();
1835}
1836
1837void
1838pass_manager::dump_profile_report () const
1839{
1840 int i, j;
1841 int last_freq_in = 0, last_count_in = 0, last_freq_out = 0, last_count_out = 0;
1842 gcov_type last_time = 0, last_size = 0;
1843 double rel_time_change, rel_size_change;
1844 int last_reported = 0;
1845
1846 if (!profile_record)
1847 return;
1848 fprintf (stderr, "\nProfile consistency report:\n\n");
1849 fprintf (stderr, "Pass name |mismatch in |mismated out|Overall\n");
1850 fprintf (stderr, " |freq count |freq count |size time\n");
1851
1852 for (i = 0; i < passes_by_id_size; i++)
1853 for (j = 0 ; j < 2; j++)
1854 if (profile_record[i].run)
1855 {
1856 if (last_time)
1857 rel_time_change = (profile_record[i].time[j]
1858 - (double)last_time) * 100 / (double)last_time;
1859 else
1860 rel_time_change = 0;
1861 if (last_size)
1862 rel_size_change = (profile_record[i].size[j]
1863 - (double)last_size) * 100 / (double)last_size;
1864 else
1865 rel_size_change = 0;
1866
1867 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in
1868 || profile_record[i].num_mismatched_freq_out[j] != last_freq_out
1869 || profile_record[i].num_mismatched_count_in[j] != last_count_in
1870 || profile_record[i].num_mismatched_count_out[j] != last_count_out
1871 || rel_time_change || rel_size_change)
1872 {
1873 last_reported = i;
1874 fprintf (stderr, "%-20s %s",
1875 passes_by_id [i]->name,
1876 j ? "(after TODO)" : " ");
1877 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in)
1878 fprintf (stderr, "| %+5i",
1879 profile_record[i].num_mismatched_freq_in[j]
1880 - last_freq_in);
1881 else
1882 fprintf (stderr, "| ");
1883 if (profile_record[i].num_mismatched_count_in[j] != last_count_in)
1884 fprintf (stderr, " %+5i",
1885 profile_record[i].num_mismatched_count_in[j]
1886 - last_count_in);
1887 else
1888 fprintf (stderr, " ");
1889 if (profile_record[i].num_mismatched_freq_out[j] != last_freq_out)
1890 fprintf (stderr, "| %+5i",
1891 profile_record[i].num_mismatched_freq_out[j]
1892 - last_freq_out);
1893 else
1894 fprintf (stderr, "| ");
1895 if (profile_record[i].num_mismatched_count_out[j] != last_count_out)
1896 fprintf (stderr, " %+5i",
1897 profile_record[i].num_mismatched_count_out[j]
1898 - last_count_out);
1899 else
1900 fprintf (stderr, " ");
1901
1902 /* Size/time units change across gimple and RTL. */
1903 if (i == pass_expand_1->static_pass_number)
1904 fprintf (stderr, "|----------");
1905 else
1906 {
1907 if (rel_size_change)
1908 fprintf (stderr, "| %+8.4f%%", rel_size_change);
1909 else
1910 fprintf (stderr, "| ");
1911 if (rel_time_change)
1912 fprintf (stderr, " %+8.4f%%", rel_time_change);
1913 }
1914 fprintf (stderr, "\n");
1915 last_freq_in = profile_record[i].num_mismatched_freq_in[j];
1916 last_freq_out = profile_record[i].num_mismatched_freq_out[j];
1917 last_count_in = profile_record[i].num_mismatched_count_in[j];
1918 last_count_out = profile_record[i].num_mismatched_count_out[j];
1919 }
1920 else if (j && last_reported != i)
1921 {
1922 last_reported = i;
1923 fprintf (stderr, "%-20s ------------| | |\n",
1924 passes_by_id [i]->name);
1925 }
1926 last_time = profile_record[i].time[j];
1927 last_size = profile_record[i].size[j];
1928 }
1929}
1930
1931/* Perform all TODO actions that ought to be done on each function. */
1932
1933static void
1934execute_function_todo (function *fn, void *data)
1935{
1936 bool from_ipa_pass = (cfun == NULL);
1937 unsigned int flags = (size_t)data;
1938 flags &= ~fn->last_verified;
1939 if (!flags)
1940 return;
1941
1942 push_cfun (fn);
1943
1944 /* Always cleanup the CFG before trying to update SSA. */
1945 if (flags & TODO_cleanup_cfg)
1946 {
1947 cleanup_tree_cfg ();
1948
1949 /* When cleanup_tree_cfg merges consecutive blocks, it may
1950 perform some simplistic propagation when removing single
1951 valued PHI nodes. This propagation may, in turn, cause the
1952 SSA form to become out-of-date (see PR 22037). So, even
1953 if the parent pass had not scheduled an SSA update, we may
1954 still need to do one. */
1955 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1956 flags |= TODO_update_ssa;
1957 }
1958
1959 if (flags & TODO_update_ssa_any)
1960 {
1961 unsigned update_flags = flags & TODO_update_ssa_any;
1962 update_ssa (update_flags);
1963 }
1964
1965 if (flag_tree_pta && (flags & TODO_rebuild_alias))
1966 compute_may_aliases ();
1967
1968 if (optimize && (flags & TODO_update_address_taken))
1969 execute_update_addresses_taken ();
1970
1971 if (flags & TODO_remove_unused_locals)
1972 remove_unused_locals ();
1973
1974 if (flags & TODO_rebuild_frequencies)
1975 rebuild_frequencies ();
1976
1977 if (flags & TODO_rebuild_cgraph_edges)
1978 cgraph_edge::rebuild_edges ();
1979
1980 gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == DOM_NONE);
1981 /* If we've seen errors do not bother running any verifiers. */
1982 if (flag_checking && !seen_error ())
1983 {
1984 dom_state pre_verify_state = dom_info_state (fn, CDI_DOMINATORS);
1985 dom_state pre_verify_pstate = dom_info_state (fn, CDI_POST_DOMINATORS);
1986
1987 if (flags & TODO_verify_il)
1988 {
1989 if (cfun->curr_properties & PROP_trees)
1990 {
1991 if (cfun->curr_properties & PROP_cfg)
1992 /* IPA passes leave stmts to be fixed up, so make sure to
1993 not verify stmts really throw. */
1994 verify_gimple_in_cfg (cfun, !from_ipa_pass);
1995 else
1996 verify_gimple_in_seq (gimple_body (cfun->decl));
1997 }
1998 if (cfun->curr_properties & PROP_ssa)
1999 /* IPA passes leave stmts to be fixed up, so make sure to
2000 not verify SSA operands whose verifier will choke on that. */
2001 verify_ssa (true, !from_ipa_pass);
2002 /* IPA passes leave basic-blocks unsplit, so make sure to
2003 not trip on that. */
2004 if ((cfun->curr_properties & PROP_cfg)
2005 && !from_ipa_pass)
2006 verify_flow_info ();
2007 if (current_loops
2008 && ! loops_state_satisfies_p (LOOPS_NEED_FIXUP))
2009 {
2010 verify_loop_structure ();
2011 if (loops_state_satisfies_p (LOOP_CLOSED_SSA))
2012 verify_loop_closed_ssa (false);
2013 }
2014 if (cfun->curr_properties & PROP_rtl)
2015 verify_rtl_sharing ();
2016 }
2017
2018 /* Make sure verifiers don't change dominator state. */
2019 gcc_assert (dom_info_state (fn, CDI_DOMINATORS) == pre_verify_state);
2020 gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == pre_verify_pstate);
2021 }
2022
2023 fn->last_verified = flags & TODO_verify_all;
2024
2025 pop_cfun ();
2026
2027 /* For IPA passes make sure to release dominator info, it can be
2028 computed by non-verifying TODOs. */
2029 if (from_ipa_pass)
2030 {
2031 free_dominance_info (fn, CDI_DOMINATORS);
2032 free_dominance_info (fn, CDI_POST_DOMINATORS);
2033 }
2034}
2035
2036/* Perform all TODO actions. */
2037static void
2038execute_todo (unsigned int flags)
2039{
2040 if (flag_checking
2041 && cfun
2042 && need_ssa_update_p (cfun))
2043 gcc_assert (flags & TODO_update_ssa_any);
2044
2045 statistics_fini_pass ();
2046
2047 if (flags)
2048 do_per_function (execute_function_todo, (void *)(size_t) flags);
2049
2050 /* At this point we should not have any unreachable code in the
2051 CFG, so it is safe to flush the pending freelist for SSA_NAMES. */
2052 if (cfun && cfun->gimple_df)
2053 flush_ssaname_freelist ();
2054
2055 /* Always remove functions just as before inlining: IPA passes might be
2056 interested to see bodies of extern inline functions that are not inlined
2057 to analyze side effects. The full removal is done just at the end
2058 of IPA pass queue. */
2059 if (flags & TODO_remove_functions)
2060 {
2061 gcc_assert (!cfun);
2062 symtab->remove_unreachable_nodes (dump_file);
2063 }
2064
2065 if ((flags & TODO_dump_symtab) && dump_file && !current_function_decl)
2066 {
2067 gcc_assert (!cfun);
2068 symtab->dump (dump_file);
2069 /* Flush the file. If verification fails, we won't be able to
2070 close the file before aborting. */
2071 fflush (dump_file);
2072 }
2073
2074 /* Now that the dumping has been done, we can get rid of the optional
2075 df problems. */
2076 if (flags & TODO_df_finish)
2077 df_finish_pass ((flags & TODO_df_verify) != 0);
2078}
2079
2080/* Verify invariants that should hold between passes. This is a place
2081 to put simple sanity checks. */
2082
2083static void
2084verify_interpass_invariants (void)
2085{
2086 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2087}
2088
2089/* Clear the last verified flag. */
2090
2091static void
2092clear_last_verified (function *fn, void *data ATTRIBUTE_UNUSED)
2093{
2094 fn->last_verified = 0;
2095}
2096
2097/* Helper function. Verify that the properties has been turn into the
2098 properties expected by the pass. */
2099
2100static void
2101verify_curr_properties (function *fn, void *data)
2102{
2103 unsigned int props = (size_t)data;
2104 gcc_assert ((fn->curr_properties & props) == props);
2105}
2106
2107/* Release dump file name if set. */
2108
2109static void
2110release_dump_file_name (void)
2111{
2112 if (dump_file_name)
2113 {
2114 free (CONST_CAST (char *, dump_file_name));
2115 dump_file_name = NULL;
2116 }
2117}
2118
2119/* Initialize pass dump file. */
2120/* This is non-static so that the plugins can use it. */
2121
2122bool
2123pass_init_dump_file (opt_pass *pass)
2124{
2125 /* If a dump file name is present, open it if enabled. */
2126 if (pass->static_pass_number != -1)
2127 {
2128 timevar_push (TV_DUMP);
2129 gcc::dump_manager *dumps = g->get_dumps ();
2130 bool initializing_dump =
2131 !dumps->dump_initialized_p (pass->static_pass_number);
2132 release_dump_file_name ();
2133 dump_file_name = dumps->get_dump_file_name (pass->static_pass_number);
2134 dumps->dump_start (pass->static_pass_number, &dump_flags);
2135 if (dump_file && current_function_decl && ! (dump_flags & TDF_GIMPLE))
2136 dump_function_header (dump_file, current_function_decl, dump_flags);
2137 if (initializing_dump
2138 && dump_file && (dump_flags & TDF_GRAPH)
2139 && cfun && (cfun->curr_properties & PROP_cfg))
2140 {
2141 clean_graph_dump_file (dump_file_name);
2142 struct dump_file_info *dfi
2143 = dumps->get_dump_file_info (pass->static_pass_number);
2144 dfi->graph_dump_initialized = true;
2145 }
2146 timevar_pop (TV_DUMP);
2147 return initializing_dump;
2148 }
2149 else
2150 return false;
2151}
2152
2153/* Flush PASS dump file. */
2154/* This is non-static so that plugins can use it. */
2155
2156void
2157pass_fini_dump_file (opt_pass *pass)
2158{
2159 timevar_push (TV_DUMP);
2160
2161 /* Flush and close dump file. */
2162 release_dump_file_name ();
2163
2164 g->get_dumps ()->dump_finish (pass->static_pass_number);
2165 timevar_pop (TV_DUMP);
2166}
2167
2168/* After executing the pass, apply expected changes to the function
2169 properties. */
2170
2171static void
2172update_properties_after_pass (function *fn, void *data)
2173{
2174 opt_pass *pass = (opt_pass *) data;
2175 fn->curr_properties = (fn->curr_properties | pass->properties_provided)
2176 & ~pass->properties_destroyed;
2177}
2178
2179/* Execute summary generation for all of the passes in IPA_PASS. */
2180
2181void
2182execute_ipa_summary_passes (ipa_opt_pass_d *ipa_pass)
2183{
2184 while (ipa_pass)
2185 {
2186 opt_pass *pass = ipa_pass;
2187
2188 /* Execute all of the IPA_PASSes in the list. */
2189 if (ipa_pass->type == IPA_PASS
2190 && pass->gate (cfun)
2191 && ipa_pass->generate_summary)
2192 {
2193 pass_init_dump_file (pass);
2194
2195 /* If a timevar is present, start it. */
2196 if (pass->tv_id)
2197 timevar_push (pass->tv_id);
2198
2199 current_pass = pass;
2200 ipa_pass->generate_summary ();
2201
2202 /* Stop timevar. */
2203 if (pass->tv_id)
2204 timevar_pop (pass->tv_id);
2205
2206 pass_fini_dump_file (pass);
2207 }
2208 ipa_pass = (ipa_opt_pass_d *)ipa_pass->next;
2209 }
2210}
2211
2212/* Execute IPA_PASS function transform on NODE. */
2213
2214static void
2215execute_one_ipa_transform_pass (struct cgraph_node *node,
2216 ipa_opt_pass_d *ipa_pass)
2217{
2218 opt_pass *pass = ipa_pass;
2219 unsigned int todo_after = 0;
2220
2221 current_pass = pass;
2222 if (!ipa_pass->function_transform)
2223 return;
2224
2225 /* Note that the folders should only create gimple expressions.
2226 This is a hack until the new folder is ready. */
2227 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2228
2229 pass_init_dump_file (pass);
2230
2231 /* If a timevar is present, start it. */
2232 if (pass->tv_id != TV_NONE)
2233 timevar_push (pass->tv_id);
2234
2235 /* Run pre-pass verification. */
2236 execute_todo (ipa_pass->function_transform_todo_flags_start);
2237
2238 /* Do it! */
2239 todo_after = ipa_pass->function_transform (node);
2240
2241 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2242 check_profile_consistency (pass->static_pass_number, 0, true);
2243
2244 /* Run post-pass cleanup and verification. */
2245 execute_todo (todo_after);
2246 verify_interpass_invariants ();
2247 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2248 check_profile_consistency (pass->static_pass_number, 1, true);
2249
2250 /* Stop timevar. */
2251 if (pass->tv_id != TV_NONE)
2252 timevar_pop (pass->tv_id);
2253
2254 if (dump_file)
2255 do_per_function (execute_function_dump, pass);
2256 pass_fini_dump_file (pass);
2257
2258 current_pass = NULL;
2259 redirect_edge_var_map_empty ();
2260
2261 /* Signal this is a suitable GC collection point. */
2262 if (!(todo_after & TODO_do_not_ggc_collect))
2263 ggc_collect ();
2264}
2265
2266/* For the current function, execute all ipa transforms. */
2267
2268void
2269execute_all_ipa_transforms (void)
2270{
2271 struct cgraph_node *node;
2272 if (!cfun)
2273 return;
2274 node = cgraph_node::get (current_function_decl);
2275
2276 if (node->ipa_transforms_to_apply.exists ())
2277 {
2278 unsigned int i;
2279
2280 for (i = 0; i < node->ipa_transforms_to_apply.length (); i++)
2281 execute_one_ipa_transform_pass (node, node->ipa_transforms_to_apply[i]);
2282 node->ipa_transforms_to_apply.release ();
2283 }
2284}
2285
2286/* Check if PASS is explicitly disabled or enabled and return
2287 the gate status. FUNC is the function to be processed, and
2288 GATE_STATUS is the gate status determined by pass manager by
2289 default. */
2290
2291static bool
2292override_gate_status (opt_pass *pass, tree func, bool gate_status)
2293{
2294 bool explicitly_enabled = false;
2295 bool explicitly_disabled = false;
2296
2297 explicitly_enabled
2298 = is_pass_explicitly_enabled_or_disabled (pass, func,
2299 enabled_pass_uid_range_tab);
2300 explicitly_disabled
2301 = is_pass_explicitly_enabled_or_disabled (pass, func,
2302 disabled_pass_uid_range_tab);
2303
2304 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
2305
2306 return gate_status;
2307}
2308
2309/* Determine if PASS_NAME matches CRITERION.
2310 Not a pure predicate, since it can update CRITERION, to support
2311 matching the Nth invocation of a pass.
2312 Subroutine of should_skip_pass_p. */
2313
2314static bool
2315determine_pass_name_match (const char *pass_name, char *criterion)
2316{
2317 size_t namelen = strlen (pass_name);
2318 if (! strncmp (pass_name, criterion, namelen))
2319 {
2320 /* The following supports starting with the Nth invocation
2321 of a pass (where N does not necessarily is equal to the
2322 dump file suffix). */
2323 if (criterion[namelen] == '\0'
2324 || (criterion[namelen] == '1'
2325 && criterion[namelen + 1] == '\0'))
2326 return true;
2327 else
2328 {
2329 if (criterion[namelen + 1] == '\0')
2330 --criterion[namelen];
2331 return false;
2332 }
2333 }
2334 else
2335 return false;
2336}
2337
2338/* For skipping passes until "startwith" pass.
2339 Return true iff PASS should be skipped.
2340 Clear cfun->pass_startwith when encountering the "startwith" pass,
2341 so that all subsequent passes are run. */
2342
2343static bool
2344should_skip_pass_p (opt_pass *pass)
2345{
2346 if (!cfun)
2347 return false;
2348 if (!cfun->pass_startwith)
2349 return false;
2350
2351 /* For __GIMPLE functions, we have to at least start when we leave
2352 SSA. Hence, we need to detect the "expand" pass, and stop skipping
2353 when we encounter it. A cheap way to identify "expand" is it to
2354 detect the destruction of PROP_ssa.
2355 For __RTL functions, we invoke "rest_of_compilation" directly, which
2356 is after "expand", and hence we don't reach this conditional. */
2357 if (pass->properties_destroyed & PROP_ssa)
2358 {
2359 if (!quiet_flag)
2360 fprintf (stderr, "starting anyway when leaving SSA: %s\n", pass->name);
2361 cfun->pass_startwith = NULL;
2362 return false;
2363 }
2364
2365 if (determine_pass_name_match (pass->name, cfun->pass_startwith))
2366 {
2367 if (!quiet_flag)
2368 fprintf (stderr, "found starting pass: %s\n", pass->name);
2369 cfun->pass_startwith = NULL;
2370 return false;
2371 }
2372
2373 /* For GIMPLE passes, run any property provider (but continue skipping
2374 afterwards).
2375 We don't want to force running RTL passes that are property providers:
2376 "expand" is covered above, and the only pass other than "expand" that
2377 provides a property is "into_cfglayout" (PROP_cfglayout), which does
2378 too much for a dumped __RTL function. */
2379 if (pass->type == GIMPLE_PASS
2380 && pass->properties_provided != 0)
2381 return false;
2382
2383 /* Don't skip df init; later RTL passes need it. */
2384 if (strstr (pass->name, "dfinit") != NULL)
2385 return false;
2386
2387 if (!quiet_flag)
2388 fprintf (stderr, "skipping pass: %s\n", pass->name);
2389
2390 /* If we get here, then we have a "startwith" that we haven't seen yet;
2391 skip the pass. */
2392 return true;
2393}
2394
2395/* Skip the given pass, for handling passes before "startwith"
2396 in __GIMPLE and__RTL-marked functions.
2397 In theory, this ought to be a no-op, but some of the RTL passes
2398 need additional processing here. */
2399
2400static void
2401skip_pass (opt_pass *pass)
2402{
2403 /* Pass "reload" sets the global "reload_completed", and many
2404 things depend on this (e.g. instructions in .md files). */
2405 if (strcmp (pass->name, "reload") == 0)
2406 reload_completed = 1;
2407
2408 /* The INSN_ADDRESSES vec is normally set up by
2409 shorten_branches; set it up for the benefit of passes that
2410 run after this. */
2411 if (strcmp (pass->name, "shorten") == 0)
2412 INSN_ADDRESSES_ALLOC (get_max_uid ());
2413
2414 /* Update the cfg hooks as appropriate. */
2415 if (strcmp (pass->name, "into_cfglayout") == 0)
2416 {
2417 cfg_layout_rtl_register_cfg_hooks ();
2418 cfun->curr_properties |= PROP_cfglayout;
2419 }
2420 if (strcmp (pass->name, "outof_cfglayout") == 0)
2421 {
2422 rtl_register_cfg_hooks ();
2423 cfun->curr_properties &= ~PROP_cfglayout;
2424 }
2425}
2426
2427/* Execute PASS. */
2428
2429bool
2430execute_one_pass (opt_pass *pass)
2431{
2432 unsigned int todo_after = 0;
2433
2434 bool gate_status;
2435
2436 /* IPA passes are executed on whole program, so cfun should be NULL.
2437 Other passes need function context set. */
2438 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2439 gcc_assert (!cfun && !current_function_decl);
2440 else
2441 gcc_assert (cfun && current_function_decl);
2442
2443 current_pass = pass;
2444
2445 /* Check whether gate check should be avoided.
2446 User controls the value of the gate through the parameter "gate_status". */
2447 gate_status = pass->gate (cfun);
2448 gate_status = override_gate_status (pass, current_function_decl, gate_status);
2449
2450 /* Override gate with plugin. */
2451 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
2452
2453 if (!gate_status)
2454 {
2455 /* Run so passes selectively disabling themselves on a given function
2456 are not miscounted. */
2457 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2458 {
2459 check_profile_consistency (pass->static_pass_number, 0, false);
2460 check_profile_consistency (pass->static_pass_number, 1, false);
2461 }
2462 current_pass = NULL;
2463 return false;
2464 }
2465
2466 if (should_skip_pass_p (pass))
2467 {
2468 skip_pass (pass);
2469 return true;
2470 }
2471
2472 /* Pass execution event trigger: useful to identify passes being
2473 executed. */
2474 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
2475
2476 if (!quiet_flag && !cfun)
2477 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
2478
2479 /* Note that the folders should only create gimple expressions.
2480 This is a hack until the new folder is ready. */
2481 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2482
2483 pass_init_dump_file (pass);
2484
2485 /* If a timevar is present, start it. */
2486 if (pass->tv_id != TV_NONE)
2487 timevar_push (pass->tv_id);
2488
2489 /* Run pre-pass verification. */
2490 execute_todo (pass->todo_flags_start);
2491
2492 if (flag_checking)
2493 do_per_function (verify_curr_properties,
2494 (void *)(size_t)pass->properties_required);
2495
2496 /* Do it! */
2497 todo_after = pass->execute (cfun);
2498
2499 if (todo_after & TODO_discard_function)
2500 {
2501 /* Stop timevar. */
2502 if (pass->tv_id != TV_NONE)
2503 timevar_pop (pass->tv_id);
2504
2505 pass_fini_dump_file (pass);
2506
2507 gcc_assert (cfun);
2508 /* As cgraph_node::release_body expects release dominators info,
2509 we have to release it. */
2510 if (dom_info_available_p (CDI_DOMINATORS))
2511 free_dominance_info (CDI_DOMINATORS);
2512
2513 if (dom_info_available_p (CDI_POST_DOMINATORS))
2514 free_dominance_info (CDI_POST_DOMINATORS);
2515
2516 tree fn = cfun->decl;
2517 pop_cfun ();
2518 gcc_assert (!cfun);
2519 cgraph_node::get (fn)->release_body ();
2520
2521 current_pass = NULL;
2522 redirect_edge_var_map_empty ();
2523
2524 ggc_collect ();
2525
2526 return true;
2527 }
2528
2529 do_per_function (clear_last_verified, NULL);
2530
2531 do_per_function (update_properties_after_pass, pass);
2532
2533 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2534 check_profile_consistency (pass->static_pass_number, 0, true);
2535
2536 /* Run post-pass cleanup and verification. */
2537 execute_todo (todo_after | pass->todo_flags_finish | TODO_verify_il);
2538 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2539 check_profile_consistency (pass->static_pass_number, 1, true);
2540
2541 verify_interpass_invariants ();
2542
2543 /* Stop timevar. */
2544 if (pass->tv_id != TV_NONE)
2545 timevar_pop (pass->tv_id);
2546
2547 if (pass->type == IPA_PASS
2548 && ((ipa_opt_pass_d *)pass)->function_transform)
2549 {
2550 struct cgraph_node *node;
2551 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2552 node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *)pass);
2553 }
2554 else if (dump_file)
2555 do_per_function (execute_function_dump, pass);
2556
2557 if (!current_function_decl)
2558 symtab->process_new_functions ();
2559
2560 pass_fini_dump_file (pass);
2561
2562 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2563 gcc_assert (!(cfun->curr_properties & PROP_trees)
2564 || pass->type != RTL_PASS);
2565
2566 current_pass = NULL;
2567 redirect_edge_var_map_empty ();
2568
2569 /* Signal this is a suitable GC collection point. */
2570 if (!((todo_after | pass->todo_flags_finish) & TODO_do_not_ggc_collect))
2571 ggc_collect ();
2572
2573 return true;
2574}
2575
2576static void
2577execute_pass_list_1 (opt_pass *pass)
2578{
2579 do
2580 {
2581 gcc_assert (pass->type == GIMPLE_PASS
2582 || pass->type == RTL_PASS);
2583
2584 if (cfun == NULL)
2585 return;
2586 if (execute_one_pass (pass) && pass->sub)
2587 execute_pass_list_1 (pass->sub);
2588 pass = pass->next;
2589 }
2590 while (pass);
2591}
2592
2593void
2594execute_pass_list (function *fn, opt_pass *pass)
2595{
2596 gcc_assert (fn == cfun);
2597 execute_pass_list_1 (pass);
2598 if (cfun && fn->cfg)
2599 {
2600 free_dominance_info (CDI_DOMINATORS);
2601 free_dominance_info (CDI_POST_DOMINATORS);
2602 }
2603}
2604
2605/* Write out all LTO data. */
2606static void
2607write_lto (void)
2608{
2609 timevar_push (TV_IPA_LTO_GIMPLE_OUT);
2610 lto_output ();
2611 timevar_pop (TV_IPA_LTO_GIMPLE_OUT);
2612 timevar_push (TV_IPA_LTO_DECL_OUT);
2613 produce_asm_for_decls ();
2614 timevar_pop (TV_IPA_LTO_DECL_OUT);
2615}
2616
2617/* Same as execute_pass_list but assume that subpasses of IPA passes
2618 are local passes. If SET is not NULL, write out summaries of only
2619 those node in SET. */
2620
2621static void
2622ipa_write_summaries_2 (opt_pass *pass, struct lto_out_decl_state *state)
2623{
2624 while (pass)
2625 {
2626 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2627 gcc_assert (!current_function_decl);
2628 gcc_assert (!cfun);
2629 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2630 if (pass->type == IPA_PASS
2631 && ipa_pass->write_summary
2632 && pass->gate (cfun))
2633 {
2634 /* If a timevar is present, start it. */
2635 if (pass->tv_id)
2636 timevar_push (pass->tv_id);
2637
2638 pass_init_dump_file (pass);
2639
2640 current_pass = pass;
2641 ipa_pass->write_summary ();
2642
2643 pass_fini_dump_file (pass);
2644
2645 /* If a timevar is present, start it. */
2646 if (pass->tv_id)
2647 timevar_pop (pass->tv_id);
2648 }
2649
2650 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2651 ipa_write_summaries_2 (pass->sub, state);
2652
2653 pass = pass->next;
2654 }
2655}
2656
2657/* Helper function of ipa_write_summaries. Creates and destroys the
2658 decl state and calls ipa_write_summaries_2 for all passes that have
2659 summaries. SET is the set of nodes to be written. */
2660
2661static void
2662ipa_write_summaries_1 (lto_symtab_encoder_t encoder)
2663{
2664 pass_manager *passes = g->get_passes ();
2665 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2666 state->symtab_node_encoder = encoder;
2667
2668 lto_output_init_mode_table ();
2669 lto_push_out_decl_state (state);
2670
2671 gcc_assert (!flag_wpa);
2672 ipa_write_summaries_2 (passes->all_regular_ipa_passes, state);
2673
2674 write_lto ();
2675
2676 gcc_assert (lto_get_out_decl_state () == state);
2677 lto_pop_out_decl_state ();
2678 lto_delete_out_decl_state (state);
2679}
2680
2681/* Write out summaries for all the nodes in the callgraph. */
2682
2683void
2684ipa_write_summaries (void)
2685{
2686 lto_symtab_encoder_t encoder;
2687 int i, order_pos;
2688 varpool_node *vnode;
2689 struct cgraph_node *node;
2690 struct cgraph_node **order;
2691
2692 if ((!flag_generate_lto && !flag_generate_offload) || seen_error ())
2693 return;
2694
2695 select_what_to_stream ();
2696
2697 encoder = lto_symtab_encoder_new (false);
2698
2699 /* Create the callgraph set in the same order used in
2700 cgraph_expand_all_functions. This mostly facilitates debugging,
2701 since it causes the gimple file to be processed in the same order
2702 as the source code. */
2703 order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
2704 order_pos = ipa_reverse_postorder (order);
2705 gcc_assert (order_pos == symtab->cgraph_count);
2706
2707 for (i = order_pos - 1; i >= 0; i--)
2708 {
2709 struct cgraph_node *node = order[i];
2710
2711 if (node->has_gimple_body_p ())
2712 {
2713 /* When streaming out references to statements as part of some IPA
2714 pass summary, the statements need to have uids assigned and the
2715 following does that for all the IPA passes here. Naturally, this
2716 ordering then matches the one IPA-passes get in their stmt_fixup
2717 hooks. */
2718
2719 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2720 renumber_gimple_stmt_uids ();
2721 pop_cfun ();
2722 }
2723 if (node->definition && node->need_lto_streaming)
2724 lto_set_symtab_encoder_in_partition (encoder, node);
2725 }
2726
2727 FOR_EACH_DEFINED_FUNCTION (node)
2728 if (node->alias && node->need_lto_streaming)
2729 lto_set_symtab_encoder_in_partition (encoder, node);
2730 FOR_EACH_DEFINED_VARIABLE (vnode)
2731 if (vnode->need_lto_streaming)
2732 lto_set_symtab_encoder_in_partition (encoder, vnode);
2733
2734 ipa_write_summaries_1 (compute_ltrans_boundary (encoder));
2735
2736 free (order);
2737}
2738
2739/* Same as execute_pass_list but assume that subpasses of IPA passes
2740 are local passes. If SET is not NULL, write out optimization summaries of
2741 only those node in SET. */
2742
2743static void
2744ipa_write_optimization_summaries_1 (opt_pass *pass,
2745 struct lto_out_decl_state *state)
2746{
2747 while (pass)
2748 {
2749 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2750 gcc_assert (!current_function_decl);
2751 gcc_assert (!cfun);
2752 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2753 if (pass->type == IPA_PASS
2754 && ipa_pass->write_optimization_summary
2755 && pass->gate (cfun))
2756 {
2757 /* If a timevar is present, start it. */
2758 if (pass->tv_id)
2759 timevar_push (pass->tv_id);
2760
2761 pass_init_dump_file (pass);
2762
2763 current_pass = pass;
2764 ipa_pass->write_optimization_summary ();
2765
2766 pass_fini_dump_file (pass);
2767
2768 /* If a timevar is present, start it. */
2769 if (pass->tv_id)
2770 timevar_pop (pass->tv_id);
2771 }
2772
2773 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2774 ipa_write_optimization_summaries_1 (pass->sub, state);
2775
2776 pass = pass->next;
2777 }
2778}
2779
2780/* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2781 NULL, write out all summaries of all nodes. */
2782
2783void
2784ipa_write_optimization_summaries (lto_symtab_encoder_t encoder)
2785{
2786 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2787 lto_symtab_encoder_iterator lsei;
2788 state->symtab_node_encoder = encoder;
2789
2790 lto_output_init_mode_table ();
2791 lto_push_out_decl_state (state);
2792 for (lsei = lsei_start_function_in_partition (encoder);
2793 !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
2794 {
2795 struct cgraph_node *node = lsei_cgraph_node (lsei);
2796 /* When streaming out references to statements as part of some IPA
2797 pass summary, the statements need to have uids assigned.
2798
2799 For functions newly born at WPA stage we need to initialize
2800 the uids here. */
2801 if (node->definition
2802 && gimple_has_body_p (node->decl))
2803 {
2804 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2805 renumber_gimple_stmt_uids ();
2806 pop_cfun ();
2807 }
2808 }
2809
2810 gcc_assert (flag_wpa);
2811 pass_manager *passes = g->get_passes ();
2812 ipa_write_optimization_summaries_1 (passes->all_regular_ipa_passes, state);
2813
2814 write_lto ();
2815
2816 gcc_assert (lto_get_out_decl_state () == state);
2817 lto_pop_out_decl_state ();
2818 lto_delete_out_decl_state (state);
2819}
2820
2821/* Same as execute_pass_list but assume that subpasses of IPA passes
2822 are local passes. */
2823
2824static void
2825ipa_read_summaries_1 (opt_pass *pass)
2826{
2827 while (pass)
2828 {
2829 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2830
2831 gcc_assert (!current_function_decl);
2832 gcc_assert (!cfun);
2833 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2834
2835 if (pass->gate (cfun))
2836 {
2837 if (pass->type == IPA_PASS && ipa_pass->read_summary)
2838 {
2839 /* If a timevar is present, start it. */
2840 if (pass->tv_id)
2841 timevar_push (pass->tv_id);
2842
2843 pass_init_dump_file (pass);
2844
2845 current_pass = pass;
2846 ipa_pass->read_summary ();
2847
2848 pass_fini_dump_file (pass);
2849
2850 /* Stop timevar. */
2851 if (pass->tv_id)
2852 timevar_pop (pass->tv_id);
2853 }
2854
2855 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2856 ipa_read_summaries_1 (pass->sub);
2857 }
2858 pass = pass->next;
2859 }
2860}
2861
2862
2863/* Read all the summaries for all_regular_ipa_passes. */
2864
2865void
2866ipa_read_summaries (void)
2867{
2868 pass_manager *passes = g->get_passes ();
2869 ipa_read_summaries_1 (passes->all_regular_ipa_passes);
2870}
2871
2872/* Same as execute_pass_list but assume that subpasses of IPA passes
2873 are local passes. */
2874
2875static void
2876ipa_read_optimization_summaries_1 (opt_pass *pass)
2877{
2878 while (pass)
2879 {
2880 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2881
2882 gcc_assert (!current_function_decl);
2883 gcc_assert (!cfun);
2884 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2885
2886 if (pass->gate (cfun))
2887 {
2888 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
2889 {
2890 /* If a timevar is present, start it. */
2891 if (pass->tv_id)
2892 timevar_push (pass->tv_id);
2893
2894 pass_init_dump_file (pass);
2895
2896 current_pass = pass;
2897 ipa_pass->read_optimization_summary ();
2898
2899 pass_fini_dump_file (pass);
2900
2901 /* Stop timevar. */
2902 if (pass->tv_id)
2903 timevar_pop (pass->tv_id);
2904 }
2905
2906 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2907 ipa_read_optimization_summaries_1 (pass->sub);
2908 }
2909 pass = pass->next;
2910 }
2911}
2912
2913/* Read all the summaries for all_regular_ipa_passes. */
2914
2915void
2916ipa_read_optimization_summaries (void)
2917{
2918 pass_manager *passes = g->get_passes ();
2919 ipa_read_optimization_summaries_1 (passes->all_regular_ipa_passes);
2920}
2921
2922/* Same as execute_pass_list but assume that subpasses of IPA passes
2923 are local passes. */
2924void
2925execute_ipa_pass_list (opt_pass *pass)
2926{
2927 do
2928 {
2929 gcc_assert (!current_function_decl);
2930 gcc_assert (!cfun);
2931 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2932 if (execute_one_pass (pass) && pass->sub)
2933 {
2934 if (pass->sub->type == GIMPLE_PASS)
2935 {
2936 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
2937 do_per_function_toporder ((void (*)(function *, void *))
2938 execute_pass_list,
2939 pass->sub);
2940 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
2941 }
2942 else if (pass->sub->type == SIMPLE_IPA_PASS
2943 || pass->sub->type == IPA_PASS)
2944 execute_ipa_pass_list (pass->sub);
2945 else
2946 gcc_unreachable ();
2947 }
2948 gcc_assert (!current_function_decl);
2949 symtab->process_new_functions ();
2950 pass = pass->next;
2951 }
2952 while (pass);
2953}
2954
2955/* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2956
2957static void
2958execute_ipa_stmt_fixups (opt_pass *pass,
2959 struct cgraph_node *node, gimple **stmts)
2960{
2961 while (pass)
2962 {
2963 /* Execute all of the IPA_PASSes in the list. */
2964 if (pass->type == IPA_PASS
2965 && pass->gate (cfun))
2966 {
2967 ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2968
2969 if (ipa_pass->stmt_fixup)
2970 {
2971 pass_init_dump_file (pass);
2972 /* If a timevar is present, start it. */
2973 if (pass->tv_id)
2974 timevar_push (pass->tv_id);
2975
2976 current_pass = pass;
2977 ipa_pass->stmt_fixup (node, stmts);
2978
2979 /* Stop timevar. */
2980 if (pass->tv_id)
2981 timevar_pop (pass->tv_id);
2982 pass_fini_dump_file (pass);
2983 }
2984 if (pass->sub)
2985 execute_ipa_stmt_fixups (pass->sub, node, stmts);
2986 }
2987 pass = pass->next;
2988 }
2989}
2990
2991/* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2992
2993void
2994execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple **stmts)
2995{
2996 pass_manager *passes = g->get_passes ();
2997 execute_ipa_stmt_fixups (passes->all_regular_ipa_passes, node, stmts);
2998}
2999
3000
3001extern void debug_properties (unsigned int);
3002extern void dump_properties (FILE *, unsigned int);
3003
3004DEBUG_FUNCTION void
3005dump_properties (FILE *dump, unsigned int props)
3006{
3007 fprintf (dump, "Properties:\n");
3008 if (props & PROP_gimple_any)
3009 fprintf (dump, "PROP_gimple_any\n");
3010 if (props & PROP_gimple_lcf)
3011 fprintf (dump, "PROP_gimple_lcf\n");
3012 if (props & PROP_gimple_leh)
3013 fprintf (dump, "PROP_gimple_leh\n");
3014 if (props & PROP_cfg)
3015 fprintf (dump, "PROP_cfg\n");
3016 if (props & PROP_ssa)
3017 fprintf (dump, "PROP_ssa\n");
3018 if (props & PROP_no_crit_edges)
3019 fprintf (dump, "PROP_no_crit_edges\n");
3020 if (props & PROP_rtl)
3021 fprintf (dump, "PROP_rtl\n");
3022 if (props & PROP_gimple_lomp)
3023 fprintf (dump, "PROP_gimple_lomp\n");
3024 if (props & PROP_gimple_lomp_dev)
3025 fprintf (dump, "PROP_gimple_lomp_dev\n");
3026 if (props & PROP_gimple_lcx)
3027 fprintf (dump, "PROP_gimple_lcx\n");
3028 if (props & PROP_gimple_lvec)
3029 fprintf (dump, "PROP_gimple_lvec\n");
3030 if (props & PROP_cfglayout)
3031 fprintf (dump, "PROP_cfglayout\n");
3032}
3033
3034DEBUG_FUNCTION void
3035debug_properties (unsigned int props)
3036{
3037 dump_properties (stderr, props);
3038}
3039
3040/* Called by local passes to see if function is called by already processed nodes.
3041 Because we process nodes in topological order, this means that function is
3042 in recursive cycle or we introduced new direct calls. */
3043bool
3044function_called_by_processed_nodes_p (void)
3045{
3046 struct cgraph_edge *e;
3047 for (e = cgraph_node::get (current_function_decl)->callers;
3048 e;
3049 e = e->next_caller)
3050 {
3051 if (e->caller->decl == current_function_decl)
3052 continue;
3053 if (!e->caller->has_gimple_body_p ())
3054 continue;
3055 if (TREE_ASM_WRITTEN (e->caller->decl))
3056 continue;
3057 if (!e->caller->process && !e->caller->global.inlined_to)
3058 break;
3059 }
3060 if (dump_file && e)
3061 {
3062 fprintf (dump_file, "Already processed call to:\n");
3063 e->caller->dump (dump_file);
3064 }
3065 return e != NULL;
3066}
3067
3068#include "gt-passes.h"
3069