1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
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"
39 #include "lto-streamer.h"
40 #include "fold-const.h"
46 #include "value-prof.h"
48 #include "tree-ssa-loop-manip.h"
49 #include "tree-into-ssa.h"
52 #include "tree-pass.h"
54 #include "ipa-utils.h"
55 #include "tree-pretty-print.h" /* for dump_function_header */
57 #include "pass_manager.h"
59 #include "tree-ssa-live.h" /* For remove_unused_locals. */
60 #include "tree-cfgcleanup.h"
64 /* This is used for debugging. It allows the current pass to printed
65 from anywhere in compilation.
66 The variable current_pass is also used for statistics and plugins. */
67 opt_pass
*current_pass
;
69 static void register_pass_name (opt_pass
*, const char *);
71 /* Most passes are single-instance (within their context) and thus don't
72 need to implement cloning, but passes that support multiple instances
73 *must* provide their own implementation of the clone method.
75 Handle this by providing a default implemenation, but make it a fatal
81 internal_error ("pass %s does not support cloning", name
);
85 opt_pass::gate (function
*)
91 opt_pass::execute (function
*)
96 opt_pass::opt_pass (const pass_data
&data
, context
*ctxt
)
100 static_pass_number (0),
107 pass_manager::execute_early_local_passes ()
109 execute_pass_list (cfun
, pass_build_ssa_passes_1
->sub
);
110 if (flag_check_pointer_bounds
)
111 execute_pass_list (cfun
, pass_chkp_instrumentation_passes_1
->sub
);
112 execute_pass_list (cfun
, pass_local_optimization_passes_1
->sub
);
116 pass_manager::execute_pass_mode_switching ()
118 return pass_mode_switching_1
->execute (cfun
);
122 /* Call from anywhere to find out what pass this is. Useful for
123 printing out debugging information deep inside an service
126 print_current_pass (FILE *file
)
129 fprintf (file
, "current pass = %s (%d)\n",
130 current_pass
->name
, current_pass
->static_pass_number
);
132 fprintf (file
, "no current pass.\n");
136 /* Call from the debugger to get the current pass name. */
140 print_current_pass (stderr
);
145 /* Global variables used to communicate with passes. */
147 bool first_pass_instance
;
150 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
153 This does nothing for local (non-static) variables, unless the
154 variable is a register variable with DECL_ASSEMBLER_NAME set. In
155 that case, or if the variable is not an automatic, it sets up the
156 RTL and outputs any assembler code (label definition, storage
157 allocation and initialization).
159 DECL is the declaration. TOP_LEVEL is nonzero
160 if this declaration is not within a function. */
163 rest_of_decl_compilation (tree decl
,
167 bool finalize
= true;
169 /* We deferred calling assemble_alias so that we could collect
170 other attributes such as visibility. Emit the alias now. */
174 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
177 alias
= TREE_VALUE (TREE_VALUE (alias
));
178 alias
= get_identifier (TREE_STRING_POINTER (alias
));
179 /* A quirk of the initial implementation of aliases required that the
180 user add "extern" to all of them. Which is silly, but now
181 historical. Do note that the symbol is in fact locally defined. */
182 DECL_EXTERNAL (decl
) = 0;
183 TREE_STATIC (decl
) = 1;
184 assemble_alias (decl
, alias
);
189 /* Can't defer this, because it needs to happen before any
190 later function definitions are processed. */
191 if (DECL_ASSEMBLER_NAME_SET_P (decl
) && DECL_REGISTER (decl
))
192 make_decl_rtl (decl
);
194 /* Forward declarations for nested functions are not "external",
195 but we need to treat them as if they were. */
196 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
197 || TREE_CODE (decl
) == FUNCTION_DECL
)
199 timevar_push (TV_VARCONST
);
201 /* Don't output anything when a tentative file-scope definition
202 is seen. But at end of compilation, do output code for them.
204 We do output all variables and rely on
205 callgraph code to defer them except for forward declarations
206 (see gcc.c-torture/compile/920624-1.c) */
208 || !DECL_DEFER_OUTPUT (decl
)
209 || DECL_INITIAL (decl
))
210 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
))
211 && !DECL_EXTERNAL (decl
))
213 /* When reading LTO unit, we also read varpool, so do not
215 if (in_lto_p
&& !at_end
)
217 else if (finalize
&& TREE_CODE (decl
) != FUNCTION_DECL
)
218 varpool_node::finalize_decl (decl
);
221 #ifdef ASM_FINISH_DECLARE_OBJECT
222 if (decl
== last_assemble_variable_decl
)
224 ASM_FINISH_DECLARE_OBJECT (asm_out_file
, decl
,
229 /* Now that we have activated any function-specific attributes
230 that might affect function decl, particularly align, relayout it. */
231 if (TREE_CODE (decl
) == FUNCTION_DECL
)
232 targetm
.target_option
.relayout_function (decl
);
234 timevar_pop (TV_VARCONST
);
236 else if (TREE_CODE (decl
) == TYPE_DECL
237 /* Like in rest_of_type_compilation, avoid confusing the debug
238 information machinery when there are errors. */
241 timevar_push (TV_SYMOUT
);
242 debug_hooks
->type_decl (decl
, !top_level
);
243 timevar_pop (TV_SYMOUT
);
246 /* Let cgraph know about the existence of variables. */
247 if (in_lto_p
&& !at_end
)
249 else if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
)
250 && TREE_STATIC (decl
))
251 varpool_node::get_create (decl
);
253 /* Generate early debug for global variables. Any local variables will
254 be handled by either handling reachable functions from
255 finalize_compilation_unit (and by consequence, locally scoped
256 symbols), or by rest_of_type_compilation below.
258 Also, pick up function prototypes, which will be mostly ignored
259 by the different early_global_decl() hooks, but will at least be
260 used by Go's hijack of the debug_hooks to implement
263 && (TREE_CODE (decl
) != FUNCTION_DECL
264 /* This will pick up function prototypes with no bodies,
265 which are not visible in finalize_compilation_unit()
266 while iterating with FOR_EACH_*_FUNCTION through the
268 || !DECL_SAVED_TREE (decl
))
270 /* We need to check both decl_function_context and
271 current_function_decl here to make sure local extern
272 declarations end up with the correct context.
274 For local extern declarations, decl_function_context is
275 empty, but current_function_decl is set to the function where
276 the extern was declared . Without the check for
277 !current_function_decl below, the local extern ends up
278 incorrectly with a top-level context.
290 extern int i; // Local extern declaration.
297 && !decl_function_context (decl
)
298 && !current_function_decl
299 && DECL_SOURCE_LOCATION (decl
) != BUILTINS_LOCATION
300 && (!decl_type_context (decl
)
301 /* If we created a varpool node for the decl make sure to
302 call early_global_decl. Otherwise we miss changes
303 introduced by member definitions like
304 struct A { static int staticdatamember; };
305 int A::staticdatamember;
306 and thus have incomplete early debug and late debug
307 called from varpool node removal fails to handle it
310 && TREE_CODE (decl
) == VAR_DECL
311 && TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)))
312 /* Avoid confusing the debug information machinery when there are
315 (*debug_hooks
->early_global_decl
) (decl
);
318 /* Called after finishing a record, union or enumeral type. */
321 rest_of_type_compilation (tree type
, int toplev
)
323 /* Avoid confusing the debug information machinery when there are
328 timevar_push (TV_SYMOUT
);
329 debug_hooks
->type_decl (TYPE_STUB_DECL (type
), !toplev
);
330 timevar_pop (TV_SYMOUT
);
337 finish_optimization_passes (void)
340 struct dump_file_info
*dfi
;
342 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
344 timevar_push (TV_DUMP
);
345 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
347 dumps
->dump_start (pass_profile_1
->static_pass_number
, NULL
);
349 dumps
->dump_finish (pass_profile_1
->static_pass_number
);
354 dumps
->dump_start (pass_profile_1
->static_pass_number
, NULL
);
355 print_combine_total_stats ();
356 dumps
->dump_finish (pass_profile_1
->static_pass_number
);
359 /* Do whatever is necessary to finish printing the graphs. */
360 for (i
= TDI_end
; (dfi
= dumps
->get_dump_file_info (i
)) != NULL
; ++i
)
361 if (dumps
->dump_initialized_p (i
)
362 && (dfi
->pflags
& TDF_GRAPH
) != 0
363 && (name
= dumps
->get_dump_file_name (i
)) != NULL
)
365 finish_graph_dump_file (name
);
369 timevar_pop (TV_DUMP
);
373 execute_build_ssa_passes (void)
375 /* Once this pass (and its sub-passes) are complete, all functions
376 will be in SSA form. Technically this state change is happening
377 a tad early, since the sub-passes have not yet run, but since
378 none of the sub-passes are IPA passes and do not create new
379 functions, this is ok. We're setting this value for the benefit
380 of IPA passes that follow. */
381 if (symtab
->state
< IPA_SSA
)
382 symtab
->state
= IPA_SSA
;
388 const pass_data pass_data_build_ssa_passes
=
390 SIMPLE_IPA_PASS
, /* type */
391 "build_ssa_passes", /* name */
392 OPTGROUP_NONE
, /* optinfo_flags */
393 TV_EARLY_LOCAL
, /* tv_id */
394 0, /* properties_required */
395 0, /* properties_provided */
396 0, /* properties_destroyed */
397 0, /* todo_flags_start */
398 /* todo_flags_finish is executed before subpases. For this reason
399 it makes no sense to remove unreachable functions here. */
400 0, /* todo_flags_finish */
403 class pass_build_ssa_passes
: public simple_ipa_opt_pass
406 pass_build_ssa_passes (gcc::context
*ctxt
)
407 : simple_ipa_opt_pass (pass_data_build_ssa_passes
, ctxt
)
410 /* opt_pass methods: */
411 virtual bool gate (function
*)
413 /* Don't bother doing anything if the program has errors. */
414 return (!seen_error () && !in_lto_p
);
417 virtual unsigned int execute (function
*)
419 return execute_build_ssa_passes ();
422 }; // class pass_build_ssa_passes
424 const pass_data pass_data_chkp_instrumentation_passes
=
426 SIMPLE_IPA_PASS
, /* type */
427 "chkp_passes", /* name */
428 OPTGROUP_NONE
, /* optinfo_flags */
430 0, /* properties_required */
431 0, /* properties_provided */
432 0, /* properties_destroyed */
433 0, /* todo_flags_start */
434 0, /* todo_flags_finish */
437 class pass_chkp_instrumentation_passes
: public simple_ipa_opt_pass
440 pass_chkp_instrumentation_passes (gcc::context
*ctxt
)
441 : simple_ipa_opt_pass (pass_data_chkp_instrumentation_passes
, ctxt
)
444 /* opt_pass methods: */
445 virtual bool gate (function
*)
447 /* Don't bother doing anything if the program has errors. */
448 return (flag_check_pointer_bounds
449 && !seen_error () && !in_lto_p
);
452 }; // class pass_chkp_instrumentation_passes
454 const pass_data pass_data_local_optimization_passes
=
456 SIMPLE_IPA_PASS
, /* type */
457 "opt_local_passes", /* name */
458 OPTGROUP_NONE
, /* optinfo_flags */
460 0, /* properties_required */
461 0, /* properties_provided */
462 0, /* properties_destroyed */
463 0, /* todo_flags_start */
464 0, /* todo_flags_finish */
467 class pass_local_optimization_passes
: public simple_ipa_opt_pass
470 pass_local_optimization_passes (gcc::context
*ctxt
)
471 : simple_ipa_opt_pass (pass_data_local_optimization_passes
, ctxt
)
474 /* opt_pass methods: */
475 virtual bool gate (function
*)
477 /* Don't bother doing anything if the program has errors. */
478 return (!seen_error () && !in_lto_p
);
481 }; // class pass_local_optimization_passes
485 simple_ipa_opt_pass
*
486 make_pass_build_ssa_passes (gcc::context
*ctxt
)
488 return new pass_build_ssa_passes (ctxt
);
491 simple_ipa_opt_pass
*
492 make_pass_chkp_instrumentation_passes (gcc::context
*ctxt
)
494 return new pass_chkp_instrumentation_passes (ctxt
);
497 simple_ipa_opt_pass
*
498 make_pass_local_optimization_passes (gcc::context
*ctxt
)
500 return new pass_local_optimization_passes (ctxt
);
505 const pass_data pass_data_all_early_optimizations
=
507 GIMPLE_PASS
, /* type */
508 "early_optimizations", /* name */
509 OPTGROUP_NONE
, /* optinfo_flags */
511 0, /* properties_required */
512 0, /* properties_provided */
513 0, /* properties_destroyed */
514 0, /* todo_flags_start */
515 0, /* todo_flags_finish */
518 class pass_all_early_optimizations
: public gimple_opt_pass
521 pass_all_early_optimizations (gcc::context
*ctxt
)
522 : gimple_opt_pass (pass_data_all_early_optimizations
, ctxt
)
525 /* opt_pass methods: */
526 virtual bool gate (function
*)
528 return (optimize
>= 1
529 /* Don't bother doing anything if the program has errors. */
533 }; // class pass_all_early_optimizations
537 static gimple_opt_pass
*
538 make_pass_all_early_optimizations (gcc::context
*ctxt
)
540 return new pass_all_early_optimizations (ctxt
);
545 const pass_data pass_data_all_optimizations
=
547 GIMPLE_PASS
, /* type */
548 "*all_optimizations", /* name */
549 OPTGROUP_NONE
, /* optinfo_flags */
550 TV_OPTIMIZE
, /* tv_id */
551 0, /* properties_required */
552 0, /* properties_provided */
553 0, /* properties_destroyed */
554 0, /* todo_flags_start */
555 0, /* todo_flags_finish */
558 class pass_all_optimizations
: public gimple_opt_pass
561 pass_all_optimizations (gcc::context
*ctxt
)
562 : gimple_opt_pass (pass_data_all_optimizations
, ctxt
)
565 /* opt_pass methods: */
566 virtual bool gate (function
*) { return optimize
>= 1 && !optimize_debug
; }
568 }; // class pass_all_optimizations
572 static gimple_opt_pass
*
573 make_pass_all_optimizations (gcc::context
*ctxt
)
575 return new pass_all_optimizations (ctxt
);
580 const pass_data pass_data_all_optimizations_g
=
582 GIMPLE_PASS
, /* type */
583 "*all_optimizations_g", /* name */
584 OPTGROUP_NONE
, /* optinfo_flags */
585 TV_OPTIMIZE
, /* tv_id */
586 0, /* properties_required */
587 0, /* properties_provided */
588 0, /* properties_destroyed */
589 0, /* todo_flags_start */
590 0, /* todo_flags_finish */
593 class pass_all_optimizations_g
: public gimple_opt_pass
596 pass_all_optimizations_g (gcc::context
*ctxt
)
597 : gimple_opt_pass (pass_data_all_optimizations_g
, ctxt
)
600 /* opt_pass methods: */
601 virtual bool gate (function
*) { return optimize
>= 1 && optimize_debug
; }
603 }; // class pass_all_optimizations_g
607 static gimple_opt_pass
*
608 make_pass_all_optimizations_g (gcc::context
*ctxt
)
610 return new pass_all_optimizations_g (ctxt
);
615 const pass_data pass_data_rest_of_compilation
=
618 "*rest_of_compilation", /* name */
619 OPTGROUP_NONE
, /* optinfo_flags */
620 TV_REST_OF_COMPILATION
, /* tv_id */
621 PROP_rtl
, /* properties_required */
622 0, /* properties_provided */
623 0, /* properties_destroyed */
624 0, /* todo_flags_start */
625 0, /* todo_flags_finish */
628 class pass_rest_of_compilation
: public rtl_opt_pass
631 pass_rest_of_compilation (gcc::context
*ctxt
)
632 : rtl_opt_pass (pass_data_rest_of_compilation
, ctxt
)
635 /* opt_pass methods: */
636 virtual bool gate (function
*)
638 /* Early return if there were errors. We can run afoul of our
639 consistency checks, and there's not really much point in fixing them. */
640 return !(rtl_dump_and_exit
|| flag_syntax_only
|| seen_error ());
643 }; // class pass_rest_of_compilation
647 static rtl_opt_pass
*
648 make_pass_rest_of_compilation (gcc::context
*ctxt
)
650 return new pass_rest_of_compilation (ctxt
);
655 const pass_data pass_data_postreload
=
658 "*all-postreload", /* name */
659 OPTGROUP_NONE
, /* optinfo_flags */
660 TV_POSTRELOAD
, /* tv_id */
661 PROP_rtl
, /* properties_required */
662 0, /* properties_provided */
663 0, /* properties_destroyed */
664 0, /* todo_flags_start */
665 0, /* todo_flags_finish */
668 class pass_postreload
: public rtl_opt_pass
671 pass_postreload (gcc::context
*ctxt
)
672 : rtl_opt_pass (pass_data_postreload
, ctxt
)
675 /* opt_pass methods: */
676 virtual bool gate (function
*) { return reload_completed
; }
678 }; // class pass_postreload
682 static rtl_opt_pass
*
683 make_pass_postreload (gcc::context
*ctxt
)
685 return new pass_postreload (ctxt
);
690 const pass_data pass_data_late_compilation
=
693 "*all-late_compilation", /* name */
694 OPTGROUP_NONE
, /* optinfo_flags */
695 TV_LATE_COMPILATION
, /* tv_id */
696 PROP_rtl
, /* properties_required */
697 0, /* properties_provided */
698 0, /* properties_destroyed */
699 0, /* todo_flags_start */
700 0, /* todo_flags_finish */
703 class pass_late_compilation
: public rtl_opt_pass
706 pass_late_compilation (gcc::context
*ctxt
)
707 : rtl_opt_pass (pass_data_late_compilation
, ctxt
)
710 /* opt_pass methods: */
711 virtual bool gate (function
*)
713 return reload_completed
|| targetm
.no_register_allocation
;
716 }; // class pass_late_compilation
720 static rtl_opt_pass
*
721 make_pass_late_compilation (gcc::context
*ctxt
)
723 return new pass_late_compilation (ctxt
);
728 /* Set the static pass number of pass PASS to ID and record that
729 in the mapping from static pass number to pass. */
733 set_pass_for_id (int id
, opt_pass
*pass
)
735 pass
->static_pass_number
= id
;
736 if (passes_by_id_size
<= id
)
738 passes_by_id
= XRESIZEVEC (opt_pass
*, passes_by_id
, id
+ 1);
739 memset (passes_by_id
+ passes_by_id_size
, 0,
740 (id
+ 1 - passes_by_id_size
) * sizeof (void *));
741 passes_by_id_size
= id
+ 1;
743 passes_by_id
[id
] = pass
;
746 /* Return the pass with the static pass number ID. */
749 pass_manager::get_pass_for_id (int id
) const
751 if (id
>= passes_by_id_size
)
753 return passes_by_id
[id
];
756 /* Iterate over the pass tree allocating dump file numbers. We want
757 to do this depth first, and independent of whether the pass is
761 register_one_dump_file (opt_pass
*pass
)
763 g
->get_passes ()->register_one_dump_file (pass
);
767 pass_manager::register_one_dump_file (opt_pass
*pass
)
769 char *dot_name
, *flag_name
, *glob_name
;
770 const char *name
, *full_name
, *prefix
;
773 int optgroup_flags
= OPTGROUP_NONE
;
774 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
776 /* See below in next_pass_1. */
778 if (pass
->static_pass_number
!= -1)
779 sprintf (num
, "%d", ((int) pass
->static_pass_number
< 0
780 ? 1 : pass
->static_pass_number
));
782 /* The name is both used to identify the pass for the purposes of plugins,
783 and to specify dump file name and option.
784 The latter two might want something short which is not quite unique; for
785 that reason, we may have a disambiguating prefix, followed by a space
786 to mark the start of the following dump file name / option string. */
787 name
= strchr (pass
->name
, ' ');
788 name
= name
? name
+ 1 : pass
->name
;
789 dot_name
= concat (".", name
, num
, NULL
);
790 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
794 optgroup_flags
|= OPTGROUP_IPA
;
796 else if (pass
->type
== GIMPLE_PASS
)
807 flag_name
= concat (prefix
, name
, num
, NULL
);
808 glob_name
= concat (prefix
, name
, NULL
);
809 optgroup_flags
|= pass
->optinfo_flags
;
810 /* For any passes that do not have an optgroup set, and which are not
811 IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
812 any dump messages are emitted properly under -fopt-info(-optall). */
813 if (optgroup_flags
== OPTGROUP_NONE
)
814 optgroup_flags
= OPTGROUP_OTHER
;
815 id
= dumps
->dump_register (dot_name
, flag_name
, glob_name
, flags
,
818 set_pass_for_id (id
, pass
);
819 full_name
= concat (prefix
, pass
->name
, num
, NULL
);
820 register_pass_name (pass
, full_name
);
821 free (CONST_CAST (char *, full_name
));
824 /* Register the dump files for the pass_manager starting at PASS. */
827 pass_manager::register_dump_files (opt_pass
*pass
)
831 if (pass
->name
&& pass
->name
[0] != '*')
832 register_one_dump_file (pass
);
835 register_dump_files (pass
->sub
);
842 static hash_map
<nofree_string_hash
, opt_pass
*> *name_to_pass_map
;
844 /* Register PASS with NAME. */
847 register_pass_name (opt_pass
*pass
, const char *name
)
849 if (!name_to_pass_map
)
850 name_to_pass_map
= new hash_map
<nofree_string_hash
, opt_pass
*> (256);
852 if (name_to_pass_map
->get (name
))
853 return; /* Ignore plugin passes. */
855 const char *unique_name
= xstrdup (name
);
856 name_to_pass_map
->put (unique_name
, pass
);
859 /* Map from pass id to canonicalized pass name. */
861 typedef const char *char_ptr
;
862 static vec
<char_ptr
> pass_tab
= vNULL
;
864 /* Callback function for traversing NAME_TO_PASS_MAP. */
867 passes_pass_traverse (const char *const &name
, opt_pass
*const &pass
, void *)
869 gcc_assert (pass
->static_pass_number
> 0);
870 gcc_assert (pass_tab
.exists ());
872 pass_tab
[pass
->static_pass_number
] = name
;
877 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
878 table for dumping purpose. */
881 create_pass_tab (void)
883 if (!flag_dump_passes
)
886 pass_tab
.safe_grow_cleared (g
->get_passes ()->passes_by_id_size
+ 1);
887 name_to_pass_map
->traverse
<void *, passes_pass_traverse
> (NULL
);
890 static bool override_gate_status (opt_pass
*, tree
, bool);
892 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
893 is turned on or not. */
896 dump_one_pass (opt_pass
*pass
, int pass_indent
)
898 int indent
= 3 * pass_indent
;
900 bool is_on
, is_really_on
;
902 is_on
= pass
->gate (cfun
);
903 is_really_on
= override_gate_status (pass
, current_function_decl
, is_on
);
905 if (pass
->static_pass_number
<= 0)
908 pn
= pass_tab
[pass
->static_pass_number
];
910 fprintf (stderr
, "%*s%-40s%*s:%s%s\n", indent
, " ", pn
,
911 (15 - indent
< 0 ? 0 : 15 - indent
), " ",
912 is_on
? " ON" : " OFF",
913 ((!is_on
) == (!is_really_on
) ? ""
914 : (is_really_on
? " (FORCED_ON)" : " (FORCED_OFF)")));
917 /* Dump pass list PASS with indentation INDENT. */
920 dump_pass_list (opt_pass
*pass
, int indent
)
924 dump_one_pass (pass
, indent
);
926 dump_pass_list (pass
->sub
, indent
+ 1);
932 /* Dump all optimization passes. */
937 g
->get_passes ()->dump_passes ();
941 pass_manager::dump_passes () const
943 push_dummy_function (true);
947 dump_pass_list (all_lowering_passes
, 1);
948 dump_pass_list (all_small_ipa_passes
, 1);
949 dump_pass_list (all_regular_ipa_passes
, 1);
950 dump_pass_list (all_late_ipa_passes
, 1);
951 dump_pass_list (all_passes
, 1);
953 pop_dummy_function ();
956 /* Returns the pass with NAME. */
959 get_pass_by_name (const char *name
)
961 opt_pass
**p
= name_to_pass_map
->get (name
);
969 /* Range [start, last]. */
975 const char *assem_name
;
976 struct uid_range
*next
;
979 typedef struct uid_range
*uid_range_p
;
982 static vec
<uid_range_p
>
983 enabled_pass_uid_range_tab
= vNULL
;
984 static vec
<uid_range_p
>
985 disabled_pass_uid_range_tab
= vNULL
;
988 /* Parse option string for -fdisable- and -fenable-
989 The syntax of the options:
992 -fdisable-<pass_name>
994 -fenable-<pass_name>=s1:e1,s2:e2,...
995 -fdisable-<pass_name>=s1:e1,s2:e2,...
999 enable_disable_pass (const char *arg
, bool is_enable
)
1002 char *range_str
, *phase_name
;
1003 char *argstr
= xstrdup (arg
);
1004 vec
<uid_range_p
> *tab
= 0;
1006 range_str
= strchr (argstr
,'=');
1013 phase_name
= argstr
;
1017 error ("unrecognized option -fenable");
1019 error ("unrecognized option -fdisable");
1023 pass
= get_pass_by_name (phase_name
);
1024 if (!pass
|| pass
->static_pass_number
== -1)
1027 error ("unknown pass %s specified in -fenable", phase_name
);
1029 error ("unknown pass %s specified in -fdisable", phase_name
);
1035 tab
= &enabled_pass_uid_range_tab
;
1037 tab
= &disabled_pass_uid_range_tab
;
1039 if ((unsigned) pass
->static_pass_number
>= tab
->length ())
1040 tab
->safe_grow_cleared (pass
->static_pass_number
+ 1);
1045 uid_range_p new_range
= XCNEW (struct uid_range
);
1047 new_range
->start
= 0;
1048 new_range
->last
= (unsigned)-1;
1050 slot
= (*tab
)[pass
->static_pass_number
];
1051 new_range
->next
= slot
;
1052 (*tab
)[pass
->static_pass_number
] = new_range
;
1054 inform (UNKNOWN_LOCATION
, "enable pass %s for functions in the range "
1055 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1057 inform (UNKNOWN_LOCATION
, "disable pass %s for functions in the range "
1058 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1062 char *next_range
= NULL
;
1063 char *one_range
= range_str
;
1064 char *end_val
= NULL
;
1069 uid_range_p new_range
;
1070 char *invalid
= NULL
;
1072 char *func_name
= NULL
;
1074 next_range
= strchr (one_range
, ',');
1081 end_val
= strchr (one_range
, ':');
1087 start
= strtol (one_range
, &invalid
, 10);
1088 if (*invalid
|| start
< 0)
1090 if (end_val
|| (one_range
[0] >= '0'
1091 && one_range
[0] <= '9'))
1093 error ("Invalid range %s in option %s",
1095 is_enable
? "-fenable" : "-fdisable");
1099 func_name
= one_range
;
1103 new_range
= XCNEW (struct uid_range
);
1106 new_range
->start
= (unsigned) start
;
1107 new_range
->last
= (unsigned) start
;
1111 new_range
->start
= (unsigned) -1;
1112 new_range
->last
= (unsigned) -1;
1113 new_range
->assem_name
= xstrdup (func_name
);
1118 long last
= strtol (end_val
, &invalid
, 10);
1119 if (*invalid
|| last
< start
)
1121 error ("Invalid range %s in option %s",
1123 is_enable
? "-fenable" : "-fdisable");
1127 new_range
= XCNEW (struct uid_range
);
1128 new_range
->start
= (unsigned) start
;
1129 new_range
->last
= (unsigned) last
;
1132 slot
= (*tab
)[pass
->static_pass_number
];
1133 new_range
->next
= slot
;
1134 (*tab
)[pass
->static_pass_number
] = new_range
;
1137 if (new_range
->assem_name
)
1138 inform (UNKNOWN_LOCATION
,
1139 "enable pass %s for function %s",
1140 phase_name
, new_range
->assem_name
);
1142 inform (UNKNOWN_LOCATION
,
1143 "enable pass %s for functions in the range of [%u, %u]",
1144 phase_name
, new_range
->start
, new_range
->last
);
1148 if (new_range
->assem_name
)
1149 inform (UNKNOWN_LOCATION
,
1150 "disable pass %s for function %s",
1151 phase_name
, new_range
->assem_name
);
1153 inform (UNKNOWN_LOCATION
,
1154 "disable pass %s for functions in the range of [%u, %u]",
1155 phase_name
, new_range
->start
, new_range
->last
);
1158 one_range
= next_range
;
1159 } while (next_range
);
1165 /* Enable pass specified by ARG. */
1168 enable_pass (const char *arg
)
1170 enable_disable_pass (arg
, true);
1173 /* Disable pass specified by ARG. */
1176 disable_pass (const char *arg
)
1178 enable_disable_pass (arg
, false);
1181 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1184 is_pass_explicitly_enabled_or_disabled (opt_pass
*pass
,
1186 vec
<uid_range_p
> tab
)
1188 uid_range_p slot
, range
;
1190 const char *aname
= NULL
;
1193 || (unsigned) pass
->static_pass_number
>= tab
.length ()
1194 || pass
->static_pass_number
== -1)
1197 slot
= tab
[pass
->static_pass_number
];
1201 cgraph_uid
= func
? cgraph_node::get (func
)->uid
: 0;
1202 if (func
&& DECL_ASSEMBLER_NAME_SET_P (func
))
1203 aname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func
));
1208 if ((unsigned) cgraph_uid
>= range
->start
1209 && (unsigned) cgraph_uid
<= range
->last
)
1211 if (range
->assem_name
&& aname
1212 && !strcmp (range
->assem_name
, aname
))
1214 range
= range
->next
;
1221 /* Update static_pass_number for passes (and the flag
1222 TODO_mark_first_instance).
1224 Passes are constructed with static_pass_number preinitialized to 0
1226 This field is used in two different ways: initially as instance numbers
1227 of their kind, and then as ids within the entire pass manager.
1229 Within pass_manager::pass_manager:
1231 * In add_pass_instance(), as called by next_pass_1 in
1232 NEXT_PASS in init_optimization_passes
1234 * When the initial instance of a pass within a pass manager is seen,
1235 it is flagged, and its static_pass_number is set to -1
1237 * On subsequent times that it is seen, the static pass number
1238 is decremented each time, so that if there are e.g. 4 dups,
1239 they have static_pass_number -4, 2, 3, 4 respectively (note
1240 how the initial one is negative and gives the count); these
1241 can be thought of as instance numbers of the specific pass
1243 * Within the register_dump_files () traversal, set_pass_for_id()
1244 is called on each pass, using these instance numbers to create
1245 dumpfile switches, and then overwriting them with a pass id,
1246 which are global to the whole pass manager (based on
1247 (TDI_end + current value of extra_dump_files_in_use) ) */
1250 add_pass_instance (opt_pass
*new_pass
, bool track_duplicates
,
1251 opt_pass
*initial_pass
)
1253 /* Are we dealing with the first pass of its kind, or a clone? */
1254 if (new_pass
!= initial_pass
)
1256 /* We're dealing with a clone. */
1257 new_pass
->todo_flags_start
&= ~TODO_mark_first_instance
;
1259 /* Indicate to register_dump_files that this pass has duplicates,
1260 and so it should rename the dump file. The first instance will
1261 be -1, and be number of duplicates = -static_pass_number - 1.
1262 Subsequent instances will be > 0 and just the duplicate number. */
1263 if ((new_pass
->name
&& new_pass
->name
[0] != '*') || track_duplicates
)
1265 initial_pass
->static_pass_number
-= 1;
1266 new_pass
->static_pass_number
= -initial_pass
->static_pass_number
;
1271 /* We're dealing with the first pass of its kind. */
1272 new_pass
->todo_flags_start
|= TODO_mark_first_instance
;
1273 new_pass
->static_pass_number
= -1;
1275 invoke_plugin_callbacks (PLUGIN_NEW_PASS
, new_pass
);
1279 /* Add a pass to the pass list. Duplicate the pass if it's already
1283 next_pass_1 (opt_pass
**list
, opt_pass
*pass
, opt_pass
*initial_pass
)
1285 /* Every pass should have a name so that plugins can refer to them. */
1286 gcc_assert (pass
->name
!= NULL
);
1288 add_pass_instance (pass
, false, initial_pass
);
1291 return &(*list
)->next
;
1294 /* List node for an inserted pass instance. We need to keep track of all
1295 the newly-added pass instances (with 'added_pass_nodes' defined below)
1296 so that we can register their dump files after pass-positioning is finished.
1297 Registering dumping files needs to be post-processed or the
1298 static_pass_number of the opt_pass object would be modified and mess up
1299 the dump file names of future pass instances to be added. */
1301 struct pass_list_node
1304 struct pass_list_node
*next
;
1307 static struct pass_list_node
*added_pass_nodes
= NULL
;
1308 static struct pass_list_node
*prev_added_pass_node
;
1310 /* Insert the pass at the proper position. Return true if the pass
1311 is successfully added.
1313 NEW_PASS_INFO - new pass to be inserted
1314 PASS_LIST - root of the pass list to insert the new pass to */
1317 position_pass (struct register_pass_info
*new_pass_info
, opt_pass
**pass_list
)
1319 opt_pass
*pass
= *pass_list
, *prev_pass
= NULL
;
1320 bool success
= false;
1322 for ( ; pass
; prev_pass
= pass
, pass
= pass
->next
)
1324 /* Check if the current pass is of the same type as the new pass and
1325 matches the name and the instance number of the reference pass. */
1326 if (pass
->type
== new_pass_info
->pass
->type
1328 && !strcmp (pass
->name
, new_pass_info
->reference_pass_name
)
1329 && ((new_pass_info
->ref_pass_instance_number
== 0)
1330 || (new_pass_info
->ref_pass_instance_number
==
1331 pass
->static_pass_number
)
1332 || (new_pass_info
->ref_pass_instance_number
== 1
1333 && pass
->todo_flags_start
& TODO_mark_first_instance
)))
1336 struct pass_list_node
*new_pass_node
;
1338 if (new_pass_info
->ref_pass_instance_number
== 0)
1340 new_pass
= new_pass_info
->pass
->clone ();
1341 add_pass_instance (new_pass
, true, new_pass_info
->pass
);
1345 new_pass
= new_pass_info
->pass
;
1346 add_pass_instance (new_pass
, true, new_pass
);
1349 /* Insert the new pass instance based on the positioning op. */
1350 switch (new_pass_info
->pos_op
)
1352 case PASS_POS_INSERT_AFTER
:
1353 new_pass
->next
= pass
->next
;
1354 pass
->next
= new_pass
;
1356 /* Skip newly inserted pass to avoid repeated
1357 insertions in the case where the new pass and the
1358 existing one have the same name. */
1361 case PASS_POS_INSERT_BEFORE
:
1362 new_pass
->next
= pass
;
1364 prev_pass
->next
= new_pass
;
1366 *pass_list
= new_pass
;
1368 case PASS_POS_REPLACE
:
1369 new_pass
->next
= pass
->next
;
1371 prev_pass
->next
= new_pass
;
1373 *pass_list
= new_pass
;
1374 new_pass
->sub
= pass
->sub
;
1375 new_pass
->tv_id
= pass
->tv_id
;
1379 error ("invalid pass positioning operation");
1383 /* Save the newly added pass (instance) in the added_pass_nodes
1384 list so that we can register its dump file later. Note that
1385 we cannot register the dump file now because doing so will modify
1386 the static_pass_number of the opt_pass object and therefore
1387 mess up the dump file name of future instances. */
1388 new_pass_node
= XCNEW (struct pass_list_node
);
1389 new_pass_node
->pass
= new_pass
;
1390 if (!added_pass_nodes
)
1391 added_pass_nodes
= new_pass_node
;
1393 prev_added_pass_node
->next
= new_pass_node
;
1394 prev_added_pass_node
= new_pass_node
;
1399 if (pass
->sub
&& position_pass (new_pass_info
, &pass
->sub
))
1406 /* Hooks a new pass into the pass lists.
1408 PASS_INFO - pass information that specifies the opt_pass object,
1409 reference pass, instance number, and how to position
1413 register_pass (struct register_pass_info
*pass_info
)
1415 g
->get_passes ()->register_pass (pass_info
);
1419 register_pass (opt_pass
* pass
, pass_positioning_ops pos
,
1420 const char* ref_pass_name
, int ref_pass_inst_number
)
1422 register_pass_info i
;
1424 i
.reference_pass_name
= ref_pass_name
;
1425 i
.ref_pass_instance_number
= ref_pass_inst_number
;
1428 g
->get_passes ()->register_pass (&i
);
1432 pass_manager::register_pass (struct register_pass_info
*pass_info
)
1434 bool all_instances
, success
;
1435 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
1437 /* The checks below could fail in buggy plugins. Existing GCC
1438 passes should never fail these checks, so we mention plugin in
1440 if (!pass_info
->pass
)
1441 fatal_error (input_location
, "plugin cannot register a missing pass");
1443 if (!pass_info
->pass
->name
)
1444 fatal_error (input_location
, "plugin cannot register an unnamed pass");
1446 if (!pass_info
->reference_pass_name
)
1449 "plugin cannot register pass %qs without reference pass name",
1450 pass_info
->pass
->name
);
1452 /* Try to insert the new pass to the pass lists. We need to check
1453 all five lists as the reference pass could be in one (or all) of
1455 all_instances
= pass_info
->ref_pass_instance_number
== 0;
1456 success
= position_pass (pass_info
, &all_lowering_passes
);
1457 if (!success
|| all_instances
)
1458 success
|= position_pass (pass_info
, &all_small_ipa_passes
);
1459 if (!success
|| all_instances
)
1460 success
|= position_pass (pass_info
, &all_regular_ipa_passes
);
1461 if (!success
|| all_instances
)
1462 success
|= position_pass (pass_info
, &all_late_ipa_passes
);
1463 if (!success
|| all_instances
)
1464 success
|= position_pass (pass_info
, &all_passes
);
1468 "pass %qs not found but is referenced by new pass %qs",
1469 pass_info
->reference_pass_name
, pass_info
->pass
->name
);
1471 /* OK, we have successfully inserted the new pass. We need to register
1472 the dump files for the newly added pass and its duplicates (if any).
1473 Because the registration of plugin/backend passes happens after the
1474 command-line options are parsed, the options that specify single
1475 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1476 passes. Therefore we currently can only enable dumping of
1477 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1478 are specified. While doing so, we also delete the pass_list_node
1479 objects created during pass positioning. */
1480 while (added_pass_nodes
)
1482 struct pass_list_node
*next_node
= added_pass_nodes
->next
;
1483 enum tree_dump_index tdi
;
1484 register_one_dump_file (added_pass_nodes
->pass
);
1485 if (added_pass_nodes
->pass
->type
== SIMPLE_IPA_PASS
1486 || added_pass_nodes
->pass
->type
== IPA_PASS
)
1488 else if (added_pass_nodes
->pass
->type
== GIMPLE_PASS
)
1492 /* Check if dump-all flag is specified. */
1493 if (dumps
->get_dump_file_info (tdi
)->pstate
)
1494 dumps
->get_dump_file_info (added_pass_nodes
->pass
->static_pass_number
)
1495 ->pstate
= dumps
->get_dump_file_info (tdi
)->pstate
;
1496 XDELETE (added_pass_nodes
);
1497 added_pass_nodes
= next_node
;
1501 /* Construct the pass tree. The sequencing of passes is driven by
1502 the cgraph routines:
1504 finalize_compilation_unit ()
1505 for each node N in the cgraph
1506 cgraph_analyze_function (N)
1507 cgraph_lower_function (N) -> all_lowering_passes
1509 If we are optimizing, compile is then invoked:
1512 ipa_passes () -> all_small_ipa_passes
1513 -> Analysis of all_regular_ipa_passes
1514 * possible LTO streaming at copmilation time *
1515 -> Execution of all_regular_ipa_passes
1516 * possible LTO streaming at link time *
1517 -> all_late_ipa_passes
1518 expand_all_functions ()
1519 for each node N in the cgraph
1520 expand_function (N) -> Transformation of all_regular_ipa_passes
1525 pass_manager::operator new (size_t sz
)
1527 /* Ensure that all fields of the pass manager are zero-initialized. */
1528 return xcalloc (1, sz
);
1532 pass_manager::operator delete (void *ptr
)
1537 pass_manager::pass_manager (context
*ctxt
)
1538 : all_passes (NULL
), all_small_ipa_passes (NULL
), all_lowering_passes (NULL
),
1539 all_regular_ipa_passes (NULL
),
1540 all_late_ipa_passes (NULL
), passes_by_id (NULL
), passes_by_id_size (0),
1545 /* Initialize the pass_lists array. */
1546 #define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1548 #undef DEF_PASS_LIST
1550 /* Build the tree of passes. */
1552 #define INSERT_PASSES_AFTER(PASS) \
1555 #define PUSH_INSERT_PASSES_WITHIN(PASS) \
1557 opt_pass **p = &(PASS ## _1)->sub;
1559 #define POP_INSERT_PASSES() \
1562 #define NEXT_PASS(PASS, NUM) \
1564 gcc_assert (NULL == PASS ## _ ## NUM); \
1566 PASS ## _1 = make_##PASS (m_ctxt); \
1569 gcc_assert (PASS ## _1); \
1570 PASS ## _ ## NUM = PASS ## _1->clone (); \
1572 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1575 #define TERMINATE_PASS_LIST() \
1578 #include "pass-instances.def"
1580 #undef INSERT_PASSES_AFTER
1581 #undef PUSH_INSERT_PASSES_WITHIN
1582 #undef POP_INSERT_PASSES
1584 #undef TERMINATE_PASS_LIST
1586 /* Register the passes with the tree dump code. */
1587 register_dump_files (all_lowering_passes
);
1588 register_dump_files (all_small_ipa_passes
);
1589 register_dump_files (all_regular_ipa_passes
);
1590 register_dump_files (all_late_ipa_passes
);
1591 register_dump_files (all_passes
);
1595 delete_pass_tree (opt_pass
*pass
)
1599 /* Recurse into child passes. */
1600 delete_pass_tree (pass
->sub
);
1602 opt_pass
*next
= pass
->next
;
1604 /* Delete this pass. */
1607 /* Iterate onto sibling passes. */
1612 pass_manager::~pass_manager ()
1614 XDELETEVEC (passes_by_id
);
1616 /* Call delete_pass_tree on each of the pass_lists. */
1617 #define DEF_PASS_LIST(LIST) \
1618 delete_pass_tree (*pass_lists[PASS_LIST_NO_##LIST]);
1620 #undef DEF_PASS_LIST
1624 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1625 function CALLBACK for every function in the call graph. Otherwise,
1626 call CALLBACK on the current function. */
1629 do_per_function (void (*callback
) (function
*, void *data
), void *data
)
1631 if (current_function_decl
)
1632 callback (cfun
, data
);
1635 struct cgraph_node
*node
;
1636 FOR_EACH_DEFINED_FUNCTION (node
)
1637 if (node
->analyzed
&& (gimple_has_body_p (node
->decl
) && !in_lto_p
)
1638 && (!node
->clone_of
|| node
->decl
!= node
->clone_of
->decl
))
1639 callback (DECL_STRUCT_FUNCTION (node
->decl
), data
);
1643 /* Because inlining might remove no-longer reachable nodes, we need to
1644 keep the array visible to garbage collector to avoid reading collected
1647 static GTY ((length ("nnodes"))) cgraph_node
**order
;
1649 /* Hook called when NODE is removed and therefore should be
1650 excluded from order vector. DATA is an array of integers.
1651 DATA[0] holds max index it may be accessed by. For cgraph
1652 node DATA[node->uid + 1] holds index of this node in order
1655 remove_cgraph_node_from_order (cgraph_node
*node
, void *data
)
1657 int *order_idx
= (int *)data
;
1659 if (node
->uid
>= order_idx
[0])
1662 int idx
= order_idx
[node
->uid
+ 1];
1663 if (idx
>= 0 && idx
< nnodes
&& order
[idx
] == node
)
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
;
1682 gcc_assert (!order
);
1683 order
= ggc_vec_alloc
<cgraph_node
*> (symtab
->cgraph_count
);
1685 order_idx
= XALLOCAVEC (int, symtab
->cgraph_max_uid
+ 1);
1686 memset (order_idx
+ 1, -1, sizeof (int) * symtab
->cgraph_max_uid
);
1687 order_idx
[0] = symtab
->cgraph_max_uid
;
1689 nnodes
= ipa_reverse_postorder (order
);
1690 for (i
= nnodes
- 1; i
>= 0; i
--)
1692 order
[i
]->process
= 1;
1693 order_idx
[order
[i
]->uid
+ 1] = i
;
1695 hook
= symtab
->add_cgraph_removal_hook (remove_cgraph_node_from_order
,
1697 for (i
= nnodes
- 1; i
>= 0; i
--)
1699 /* Function could be inlined and removed as unreachable. */
1703 struct cgraph_node
*node
= order
[i
];
1705 /* Allow possibly removed nodes to be garbage collected. */
1708 if (node
->has_gimple_body_p ())
1710 struct function
*fn
= DECL_STRUCT_FUNCTION (node
->decl
);
1712 callback (fn
, data
);
1716 symtab
->remove_cgraph_removal_hook (hook
);
1723 /* Helper function to perform function body dump. */
1726 execute_function_dump (function
*fn
, void *data
)
1728 opt_pass
*pass
= (opt_pass
*)data
;
1734 if (fn
->curr_properties
& PROP_trees
)
1735 dump_function_to_file (fn
->decl
, dump_file
, dump_flags
);
1737 print_rtl_with_bb (dump_file
, get_insns (), dump_flags
);
1739 /* Flush the file. If verification fails, we won't be able to
1740 close the file before aborting. */
1743 if ((fn
->curr_properties
& PROP_cfg
)
1744 && (dump_flags
& TDF_GRAPH
))
1746 if (!pass
->graph_dump_initialized
)
1748 clean_graph_dump_file (dump_file_name
);
1749 pass
->graph_dump_initialized
= true;
1751 print_graph_cfg (dump_file_name
, fn
);
1758 static struct profile_record
*profile_record
;
1760 /* Do profile consistency book-keeping for the pass with static number INDEX.
1761 If SUBPASS is zero, we run _before_ the pass, and if SUBPASS is one, then
1762 we run _after_ the pass. RUN is true if the pass really runs, or FALSE
1763 if we are only book-keeping on passes that may have selectively disabled
1764 themselves on a given function. */
1766 check_profile_consistency (int index
, int subpass
, bool run
)
1768 pass_manager
*passes
= g
->get_passes ();
1771 if (!profile_record
)
1772 profile_record
= XCNEWVEC (struct profile_record
,
1773 passes
->passes_by_id_size
);
1774 gcc_assert (index
< passes
->passes_by_id_size
&& index
>= 0);
1775 gcc_assert (subpass
< 2);
1776 profile_record
[index
].run
|= run
;
1777 account_profile_record (&profile_record
[index
], subpass
);
1780 /* Output profile consistency. */
1783 dump_profile_report (void)
1785 g
->get_passes ()->dump_profile_report ();
1789 pass_manager::dump_profile_report () const
1792 int last_freq_in
= 0, last_count_in
= 0, last_freq_out
= 0, last_count_out
= 0;
1793 gcov_type last_time
= 0, last_size
= 0;
1794 double rel_time_change
, rel_size_change
;
1795 int last_reported
= 0;
1797 if (!profile_record
)
1799 fprintf (stderr
, "\nProfile consistency report:\n\n");
1800 fprintf (stderr
, "Pass name |mismatch in |mismated out|Overall\n");
1801 fprintf (stderr
, " |freq count |freq count |size time\n");
1803 for (i
= 0; i
< passes_by_id_size
; i
++)
1804 for (j
= 0 ; j
< 2; j
++)
1805 if (profile_record
[i
].run
)
1808 rel_time_change
= (profile_record
[i
].time
[j
]
1809 - (double)last_time
) * 100 / (double)last_time
;
1811 rel_time_change
= 0;
1813 rel_size_change
= (profile_record
[i
].size
[j
]
1814 - (double)last_size
) * 100 / (double)last_size
;
1816 rel_size_change
= 0;
1818 if (profile_record
[i
].num_mismatched_freq_in
[j
] != last_freq_in
1819 || profile_record
[i
].num_mismatched_freq_out
[j
] != last_freq_out
1820 || profile_record
[i
].num_mismatched_count_in
[j
] != last_count_in
1821 || profile_record
[i
].num_mismatched_count_out
[j
] != last_count_out
1822 || rel_time_change
|| rel_size_change
)
1825 fprintf (stderr
, "%-20s %s",
1826 passes_by_id
[i
]->name
,
1827 j
? "(after TODO)" : " ");
1828 if (profile_record
[i
].num_mismatched_freq_in
[j
] != last_freq_in
)
1829 fprintf (stderr
, "| %+5i",
1830 profile_record
[i
].num_mismatched_freq_in
[j
]
1833 fprintf (stderr
, "| ");
1834 if (profile_record
[i
].num_mismatched_count_in
[j
] != last_count_in
)
1835 fprintf (stderr
, " %+5i",
1836 profile_record
[i
].num_mismatched_count_in
[j
]
1839 fprintf (stderr
, " ");
1840 if (profile_record
[i
].num_mismatched_freq_out
[j
] != last_freq_out
)
1841 fprintf (stderr
, "| %+5i",
1842 profile_record
[i
].num_mismatched_freq_out
[j
]
1845 fprintf (stderr
, "| ");
1846 if (profile_record
[i
].num_mismatched_count_out
[j
] != last_count_out
)
1847 fprintf (stderr
, " %+5i",
1848 profile_record
[i
].num_mismatched_count_out
[j
]
1851 fprintf (stderr
, " ");
1853 /* Size/time units change across gimple and RTL. */
1854 if (i
== pass_expand_1
->static_pass_number
)
1855 fprintf (stderr
, "|----------");
1858 if (rel_size_change
)
1859 fprintf (stderr
, "| %+8.4f%%", rel_size_change
);
1861 fprintf (stderr
, "| ");
1862 if (rel_time_change
)
1863 fprintf (stderr
, " %+8.4f%%", rel_time_change
);
1865 fprintf (stderr
, "\n");
1866 last_freq_in
= profile_record
[i
].num_mismatched_freq_in
[j
];
1867 last_freq_out
= profile_record
[i
].num_mismatched_freq_out
[j
];
1868 last_count_in
= profile_record
[i
].num_mismatched_count_in
[j
];
1869 last_count_out
= profile_record
[i
].num_mismatched_count_out
[j
];
1871 else if (j
&& last_reported
!= i
)
1874 fprintf (stderr
, "%-20s ------------| | |\n",
1875 passes_by_id
[i
]->name
);
1877 last_time
= profile_record
[i
].time
[j
];
1878 last_size
= profile_record
[i
].size
[j
];
1882 /* Perform all TODO actions that ought to be done on each function. */
1885 execute_function_todo (function
*fn
, void *data
)
1887 bool from_ipa_pass
= (cfun
== NULL
);
1888 unsigned int flags
= (size_t)data
;
1889 flags
&= ~fn
->last_verified
;
1895 /* Always cleanup the CFG before trying to update SSA. */
1896 if (flags
& TODO_cleanup_cfg
)
1898 cleanup_tree_cfg ();
1900 /* When cleanup_tree_cfg merges consecutive blocks, it may
1901 perform some simplistic propagation when removing single
1902 valued PHI nodes. This propagation may, in turn, cause the
1903 SSA form to become out-of-date (see PR 22037). So, even
1904 if the parent pass had not scheduled an SSA update, we may
1905 still need to do one. */
1906 if (!(flags
& TODO_update_ssa_any
) && need_ssa_update_p (cfun
))
1907 flags
|= TODO_update_ssa
;
1910 if (flags
& TODO_update_ssa_any
)
1912 unsigned update_flags
= flags
& TODO_update_ssa_any
;
1913 update_ssa (update_flags
);
1916 if (flag_tree_pta
&& (flags
& TODO_rebuild_alias
))
1917 compute_may_aliases ();
1919 if (optimize
&& (flags
& TODO_update_address_taken
))
1920 execute_update_addresses_taken ();
1922 if (flags
& TODO_remove_unused_locals
)
1923 remove_unused_locals ();
1925 if (flags
& TODO_rebuild_frequencies
)
1926 rebuild_frequencies ();
1928 if (flags
& TODO_rebuild_cgraph_edges
)
1929 cgraph_edge::rebuild_edges ();
1931 gcc_assert (dom_info_state (fn
, CDI_POST_DOMINATORS
) == DOM_NONE
);
1932 /* If we've seen errors do not bother running any verifiers. */
1933 if (flag_checking
&& !seen_error ())
1935 dom_state pre_verify_state
= dom_info_state (fn
, CDI_DOMINATORS
);
1936 dom_state pre_verify_pstate
= dom_info_state (fn
, CDI_POST_DOMINATORS
);
1938 if (flags
& TODO_verify_il
)
1940 if (cfun
->curr_properties
& PROP_trees
)
1942 if (cfun
->curr_properties
& PROP_cfg
)
1943 /* IPA passes leave stmts to be fixed up, so make sure to
1944 not verify stmts really throw. */
1945 verify_gimple_in_cfg (cfun
, !from_ipa_pass
);
1947 verify_gimple_in_seq (gimple_body (cfun
->decl
));
1949 if (cfun
->curr_properties
& PROP_ssa
)
1950 /* IPA passes leave stmts to be fixed up, so make sure to
1951 not verify SSA operands whose verifier will choke on that. */
1952 verify_ssa (true, !from_ipa_pass
);
1953 /* IPA passes leave basic-blocks unsplit, so make sure to
1954 not trip on that. */
1955 if ((cfun
->curr_properties
& PROP_cfg
)
1957 verify_flow_info ();
1959 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1960 verify_loop_closed_ssa (false);
1961 if (cfun
->curr_properties
& PROP_rtl
)
1962 verify_rtl_sharing ();
1965 /* Make sure verifiers don't change dominator state. */
1966 gcc_assert (dom_info_state (fn
, CDI_DOMINATORS
) == pre_verify_state
);
1967 gcc_assert (dom_info_state (fn
, CDI_POST_DOMINATORS
) == pre_verify_pstate
);
1970 fn
->last_verified
= flags
& TODO_verify_all
;
1974 /* For IPA passes make sure to release dominator info, it can be
1975 computed by non-verifying TODOs. */
1978 free_dominance_info (fn
, CDI_DOMINATORS
);
1979 free_dominance_info (fn
, CDI_POST_DOMINATORS
);
1983 /* Perform all TODO actions. */
1985 execute_todo (unsigned int flags
)
1989 && need_ssa_update_p (cfun
))
1990 gcc_assert (flags
& TODO_update_ssa_any
);
1992 timevar_push (TV_TODO
);
1994 /* Inform the pass whether it is the first time it is run. */
1995 first_pass_instance
= (flags
& TODO_mark_first_instance
) != 0;
1997 statistics_fini_pass ();
2000 do_per_function (execute_function_todo
, (void *)(size_t) flags
);
2002 /* At this point we should not have any unreachable code in the
2003 CFG, so it is safe to flush the pending freelist for SSA_NAMES. */
2004 if (cfun
&& cfun
->gimple_df
)
2005 flush_ssaname_freelist ();
2007 /* Always remove functions just as before inlining: IPA passes might be
2008 interested to see bodies of extern inline functions that are not inlined
2009 to analyze side effects. The full removal is done just at the end
2010 of IPA pass queue. */
2011 if (flags
& TODO_remove_functions
)
2014 symtab
->remove_unreachable_nodes (dump_file
);
2017 if ((flags
& TODO_dump_symtab
) && dump_file
&& !current_function_decl
)
2020 symtab_node::dump_table (dump_file
);
2021 /* Flush the file. If verification fails, we won't be able to
2022 close the file before aborting. */
2026 /* Now that the dumping has been done, we can get rid of the optional
2028 if (flags
& TODO_df_finish
)
2029 df_finish_pass ((flags
& TODO_df_verify
) != 0);
2031 timevar_pop (TV_TODO
);
2034 /* Verify invariants that should hold between passes. This is a place
2035 to put simple sanity checks. */
2038 verify_interpass_invariants (void)
2040 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2043 /* Clear the last verified flag. */
2046 clear_last_verified (function
*fn
, void *data ATTRIBUTE_UNUSED
)
2048 fn
->last_verified
= 0;
2051 /* Helper function. Verify that the properties has been turn into the
2052 properties expected by the pass. */
2055 verify_curr_properties (function
*fn
, void *data
)
2057 unsigned int props
= (size_t)data
;
2058 gcc_assert ((fn
->curr_properties
& props
) == props
);
2061 /* Release dump file name if set. */
2064 release_dump_file_name (void)
2068 free (CONST_CAST (char *, dump_file_name
));
2069 dump_file_name
= NULL
;
2073 /* Initialize pass dump file. */
2074 /* This is non-static so that the plugins can use it. */
2077 pass_init_dump_file (opt_pass
*pass
)
2079 /* If a dump file name is present, open it if enabled. */
2080 if (pass
->static_pass_number
!= -1)
2082 timevar_push (TV_DUMP
);
2083 gcc::dump_manager
*dumps
= g
->get_dumps ();
2084 bool initializing_dump
=
2085 !dumps
->dump_initialized_p (pass
->static_pass_number
);
2086 release_dump_file_name ();
2087 dump_file_name
= dumps
->get_dump_file_name (pass
->static_pass_number
);
2088 dumps
->dump_start (pass
->static_pass_number
, &dump_flags
);
2089 if (dump_file
&& current_function_decl
)
2090 dump_function_header (dump_file
, current_function_decl
, dump_flags
);
2091 if (initializing_dump
2092 && dump_file
&& (dump_flags
& TDF_GRAPH
)
2093 && cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2095 clean_graph_dump_file (dump_file_name
);
2096 pass
->graph_dump_initialized
= true;
2098 timevar_pop (TV_DUMP
);
2099 return initializing_dump
;
2105 /* Flush PASS dump file. */
2106 /* This is non-static so that plugins can use it. */
2109 pass_fini_dump_file (opt_pass
*pass
)
2111 timevar_push (TV_DUMP
);
2113 /* Flush and close dump file. */
2114 release_dump_file_name ();
2116 g
->get_dumps ()->dump_finish (pass
->static_pass_number
);
2117 timevar_pop (TV_DUMP
);
2120 /* After executing the pass, apply expected changes to the function
2124 update_properties_after_pass (function
*fn
, void *data
)
2126 opt_pass
*pass
= (opt_pass
*) data
;
2127 fn
->curr_properties
= (fn
->curr_properties
| pass
->properties_provided
)
2128 & ~pass
->properties_destroyed
;
2131 /* Execute summary generation for all of the passes in IPA_PASS. */
2134 execute_ipa_summary_passes (ipa_opt_pass_d
*ipa_pass
)
2138 opt_pass
*pass
= ipa_pass
;
2140 /* Execute all of the IPA_PASSes in the list. */
2141 if (ipa_pass
->type
== IPA_PASS
2142 && pass
->gate (cfun
)
2143 && ipa_pass
->generate_summary
)
2145 pass_init_dump_file (pass
);
2147 /* If a timevar is present, start it. */
2149 timevar_push (pass
->tv_id
);
2151 current_pass
= pass
;
2152 ipa_pass
->generate_summary ();
2156 timevar_pop (pass
->tv_id
);
2158 pass_fini_dump_file (pass
);
2160 ipa_pass
= (ipa_opt_pass_d
*)ipa_pass
->next
;
2164 /* Execute IPA_PASS function transform on NODE. */
2167 execute_one_ipa_transform_pass (struct cgraph_node
*node
,
2168 ipa_opt_pass_d
*ipa_pass
)
2170 opt_pass
*pass
= ipa_pass
;
2171 unsigned int todo_after
= 0;
2173 current_pass
= pass
;
2174 if (!ipa_pass
->function_transform
)
2177 /* Note that the folders should only create gimple expressions.
2178 This is a hack until the new folder is ready. */
2179 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2181 pass_init_dump_file (pass
);
2183 /* Run pre-pass verification. */
2184 execute_todo (ipa_pass
->function_transform_todo_flags_start
);
2186 /* If a timevar is present, start it. */
2187 if (pass
->tv_id
!= TV_NONE
)
2188 timevar_push (pass
->tv_id
);
2191 todo_after
= ipa_pass
->function_transform (node
);
2194 if (pass
->tv_id
!= TV_NONE
)
2195 timevar_pop (pass
->tv_id
);
2197 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2198 check_profile_consistency (pass
->static_pass_number
, 0, true);
2200 /* Run post-pass cleanup and verification. */
2201 execute_todo (todo_after
);
2202 verify_interpass_invariants ();
2203 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2204 check_profile_consistency (pass
->static_pass_number
, 1, true);
2207 do_per_function (execute_function_dump
, NULL
);
2208 pass_fini_dump_file (pass
);
2210 current_pass
= NULL
;
2212 /* Signal this is a suitable GC collection point. */
2213 if (!(todo_after
& TODO_do_not_ggc_collect
))
2217 /* For the current function, execute all ipa transforms. */
2220 execute_all_ipa_transforms (void)
2222 struct cgraph_node
*node
;
2225 node
= cgraph_node::get (current_function_decl
);
2227 if (node
->ipa_transforms_to_apply
.exists ())
2231 for (i
= 0; i
< node
->ipa_transforms_to_apply
.length (); i
++)
2232 execute_one_ipa_transform_pass (node
, node
->ipa_transforms_to_apply
[i
]);
2233 node
->ipa_transforms_to_apply
.release ();
2237 /* Check if PASS is explicitly disabled or enabled and return
2238 the gate status. FUNC is the function to be processed, and
2239 GATE_STATUS is the gate status determined by pass manager by
2243 override_gate_status (opt_pass
*pass
, tree func
, bool gate_status
)
2245 bool explicitly_enabled
= false;
2246 bool explicitly_disabled
= false;
2249 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2250 enabled_pass_uid_range_tab
);
2252 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2253 disabled_pass_uid_range_tab
);
2255 gate_status
= !explicitly_disabled
&& (gate_status
|| explicitly_enabled
);
2264 execute_one_pass (opt_pass
*pass
)
2266 unsigned int todo_after
= 0;
2270 /* IPA passes are executed on whole program, so cfun should be NULL.
2271 Other passes need function context set. */
2272 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
2273 gcc_assert (!cfun
&& !current_function_decl
);
2275 gcc_assert (cfun
&& current_function_decl
);
2277 current_pass
= pass
;
2279 /* Check whether gate check should be avoided.
2280 User controls the value of the gate through the parameter "gate_status". */
2281 gate_status
= pass
->gate (cfun
);
2282 gate_status
= override_gate_status (pass
, current_function_decl
, gate_status
);
2284 /* Override gate with plugin. */
2285 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE
, &gate_status
);
2289 /* Run so passes selectively disabling themselves on a given function
2290 are not miscounted. */
2291 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2293 check_profile_consistency (pass
->static_pass_number
, 0, false);
2294 check_profile_consistency (pass
->static_pass_number
, 1, false);
2296 current_pass
= NULL
;
2300 /* Pass execution event trigger: useful to identify passes being
2302 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION
, pass
);
2304 if (!quiet_flag
&& !cfun
)
2305 fprintf (stderr
, " <%s>", pass
->name
? pass
->name
: "");
2307 /* Note that the folders should only create gimple expressions.
2308 This is a hack until the new folder is ready. */
2309 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2311 pass_init_dump_file (pass
);
2313 /* Run pre-pass verification. */
2314 execute_todo (pass
->todo_flags_start
);
2317 do_per_function (verify_curr_properties
,
2318 (void *)(size_t)pass
->properties_required
);
2320 /* If a timevar is present, start it. */
2321 if (pass
->tv_id
!= TV_NONE
)
2322 timevar_push (pass
->tv_id
);
2325 todo_after
= pass
->execute (cfun
);
2326 do_per_function (clear_last_verified
, NULL
);
2329 if (pass
->tv_id
!= TV_NONE
)
2330 timevar_pop (pass
->tv_id
);
2332 do_per_function (update_properties_after_pass
, pass
);
2334 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2335 check_profile_consistency (pass
->static_pass_number
, 0, true);
2337 /* Run post-pass cleanup and verification. */
2338 execute_todo (todo_after
| pass
->todo_flags_finish
| TODO_verify_il
);
2339 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2340 check_profile_consistency (pass
->static_pass_number
, 1, true);
2342 verify_interpass_invariants ();
2344 do_per_function (execute_function_dump
, pass
);
2345 if (pass
->type
== IPA_PASS
)
2347 struct cgraph_node
*node
;
2348 if (((ipa_opt_pass_d
*)pass
)->function_transform
)
2349 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
2350 node
->ipa_transforms_to_apply
.safe_push ((ipa_opt_pass_d
*)pass
);
2353 if (!current_function_decl
)
2354 symtab
->process_new_functions ();
2356 pass_fini_dump_file (pass
);
2358 if (pass
->type
!= SIMPLE_IPA_PASS
&& pass
->type
!= IPA_PASS
)
2359 gcc_assert (!(cfun
->curr_properties
& PROP_trees
)
2360 || pass
->type
!= RTL_PASS
);
2362 current_pass
= NULL
;
2364 if (todo_after
& TODO_discard_function
)
2367 /* As cgraph_node::release_body expects release dominators info,
2368 we have to release it. */
2369 if (dom_info_available_p (CDI_DOMINATORS
))
2370 free_dominance_info (CDI_DOMINATORS
);
2372 if (dom_info_available_p (CDI_POST_DOMINATORS
))
2373 free_dominance_info (CDI_POST_DOMINATORS
);
2375 tree fn
= cfun
->decl
;
2378 cgraph_node::get (fn
)->release_body ();
2381 /* Signal this is a suitable GC collection point. */
2382 if (!((todo_after
| pass
->todo_flags_finish
) & TODO_do_not_ggc_collect
))
2389 execute_pass_list_1 (opt_pass
*pass
)
2393 gcc_assert (pass
->type
== GIMPLE_PASS
2394 || pass
->type
== RTL_PASS
);
2398 if (execute_one_pass (pass
) && pass
->sub
)
2399 execute_pass_list_1 (pass
->sub
);
2406 execute_pass_list (function
*fn
, opt_pass
*pass
)
2408 gcc_assert (fn
== cfun
);
2409 execute_pass_list_1 (pass
);
2410 if (cfun
&& fn
->cfg
)
2412 free_dominance_info (CDI_DOMINATORS
);
2413 free_dominance_info (CDI_POST_DOMINATORS
);
2417 /* Write out all LTO data. */
2421 timevar_push (TV_IPA_LTO_GIMPLE_OUT
);
2423 timevar_pop (TV_IPA_LTO_GIMPLE_OUT
);
2424 timevar_push (TV_IPA_LTO_DECL_OUT
);
2425 produce_asm_for_decls ();
2426 timevar_pop (TV_IPA_LTO_DECL_OUT
);
2429 /* Same as execute_pass_list but assume that subpasses of IPA passes
2430 are local passes. If SET is not NULL, write out summaries of only
2431 those node in SET. */
2434 ipa_write_summaries_2 (opt_pass
*pass
, struct lto_out_decl_state
*state
)
2438 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*)pass
;
2439 gcc_assert (!current_function_decl
);
2441 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2442 if (pass
->type
== IPA_PASS
2443 && ipa_pass
->write_summary
2444 && pass
->gate (cfun
))
2446 /* If a timevar is present, start it. */
2448 timevar_push (pass
->tv_id
);
2450 pass_init_dump_file (pass
);
2452 current_pass
= pass
;
2453 ipa_pass
->write_summary ();
2455 pass_fini_dump_file (pass
);
2457 /* If a timevar is present, start it. */
2459 timevar_pop (pass
->tv_id
);
2462 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2463 ipa_write_summaries_2 (pass
->sub
, state
);
2469 /* Helper function of ipa_write_summaries. Creates and destroys the
2470 decl state and calls ipa_write_summaries_2 for all passes that have
2471 summaries. SET is the set of nodes to be written. */
2474 ipa_write_summaries_1 (lto_symtab_encoder_t encoder
)
2476 pass_manager
*passes
= g
->get_passes ();
2477 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2478 state
->symtab_node_encoder
= encoder
;
2480 lto_output_init_mode_table ();
2481 lto_push_out_decl_state (state
);
2483 gcc_assert (!flag_wpa
);
2484 ipa_write_summaries_2 (passes
->all_regular_ipa_passes
, state
);
2488 gcc_assert (lto_get_out_decl_state () == state
);
2489 lto_pop_out_decl_state ();
2490 lto_delete_out_decl_state (state
);
2493 /* Write out summaries for all the nodes in the callgraph. */
2496 ipa_write_summaries (void)
2498 lto_symtab_encoder_t encoder
;
2500 varpool_node
*vnode
;
2501 struct cgraph_node
*node
;
2502 struct cgraph_node
**order
;
2504 if ((!flag_generate_lto
&& !flag_generate_offload
) || seen_error ())
2507 select_what_to_stream ();
2509 encoder
= lto_symtab_encoder_new (false);
2511 /* Create the callgraph set in the same order used in
2512 cgraph_expand_all_functions. This mostly facilitates debugging,
2513 since it causes the gimple file to be processed in the same order
2514 as the source code. */
2515 order
= XCNEWVEC (struct cgraph_node
*, symtab
->cgraph_count
);
2516 order_pos
= ipa_reverse_postorder (order
);
2517 gcc_assert (order_pos
== symtab
->cgraph_count
);
2519 for (i
= order_pos
- 1; i
>= 0; i
--)
2521 struct cgraph_node
*node
= order
[i
];
2523 if (node
->has_gimple_body_p ())
2525 /* When streaming out references to statements as part of some IPA
2526 pass summary, the statements need to have uids assigned and the
2527 following does that for all the IPA passes here. Naturally, this
2528 ordering then matches the one IPA-passes get in their stmt_fixup
2531 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2532 renumber_gimple_stmt_uids ();
2535 if (node
->definition
&& node
->need_lto_streaming
)
2536 lto_set_symtab_encoder_in_partition (encoder
, node
);
2539 FOR_EACH_DEFINED_FUNCTION (node
)
2540 if (node
->alias
&& node
->need_lto_streaming
)
2541 lto_set_symtab_encoder_in_partition (encoder
, node
);
2542 FOR_EACH_DEFINED_VARIABLE (vnode
)
2543 if (vnode
->need_lto_streaming
)
2544 lto_set_symtab_encoder_in_partition (encoder
, vnode
);
2546 ipa_write_summaries_1 (compute_ltrans_boundary (encoder
));
2551 /* Same as execute_pass_list but assume that subpasses of IPA passes
2552 are local passes. If SET is not NULL, write out optimization summaries of
2553 only those node in SET. */
2556 ipa_write_optimization_summaries_1 (opt_pass
*pass
,
2557 struct lto_out_decl_state
*state
)
2561 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*)pass
;
2562 gcc_assert (!current_function_decl
);
2564 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2565 if (pass
->type
== IPA_PASS
2566 && ipa_pass
->write_optimization_summary
2567 && pass
->gate (cfun
))
2569 /* If a timevar is present, start it. */
2571 timevar_push (pass
->tv_id
);
2573 pass_init_dump_file (pass
);
2575 current_pass
= pass
;
2576 ipa_pass
->write_optimization_summary ();
2578 pass_fini_dump_file (pass
);
2580 /* If a timevar is present, start it. */
2582 timevar_pop (pass
->tv_id
);
2585 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2586 ipa_write_optimization_summaries_1 (pass
->sub
, state
);
2592 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2593 NULL, write out all summaries of all nodes. */
2596 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder
)
2598 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2599 lto_symtab_encoder_iterator lsei
;
2600 state
->symtab_node_encoder
= encoder
;
2602 lto_output_init_mode_table ();
2603 lto_push_out_decl_state (state
);
2604 for (lsei
= lsei_start_function_in_partition (encoder
);
2605 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
2607 struct cgraph_node
*node
= lsei_cgraph_node (lsei
);
2608 /* When streaming out references to statements as part of some IPA
2609 pass summary, the statements need to have uids assigned.
2611 For functions newly born at WPA stage we need to initialize
2613 if (node
->definition
2614 && gimple_has_body_p (node
->decl
))
2616 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2617 renumber_gimple_stmt_uids ();
2622 gcc_assert (flag_wpa
);
2623 pass_manager
*passes
= g
->get_passes ();
2624 ipa_write_optimization_summaries_1 (passes
->all_regular_ipa_passes
, state
);
2628 gcc_assert (lto_get_out_decl_state () == state
);
2629 lto_pop_out_decl_state ();
2630 lto_delete_out_decl_state (state
);
2633 /* Same as execute_pass_list but assume that subpasses of IPA passes
2634 are local passes. */
2637 ipa_read_summaries_1 (opt_pass
*pass
)
2641 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2643 gcc_assert (!current_function_decl
);
2645 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2647 if (pass
->gate (cfun
))
2649 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_summary
)
2651 /* If a timevar is present, start it. */
2653 timevar_push (pass
->tv_id
);
2655 pass_init_dump_file (pass
);
2657 current_pass
= pass
;
2658 ipa_pass
->read_summary ();
2660 pass_fini_dump_file (pass
);
2664 timevar_pop (pass
->tv_id
);
2667 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2668 ipa_read_summaries_1 (pass
->sub
);
2675 /* Read all the summaries for all_regular_ipa_passes. */
2678 ipa_read_summaries (void)
2680 pass_manager
*passes
= g
->get_passes ();
2681 ipa_read_summaries_1 (passes
->all_regular_ipa_passes
);
2684 /* Same as execute_pass_list but assume that subpasses of IPA passes
2685 are local passes. */
2688 ipa_read_optimization_summaries_1 (opt_pass
*pass
)
2692 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2694 gcc_assert (!current_function_decl
);
2696 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2698 if (pass
->gate (cfun
))
2700 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_optimization_summary
)
2702 /* If a timevar is present, start it. */
2704 timevar_push (pass
->tv_id
);
2706 pass_init_dump_file (pass
);
2708 current_pass
= pass
;
2709 ipa_pass
->read_optimization_summary ();
2711 pass_fini_dump_file (pass
);
2715 timevar_pop (pass
->tv_id
);
2718 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2719 ipa_read_optimization_summaries_1 (pass
->sub
);
2725 /* Read all the summaries for all_regular_ipa_passes. */
2728 ipa_read_optimization_summaries (void)
2730 pass_manager
*passes
= g
->get_passes ();
2731 ipa_read_optimization_summaries_1 (passes
->all_regular_ipa_passes
);
2734 /* Same as execute_pass_list but assume that subpasses of IPA passes
2735 are local passes. */
2737 execute_ipa_pass_list (opt_pass
*pass
)
2741 gcc_assert (!current_function_decl
);
2743 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2744 if (execute_one_pass (pass
) && pass
->sub
)
2746 if (pass
->sub
->type
== GIMPLE_PASS
)
2748 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START
, NULL
);
2749 do_per_function_toporder ((void (*)(function
*, void *))
2752 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END
, NULL
);
2754 else if (pass
->sub
->type
== SIMPLE_IPA_PASS
2755 || pass
->sub
->type
== IPA_PASS
)
2756 execute_ipa_pass_list (pass
->sub
);
2760 gcc_assert (!current_function_decl
);
2761 symtab
->process_new_functions ();
2767 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2770 execute_ipa_stmt_fixups (opt_pass
*pass
,
2771 struct cgraph_node
*node
, gimple
**stmts
)
2775 /* Execute all of the IPA_PASSes in the list. */
2776 if (pass
->type
== IPA_PASS
2777 && pass
->gate (cfun
))
2779 ipa_opt_pass_d
*ipa_pass
= (ipa_opt_pass_d
*) pass
;
2781 if (ipa_pass
->stmt_fixup
)
2783 pass_init_dump_file (pass
);
2784 /* If a timevar is present, start it. */
2786 timevar_push (pass
->tv_id
);
2788 current_pass
= pass
;
2789 ipa_pass
->stmt_fixup (node
, stmts
);
2793 timevar_pop (pass
->tv_id
);
2794 pass_fini_dump_file (pass
);
2797 execute_ipa_stmt_fixups (pass
->sub
, node
, stmts
);
2803 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2806 execute_all_ipa_stmt_fixups (struct cgraph_node
*node
, gimple
**stmts
)
2808 pass_manager
*passes
= g
->get_passes ();
2809 execute_ipa_stmt_fixups (passes
->all_regular_ipa_passes
, node
, stmts
);
2813 extern void debug_properties (unsigned int);
2814 extern void dump_properties (FILE *, unsigned int);
2817 dump_properties (FILE *dump
, unsigned int props
)
2819 fprintf (dump
, "Properties:\n");
2820 if (props
& PROP_gimple_any
)
2821 fprintf (dump
, "PROP_gimple_any\n");
2822 if (props
& PROP_gimple_lcf
)
2823 fprintf (dump
, "PROP_gimple_lcf\n");
2824 if (props
& PROP_gimple_leh
)
2825 fprintf (dump
, "PROP_gimple_leh\n");
2826 if (props
& PROP_cfg
)
2827 fprintf (dump
, "PROP_cfg\n");
2828 if (props
& PROP_ssa
)
2829 fprintf (dump
, "PROP_ssa\n");
2830 if (props
& PROP_no_crit_edges
)
2831 fprintf (dump
, "PROP_no_crit_edges\n");
2832 if (props
& PROP_rtl
)
2833 fprintf (dump
, "PROP_rtl\n");
2834 if (props
& PROP_gimple_lomp
)
2835 fprintf (dump
, "PROP_gimple_lomp\n");
2836 if (props
& PROP_gimple_lcx
)
2837 fprintf (dump
, "PROP_gimple_lcx\n");
2838 if (props
& PROP_gimple_lvec
)
2839 fprintf (dump
, "PROP_gimple_lvec\n");
2840 if (props
& PROP_cfglayout
)
2841 fprintf (dump
, "PROP_cfglayout\n");
2845 debug_properties (unsigned int props
)
2847 dump_properties (stderr
, props
);
2850 /* Called by local passes to see if function is called by already processed nodes.
2851 Because we process nodes in topological order, this means that function is
2852 in recursive cycle or we introduced new direct calls. */
2854 function_called_by_processed_nodes_p (void)
2856 struct cgraph_edge
*e
;
2857 for (e
= cgraph_node::get (current_function_decl
)->callers
;
2861 if (e
->caller
->decl
== current_function_decl
)
2863 if (!e
->caller
->has_gimple_body_p ())
2865 if (TREE_ASM_WRITTEN (e
->caller
->decl
))
2867 if (!e
->caller
->process
&& !e
->caller
->global
.inlined_to
)
2872 fprintf (dump_file
, "Already processed call to:\n");
2873 e
->caller
->dump (dump_file
);
2878 #include "gt-passes.h"