1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2019 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
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
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. */
27 #include "coretypes.h"
40 #include "lto-streamer.h"
41 #include "fold-const.h"
47 #include "value-prof.h"
49 #include "tree-ssa-loop-manip.h"
50 #include "tree-into-ssa.h"
53 #include "tree-pass.h"
55 #include "ipa-utils.h"
56 #include "tree-pretty-print.h" /* for dump_function_header */
58 #include "pass_manager.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"
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. */
72 opt_pass
*current_pass
;
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.
78 Handle this by providing a default implemenation, but make it a fatal
84 internal_error ("pass %s does not support cloning", name
);
88 opt_pass::set_pass_param (unsigned int, bool)
90 internal_error ("pass %s needs a %<set_pass_param%> implementation "
91 "to handle the extra argument in %<NEXT_PASS%>", name
);
95 opt_pass::gate (function
*)
101 opt_pass::execute (function
*)
106 opt_pass::opt_pass (const pass_data
&data
, context
*ctxt
)
110 static_pass_number (0),
117 pass_manager::execute_early_local_passes ()
119 execute_pass_list (cfun
, pass_build_ssa_passes_1
->sub
);
120 execute_pass_list (cfun
, pass_local_optimization_passes_1
->sub
);
124 pass_manager::execute_pass_mode_switching ()
126 return pass_mode_switching_1
->execute (cfun
);
130 /* Call from anywhere to find out what pass this is. Useful for
131 printing out debugging information deep inside an service
134 print_current_pass (FILE *file
)
137 fprintf (file
, "current pass = %s (%d)\n",
138 current_pass
->name
, current_pass
->static_pass_number
);
140 fprintf (file
, "no current pass.\n");
144 /* Call from the debugger to get the current pass name. */
148 print_current_pass (stderr
);
153 /* Global variables used to communicate with passes. */
157 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
160 This does nothing for local (non-static) variables, unless the
161 variable is a register variable with DECL_ASSEMBLER_NAME set. In
162 that case, or if the variable is not an automatic, it sets up the
163 RTL and outputs any assembler code (label definition, storage
164 allocation and initialization).
166 DECL is the declaration. TOP_LEVEL is nonzero
167 if this declaration is not within a function. */
170 rest_of_decl_compilation (tree decl
,
174 bool finalize
= true;
176 /* We deferred calling assemble_alias so that we could collect
177 other attributes such as visibility. Emit the alias now. */
181 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
184 alias
= TREE_VALUE (TREE_VALUE (alias
));
185 alias
= get_identifier (TREE_STRING_POINTER (alias
));
186 /* A quirk of the initial implementation of aliases required that the
187 user add "extern" to all of them. Which is silly, but now
188 historical. Do note that the symbol is in fact locally defined. */
189 DECL_EXTERNAL (decl
) = 0;
190 TREE_STATIC (decl
) = 1;
191 assemble_alias (decl
, alias
);
196 /* Can't defer this, because it needs to happen before any
197 later function definitions are processed. */
198 if (HAS_DECL_ASSEMBLER_NAME_P (decl
)
199 && DECL_ASSEMBLER_NAME_SET_P (decl
)
200 && DECL_REGISTER (decl
))
201 make_decl_rtl (decl
);
203 /* Forward declarations for nested functions are not "external",
204 but we need to treat them as if they were. */
205 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
206 || TREE_CODE (decl
) == FUNCTION_DECL
)
208 timevar_push (TV_VARCONST
);
210 /* Don't output anything when a tentative file-scope definition
211 is seen. But at end of compilation, do output code for them.
213 We do output all variables and rely on
214 callgraph code to defer them except for forward declarations
215 (see gcc.c-torture/compile/920624-1.c) */
217 || !DECL_DEFER_OUTPUT (decl
)
218 || DECL_INITIAL (decl
))
219 && (!VAR_P (decl
) || !DECL_HAS_VALUE_EXPR_P (decl
))
220 && !DECL_EXTERNAL (decl
))
222 /* When reading LTO unit, we also read varpool, so do not
224 if (in_lto_p
&& !at_end
)
226 else if (finalize
&& TREE_CODE (decl
) != FUNCTION_DECL
)
227 varpool_node::finalize_decl (decl
);
230 #ifdef ASM_FINISH_DECLARE_OBJECT
231 if (decl
== last_assemble_variable_decl
)
233 ASM_FINISH_DECLARE_OBJECT (asm_out_file
, decl
,
238 /* Now that we have activated any function-specific attributes
239 that might affect function decl, particularly align, relayout it. */
240 if (TREE_CODE (decl
) == FUNCTION_DECL
)
241 targetm
.target_option
.relayout_function (decl
);
243 timevar_pop (TV_VARCONST
);
245 else if (TREE_CODE (decl
) == TYPE_DECL
246 /* Like in rest_of_type_compilation, avoid confusing the debug
247 information machinery when there are errors. */
250 timevar_push (TV_SYMOUT
);
251 debug_hooks
->type_decl (decl
, !top_level
);
252 timevar_pop (TV_SYMOUT
);
255 /* Let cgraph know about the existence of variables. */
256 if (in_lto_p
&& !at_end
)
258 else if (VAR_P (decl
) && !DECL_EXTERNAL (decl
)
259 && TREE_STATIC (decl
))
260 varpool_node::get_create (decl
);
262 /* Generate early debug for global variables. Any local variables will
263 be handled by either handling reachable functions from
264 finalize_compilation_unit (and by consequence, locally scoped
265 symbols), or by rest_of_type_compilation below.
267 For Go's hijack of the debug_hooks to implement -fdump-go-spec, pick up
268 function prototypes. Go's debug_hooks will not forward them to the
271 && (TREE_CODE (decl
) != FUNCTION_DECL
272 /* This will pick up function prototypes with no bodies,
273 which are not visible in finalize_compilation_unit()
274 while iterating with FOR_EACH_*_FUNCTION through the
276 || (flag_dump_go_spec
!= NULL
277 && !DECL_SAVED_TREE (decl
)
278 && DECL_STRUCT_FUNCTION (decl
) == NULL
))
280 /* We need to check both decl_function_context and
281 current_function_decl here to make sure local extern
282 declarations end up with the correct context.
284 For local extern declarations, decl_function_context is
285 empty, but current_function_decl is set to the function where
286 the extern was declared . Without the check for
287 !current_function_decl below, the local extern ends up
288 incorrectly with a top-level context.
300 extern int i; // Local extern declaration.
307 && !decl_function_context (decl
)
308 && !current_function_decl
309 && DECL_SOURCE_LOCATION (decl
) != BUILTINS_LOCATION
310 && (!decl_type_context (decl
)
311 /* If we created a varpool node for the decl make sure to
312 call early_global_decl. Otherwise we miss changes
313 introduced by member definitions like
314 struct A { static int staticdatamember; };
315 int A::staticdatamember;
316 and thus have incomplete early debug and late debug
317 called from varpool node removal fails to handle it
321 && TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)))
322 /* Avoid confusing the debug information machinery when there are
325 (*debug_hooks
->early_global_decl
) (decl
);
328 /* Called after finishing a record, union or enumeral type. */
331 rest_of_type_compilation (tree type
, int toplev
)
333 /* Avoid confusing the debug information machinery when there are
338 timevar_push (TV_SYMOUT
);
339 debug_hooks
->type_decl (TYPE_STUB_DECL (type
), !toplev
);
340 timevar_pop (TV_SYMOUT
);
347 finish_optimization_passes (void)
350 struct dump_file_info
*dfi
;
352 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
354 timevar_push (TV_DUMP
);
355 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
357 dumps
->dump_start (pass_profile_1
->static_pass_number
, NULL
);
359 dumps
->dump_finish (pass_profile_1
->static_pass_number
);
364 dumps
->dump_start (pass_combine_1
->static_pass_number
, NULL
);
365 print_combine_total_stats ();
366 dumps
->dump_finish (pass_combine_1
->static_pass_number
);
369 /* Do whatever is necessary to finish printing the graphs. */
370 for (i
= TDI_end
; (dfi
= dumps
->get_dump_file_info (i
)) != NULL
; ++i
)
371 if (dfi
->graph_dump_initialized
)
373 name
= dumps
->get_dump_file_name (dfi
);
374 finish_graph_dump_file (name
);
378 timevar_pop (TV_DUMP
);
382 execute_build_ssa_passes (void)
384 /* Once this pass (and its sub-passes) are complete, all functions
385 will be in SSA form. Technically this state change is happening
386 a tad early, since the sub-passes have not yet run, but since
387 none of the sub-passes are IPA passes and do not create new
388 functions, this is ok. We're setting this value for the benefit
389 of IPA passes that follow. */
390 if (symtab
->state
< IPA_SSA
)
391 symtab
->state
= IPA_SSA
;
397 const pass_data pass_data_build_ssa_passes
=
399 SIMPLE_IPA_PASS
, /* type */
400 "build_ssa_passes", /* name */
401 OPTGROUP_NONE
, /* optinfo_flags */
402 TV_EARLY_LOCAL
, /* tv_id */
403 0, /* properties_required */
404 0, /* properties_provided */
405 0, /* properties_destroyed */
406 0, /* todo_flags_start */
407 /* todo_flags_finish is executed before subpases. For this reason
408 it makes no sense to remove unreachable functions here. */
409 0, /* todo_flags_finish */
412 class pass_build_ssa_passes
: public simple_ipa_opt_pass
415 pass_build_ssa_passes (gcc::context
*ctxt
)
416 : simple_ipa_opt_pass (pass_data_build_ssa_passes
, ctxt
)
419 /* opt_pass methods: */
420 virtual bool gate (function
*)
422 /* Don't bother doing anything if the program has errors. */
423 return (!seen_error () && !in_lto_p
);
426 virtual unsigned int execute (function
*)
428 return execute_build_ssa_passes ();
431 }; // class pass_build_ssa_passes
433 const pass_data pass_data_local_optimization_passes
=
435 SIMPLE_IPA_PASS
, /* type */
436 "opt_local_passes", /* name */
437 OPTGROUP_NONE
, /* optinfo_flags */
439 0, /* properties_required */
440 0, /* properties_provided */
441 0, /* properties_destroyed */
442 0, /* todo_flags_start */
443 0, /* todo_flags_finish */
446 class pass_local_optimization_passes
: public simple_ipa_opt_pass
449 pass_local_optimization_passes (gcc::context
*ctxt
)
450 : simple_ipa_opt_pass (pass_data_local_optimization_passes
, ctxt
)
453 /* opt_pass methods: */
454 virtual bool gate (function
*)
456 /* Don't bother doing anything if the program has errors. */
457 return (!seen_error () && !in_lto_p
);
460 }; // class pass_local_optimization_passes
462 const pass_data pass_data_ipa_remove_symbols
=
464 SIMPLE_IPA_PASS
, /* type */
465 "remove_symbols", /* name */
466 OPTGROUP_NONE
, /* optinfo_flags */
468 0, /* properties_required */
469 0, /* properties_provided */
470 0, /* properties_destroyed */
471 0, /* todo_flags_start */
472 TODO_remove_functions
| TODO_dump_symtab
, /* todo_flags_finish */
475 class pass_ipa_remove_symbols
: public simple_ipa_opt_pass
478 pass_ipa_remove_symbols (gcc::context
*ctxt
)
479 : simple_ipa_opt_pass (pass_data_ipa_remove_symbols
, ctxt
)
482 /* opt_pass methods: */
483 virtual bool gate (function
*)
485 /* Don't bother doing anything if the program has errors. */
486 return (!seen_error () && !in_lto_p
);
489 }; // class pass_local_optimization_passes
493 simple_ipa_opt_pass
*
494 make_pass_build_ssa_passes (gcc::context
*ctxt
)
496 return new pass_build_ssa_passes (ctxt
);
499 simple_ipa_opt_pass
*
500 make_pass_local_optimization_passes (gcc::context
*ctxt
)
502 return new pass_local_optimization_passes (ctxt
);
505 simple_ipa_opt_pass
*
506 make_pass_ipa_remove_symbols (gcc::context
*ctxt
)
508 return new pass_ipa_remove_symbols (ctxt
);
513 const pass_data pass_data_all_early_optimizations
=
515 GIMPLE_PASS
, /* type */
516 "early_optimizations", /* name */
517 OPTGROUP_NONE
, /* optinfo_flags */
519 0, /* properties_required */
520 0, /* properties_provided */
521 0, /* properties_destroyed */
522 0, /* todo_flags_start */
523 0, /* todo_flags_finish */
526 class pass_all_early_optimizations
: public gimple_opt_pass
529 pass_all_early_optimizations (gcc::context
*ctxt
)
530 : gimple_opt_pass (pass_data_all_early_optimizations
, ctxt
)
533 /* opt_pass methods: */
534 virtual bool gate (function
*)
536 return (optimize
>= 1
537 /* Don't bother doing anything if the program has errors. */
541 }; // class pass_all_early_optimizations
545 static gimple_opt_pass
*
546 make_pass_all_early_optimizations (gcc::context
*ctxt
)
548 return new pass_all_early_optimizations (ctxt
);
553 const pass_data pass_data_all_optimizations
=
555 GIMPLE_PASS
, /* type */
556 "*all_optimizations", /* name */
557 OPTGROUP_NONE
, /* optinfo_flags */
558 TV_OPTIMIZE
, /* tv_id */
559 0, /* properties_required */
560 0, /* properties_provided */
561 0, /* properties_destroyed */
562 0, /* todo_flags_start */
563 0, /* todo_flags_finish */
566 class pass_all_optimizations
: public gimple_opt_pass
569 pass_all_optimizations (gcc::context
*ctxt
)
570 : gimple_opt_pass (pass_data_all_optimizations
, ctxt
)
573 /* opt_pass methods: */
574 virtual bool gate (function
*) { return optimize
>= 1 && !optimize_debug
; }
576 }; // class pass_all_optimizations
580 static gimple_opt_pass
*
581 make_pass_all_optimizations (gcc::context
*ctxt
)
583 return new pass_all_optimizations (ctxt
);
588 const pass_data pass_data_all_optimizations_g
=
590 GIMPLE_PASS
, /* type */
591 "*all_optimizations_g", /* name */
592 OPTGROUP_NONE
, /* optinfo_flags */
593 TV_OPTIMIZE
, /* tv_id */
594 0, /* properties_required */
595 0, /* properties_provided */
596 0, /* properties_destroyed */
597 0, /* todo_flags_start */
598 0, /* todo_flags_finish */
601 class pass_all_optimizations_g
: public gimple_opt_pass
604 pass_all_optimizations_g (gcc::context
*ctxt
)
605 : gimple_opt_pass (pass_data_all_optimizations_g
, ctxt
)
608 /* opt_pass methods: */
609 virtual bool gate (function
*) { return optimize
>= 1 && optimize_debug
; }
611 }; // class pass_all_optimizations_g
615 static gimple_opt_pass
*
616 make_pass_all_optimizations_g (gcc::context
*ctxt
)
618 return new pass_all_optimizations_g (ctxt
);
623 const pass_data pass_data_rest_of_compilation
=
626 "*rest_of_compilation", /* name */
627 OPTGROUP_NONE
, /* optinfo_flags */
628 TV_REST_OF_COMPILATION
, /* tv_id */
629 PROP_rtl
, /* properties_required */
630 0, /* properties_provided */
631 0, /* properties_destroyed */
632 0, /* todo_flags_start */
633 0, /* todo_flags_finish */
636 class pass_rest_of_compilation
: public rtl_opt_pass
639 pass_rest_of_compilation (gcc::context
*ctxt
)
640 : rtl_opt_pass (pass_data_rest_of_compilation
, ctxt
)
643 /* opt_pass methods: */
644 virtual bool gate (function
*)
646 /* Early return if there were errors. We can run afoul of our
647 consistency checks, and there's not really much point in fixing them. */
648 return !(rtl_dump_and_exit
|| flag_syntax_only
|| seen_error ());
651 }; // class pass_rest_of_compilation
655 static rtl_opt_pass
*
656 make_pass_rest_of_compilation (gcc::context
*ctxt
)
658 return new pass_rest_of_compilation (ctxt
);
663 const pass_data pass_data_postreload
=
666 "*all-postreload", /* name */
667 OPTGROUP_NONE
, /* optinfo_flags */
668 TV_POSTRELOAD
, /* tv_id */
669 PROP_rtl
, /* properties_required */
670 0, /* properties_provided */
671 0, /* properties_destroyed */
672 0, /* todo_flags_start */
673 0, /* todo_flags_finish */
676 class pass_postreload
: public rtl_opt_pass
679 pass_postreload (gcc::context
*ctxt
)
680 : rtl_opt_pass (pass_data_postreload
, ctxt
)
683 /* opt_pass methods: */
684 virtual bool gate (function
*) { return reload_completed
; }
686 }; // class pass_postreload
690 static rtl_opt_pass
*
691 make_pass_postreload (gcc::context
*ctxt
)
693 return new pass_postreload (ctxt
);
698 const pass_data pass_data_late_compilation
=
701 "*all-late_compilation", /* name */
702 OPTGROUP_NONE
, /* optinfo_flags */
703 TV_LATE_COMPILATION
, /* tv_id */
704 PROP_rtl
, /* properties_required */
705 0, /* properties_provided */
706 0, /* properties_destroyed */
707 0, /* todo_flags_start */
708 0, /* todo_flags_finish */
711 class pass_late_compilation
: public rtl_opt_pass
714 pass_late_compilation (gcc::context
*ctxt
)
715 : rtl_opt_pass (pass_data_late_compilation
, ctxt
)
718 /* opt_pass methods: */
719 virtual bool gate (function
*)
721 return reload_completed
|| targetm
.no_register_allocation
;
724 }; // class pass_late_compilation
728 static rtl_opt_pass
*
729 make_pass_late_compilation (gcc::context
*ctxt
)
731 return new pass_late_compilation (ctxt
);
736 /* Set the static pass number of pass PASS to ID and record that
737 in the mapping from static pass number to pass. */
741 set_pass_for_id (int id
, opt_pass
*pass
)
743 pass
->static_pass_number
= id
;
744 if (passes_by_id_size
<= id
)
746 passes_by_id
= XRESIZEVEC (opt_pass
*, passes_by_id
, id
+ 1);
747 memset (passes_by_id
+ passes_by_id_size
, 0,
748 (id
+ 1 - passes_by_id_size
) * sizeof (void *));
749 passes_by_id_size
= id
+ 1;
751 passes_by_id
[id
] = pass
;
754 /* Return the pass with the static pass number ID. */
757 pass_manager::get_pass_for_id (int id
) const
759 if (id
>= passes_by_id_size
)
761 return passes_by_id
[id
];
764 /* Iterate over the pass tree allocating dump file numbers. We want
765 to do this depth first, and independent of whether the pass is
769 register_one_dump_file (opt_pass
*pass
)
771 g
->get_passes ()->register_one_dump_file (pass
);
775 pass_manager::register_one_dump_file (opt_pass
*pass
)
777 char *dot_name
, *flag_name
, *glob_name
;
778 const char *name
, *full_name
, *prefix
;
780 /* Buffer big enough to format a 32-bit UINT_MAX into. */
784 optgroup_flags_t optgroup_flags
= OPTGROUP_NONE
;
785 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
787 /* See below in next_pass_1. */
789 if (pass
->static_pass_number
!= -1)
790 sprintf (num
, "%u", ((int) pass
->static_pass_number
< 0
791 ? 1 : pass
->static_pass_number
));
793 /* The name is both used to identify the pass for the purposes of plugins,
794 and to specify dump file name and option.
795 The latter two might want something short which is not quite unique; for
796 that reason, we may have a disambiguating prefix, followed by a space
797 to mark the start of the following dump file name / option string. */
798 name
= strchr (pass
->name
, ' ');
799 name
= name
? name
+ 1 : pass
->name
;
800 dot_name
= concat (".", name
, num
, NULL
);
801 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
805 optgroup_flags
|= OPTGROUP_IPA
;
807 else if (pass
->type
== GIMPLE_PASS
)
818 flag_name
= concat (prefix
, name
, num
, NULL
);
819 glob_name
= concat (prefix
, name
, NULL
);
820 optgroup_flags
|= pass
->optinfo_flags
;
821 /* For any passes that do not have an optgroup set, and which are not
822 IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
823 any dump messages are emitted properly under -fopt-info(-optall). */
824 if (optgroup_flags
== OPTGROUP_NONE
)
825 optgroup_flags
= OPTGROUP_OTHER
;
826 id
= dumps
->dump_register (dot_name
, flag_name
, glob_name
, dkind
,
829 set_pass_for_id (id
, pass
);
830 full_name
= concat (prefix
, pass
->name
, num
, NULL
);
831 register_pass_name (pass
, full_name
);
832 free (CONST_CAST (char *, full_name
));
835 /* Register the dump files for the pass_manager starting at PASS. */
838 pass_manager::register_dump_files (opt_pass
*pass
)
842 if (pass
->name
&& pass
->name
[0] != '*')
843 register_one_dump_file (pass
);
846 register_dump_files (pass
->sub
);
853 /* Register PASS with NAME. */
856 pass_manager::register_pass_name (opt_pass
*pass
, const char *name
)
858 if (!m_name_to_pass_map
)
859 m_name_to_pass_map
= new hash_map
<nofree_string_hash
, opt_pass
*> (256);
861 if (m_name_to_pass_map
->get (name
))
862 return; /* Ignore plugin passes. */
864 const char *unique_name
= xstrdup (name
);
865 m_name_to_pass_map
->put (unique_name
, pass
);
868 /* Map from pass id to canonicalized pass name. */
870 typedef const char *char_ptr
;
871 static vec
<char_ptr
> pass_tab
;
873 /* Callback function for traversing NAME_TO_PASS_MAP. */
876 passes_pass_traverse (const char *const &name
, opt_pass
*const &pass
, void *)
878 gcc_assert (pass
->static_pass_number
> 0);
879 gcc_assert (pass_tab
.exists ());
881 pass_tab
[pass
->static_pass_number
] = name
;
886 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
887 table for dumping purpose. */
890 pass_manager::create_pass_tab (void) const
892 if (!flag_dump_passes
)
895 pass_tab
.safe_grow_cleared (passes_by_id_size
+ 1);
896 m_name_to_pass_map
->traverse
<void *, passes_pass_traverse
> (NULL
);
899 static bool override_gate_status (opt_pass
*, tree
, bool);
901 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
902 is turned on or not. */
905 dump_one_pass (opt_pass
*pass
, int pass_indent
)
907 int indent
= 3 * pass_indent
;
909 bool is_on
, is_really_on
;
911 is_on
= pass
->gate (cfun
);
912 is_really_on
= override_gate_status (pass
, current_function_decl
, is_on
);
914 if (pass
->static_pass_number
<= 0)
917 pn
= pass_tab
[pass
->static_pass_number
];
919 fprintf (stderr
, "%*s%-40s%*s:%s%s\n", indent
, " ", pn
,
920 (15 - indent
< 0 ? 0 : 15 - indent
), " ",
921 is_on
? " ON" : " OFF",
922 ((!is_on
) == (!is_really_on
) ? ""
923 : (is_really_on
? " (FORCED_ON)" : " (FORCED_OFF)")));
926 /* Dump pass list PASS with indentation INDENT. */
929 dump_pass_list (opt_pass
*pass
, int indent
)
933 dump_one_pass (pass
, indent
);
935 dump_pass_list (pass
->sub
, indent
+ 1);
941 /* Dump all optimization passes. */
946 g
->get_passes ()->dump_passes ();
950 pass_manager::dump_passes () const
952 push_dummy_function (true);
956 dump_pass_list (all_lowering_passes
, 1);
957 dump_pass_list (all_small_ipa_passes
, 1);
958 dump_pass_list (all_regular_ipa_passes
, 1);
959 dump_pass_list (all_late_ipa_passes
, 1);
960 dump_pass_list (all_passes
, 1);
962 pop_dummy_function ();
965 /* Returns the pass with NAME. */
968 pass_manager::get_pass_by_name (const char *name
)
970 opt_pass
**p
= m_name_to_pass_map
->get (name
);
978 /* Range [start, last]. */
984 const char *assem_name
;
985 struct uid_range
*next
;
988 typedef struct uid_range
*uid_range_p
;
991 static vec
<uid_range_p
> enabled_pass_uid_range_tab
;
992 static vec
<uid_range_p
> disabled_pass_uid_range_tab
;
995 /* Parse option string for -fdisable- and -fenable-
996 The syntax of the options:
999 -fdisable-<pass_name>
1001 -fenable-<pass_name>=s1:e1,s2:e2,...
1002 -fdisable-<pass_name>=s1:e1,s2:e2,...
1006 enable_disable_pass (const char *arg
, bool is_enable
)
1009 char *range_str
, *phase_name
;
1010 char *argstr
= xstrdup (arg
);
1011 vec
<uid_range_p
> *tab
= 0;
1013 range_str
= strchr (argstr
,'=');
1020 phase_name
= argstr
;
1024 error ("unrecognized option %<-fenable%>");
1026 error ("unrecognized option %<-fdisable%>");
1030 pass
= g
->get_passes ()->get_pass_by_name (phase_name
);
1031 if (!pass
|| pass
->static_pass_number
== -1)
1034 error ("unknown pass %s specified in %<-fenable%>", phase_name
);
1036 error ("unknown pass %s specified in %<-fdisable%>", phase_name
);
1042 tab
= &enabled_pass_uid_range_tab
;
1044 tab
= &disabled_pass_uid_range_tab
;
1046 if ((unsigned) pass
->static_pass_number
>= tab
->length ())
1047 tab
->safe_grow_cleared (pass
->static_pass_number
+ 1);
1052 uid_range_p new_range
= XCNEW (struct uid_range
);
1054 new_range
->start
= 0;
1055 new_range
->last
= (unsigned)-1;
1057 slot
= (*tab
)[pass
->static_pass_number
];
1058 new_range
->next
= slot
;
1059 (*tab
)[pass
->static_pass_number
] = new_range
;
1061 inform (UNKNOWN_LOCATION
, "enable pass %s for functions in the range "
1062 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1064 inform (UNKNOWN_LOCATION
, "disable pass %s for functions in the range "
1065 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1069 char *next_range
= NULL
;
1070 char *one_range
= range_str
;
1071 char *end_val
= NULL
;
1076 uid_range_p new_range
;
1077 char *invalid
= NULL
;
1079 char *func_name
= NULL
;
1081 next_range
= strchr (one_range
, ',');
1088 end_val
= strchr (one_range
, ':');
1094 start
= strtol (one_range
, &invalid
, 10);
1095 if (*invalid
|| start
< 0)
1097 if (end_val
|| (one_range
[0] >= '0'
1098 && one_range
[0] <= '9'))
1100 error ("Invalid range %s in option %s",
1102 is_enable
? "-fenable" : "-fdisable");
1106 func_name
= one_range
;
1110 new_range
= XCNEW (struct uid_range
);
1113 new_range
->start
= (unsigned) start
;
1114 new_range
->last
= (unsigned) start
;
1118 new_range
->start
= (unsigned) -1;
1119 new_range
->last
= (unsigned) -1;
1120 new_range
->assem_name
= xstrdup (func_name
);
1125 long last
= strtol (end_val
, &invalid
, 10);
1126 if (*invalid
|| last
< start
)
1128 error ("Invalid range %s in option %s",
1130 is_enable
? "-fenable" : "-fdisable");
1134 new_range
= XCNEW (struct uid_range
);
1135 new_range
->start
= (unsigned) start
;
1136 new_range
->last
= (unsigned) last
;
1139 slot
= (*tab
)[pass
->static_pass_number
];
1140 new_range
->next
= slot
;
1141 (*tab
)[pass
->static_pass_number
] = new_range
;
1144 if (new_range
->assem_name
)
1145 inform (UNKNOWN_LOCATION
,
1146 "enable pass %s for function %s",
1147 phase_name
, new_range
->assem_name
);
1149 inform (UNKNOWN_LOCATION
,
1150 "enable pass %s for functions in the range of [%u, %u]",
1151 phase_name
, new_range
->start
, new_range
->last
);
1155 if (new_range
->assem_name
)
1156 inform (UNKNOWN_LOCATION
,
1157 "disable pass %s for function %s",
1158 phase_name
, new_range
->assem_name
);
1160 inform (UNKNOWN_LOCATION
,
1161 "disable pass %s for functions in the range of [%u, %u]",
1162 phase_name
, new_range
->start
, new_range
->last
);
1165 one_range
= next_range
;
1166 } while (next_range
);
1172 /* Enable pass specified by ARG. */
1175 enable_pass (const char *arg
)
1177 enable_disable_pass (arg
, true);
1180 /* Disable pass specified by ARG. */
1183 disable_pass (const char *arg
)
1185 enable_disable_pass (arg
, false);
1188 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1191 is_pass_explicitly_enabled_or_disabled (opt_pass
*pass
,
1193 vec
<uid_range_p
> tab
)
1195 uid_range_p slot
, range
;
1197 const char *aname
= NULL
;
1200 || (unsigned) pass
->static_pass_number
>= tab
.length ()
1201 || pass
->static_pass_number
== -1)
1204 slot
= tab
[pass
->static_pass_number
];
1208 cgraph_uid
= func
? cgraph_node::get (func
)->get_uid () : 0;
1209 if (func
&& DECL_ASSEMBLER_NAME_SET_P (func
))
1210 aname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func
));
1215 if ((unsigned) cgraph_uid
>= range
->start
1216 && (unsigned) cgraph_uid
<= range
->last
)
1218 if (range
->assem_name
&& aname
1219 && !strcmp (range
->assem_name
, aname
))
1221 range
= range
->next
;
1228 /* Update static_pass_number for passes (and the flag
1229 TODO_mark_first_instance).
1231 Passes are constructed with static_pass_number preinitialized to 0
1233 This field is used in two different ways: initially as instance numbers
1234 of their kind, and then as ids within the entire pass manager.
1236 Within pass_manager::pass_manager:
1238 * In add_pass_instance(), as called by next_pass_1 in
1239 NEXT_PASS in init_optimization_passes
1241 * When the initial instance of a pass within a pass manager is seen,
1242 it is flagged, and its static_pass_number is set to -1
1244 * On subsequent times that it is seen, the static pass number
1245 is decremented each time, so that if there are e.g. 4 dups,
1246 they have static_pass_number -4, 2, 3, 4 respectively (note
1247 how the initial one is negative and gives the count); these
1248 can be thought of as instance numbers of the specific pass
1250 * Within the register_dump_files () traversal, set_pass_for_id()
1251 is called on each pass, using these instance numbers to create
1252 dumpfile switches, and then overwriting them with a pass id,
1253 which are global to the whole pass manager (based on
1254 (TDI_end + current value of extra_dump_files_in_use) ) */
1257 add_pass_instance (opt_pass
*new_pass
, bool track_duplicates
,
1258 opt_pass
*initial_pass
)
1260 /* Are we dealing with the first pass of its kind, or a clone? */
1261 if (new_pass
!= initial_pass
)
1263 /* We're dealing with a clone. */
1264 new_pass
->todo_flags_start
&= ~TODO_mark_first_instance
;
1266 /* Indicate to register_dump_files that this pass has duplicates,
1267 and so it should rename the dump file. The first instance will
1268 be -1, and be number of duplicates = -static_pass_number - 1.
1269 Subsequent instances will be > 0 and just the duplicate number. */
1270 if ((new_pass
->name
&& new_pass
->name
[0] != '*') || track_duplicates
)
1272 initial_pass
->static_pass_number
-= 1;
1273 new_pass
->static_pass_number
= -initial_pass
->static_pass_number
;
1278 /* We're dealing with the first pass of its kind. */
1279 new_pass
->todo_flags_start
|= TODO_mark_first_instance
;
1280 new_pass
->static_pass_number
= -1;
1282 invoke_plugin_callbacks (PLUGIN_NEW_PASS
, new_pass
);
1286 /* Add a pass to the pass list. Duplicate the pass if it's already
1290 next_pass_1 (opt_pass
**list
, opt_pass
*pass
, opt_pass
*initial_pass
)
1292 /* Every pass should have a name so that plugins can refer to them. */
1293 gcc_assert (pass
->name
!= NULL
);
1295 add_pass_instance (pass
, false, initial_pass
);
1298 return &(*list
)->next
;
1301 /* List node for an inserted pass instance. We need to keep track of all
1302 the newly-added pass instances (with 'added_pass_nodes' defined below)
1303 so that we can register their dump files after pass-positioning is finished.
1304 Registering dumping files needs to be post-processed or the
1305 static_pass_number of the opt_pass object would be modified and mess up
1306 the dump file names of future pass instances to be added. */
1308 struct pass_list_node
1311 struct pass_list_node
*next
;
1314 static struct pass_list_node
*added_pass_nodes
= NULL
;
1315 static struct pass_list_node
*prev_added_pass_node
;
1317 /* Insert the pass at the proper position. Return true if the pass
1318 is successfully added.
1320 NEW_PASS_INFO - new pass to be inserted
1321 PASS_LIST - root of the pass list to insert the new pass to */
1324 position_pass (struct register_pass_info
*new_pass_info
, opt_pass
**pass_list
)
1326 opt_pass
*pass
= *pass_list
, *prev_pass
= NULL
;
1327 bool success
= false;
1329 for ( ; pass
; prev_pass
= pass
, pass
= pass
->next
)
1331 /* Check if the current pass is of the same type as the new pass and
1332 matches the name and the instance number of the reference pass. */
1333 if (pass
->type
== new_pass_info
->pass
->type
1335 && !strcmp (pass
->name
, new_pass_info
->reference_pass_name
)
1336 && ((new_pass_info
->ref_pass_instance_number
== 0)
1337 || (new_pass_info
->ref_pass_instance_number
==
1338 pass
->static_pass_number
)
1339 || (new_pass_info
->ref_pass_instance_number
== 1
1340 && pass
->todo_flags_start
& TODO_mark_first_instance
)))
1343 struct pass_list_node
*new_pass_node
;
1345 if (new_pass_info
->ref_pass_instance_number
== 0)
1347 new_pass
= new_pass_info
->pass
->clone ();
1348 add_pass_instance (new_pass
, true, new_pass_info
->pass
);
1352 new_pass
= new_pass_info
->pass
;
1353 add_pass_instance (new_pass
, true, new_pass
);
1356 /* Insert the new pass instance based on the positioning op. */
1357 switch (new_pass_info
->pos_op
)
1359 case PASS_POS_INSERT_AFTER
:
1360 new_pass
->next
= pass
->next
;
1361 pass
->next
= new_pass
;
1363 /* Skip newly inserted pass to avoid repeated
1364 insertions in the case where the new pass and the
1365 existing one have the same name. */
1368 case PASS_POS_INSERT_BEFORE
:
1369 new_pass
->next
= pass
;
1371 prev_pass
->next
= new_pass
;
1373 *pass_list
= new_pass
;
1375 case PASS_POS_REPLACE
:
1376 new_pass
->next
= pass
->next
;
1378 prev_pass
->next
= new_pass
;
1380 *pass_list
= new_pass
;
1381 new_pass
->sub
= pass
->sub
;
1382 new_pass
->tv_id
= pass
->tv_id
;
1386 error ("invalid pass positioning operation");
1390 /* Save the newly added pass (instance) in the added_pass_nodes
1391 list so that we can register its dump file later. Note that
1392 we cannot register the dump file now because doing so will modify
1393 the static_pass_number of the opt_pass object and therefore
1394 mess up the dump file name of future instances. */
1395 new_pass_node
= XCNEW (struct pass_list_node
);
1396 new_pass_node
->pass
= new_pass
;
1397 if (!added_pass_nodes
)
1398 added_pass_nodes
= new_pass_node
;
1400 prev_added_pass_node
->next
= new_pass_node
;
1401 prev_added_pass_node
= new_pass_node
;
1406 if (pass
->sub
&& position_pass (new_pass_info
, &pass
->sub
))
1413 /* Hooks a new pass into the pass lists.
1415 PASS_INFO - pass information that specifies the opt_pass object,
1416 reference pass, instance number, and how to position
1420 register_pass (struct register_pass_info
*pass_info
)
1422 g
->get_passes ()->register_pass (pass_info
);
1426 register_pass (opt_pass
* pass
, pass_positioning_ops pos
,
1427 const char* ref_pass_name
, int ref_pass_inst_number
)
1429 register_pass_info i
;
1431 i
.reference_pass_name
= ref_pass_name
;
1432 i
.ref_pass_instance_number
= ref_pass_inst_number
;
1435 g
->get_passes ()->register_pass (&i
);
1439 pass_manager::register_pass (struct register_pass_info
*pass_info
)
1441 bool all_instances
, success
;
1443 /* The checks below could fail in buggy plugins. Existing GCC
1444 passes should never fail these checks, so we mention plugin in
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
)
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
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
);
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 While doing so, we also delete the pass_list_node
1480 objects created during pass positioning. */
1481 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
1482 while (added_pass_nodes
)
1484 struct pass_list_node
*next_node
= added_pass_nodes
->next
;
1486 /* Handle -fdump-* and -fopt-info. */
1487 dumps
->register_pass (added_pass_nodes
->pass
);
1489 XDELETE (added_pass_nodes
);
1490 added_pass_nodes
= next_node
;
1494 /* Construct the pass tree. The sequencing of passes is driven by
1495 the cgraph routines:
1497 finalize_compilation_unit ()
1498 for each node N in the cgraph
1499 cgraph_analyze_function (N)
1500 cgraph_lower_function (N) -> all_lowering_passes
1502 If we are optimizing, compile is then invoked:
1505 ipa_passes () -> all_small_ipa_passes
1506 -> Analysis of all_regular_ipa_passes
1507 * possible LTO streaming at copmilation time *
1508 -> Execution of all_regular_ipa_passes
1509 * possible LTO streaming at link time *
1510 -> all_late_ipa_passes
1511 expand_all_functions ()
1512 for each node N in the cgraph
1513 expand_function (N) -> Transformation of all_regular_ipa_passes
1517 pass_manager::pass_manager (context
*ctxt
)
1518 : all_passes (NULL
), all_small_ipa_passes (NULL
), all_lowering_passes (NULL
),
1519 all_regular_ipa_passes (NULL
),
1520 all_late_ipa_passes (NULL
), passes_by_id (NULL
), passes_by_id_size (0),
1521 m_ctxt (ctxt
), m_name_to_pass_map (NULL
)
1525 /* Zero-initialize pass members. */
1526 #define INSERT_PASSES_AFTER(PASS)
1527 #define PUSH_INSERT_PASSES_WITHIN(PASS)
1528 #define POP_INSERT_PASSES()
1529 #define NEXT_PASS(PASS, NUM) PASS ## _ ## NUM = NULL
1530 #define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) NEXT_PASS (PASS, NUM)
1531 #define TERMINATE_PASS_LIST(PASS)
1532 #include "pass-instances.def"
1533 #undef INSERT_PASSES_AFTER
1534 #undef PUSH_INSERT_PASSES_WITHIN
1535 #undef POP_INSERT_PASSES
1537 #undef NEXT_PASS_WITH_ARG
1538 #undef TERMINATE_PASS_LIST
1540 /* Initialize the pass_lists array. */
1541 #define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1543 #undef DEF_PASS_LIST
1545 /* Build the tree of passes. */
1547 #define INSERT_PASSES_AFTER(PASS) \
1549 opt_pass **p_start; \
1550 p_start = p = &(PASS);
1552 #define TERMINATE_PASS_LIST(PASS) \
1553 gcc_assert (p_start == &PASS); \
1557 #define PUSH_INSERT_PASSES_WITHIN(PASS) \
1559 opt_pass **p = &(PASS ## _1)->sub;
1561 #define POP_INSERT_PASSES() \
1564 #define NEXT_PASS(PASS, NUM) \
1566 gcc_assert (PASS ## _ ## NUM == NULL); \
1568 PASS ## _1 = make_##PASS (m_ctxt); \
1571 gcc_assert (PASS ## _1); \
1572 PASS ## _ ## NUM = PASS ## _1->clone (); \
1574 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1577 #define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) \
1579 NEXT_PASS (PASS, NUM); \
1580 PASS ## _ ## NUM->set_pass_param (0, ARG); \
1583 #include "pass-instances.def"
1585 #undef INSERT_PASSES_AFTER
1586 #undef PUSH_INSERT_PASSES_WITHIN
1587 #undef POP_INSERT_PASSES
1589 #undef NEXT_PASS_WITH_ARG
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
);
1601 delete_pass_tree (opt_pass
*pass
)
1605 /* Recurse into child passes. */
1606 delete_pass_tree (pass
->sub
);
1608 opt_pass
*next
= pass
->next
;
1610 /* Delete this pass. */
1613 /* Iterate onto sibling passes. */
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]);
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. */
1635 do_per_function (void (*callback
) (function
*, void *data
), void *data
)
1637 if (current_function_decl
)
1638 callback (cfun
, data
);
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
1653 static GTY ((length ("nnodes"))) cgraph_node
**order
;
1655 #define uid_hash_t hash_set<int_hash <int, 0, -1> >
1657 /* Hook called when NODE is removed and therefore should be
1658 excluded from order vector. DATA is a hash set with removed nodes. */
1661 remove_cgraph_node_from_order (cgraph_node
*node
, void *data
)
1663 uid_hash_t
*removed_nodes
= (uid_hash_t
*)data
;
1664 removed_nodes
->add (node
->get_uid ());
1667 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1668 function CALLBACK for every function in the call graph. Otherwise,
1669 call CALLBACK on the current function.
1670 This function is global so that plugins can use it. */
1672 do_per_function_toporder (void (*callback
) (function
*, void *data
), void *data
)
1676 if (current_function_decl
)
1677 callback (cfun
, data
);
1680 cgraph_node_hook_list
*hook
;
1681 uid_hash_t removed_nodes
;
1682 gcc_assert (!order
);
1683 order
= ggc_vec_alloc
<cgraph_node
*> (symtab
->cgraph_count
);
1685 nnodes
= ipa_reverse_postorder (order
);
1686 for (i
= nnodes
- 1; i
>= 0; i
--)
1687 order
[i
]->process
= 1;
1688 hook
= symtab
->add_cgraph_removal_hook (remove_cgraph_node_from_order
,
1690 for (i
= nnodes
- 1; i
>= 0; i
--)
1692 cgraph_node
*node
= order
[i
];
1694 /* Function could be inlined and removed as unreachable. */
1695 if (node
== NULL
|| removed_nodes
.contains (node
->get_uid ()))
1698 /* Allow possibly removed nodes to be garbage collected. */
1701 if (node
->has_gimple_body_p ())
1703 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1705 callback (fn
, data
);
1709 symtab
->remove_cgraph_removal_hook (hook
);
1716 /* Helper function to perform function body dump. */
1719 execute_function_dump (function
*fn
, void *data
)
1721 opt_pass
*pass
= (opt_pass
*)data
;
1727 if (fn
->curr_properties
& PROP_trees
)
1728 dump_function_to_file (fn
->decl
, dump_file
, dump_flags
);
1730 print_rtl_with_bb (dump_file
, get_insns (), dump_flags
);
1732 /* Flush the file. If verification fails, we won't be able to
1733 close the file before aborting. */
1736 if ((fn
->curr_properties
& PROP_cfg
)
1737 && (dump_flags
& TDF_GRAPH
))
1739 gcc::dump_manager
*dumps
= g
->get_dumps ();
1740 struct dump_file_info
*dfi
1741 = dumps
->get_dump_file_info (pass
->static_pass_number
);
1742 if (!dfi
->graph_dump_initialized
)
1744 clean_graph_dump_file (dump_file_name
);
1745 dfi
->graph_dump_initialized
= true;
1747 print_graph_cfg (dump_file_name
, fn
);
1754 /* This function is called when an internal compiler error is encountered.
1755 Ensure that function dump is made available before compiler is aborted. */
1758 emergency_dump_function ()
1762 enum opt_pass_type pt
= current_pass
->type
;
1763 fnotice (stderr
, "during %s pass: %s\n",
1764 pt
== GIMPLE_PASS
? "GIMPLE" : pt
== RTL_PASS
? "RTL" : "IPA",
1765 current_pass
->name
);
1766 if (!dump_file
|| !cfun
)
1768 fnotice (stderr
, "dump file: %s\n", dump_file_name
);
1769 fprintf (dump_file
, "\n\n\nEMERGENCY DUMP:\n\n");
1770 execute_function_dump (cfun
, current_pass
);
1773 static struct profile_record
*profile_record
;
1775 /* Do profile consistency book-keeping for the pass with static number INDEX.
1776 RUN is true if the pass really runs, or FALSE
1777 if we are only book-keeping on passes that may have selectively disabled
1778 themselves on a given function. */
1781 check_profile_consistency (int index
, bool run
)
1783 pass_manager
*passes
= g
->get_passes ();
1786 if (!profile_record
)
1787 profile_record
= XCNEWVEC (struct profile_record
,
1788 passes
->passes_by_id_size
);
1789 gcc_assert (index
< passes
->passes_by_id_size
&& index
>= 0);
1790 profile_record
[index
].run
|= run
;
1791 profile_record_check_consistency (&profile_record
[index
]);
1794 /* Account profile the pass with static number INDEX.
1795 RUN is true if the pass really runs, or FALSE
1796 if we are only book-keeping on passes that may have selectively disabled
1797 themselves on a given function. */
1800 account_profile (int index
, bool run
)
1802 pass_manager
*passes
= g
->get_passes ();
1805 if (!profile_record
)
1806 profile_record
= XCNEWVEC (struct profile_record
,
1807 passes
->passes_by_id_size
);
1808 gcc_assert (index
< passes
->passes_by_id_size
&& index
>= 0);
1809 profile_record
[index
].run
|= run
;
1810 profile_record_account_profile (&profile_record
[index
]);
1813 /* Output profile consistency. */
1816 dump_profile_report (void)
1818 g
->get_passes ()->dump_profile_report ();
1822 pass_manager::dump_profile_report () const
1824 int last_freq_in
= 0, last_count_in
= 0, last_freq_out
= 0, last_count_out
= 0;
1825 gcov_type last_time
= 0, last_size
= 0;
1826 double rel_time_change
, rel_size_change
;
1827 int last_reported
= 0;
1829 if (!profile_record
)
1831 fprintf (stderr
, "\nProfile consistency report:\n\n");
1832 fprintf (stderr
, " |mismatch |mismatch | |\n");
1833 fprintf (stderr
, "Pass name |IN |IN |OUT |OUT |overall |\n");
1834 fprintf (stderr
, " |freq |count |freq |count |size |time |\n");
1836 for (int i
= 1; i
< passes_by_id_size
; i
++)
1837 if (profile_record
[i
].run
)
1840 rel_time_change
= (profile_record
[i
].time
1841 - (double)last_time
) * 100 / (double)last_time
;
1843 rel_time_change
= 0;
1845 rel_size_change
= (profile_record
[i
].size
1846 - (double)last_size
) * 100 / (double)last_size
;
1848 rel_size_change
= 0;
1850 if (profile_record
[i
].num_mismatched_freq_in
!= last_freq_in
1851 || profile_record
[i
].num_mismatched_freq_out
!= last_freq_out
1852 || profile_record
[i
].num_mismatched_count_in
!= last_count_in
1853 || profile_record
[i
].num_mismatched_count_out
!= last_count_out
1854 || rel_time_change
|| rel_size_change
)
1857 fprintf (stderr
, "%-33s", passes_by_id
[i
]->name
);
1858 if (profile_record
[i
].num_mismatched_freq_in
!= last_freq_in
)
1859 fprintf (stderr
, "| %+5i",
1860 profile_record
[i
].num_mismatched_freq_in
1863 fprintf (stderr
, "| ");
1864 if (profile_record
[i
].num_mismatched_count_in
!= last_count_in
)
1865 fprintf (stderr
, "| %+5i",
1866 profile_record
[i
].num_mismatched_count_in
1869 fprintf (stderr
, "| ");
1870 if (profile_record
[i
].num_mismatched_freq_out
!= last_freq_out
)
1871 fprintf (stderr
, "| %+5i",
1872 profile_record
[i
].num_mismatched_freq_out
1875 fprintf (stderr
, "| ");
1876 if (profile_record
[i
].num_mismatched_count_out
!= last_count_out
)
1877 fprintf (stderr
, "| %+5i",
1878 profile_record
[i
].num_mismatched_count_out
1881 fprintf (stderr
, "| ");
1883 /* Size/time units change across gimple and RTL. */
1884 if (i
== pass_expand_1
->static_pass_number
)
1885 fprintf (stderr
, "|----------|----------");
1888 if (rel_size_change
)
1889 fprintf (stderr
, "| %+8.1f%%", rel_size_change
);
1891 fprintf (stderr
, "| ");
1892 if (rel_time_change
)
1893 fprintf (stderr
, "| %+8.1f%%", rel_time_change
);
1895 fprintf (stderr
, "| ");
1897 fprintf (stderr
, "|\n");
1898 last_freq_in
= profile_record
[i
].num_mismatched_freq_in
;
1899 last_freq_out
= profile_record
[i
].num_mismatched_freq_out
;
1900 last_count_in
= profile_record
[i
].num_mismatched_count_in
;
1901 last_count_out
= profile_record
[i
].num_mismatched_count_out
;
1903 else if (last_reported
!= i
)
1906 fprintf (stderr
, "%-20s ------------| | | | | | |\n",
1907 passes_by_id
[i
]->name
);
1909 last_time
= profile_record
[i
].time
;
1910 last_size
= profile_record
[i
].size
;
1914 /* Perform all TODO actions that ought to be done on each function. */
1917 execute_function_todo (function
*fn
, void *data
)
1919 bool from_ipa_pass
= (cfun
== NULL
);
1920 unsigned int flags
= (size_t)data
;
1921 flags
&= ~fn
->last_verified
;
1927 /* If we need to cleanup the CFG let it perform a needed SSA update. */
1928 if (flags
& TODO_cleanup_cfg
)
1929 cleanup_tree_cfg (flags
& TODO_update_ssa_any
);
1930 else if (flags
& TODO_update_ssa_any
)
1931 update_ssa (flags
& TODO_update_ssa_any
);
1932 gcc_assert (!need_ssa_update_p (fn
));
1934 if (flag_tree_pta
&& (flags
& TODO_rebuild_alias
))
1935 compute_may_aliases ();
1937 if (optimize
&& (flags
& TODO_update_address_taken
))
1938 execute_update_addresses_taken ();
1940 if (flags
& TODO_remove_unused_locals
)
1941 remove_unused_locals ();
1943 if (flags
& TODO_rebuild_frequencies
)
1944 rebuild_frequencies ();
1946 if (flags
& TODO_rebuild_cgraph_edges
)
1947 cgraph_edge::rebuild_edges ();
1949 gcc_assert (dom_info_state (fn
, CDI_POST_DOMINATORS
) == DOM_NONE
);
1950 /* If we've seen errors do not bother running any verifiers. */
1951 if (flag_checking
&& !seen_error ())
1953 dom_state pre_verify_state
= dom_info_state (fn
, CDI_DOMINATORS
);
1954 dom_state pre_verify_pstate
= dom_info_state (fn
, CDI_POST_DOMINATORS
);
1956 if (flags
& TODO_verify_il
)
1958 if (cfun
->curr_properties
& PROP_trees
)
1960 if (cfun
->curr_properties
& PROP_cfg
)
1961 /* IPA passes leave stmts to be fixed up, so make sure to
1962 not verify stmts really throw. */
1963 verify_gimple_in_cfg (cfun
, !from_ipa_pass
);
1965 verify_gimple_in_seq (gimple_body (cfun
->decl
));
1967 if (cfun
->curr_properties
& PROP_ssa
)
1968 /* IPA passes leave stmts to be fixed up, so make sure to
1969 not verify SSA operands whose verifier will choke on that. */
1970 verify_ssa (true, !from_ipa_pass
);
1971 /* IPA passes leave basic-blocks unsplit, so make sure to
1972 not trip on that. */
1973 if ((cfun
->curr_properties
& PROP_cfg
)
1975 verify_flow_info ();
1977 && ! loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
1979 verify_loop_structure ();
1980 if (loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1981 verify_loop_closed_ssa (false);
1983 if (cfun
->curr_properties
& PROP_rtl
)
1984 verify_rtl_sharing ();
1987 /* Make sure verifiers don't change dominator state. */
1988 gcc_assert (dom_info_state (fn
, CDI_DOMINATORS
) == pre_verify_state
);
1989 gcc_assert (dom_info_state (fn
, CDI_POST_DOMINATORS
) == pre_verify_pstate
);
1992 fn
->last_verified
= flags
& TODO_verify_all
;
1996 /* For IPA passes make sure to release dominator info, it can be
1997 computed by non-verifying TODOs. */
2000 free_dominance_info (fn
, CDI_DOMINATORS
);
2001 free_dominance_info (fn
, CDI_POST_DOMINATORS
);
2005 /* Perform all TODO actions. */
2007 execute_todo (unsigned int flags
)
2011 && need_ssa_update_p (cfun
))
2012 gcc_assert (flags
& TODO_update_ssa_any
);
2014 statistics_fini_pass ();
2017 do_per_function (execute_function_todo
, (void *)(size_t) flags
);
2019 /* At this point we should not have any unreachable code in the
2020 CFG, so it is safe to flush the pending freelist for SSA_NAMES. */
2021 if (cfun
&& cfun
->gimple_df
)
2022 flush_ssaname_freelist ();
2024 /* Always remove functions just as before inlining: IPA passes might be
2025 interested to see bodies of extern inline functions that are not inlined
2026 to analyze side effects. The full removal is done just at the end
2027 of IPA pass queue. */
2028 if (flags
& TODO_remove_functions
)
2031 symtab
->remove_unreachable_nodes (dump_file
);
2034 if ((flags
& TODO_dump_symtab
) && dump_file
&& !current_function_decl
)
2037 symtab
->dump (dump_file
);
2038 /* Flush the file. If verification fails, we won't be able to
2039 close the file before aborting. */
2043 /* Now that the dumping has been done, we can get rid of the optional
2045 if (flags
& TODO_df_finish
)
2046 df_finish_pass ((flags
& TODO_df_verify
) != 0);
2049 /* Verify invariants that should hold between passes. This is a place
2050 to put simple sanity checks. */
2053 verify_interpass_invariants (void)
2055 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2058 /* Clear the last verified flag. */
2061 clear_last_verified (function
*fn
, void *data ATTRIBUTE_UNUSED
)
2063 fn
->last_verified
= 0;
2066 /* Helper function. Verify that the properties has been turn into the
2067 properties expected by the pass. */
2070 verify_curr_properties (function
*fn
, void *data
)
2072 unsigned int props
= (size_t)data
;
2073 gcc_assert ((fn
->curr_properties
& props
) == props
);
2076 /* Release dump file name if set. */
2079 release_dump_file_name (void)
2083 free (CONST_CAST (char *, dump_file_name
));
2084 dump_file_name
= NULL
;
2088 /* Initialize pass dump file. */
2089 /* This is non-static so that the plugins can use it. */
2092 pass_init_dump_file (opt_pass
*pass
)
2094 /* If a dump file name is present, open it if enabled. */
2095 if (pass
->static_pass_number
!= -1)
2097 timevar_push (TV_DUMP
);
2098 gcc::dump_manager
*dumps
= g
->get_dumps ();
2099 bool initializing_dump
=
2100 !dumps
->dump_initialized_p (pass
->static_pass_number
);
2101 release_dump_file_name ();
2102 dump_file_name
= dumps
->get_dump_file_name (pass
->static_pass_number
);
2103 dumps
->dump_start (pass
->static_pass_number
, &dump_flags
);
2104 if (dump_file
&& current_function_decl
&& ! (dump_flags
& TDF_GIMPLE
))
2105 dump_function_header (dump_file
, current_function_decl
, dump_flags
);
2106 if (initializing_dump
2107 && dump_file
&& (dump_flags
& TDF_GRAPH
)
2108 && cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2110 clean_graph_dump_file (dump_file_name
);
2111 struct dump_file_info
*dfi
2112 = dumps
->get_dump_file_info (pass
->static_pass_number
);
2113 dfi
->graph_dump_initialized
= true;
2115 timevar_pop (TV_DUMP
);
2116 return initializing_dump
;
2122 /* Flush PASS dump file. */
2123 /* This is non-static so that plugins can use it. */
2126 pass_fini_dump_file (opt_pass
*pass
)
2128 timevar_push (TV_DUMP
);
2130 /* Flush and close dump file. */
2131 release_dump_file_name ();
2133 g
->get_dumps ()->dump_finish (pass
->static_pass_number
);
2134 timevar_pop (TV_DUMP
);
2137 /* After executing the pass, apply expected changes to the function
2141 update_properties_after_pass (function
*fn
, void *data
)
2143 opt_pass
*pass
= (opt_pass
*) data
;
2144 fn
->curr_properties
= (fn
->curr_properties
| pass
->properties_provided
)
2145 & ~pass
->properties_destroyed
;
2148 /* Execute summary generation for all of the passes in IPA_PASS. */
2151 execute_ipa_summary_passes (ipa_opt_pass_d
*ipa_pass
)
2155 opt_pass
*pass
= ipa_pass
;
2157 /* Execute all of the IPA_PASSes in the list. */
2158 if (ipa_pass
->type
== IPA_PASS
2159 && pass
->gate (cfun
)
2160 && ipa_pass
->generate_summary
)
2162 pass_init_dump_file (pass
);
2164 /* If a timevar is present, start it. */
2166 timevar_push (pass
->tv_id
);
2168 current_pass
= pass
;
2169 ipa_pass
->generate_summary ();
2173 timevar_pop (pass
->tv_id
);
2175 pass_fini_dump_file (pass
);
2177 ipa_pass
= (ipa_opt_pass_d
*)ipa_pass
->next
;
2181 /* Execute IPA_PASS function transform on NODE. */
2184 execute_one_ipa_transform_pass (struct cgraph_node
*node
,
2185 ipa_opt_pass_d
*ipa_pass
)
2187 opt_pass
*pass
= ipa_pass
;
2188 unsigned int todo_after
= 0;
2190 current_pass
= pass
;
2191 if (!ipa_pass
->function_transform
)
2194 /* Note that the folders should only create gimple expressions.
2195 This is a hack until the new folder is ready. */
2196 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2198 pass_init_dump_file (pass
);
2200 /* If a timevar is present, start it. */
2201 if (pass
->tv_id
!= TV_NONE
)
2202 timevar_push (pass
->tv_id
);
2204 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2205 check_profile_consistency (pass
->static_pass_number
, true);
2207 /* Run pre-pass verification. */
2208 execute_todo (ipa_pass
->function_transform_todo_flags_start
);
2211 todo_after
= ipa_pass
->function_transform (node
);
2213 /* Run post-pass cleanup and verification. */
2214 execute_todo (todo_after
);
2215 verify_interpass_invariants ();
2216 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2217 account_profile (pass
->static_pass_number
, true);
2220 if (pass
->tv_id
!= TV_NONE
)
2221 timevar_pop (pass
->tv_id
);
2224 do_per_function (execute_function_dump
, pass
);
2225 pass_fini_dump_file (pass
);
2227 current_pass
= NULL
;
2228 redirect_edge_var_map_empty ();
2230 /* Signal this is a suitable GC collection point. */
2231 if (!(todo_after
& TODO_do_not_ggc_collect
))
2235 /* For the current function, execute all ipa transforms. */
2238 execute_all_ipa_transforms (void)
2240 struct cgraph_node
*node
;
2243 node
= cgraph_node::get (current_function_decl
);
2245 if (node
->ipa_transforms_to_apply
.exists ())
2249 for (i
= 0; i
< node
->ipa_transforms_to_apply
.length (); i
++)
2250 execute_one_ipa_transform_pass (node
, node
->ipa_transforms_to_apply
[i
]);
2251 node
->ipa_transforms_to_apply
.release ();
2255 /* Check if PASS is explicitly disabled or enabled and return
2256 the gate status. FUNC is the function to be processed, and
2257 GATE_STATUS is the gate status determined by pass manager by
2261 override_gate_status (opt_pass
*pass
, tree func
, bool gate_status
)
2263 bool explicitly_enabled
= false;
2264 bool explicitly_disabled
= false;
2267 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2268 enabled_pass_uid_range_tab
);
2270 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2271 disabled_pass_uid_range_tab
);
2273 gate_status
= !explicitly_disabled
&& (gate_status
|| explicitly_enabled
);
2278 /* Determine if PASS_NAME matches CRITERION.
2279 Not a pure predicate, since it can update CRITERION, to support
2280 matching the Nth invocation of a pass.
2281 Subroutine of should_skip_pass_p. */
2284 determine_pass_name_match (const char *pass_name
, char *criterion
)
2286 size_t namelen
= strlen (pass_name
);
2287 if (! strncmp (pass_name
, criterion
, namelen
))
2289 /* The following supports starting with the Nth invocation
2290 of a pass (where N does not necessarily is equal to the
2291 dump file suffix). */
2292 if (criterion
[namelen
] == '\0'
2293 || (criterion
[namelen
] == '1'
2294 && criterion
[namelen
+ 1] == '\0'))
2298 if (criterion
[namelen
+ 1] == '\0')
2299 --criterion
[namelen
];
2307 /* For skipping passes until "startwith" pass.
2308 Return true iff PASS should be skipped.
2309 Clear cfun->pass_startwith when encountering the "startwith" pass,
2310 so that all subsequent passes are run. */
2313 should_skip_pass_p (opt_pass
*pass
)
2317 if (!cfun
->pass_startwith
)
2320 /* For __GIMPLE functions, we have to at least start when we leave
2321 SSA. Hence, we need to detect the "expand" pass, and stop skipping
2322 when we encounter it. A cheap way to identify "expand" is it to
2323 detect the destruction of PROP_ssa.
2324 For __RTL functions, we invoke "rest_of_compilation" directly, which
2325 is after "expand", and hence we don't reach this conditional. */
2326 if (pass
->properties_destroyed
& PROP_ssa
)
2329 fprintf (stderr
, "starting anyway when leaving SSA: %s\n", pass
->name
);
2330 cfun
->pass_startwith
= NULL
;
2334 if (determine_pass_name_match (pass
->name
, cfun
->pass_startwith
))
2337 fprintf (stderr
, "found starting pass: %s\n", pass
->name
);
2338 cfun
->pass_startwith
= NULL
;
2342 /* For GIMPLE passes, run any property provider (but continue skipping
2344 We don't want to force running RTL passes that are property providers:
2345 "expand" is covered above, and the only pass other than "expand" that
2346 provides a property is "into_cfglayout" (PROP_cfglayout), which does
2347 too much for a dumped __RTL function. */
2348 if (pass
->type
== GIMPLE_PASS
2349 && pass
->properties_provided
!= 0)
2352 /* We need to (re-)build cgraph edges as needed. */
2353 if (strstr (pass
->name
, "build_cgraph_edges") != NULL
)
2356 /* Don't skip df init; later RTL passes need it. */
2357 if (strstr (pass
->name
, "dfinit") != NULL
)
2361 fprintf (stderr
, "skipping pass: %s\n", pass
->name
);
2363 /* If we get here, then we have a "startwith" that we haven't seen yet;
2368 /* Skip the given pass, for handling passes before "startwith"
2369 in __GIMPLE and__RTL-marked functions.
2370 In theory, this ought to be a no-op, but some of the RTL passes
2371 need additional processing here. */
2374 skip_pass (opt_pass
*pass
)
2376 /* Pass "reload" sets the global "reload_completed", and many
2377 things depend on this (e.g. instructions in .md files). */
2378 if (strcmp (pass
->name
, "reload") == 0)
2379 reload_completed
= 1;
2381 /* The INSN_ADDRESSES vec is normally set up by
2382 shorten_branches; set it up for the benefit of passes that
2384 if (strcmp (pass
->name
, "shorten") == 0)
2385 INSN_ADDRESSES_ALLOC (get_max_uid ());
2387 /* Update the cfg hooks as appropriate. */
2388 if (strcmp (pass
->name
, "into_cfglayout") == 0)
2390 cfg_layout_rtl_register_cfg_hooks ();
2391 cfun
->curr_properties
|= PROP_cfglayout
;
2393 if (strcmp (pass
->name
, "outof_cfglayout") == 0)
2395 rtl_register_cfg_hooks ();
2396 cfun
->curr_properties
&= ~PROP_cfglayout
;
2403 execute_one_pass (opt_pass
*pass
)
2405 unsigned int todo_after
= 0;
2409 /* IPA passes are executed on whole program, so cfun should be NULL.
2410 Other passes need function context set. */
2411 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
2412 gcc_assert (!cfun
&& !current_function_decl
);
2414 gcc_assert (cfun
&& current_function_decl
);
2416 current_pass
= pass
;
2418 /* Check whether gate check should be avoided.
2419 User controls the value of the gate through the parameter "gate_status". */
2420 gate_status
= pass
->gate (cfun
);
2421 gate_status
= override_gate_status (pass
, current_function_decl
, gate_status
);
2423 /* Override gate with plugin. */
2424 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE
, &gate_status
);
2428 /* Run so passes selectively disabling themselves on a given function
2429 are not miscounted. */
2430 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2432 check_profile_consistency (pass
->static_pass_number
, false);
2433 account_profile (pass
->static_pass_number
, false);
2435 current_pass
= NULL
;
2439 if (should_skip_pass_p (pass
))
2445 /* Pass execution event trigger: useful to identify passes being
2447 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION
, pass
);
2449 if (!quiet_flag
&& !cfun
)
2450 fprintf (stderr
, " <%s>", pass
->name
? pass
->name
: "");
2452 /* Note that the folders should only create gimple expressions.
2453 This is a hack until the new folder is ready. */
2454 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2456 pass_init_dump_file (pass
);
2458 /* If a timevar is present, start it. */
2459 if (pass
->tv_id
!= TV_NONE
)
2460 timevar_push (pass
->tv_id
);
2462 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2463 check_profile_consistency (pass
->static_pass_number
, true);
2465 /* Run pre-pass verification. */
2466 execute_todo (pass
->todo_flags_start
);
2469 do_per_function (verify_curr_properties
,
2470 (void *)(size_t)pass
->properties_required
);
2473 todo_after
= pass
->execute (cfun
);
2475 if (todo_after
& TODO_discard_function
)
2478 if (pass
->tv_id
!= TV_NONE
)
2479 timevar_pop (pass
->tv_id
);
2481 pass_fini_dump_file (pass
);
2484 /* As cgraph_node::release_body expects release dominators info,
2485 we have to release it. */
2486 if (dom_info_available_p (CDI_DOMINATORS
))
2487 free_dominance_info (CDI_DOMINATORS
);
2489 if (dom_info_available_p (CDI_POST_DOMINATORS
))
2490 free_dominance_info (CDI_POST_DOMINATORS
);
2492 tree fn
= cfun
->decl
;
2495 cgraph_node::get (fn
)->release_body ();
2497 current_pass
= NULL
;
2498 redirect_edge_var_map_empty ();
2505 do_per_function (clear_last_verified
, NULL
);
2507 do_per_function (update_properties_after_pass
, pass
);
2509 /* Run post-pass cleanup and verification. */
2510 execute_todo (todo_after
| pass
->todo_flags_finish
| TODO_verify_il
);
2511 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2512 account_profile (pass
->static_pass_number
, true);
2514 verify_interpass_invariants ();
2517 if (pass
->tv_id
!= TV_NONE
)
2518 timevar_pop (pass
->tv_id
);
2520 if (pass
->type
== IPA_PASS
2521 && ((ipa_opt_pass_d
*)pass
)->function_transform
)
2523 struct cgraph_node
*node
;
2524 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
2525 node
->ipa_transforms_to_apply
.safe_push ((ipa_opt_pass_d
*)pass
);
2528 do_per_function (execute_function_dump
, pass
);
2530 if (!current_function_decl
)
2531 symtab
->process_new_functions ();
2533 pass_fini_dump_file (pass
);
2535 if (pass
->type
!= SIMPLE_IPA_PASS
&& pass
->type
!= IPA_PASS
)
2536 gcc_assert (!(cfun
->curr_properties
& PROP_trees
)
2537 || pass
->type
!= RTL_PASS
);
2539 current_pass
= NULL
;
2540 redirect_edge_var_map_empty ();
2542 /* Signal this is a suitable GC collection point. */
2543 if (!((todo_after
| pass
->todo_flags_finish
) & TODO_do_not_ggc_collect
))
2550 execute_pass_list_1 (opt_pass
*pass
)
2554 gcc_assert (pass
->type
== GIMPLE_PASS
2555 || pass
->type
== RTL_PASS
);
2559 if (execute_one_pass (pass
) && pass
->sub
)
2560 execute_pass_list_1 (pass
->sub
);
2567 execute_pass_list (function
*fn
, opt_pass
*pass
)
2569 gcc_assert (fn
== cfun
);
2570 execute_pass_list_1 (pass
);
2571 if (cfun
&& fn
->cfg
)
2573 free_dominance_info (CDI_DOMINATORS
);
2574 free_dominance_info (CDI_POST_DOMINATORS
);
2578 /* Write out all LTO data. */
2582 timevar_push (TV_IPA_LTO_GIMPLE_OUT
);
2584 timevar_pop (TV_IPA_LTO_GIMPLE_OUT
);
2585 timevar_push (TV_IPA_LTO_DECL_OUT
);
2586 produce_asm_for_decls ();
2587 timevar_pop (TV_IPA_LTO_DECL_OUT
);
2590 /* Same as execute_pass_list but assume that subpasses of IPA passes
2591 are local passes. If SET is not NULL, write out summaries of only
2592 those node in SET. */
2595 ipa_write_summaries_2 (opt_pass
*pass
, struct lto_out_decl_state
*state
)
2599 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*)pass
;
2600 gcc_assert (!current_function_decl
);
2602 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2603 if (pass
->type
== IPA_PASS
2604 && ipa_pass
->write_summary
2605 && pass
->gate (cfun
))
2607 /* If a timevar is present, start it. */
2609 timevar_push (pass
->tv_id
);
2611 pass_init_dump_file (pass
);
2613 current_pass
= pass
;
2614 ipa_pass
->write_summary ();
2616 pass_fini_dump_file (pass
);
2618 /* If a timevar is present, start it. */
2620 timevar_pop (pass
->tv_id
);
2623 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2624 ipa_write_summaries_2 (pass
->sub
, state
);
2630 /* Helper function of ipa_write_summaries. Creates and destroys the
2631 decl state and calls ipa_write_summaries_2 for all passes that have
2632 summaries. SET is the set of nodes to be written. */
2635 ipa_write_summaries_1 (lto_symtab_encoder_t encoder
)
2637 pass_manager
*passes
= g
->get_passes ();
2638 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2639 state
->symtab_node_encoder
= encoder
;
2641 lto_output_init_mode_table ();
2642 lto_push_out_decl_state (state
);
2644 gcc_assert (!flag_wpa
);
2645 ipa_write_summaries_2 (passes
->all_regular_ipa_passes
, state
);
2649 gcc_assert (lto_get_out_decl_state () == state
);
2650 lto_pop_out_decl_state ();
2651 lto_delete_out_decl_state (state
);
2654 /* Write out summaries for all the nodes in the callgraph. */
2657 ipa_write_summaries (void)
2659 lto_symtab_encoder_t encoder
;
2661 varpool_node
*vnode
;
2662 struct cgraph_node
*node
;
2663 struct cgraph_node
**order
;
2665 if ((!flag_generate_lto
&& !flag_generate_offload
) || seen_error ())
2668 gcc_assert (!dump_file
);
2669 streamer_dump_file
= dump_begin (TDI_lto_stream_out
, NULL
);
2671 select_what_to_stream ();
2673 encoder
= lto_symtab_encoder_new (false);
2675 /* Create the callgraph set in the same order used in
2676 cgraph_expand_all_functions. This mostly facilitates debugging,
2677 since it causes the gimple file to be processed in the same order
2678 as the source code. */
2679 order
= XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
2680 order_pos
= ipa_reverse_postorder (order
);
2681 gcc_assert (order_pos
== symtab
->cgraph_count
);
2683 for (i
= order_pos
- 1; i
>= 0; i
--)
2685 struct cgraph_node
*node
= order
[i
];
2687 if (gimple_has_body_p (node
->decl
))
2689 /* When streaming out references to statements as part of some IPA
2690 pass summary, the statements need to have uids assigned and the
2691 following does that for all the IPA passes here. Naturally, this
2692 ordering then matches the one IPA-passes get in their stmt_fixup
2695 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2696 renumber_gimple_stmt_uids ();
2699 if (node
->definition
&& node
->need_lto_streaming
)
2700 lto_set_symtab_encoder_in_partition (encoder
, node
);
2703 FOR_EACH_DEFINED_FUNCTION (node
)
2704 if (node
->alias
&& node
->need_lto_streaming
)
2705 lto_set_symtab_encoder_in_partition (encoder
, node
);
2706 FOR_EACH_DEFINED_VARIABLE (vnode
)
2707 if (vnode
->need_lto_streaming
)
2708 lto_set_symtab_encoder_in_partition (encoder
, vnode
);
2710 ipa_write_summaries_1 (compute_ltrans_boundary (encoder
));
2713 if (streamer_dump_file
)
2715 dump_end (TDI_lto_stream_out
, streamer_dump_file
);
2716 streamer_dump_file
= NULL
;
2720 /* Same as execute_pass_list but assume that subpasses of IPA passes
2721 are local passes. If SET is not NULL, write out optimization summaries of
2722 only those node in SET. */
2725 ipa_write_optimization_summaries_1 (opt_pass
*pass
,
2726 struct lto_out_decl_state
*state
)
2730 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*)pass
;
2731 gcc_assert (!current_function_decl
);
2733 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2734 if (pass
->type
== IPA_PASS
2735 && ipa_pass
->write_optimization_summary
2736 && pass
->gate (cfun
))
2738 /* If a timevar is present, start it. */
2740 timevar_push (pass
->tv_id
);
2742 pass_init_dump_file (pass
);
2744 current_pass
= pass
;
2745 ipa_pass
->write_optimization_summary ();
2747 pass_fini_dump_file (pass
);
2749 /* If a timevar is present, start it. */
2751 timevar_pop (pass
->tv_id
);
2754 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2755 ipa_write_optimization_summaries_1 (pass
->sub
, state
);
2761 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2762 NULL, write out all summaries of all nodes. */
2765 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder
)
2767 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2768 lto_symtab_encoder_iterator lsei
;
2769 state
->symtab_node_encoder
= encoder
;
2771 lto_output_init_mode_table ();
2772 lto_push_out_decl_state (state
);
2773 for (lsei
= lsei_start_function_in_partition (encoder
);
2774 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
2776 struct cgraph_node
*node
= lsei_cgraph_node (lsei
);
2777 /* When streaming out references to statements as part of some IPA
2778 pass summary, the statements need to have uids assigned.
2780 For functions newly born at WPA stage we need to initialize
2782 if (node
->definition
2783 && gimple_has_body_p (node
->decl
))
2785 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2786 renumber_gimple_stmt_uids ();
2791 gcc_assert (flag_wpa
);
2792 pass_manager
*passes
= g
->get_passes ();
2793 ipa_write_optimization_summaries_1 (passes
->all_regular_ipa_passes
, state
);
2797 gcc_assert (lto_get_out_decl_state () == state
);
2798 lto_pop_out_decl_state ();
2799 lto_delete_out_decl_state (state
);
2802 /* Same as execute_pass_list but assume that subpasses of IPA passes
2803 are local passes. */
2806 ipa_read_summaries_1 (opt_pass
*pass
)
2810 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2812 gcc_assert (!current_function_decl
);
2814 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2816 if (pass
->gate (cfun
))
2818 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_summary
)
2820 /* If a timevar is present, start it. */
2822 timevar_push (pass
->tv_id
);
2824 pass_init_dump_file (pass
);
2826 current_pass
= pass
;
2827 ipa_pass
->read_summary ();
2829 pass_fini_dump_file (pass
);
2833 timevar_pop (pass
->tv_id
);
2836 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2837 ipa_read_summaries_1 (pass
->sub
);
2844 /* Read all the summaries for all_regular_ipa_passes. */
2847 ipa_read_summaries (void)
2849 pass_manager
*passes
= g
->get_passes ();
2850 ipa_read_summaries_1 (passes
->all_regular_ipa_passes
);
2853 /* Same as execute_pass_list but assume that subpasses of IPA passes
2854 are local passes. */
2857 ipa_read_optimization_summaries_1 (opt_pass
*pass
)
2861 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2863 gcc_assert (!current_function_decl
);
2865 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2867 if (pass
->gate (cfun
))
2869 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_optimization_summary
)
2871 /* If a timevar is present, start it. */
2873 timevar_push (pass
->tv_id
);
2875 pass_init_dump_file (pass
);
2877 current_pass
= pass
;
2878 ipa_pass
->read_optimization_summary ();
2880 pass_fini_dump_file (pass
);
2884 timevar_pop (pass
->tv_id
);
2887 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2888 ipa_read_optimization_summaries_1 (pass
->sub
);
2894 /* Read all the summaries for all_regular_ipa_passes. */
2897 ipa_read_optimization_summaries (void)
2899 pass_manager
*passes
= g
->get_passes ();
2900 ipa_read_optimization_summaries_1 (passes
->all_regular_ipa_passes
);
2903 /* Same as execute_pass_list but assume that subpasses of IPA passes
2904 are local passes. */
2906 execute_ipa_pass_list (opt_pass
*pass
)
2910 gcc_assert (!current_function_decl
);
2912 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2913 if (execute_one_pass (pass
) && pass
->sub
)
2915 if (pass
->sub
->type
== GIMPLE_PASS
)
2917 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START
, NULL
);
2918 do_per_function_toporder ((void (*)(function
*, void *))
2921 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END
, NULL
);
2923 else if (pass
->sub
->type
== SIMPLE_IPA_PASS
2924 || pass
->sub
->type
== IPA_PASS
)
2925 execute_ipa_pass_list (pass
->sub
);
2929 gcc_assert (!current_function_decl
);
2930 symtab
->process_new_functions ();
2936 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2939 execute_ipa_stmt_fixups (opt_pass
*pass
,
2940 struct cgraph_node
*node
, gimple
**stmts
)
2944 /* Execute all of the IPA_PASSes in the list. */
2945 if (pass
->type
== IPA_PASS
2946 && pass
->gate (cfun
))
2948 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2950 if (ipa_pass
->stmt_fixup
)
2952 pass_init_dump_file (pass
);
2953 /* If a timevar is present, start it. */
2955 timevar_push (pass
->tv_id
);
2957 current_pass
= pass
;
2958 ipa_pass
->stmt_fixup (node
, stmts
);
2962 timevar_pop (pass
->tv_id
);
2963 pass_fini_dump_file (pass
);
2966 execute_ipa_stmt_fixups (pass
->sub
, node
, stmts
);
2972 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2975 execute_all_ipa_stmt_fixups (struct cgraph_node
*node
, gimple
**stmts
)
2977 pass_manager
*passes
= g
->get_passes ();
2978 execute_ipa_stmt_fixups (passes
->all_regular_ipa_passes
, node
, stmts
);
2982 extern void debug_properties (unsigned int);
2983 extern void dump_properties (FILE *, unsigned int);
2986 dump_properties (FILE *dump
, unsigned int props
)
2988 fprintf (dump
, "Properties:\n");
2989 if (props
& PROP_gimple_any
)
2990 fprintf (dump
, "PROP_gimple_any\n");
2991 if (props
& PROP_gimple_lcf
)
2992 fprintf (dump
, "PROP_gimple_lcf\n");
2993 if (props
& PROP_gimple_leh
)
2994 fprintf (dump
, "PROP_gimple_leh\n");
2995 if (props
& PROP_cfg
)
2996 fprintf (dump
, "PROP_cfg\n");
2997 if (props
& PROP_ssa
)
2998 fprintf (dump
, "PROP_ssa\n");
2999 if (props
& PROP_no_crit_edges
)
3000 fprintf (dump
, "PROP_no_crit_edges\n");
3001 if (props
& PROP_rtl
)
3002 fprintf (dump
, "PROP_rtl\n");
3003 if (props
& PROP_gimple_lomp
)
3004 fprintf (dump
, "PROP_gimple_lomp\n");
3005 if (props
& PROP_gimple_lomp_dev
)
3006 fprintf (dump
, "PROP_gimple_lomp_dev\n");
3007 if (props
& PROP_gimple_lcx
)
3008 fprintf (dump
, "PROP_gimple_lcx\n");
3009 if (props
& PROP_gimple_lvec
)
3010 fprintf (dump
, "PROP_gimple_lvec\n");
3011 if (props
& PROP_cfglayout
)
3012 fprintf (dump
, "PROP_cfglayout\n");
3016 debug_properties (unsigned int props
)
3018 dump_properties (stderr
, props
);
3021 /* Called by local passes to see if function is called by already processed nodes.
3022 Because we process nodes in topological order, this means that function is
3023 in recursive cycle or we introduced new direct calls. */
3025 function_called_by_processed_nodes_p (void)
3027 struct cgraph_edge
*e
;
3028 for (e
= cgraph_node::get (current_function_decl
)->callers
;
3032 if (e
->caller
->decl
== current_function_decl
)
3034 if (!e
->caller
->has_gimple_body_p ())
3036 if (TREE_ASM_WRITTEN (e
->caller
->decl
))
3038 if (!e
->caller
->process
&& !e
->caller
->global
.inlined_to
)
3043 fprintf (dump_file
, "Already processed call to:\n");
3044 e
->caller
->dump (dump_file
);
3049 #include "gt-passes.h"