1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This is the top level of cc1/c++.
23 It parses command args, opens files, invokes the various passes
24 in the proper order, and counts the time used by each.
25 Error messages and low-level interface to malloc also handled here. */
29 #include "coretypes.h"
33 #ifdef HAVE_SYS_RESOURCE_H
34 # include <sys/resource.h>
37 #ifdef HAVE_SYS_TIMES_H
38 # include <sys/times.h>
47 #include "insn-attr.h"
48 #include "insn-config.h"
49 #include "insn-flags.h"
50 #include "hard-reg-set.h"
57 #include "basic-block.h"
63 #include "diagnostic.h"
66 #include "dwarf2asm.h"
67 #include "integrate.h"
71 #include "langhooks.h"
72 #include "cfglayout.h"
74 #include "hosthooks.h"
78 #include "value-prof.h"
79 #include "tree-inline.h"
80 #include "tree-flow.h"
81 #include "tree-pass.h"
82 #include "tree-dump.h"
85 #include "lto-streamer.h"
88 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
89 #include "dwarf2out.h"
92 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
96 #ifdef SDB_DEBUGGING_INFO
100 #ifdef XCOFF_DEBUGGING_INFO
101 #include "xcoffout.h" /* Needed for external data
102 declarations for e.g. AIX 4.x. */
105 /* This is used for debugging. It allows the current pass to printed
106 from anywhere in compilation.
107 The variable current_pass is also used for statistics and plugins. */
108 struct opt_pass *current_pass;
110 /* Call from anywhere to find out what pass this is. Useful for
111 printing out debugging information deep inside an service
114 print_current_pass (FILE *file)
117 fprintf (file, "current pass = %s (%d)\n",
118 current_pass->name, current_pass->static_pass_number);
120 fprintf (file, "no current pass.\n");
124 /* Call from the debugger to get the current pass name. */
128 print_current_pass (stderr);
133 /* Global variables used to communicate with passes. */
136 bool first_pass_instance;
139 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
142 This does nothing for local (non-static) variables, unless the
143 variable is a register variable with DECL_ASSEMBLER_NAME set. In
144 that case, or if the variable is not an automatic, it sets up the
145 RTL and outputs any assembler code (label definition, storage
146 allocation and initialization).
148 DECL is the declaration. TOP_LEVEL is nonzero
149 if this declaration is not within a function. */
152 rest_of_decl_compilation (tree decl,
156 /* We deferred calling assemble_alias so that we could collect
157 other attributes such as visibility. Emit the alias now. */
160 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
163 alias = TREE_VALUE (TREE_VALUE (alias));
164 alias = get_identifier (TREE_STRING_POINTER (alias));
165 assemble_alias (decl, alias);
169 /* Can't defer this, because it needs to happen before any
170 later function definitions are processed. */
171 if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
172 make_decl_rtl (decl);
174 /* Forward declarations for nested functions are not "external",
175 but we need to treat them as if they were. */
176 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
177 || TREE_CODE (decl) == FUNCTION_DECL)
179 timevar_push (TV_VARCONST);
181 /* Don't output anything when a tentative file-scope definition
182 is seen. But at end of compilation, do output code for them.
184 We do output all variables and rely on
185 callgraph code to defer them except for forward declarations
186 (see gcc.c-torture/compile/920624-1.c) */
188 || !DECL_DEFER_OUTPUT (decl)
189 || DECL_INITIAL (decl))
190 && !DECL_EXTERNAL (decl))
192 /* When reading LTO unit, we also read varpool, so do not
194 if (in_lto_p && !at_end)
196 else if (TREE_CODE (decl) != FUNCTION_DECL)
197 varpool_finalize_decl (decl);
199 assemble_variable (decl, top_level, at_end, 0);
202 #ifdef ASM_FINISH_DECLARE_OBJECT
203 if (decl == last_assemble_variable_decl)
205 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
210 timevar_pop (TV_VARCONST);
212 else if (TREE_CODE (decl) == TYPE_DECL
213 /* Like in rest_of_type_compilation, avoid confusing the debug
214 information machinery when there are errors. */
215 && !(sorrycount || errorcount))
217 timevar_push (TV_SYMOUT);
218 debug_hooks->type_decl (decl, !top_level);
219 timevar_pop (TV_SYMOUT);
222 /* Let cgraph know about the existence of variables. */
223 if (in_lto_p && !at_end)
225 else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
229 /* Called after finishing a record, union or enumeral type. */
232 rest_of_type_compilation (tree type, int toplev)
234 /* Avoid confusing the debug information machinery when there are
236 if (errorcount != 0 || sorrycount != 0)
239 timevar_push (TV_SYMOUT);
240 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
241 timevar_pop (TV_SYMOUT);
247 finish_optimization_passes (void)
250 struct dump_file_info *dfi;
253 timevar_push (TV_DUMP);
254 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
256 dump_file = dump_begin (pass_profile.pass.static_pass_number, NULL);
259 dump_end (pass_profile.pass.static_pass_number, dump_file);
264 dump_file = dump_begin (pass_combine.pass.static_pass_number, NULL);
267 dump_combine_total_stats (dump_file);
268 dump_end (pass_combine.pass.static_pass_number, dump_file);
272 /* Do whatever is necessary to finish printing the graphs. */
273 if (graph_dump_format != no_graph)
274 for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
275 if (dump_initialized_p (i)
276 && (dfi->flags & TDF_GRAPH) != 0
277 && (name = get_dump_file_name (i)) != NULL)
279 finish_graph_dump_file (name);
283 timevar_pop (TV_DUMP);
287 gate_rest_of_compilation (void)
289 /* Early return if there were errors. We can run afoul of our
290 consistency checks, and there's not really much point in fixing them. */
291 return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
294 struct gimple_opt_pass pass_rest_of_compilation =
298 "*rest_of_compilation", /* name */
299 gate_rest_of_compilation, /* gate */
303 0, /* static_pass_number */
304 TV_REST_OF_COMPILATION, /* tv_id */
305 PROP_rtl, /* properties_required */
306 0, /* properties_provided */
307 0, /* properties_destroyed */
308 0, /* todo_flags_start */
309 TODO_ggc_collect /* todo_flags_finish */
314 gate_postreload (void)
316 return reload_completed;
319 struct rtl_opt_pass pass_postreload =
323 "*all-postreload", /* name */
324 gate_postreload, /* gate */
328 0, /* static_pass_number */
330 PROP_rtl, /* properties_required */
331 0, /* properties_provided */
332 0, /* properties_destroyed */
333 0, /* todo_flags_start */
334 TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */
340 /* The root of the compilation pass tree, once constructed. */
341 struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes,
342 *all_regular_ipa_passes, *all_lto_gen_passes;
344 /* This is used by plugins, and should also be used in register_pass. */
345 #define DEF_PASS_LIST(LIST) &LIST,
346 struct opt_pass **gcc_pass_lists[] = { GCC_PASS_LISTS NULL };
349 /* A map from static pass id to optimization pass. */
350 struct opt_pass **passes_by_id;
351 int passes_by_id_size;
353 /* Set the static pass number of pass PASS to ID and record that
354 in the mapping from static pass number to pass. */
357 set_pass_for_id (int id, struct opt_pass *pass)
359 pass->static_pass_number = id;
360 if (passes_by_id_size <= id)
362 passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1);
363 memset (passes_by_id + passes_by_id_size, 0,
364 (id + 1 - passes_by_id_size) * sizeof (void *));
365 passes_by_id_size = id + 1;
367 passes_by_id[id] = pass;
370 /* Return the pass with the static pass number ID. */
373 get_pass_for_id (int id)
375 if (id >= passes_by_id_size)
377 return passes_by_id[id];
380 /* Iterate over the pass tree allocating dump file numbers. We want
381 to do this depth first, and independent of whether the pass is
385 register_one_dump_file (struct opt_pass *pass)
387 char *dot_name, *flag_name, *glob_name;
388 const char *name, *prefix;
392 /* See below in next_pass_1. */
394 if (pass->static_pass_number != -1)
395 sprintf (num, "%d", ((int) pass->static_pass_number < 0
396 ? 1 : pass->static_pass_number));
398 /* The name is both used to identify the pass for the purposes of plugins,
399 and to specify dump file name and option.
400 The latter two might want something short which is not quite unique; for
401 that reason, we may have a disambiguating prefix, followed by a space
402 to mark the start of the following dump file name / option string. */
403 name = strchr (pass->name, ' ');
404 name = name ? name + 1 : pass->name;
405 dot_name = concat (".", name, num, NULL);
406 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
407 prefix = "ipa-", flags = TDF_IPA;
408 else if (pass->type == GIMPLE_PASS)
409 prefix = "tree-", flags = TDF_TREE;
411 prefix = "rtl-", flags = TDF_RTL;
413 flag_name = concat (prefix, name, num, NULL);
414 glob_name = concat (prefix, name, NULL);
415 id = dump_register (dot_name, flag_name, glob_name, flags);
416 set_pass_for_id (id, pass);
419 /* Recursive worker function for register_dump_files. */
422 register_dump_files_1 (struct opt_pass *pass, int properties)
426 int new_properties = (properties | pass->properties_provided)
427 & ~pass->properties_destroyed;
429 if (pass->name && pass->name[0] != '*')
430 register_one_dump_file (pass);
433 new_properties = register_dump_files_1 (pass->sub, new_properties);
435 /* If we have a gate, combine the properties that we could have with
436 and without the pass being examined. */
438 properties &= new_properties;
440 properties = new_properties;
449 /* Register the dump files for the pipeline starting at PASS.
450 PROPERTIES reflects the properties that are guaranteed to be available at
451 the beginning of the pipeline. */
454 register_dump_files (struct opt_pass *pass,int properties)
456 pass->properties_required |= properties;
457 register_dump_files_1 (pass, properties);
460 /* Look at the static_pass_number and duplicate the pass
461 if it is already added to a list. */
463 static struct opt_pass *
464 make_pass_instance (struct opt_pass *pass, bool track_duplicates)
466 /* A nonzero static_pass_number indicates that the
467 pass is already in the list. */
468 if (pass->static_pass_number)
470 struct opt_pass *new_pass;
472 if (pass->type == GIMPLE_PASS
473 || pass->type == RTL_PASS
474 || pass->type == SIMPLE_IPA_PASS)
476 new_pass = XNEW (struct opt_pass);
477 memcpy (new_pass, pass, sizeof (struct opt_pass));
479 else if (pass->type == IPA_PASS)
481 new_pass = (struct opt_pass *)XNEW (struct ipa_opt_pass_d);
482 memcpy (new_pass, pass, sizeof (struct ipa_opt_pass_d));
487 new_pass->next = NULL;
489 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
491 /* Indicate to register_dump_files that this pass has duplicates,
492 and so it should rename the dump file. The first instance will
493 be -1, and be number of duplicates = -static_pass_number - 1.
494 Subsequent instances will be > 0 and just the duplicate number. */
495 if ((pass->name && pass->name[0] != '*') || track_duplicates)
497 pass->static_pass_number -= 1;
498 new_pass->static_pass_number = -pass->static_pass_number;
504 pass->todo_flags_start |= TODO_mark_first_instance;
505 pass->static_pass_number = -1;
507 invoke_plugin_callbacks (PLUGIN_NEW_PASS, pass);
512 /* Add a pass to the pass list. Duplicate the pass if it's already
515 static struct opt_pass **
516 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
518 /* Every pass should have a name so that plugins can refer to them. */
519 gcc_assert (pass->name != NULL);
521 *list = make_pass_instance (pass, false);
523 return &(*list)->next;
526 /* List node for an inserted pass instance. We need to keep track of all
527 the newly-added pass instances (with 'added_pass_nodes' defined below)
528 so that we can register their dump files after pass-positioning is finished.
529 Registering dumping files needs to be post-processed or the
530 static_pass_number of the opt_pass object would be modified and mess up
531 the dump file names of future pass instances to be added. */
533 struct pass_list_node
535 struct opt_pass *pass;
536 struct pass_list_node *next;
539 static struct pass_list_node *added_pass_nodes = NULL;
540 static struct pass_list_node *prev_added_pass_node;
542 /* Insert the pass at the proper position. Return true if the pass
543 is successfully added.
545 NEW_PASS_INFO - new pass to be inserted
546 PASS_LIST - root of the pass list to insert the new pass to */
549 position_pass (struct register_pass_info *new_pass_info,
550 struct opt_pass **pass_list)
552 struct opt_pass *pass = *pass_list, *prev_pass = NULL;
553 bool success = false;
555 for ( ; pass; prev_pass = pass, pass = pass->next)
557 /* Check if the current pass is of the same type as the new pass and
558 matches the name and the instance number of the reference pass. */
559 if (pass->type == new_pass_info->pass->type
561 && !strcmp (pass->name, new_pass_info->reference_pass_name)
562 && ((new_pass_info->ref_pass_instance_number == 0)
563 || (new_pass_info->ref_pass_instance_number ==
564 pass->static_pass_number)
565 || (new_pass_info->ref_pass_instance_number == 1
566 && pass->todo_flags_start & TODO_mark_first_instance)))
568 struct opt_pass *new_pass;
569 struct pass_list_node *new_pass_node;
571 new_pass = make_pass_instance (new_pass_info->pass, true);
573 /* Insert the new pass instance based on the positioning op. */
574 switch (new_pass_info->pos_op)
576 case PASS_POS_INSERT_AFTER:
577 new_pass->next = pass->next;
578 pass->next = new_pass;
580 /* Skip newly inserted pass to avoid repeated
581 insertions in the case where the new pass and the
582 existing one have the same name. */
585 case PASS_POS_INSERT_BEFORE:
586 new_pass->next = pass;
588 prev_pass->next = new_pass;
590 *pass_list = new_pass;
592 case PASS_POS_REPLACE:
593 new_pass->next = pass->next;
595 prev_pass->next = new_pass;
597 *pass_list = new_pass;
598 new_pass->sub = pass->sub;
599 new_pass->tv_id = pass->tv_id;
603 error ("Invalid pass positioning operation");
607 /* Save the newly added pass (instance) in the added_pass_nodes
608 list so that we can register its dump file later. Note that
609 we cannot register the dump file now because doing so will modify
610 the static_pass_number of the opt_pass object and therefore
611 mess up the dump file name of future instances. */
612 new_pass_node = XCNEW (struct pass_list_node);
613 new_pass_node->pass = new_pass;
614 if (!added_pass_nodes)
615 added_pass_nodes = new_pass_node;
617 prev_added_pass_node->next = new_pass_node;
618 prev_added_pass_node = new_pass_node;
623 if (pass->sub && position_pass (new_pass_info, &pass->sub))
630 /* Hooks a new pass into the pass lists.
632 PASS_INFO - pass information that specifies the opt_pass object,
633 reference pass, instance number, and how to position
637 register_pass (struct register_pass_info *pass_info)
639 bool all_instances, success;
641 /* The checks below could fail in buggy plugins. Existing GCC
642 passes should never fail these checks, so we mention plugin in
644 if (!pass_info->pass)
645 fatal_error ("plugin cannot register a missing pass");
647 if (!pass_info->pass->name)
648 fatal_error ("plugin cannot register an unnamed pass");
650 if (!pass_info->reference_pass_name)
652 ("plugin cannot register pass %qs without reference pass name",
653 pass_info->pass->name);
655 /* Try to insert the new pass to the pass lists. We need to check
656 all five lists as the reference pass could be in one (or all) of
658 all_instances = pass_info->ref_pass_instance_number == 0;
659 success = position_pass (pass_info, &all_lowering_passes);
660 if (!success || all_instances)
661 success |= position_pass (pass_info, &all_small_ipa_passes);
662 if (!success || all_instances)
663 success |= position_pass (pass_info, &all_regular_ipa_passes);
664 if (!success || all_instances)
665 success |= position_pass (pass_info, &all_lto_gen_passes);
666 if (!success || all_instances)
667 success |= position_pass (pass_info, &all_passes);
670 ("pass %qs not found but is referenced by new pass %qs",
671 pass_info->reference_pass_name, pass_info->pass->name);
673 /* OK, we have successfully inserted the new pass. We need to register
674 the dump files for the newly added pass and its duplicates (if any).
675 Because the registration of plugin/backend passes happens after the
676 command-line options are parsed, the options that specify single
677 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
678 passes. Therefore we currently can only enable dumping of
679 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
680 are specified. While doing so, we also delete the pass_list_node
681 objects created during pass positioning. */
682 while (added_pass_nodes)
684 struct pass_list_node *next_node = added_pass_nodes->next;
685 enum tree_dump_index tdi;
686 register_one_dump_file (added_pass_nodes->pass);
687 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
688 || added_pass_nodes->pass->type == IPA_PASS)
690 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
694 /* Check if dump-all flag is specified. */
695 if (get_dump_file_info (tdi)->state)
696 get_dump_file_info (added_pass_nodes->pass->static_pass_number)
697 ->state = get_dump_file_info (tdi)->state;
698 XDELETE (added_pass_nodes);
699 added_pass_nodes = next_node;
703 /* Construct the pass tree. The sequencing of passes is driven by
706 cgraph_finalize_compilation_unit ()
707 for each node N in the cgraph
708 cgraph_analyze_function (N)
709 cgraph_lower_function (N) -> all_lowering_passes
711 If we are optimizing, cgraph_optimize is then invoked:
714 ipa_passes () -> all_small_ipa_passes
715 cgraph_expand_all_functions ()
716 for each node N in the cgraph
717 cgraph_expand_function (N)
718 tree_rest_of_compilation (DECL (N)) -> all_passes
722 init_optimization_passes (void)
726 #define NEXT_PASS(PASS) (p = next_pass_1 (p, &((PASS).pass)))
728 /* All passes needed to lower the function into shape optimizers can
729 operate on. These passes are always run first on the function, but
730 backend might produce already lowered functions that are not processed
732 p = &all_lowering_passes;
733 NEXT_PASS (pass_warn_unused_result);
734 NEXT_PASS (pass_diagnose_omp_blocks);
735 NEXT_PASS (pass_mudflap_1);
736 NEXT_PASS (pass_lower_omp);
737 NEXT_PASS (pass_lower_cf);
738 NEXT_PASS (pass_refactor_eh);
739 NEXT_PASS (pass_lower_eh);
740 NEXT_PASS (pass_build_cfg);
741 NEXT_PASS (pass_lower_vector);
742 NEXT_PASS (pass_warn_function_return);
743 NEXT_PASS (pass_build_cgraph_edges);
744 NEXT_PASS (pass_inline_parameters);
747 /* Interprocedural optimization passes. */
748 p = &all_small_ipa_passes;
749 NEXT_PASS (pass_ipa_free_lang_data);
750 NEXT_PASS (pass_ipa_function_and_variable_visibility);
751 NEXT_PASS (pass_ipa_early_inline);
753 struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
754 NEXT_PASS (pass_early_inline);
755 NEXT_PASS (pass_inline_parameters);
756 NEXT_PASS (pass_rebuild_cgraph_edges);
758 NEXT_PASS (pass_early_local_passes);
760 struct opt_pass **p = &pass_early_local_passes.pass.sub;
761 NEXT_PASS (pass_fixup_cfg);
762 NEXT_PASS (pass_tree_profile);
763 NEXT_PASS (pass_cleanup_cfg);
764 NEXT_PASS (pass_init_datastructures);
765 NEXT_PASS (pass_expand_omp);
767 NEXT_PASS (pass_referenced_vars);
768 NEXT_PASS (pass_build_ssa);
769 NEXT_PASS (pass_early_warn_uninitialized);
770 /* Note that it is not strictly necessary to schedule an early
771 inline pass here. However, some test cases (e.g.,
772 g++.dg/other/p334435.C g++.dg/other/i386-1.C) expect extern
773 inline functions to be inlined even at -O0. This does not
774 happen during the first early inline pass. */
775 NEXT_PASS (pass_rebuild_cgraph_edges);
776 NEXT_PASS (pass_early_inline);
777 NEXT_PASS (pass_all_early_optimizations);
779 struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
780 NEXT_PASS (pass_remove_cgraph_callee_edges);
781 NEXT_PASS (pass_rename_ssa_copies);
782 NEXT_PASS (pass_ccp);
783 NEXT_PASS (pass_forwprop);
784 /* pass_build_ealias is a dummy pass that ensures that we
785 execute TODO_rebuild_alias at this point. Re-building
786 alias information also rewrites no longer addressed
787 locals into SSA form if possible. */
788 NEXT_PASS (pass_build_ealias);
789 NEXT_PASS (pass_sra_early);
790 NEXT_PASS (pass_copy_prop);
791 NEXT_PASS (pass_merge_phi);
792 NEXT_PASS (pass_cd_dce);
793 NEXT_PASS (pass_early_ipa_sra);
794 NEXT_PASS (pass_tail_recursion);
795 NEXT_PASS (pass_convert_switch);
796 NEXT_PASS (pass_cleanup_eh);
797 NEXT_PASS (pass_profile);
798 NEXT_PASS (pass_local_pure_const);
800 NEXT_PASS (pass_release_ssa_names);
801 NEXT_PASS (pass_rebuild_cgraph_edges);
802 NEXT_PASS (pass_inline_parameters);
804 NEXT_PASS (pass_ipa_increase_alignment);
805 NEXT_PASS (pass_ipa_matrix_reorg);
808 p = &all_regular_ipa_passes;
809 NEXT_PASS (pass_ipa_whole_program_visibility);
810 NEXT_PASS (pass_ipa_profile);
811 NEXT_PASS (pass_ipa_cp);
812 NEXT_PASS (pass_ipa_inline);
813 NEXT_PASS (pass_ipa_reference);
814 NEXT_PASS (pass_ipa_pure_const);
815 NEXT_PASS (pass_ipa_type_escape);
816 NEXT_PASS (pass_ipa_pta);
817 NEXT_PASS (pass_ipa_struct_reorg);
820 p = &all_lto_gen_passes;
821 NEXT_PASS (pass_ipa_lto_gimple_out);
822 NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */
825 /* These passes are run after IPA passes on every function that is being
826 output to the assembler file. */
828 NEXT_PASS (pass_lower_eh_dispatch);
829 NEXT_PASS (pass_all_optimizations);
831 struct opt_pass **p = &pass_all_optimizations.pass.sub;
832 NEXT_PASS (pass_remove_cgraph_callee_edges);
833 /* Initial scalar cleanups before alias computation.
834 They ensure memory accesses are not indirect wherever possible. */
835 NEXT_PASS (pass_strip_predict_hints);
836 NEXT_PASS (pass_update_address_taken);
837 NEXT_PASS (pass_rename_ssa_copies);
838 NEXT_PASS (pass_complete_unrolli);
839 NEXT_PASS (pass_ccp);
840 NEXT_PASS (pass_forwprop);
841 NEXT_PASS (pass_call_cdce);
842 /* pass_build_alias is a dummy pass that ensures that we
843 execute TODO_rebuild_alias at this point. Re-building
844 alias information also rewrites no longer addressed
845 locals into SSA form if possible. */
846 NEXT_PASS (pass_build_alias);
847 NEXT_PASS (pass_return_slot);
848 NEXT_PASS (pass_phiprop);
849 NEXT_PASS (pass_fre);
850 NEXT_PASS (pass_copy_prop);
851 NEXT_PASS (pass_merge_phi);
852 NEXT_PASS (pass_vrp);
853 NEXT_PASS (pass_dce);
854 NEXT_PASS (pass_cselim);
855 NEXT_PASS (pass_tree_ifcombine);
856 NEXT_PASS (pass_phiopt);
857 NEXT_PASS (pass_tail_recursion);
859 NEXT_PASS (pass_stdarg);
860 NEXT_PASS (pass_lower_complex);
861 NEXT_PASS (pass_sra);
862 NEXT_PASS (pass_rename_ssa_copies);
863 /* The dom pass will also resolve all __builtin_constant_p calls
864 that are still there to 0. This has to be done after some
865 propagations have already run, but before some more dead code
866 is removed, and this place fits nicely. Remember this when
867 trying to move or duplicate pass_dominator somewhere earlier. */
868 NEXT_PASS (pass_dominator);
869 /* The only const/copy propagation opportunities left after
870 DOM should be due to degenerate PHI nodes. So rather than
871 run the full propagators, run a specialized pass which
872 only examines PHIs to discover const/copy propagation
874 NEXT_PASS (pass_phi_only_cprop);
875 NEXT_PASS (pass_dse);
876 NEXT_PASS (pass_reassoc);
877 NEXT_PASS (pass_dce);
878 NEXT_PASS (pass_forwprop);
879 NEXT_PASS (pass_phiopt);
880 NEXT_PASS (pass_object_sizes);
881 NEXT_PASS (pass_ccp);
882 NEXT_PASS (pass_copy_prop);
883 NEXT_PASS (pass_cse_sincos);
884 NEXT_PASS (pass_optimize_bswap);
885 NEXT_PASS (pass_split_crit_edges);
886 NEXT_PASS (pass_pre);
887 NEXT_PASS (pass_sink_code);
888 NEXT_PASS (pass_tree_loop);
890 struct opt_pass **p = &pass_tree_loop.pass.sub;
891 NEXT_PASS (pass_tree_loop_init);
892 NEXT_PASS (pass_lim);
893 NEXT_PASS (pass_copy_prop);
894 NEXT_PASS (pass_dce_loop);
895 NEXT_PASS (pass_tree_unswitch);
896 NEXT_PASS (pass_scev_cprop);
897 NEXT_PASS (pass_record_bounds);
898 NEXT_PASS (pass_check_data_deps);
899 NEXT_PASS (pass_loop_distribution);
900 NEXT_PASS (pass_linear_transform);
901 NEXT_PASS (pass_graphite_transforms);
903 struct opt_pass **p = &pass_graphite_transforms.pass.sub;
904 NEXT_PASS (pass_copy_prop);
905 NEXT_PASS (pass_dce_loop);
906 NEXT_PASS (pass_lim);
908 NEXT_PASS (pass_iv_canon);
909 NEXT_PASS (pass_if_conversion);
910 NEXT_PASS (pass_vectorize);
912 struct opt_pass **p = &pass_vectorize.pass.sub;
913 NEXT_PASS (pass_lower_vector_ssa);
914 NEXT_PASS (pass_dce_loop);
916 NEXT_PASS (pass_predcom);
917 NEXT_PASS (pass_complete_unroll);
918 NEXT_PASS (pass_slp_vectorize);
919 NEXT_PASS (pass_parallelize_loops);
920 NEXT_PASS (pass_loop_prefetch);
921 NEXT_PASS (pass_iv_optimize);
922 NEXT_PASS (pass_tree_loop_done);
924 NEXT_PASS (pass_cse_reciprocals);
925 NEXT_PASS (pass_reassoc);
926 NEXT_PASS (pass_vrp);
927 NEXT_PASS (pass_dominator);
928 /* The only const/copy propagation opportunities left after
929 DOM should be due to degenerate PHI nodes. So rather than
930 run the full propagators, run a specialized pass which
931 only examines PHIs to discover const/copy propagation
933 NEXT_PASS (pass_phi_only_cprop);
934 NEXT_PASS (pass_cd_dce);
935 NEXT_PASS (pass_tracer);
937 /* FIXME: If DCE is not run before checking for uninitialized uses,
938 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
939 However, this also causes us to misdiagnose cases that should be
940 real warnings (e.g., testsuite/gcc.dg/pr18501.c).
942 To fix the false positives in uninit-5.c, we would have to
943 account for the predicates protecting the set and the use of each
944 variable. Using a representation like Gated Single Assignment
946 NEXT_PASS (pass_late_warn_uninitialized);
947 NEXT_PASS (pass_dse);
948 NEXT_PASS (pass_forwprop);
949 NEXT_PASS (pass_phiopt);
950 NEXT_PASS (pass_fold_builtins);
951 NEXT_PASS (pass_optimize_widening_mul);
952 NEXT_PASS (pass_tail_calls);
953 NEXT_PASS (pass_rename_ssa_copies);
954 NEXT_PASS (pass_uncprop);
955 NEXT_PASS (pass_local_pure_const);
957 NEXT_PASS (pass_lower_complex_O0);
958 NEXT_PASS (pass_cleanup_eh);
959 NEXT_PASS (pass_lower_resx);
960 NEXT_PASS (pass_nrv);
961 NEXT_PASS (pass_mudflap_2);
962 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
963 NEXT_PASS (pass_warn_function_noreturn);
965 NEXT_PASS (pass_expand);
967 NEXT_PASS (pass_rest_of_compilation);
969 struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
970 NEXT_PASS (pass_init_function);
971 NEXT_PASS (pass_jump);
972 NEXT_PASS (pass_rtl_eh);
973 NEXT_PASS (pass_initial_value_sets);
974 NEXT_PASS (pass_unshare_all_rtl);
975 NEXT_PASS (pass_instantiate_virtual_regs);
976 NEXT_PASS (pass_into_cfg_layout_mode);
977 NEXT_PASS (pass_jump2);
978 NEXT_PASS (pass_lower_subreg);
979 NEXT_PASS (pass_df_initialize_opt);
980 NEXT_PASS (pass_cse);
981 NEXT_PASS (pass_rtl_fwprop);
982 NEXT_PASS (pass_rtl_cprop);
983 NEXT_PASS (pass_rtl_pre);
984 NEXT_PASS (pass_rtl_hoist);
985 NEXT_PASS (pass_rtl_cprop);
986 NEXT_PASS (pass_rtl_store_motion);
987 NEXT_PASS (pass_cse_after_global_opts);
988 NEXT_PASS (pass_rtl_ifcvt);
989 NEXT_PASS (pass_reginfo_init);
990 /* Perform loop optimizations. It might be better to do them a bit
991 sooner, but we want the profile feedback to work more
993 NEXT_PASS (pass_loop2);
995 struct opt_pass **p = &pass_loop2.pass.sub;
996 NEXT_PASS (pass_rtl_loop_init);
997 NEXT_PASS (pass_rtl_move_loop_invariants);
998 NEXT_PASS (pass_rtl_unswitch);
999 NEXT_PASS (pass_rtl_unroll_and_peel_loops);
1000 NEXT_PASS (pass_rtl_doloop);
1001 NEXT_PASS (pass_rtl_loop_done);
1004 NEXT_PASS (pass_web);
1005 NEXT_PASS (pass_rtl_cprop);
1006 NEXT_PASS (pass_cse2);
1007 NEXT_PASS (pass_rtl_dse1);
1008 NEXT_PASS (pass_rtl_fwprop_addr);
1009 NEXT_PASS (pass_inc_dec);
1010 NEXT_PASS (pass_initialize_regs);
1011 NEXT_PASS (pass_ud_rtl_dce);
1012 NEXT_PASS (pass_combine);
1013 NEXT_PASS (pass_if_after_combine);
1014 NEXT_PASS (pass_partition_blocks);
1015 NEXT_PASS (pass_regmove);
1016 NEXT_PASS (pass_outof_cfg_layout_mode);
1017 NEXT_PASS (pass_split_all_insns);
1018 NEXT_PASS (pass_lower_subreg2);
1019 NEXT_PASS (pass_df_initialize_no_opt);
1020 NEXT_PASS (pass_stack_ptr_mod);
1021 NEXT_PASS (pass_mode_switching);
1022 NEXT_PASS (pass_match_asm_constraints);
1023 NEXT_PASS (pass_sms);
1024 NEXT_PASS (pass_sched);
1025 NEXT_PASS (pass_ira);
1026 NEXT_PASS (pass_postreload);
1028 struct opt_pass **p = &pass_postreload.pass.sub;
1029 NEXT_PASS (pass_postreload_cse);
1030 NEXT_PASS (pass_gcse2);
1031 NEXT_PASS (pass_split_after_reload);
1032 NEXT_PASS (pass_implicit_zee);
1033 NEXT_PASS (pass_branch_target_load_optimize1);
1034 NEXT_PASS (pass_thread_prologue_and_epilogue);
1035 NEXT_PASS (pass_rtl_dse2);
1036 NEXT_PASS (pass_stack_adjustments);
1037 NEXT_PASS (pass_peephole2);
1038 NEXT_PASS (pass_if_after_reload);
1039 NEXT_PASS (pass_regrename);
1040 NEXT_PASS (pass_cprop_hardreg);
1041 NEXT_PASS (pass_fast_rtl_dce);
1042 NEXT_PASS (pass_reorder_blocks);
1043 NEXT_PASS (pass_branch_target_load_optimize2);
1044 NEXT_PASS (pass_leaf_regs);
1045 NEXT_PASS (pass_split_before_sched2);
1046 NEXT_PASS (pass_sched2);
1047 NEXT_PASS (pass_stack_regs);
1049 struct opt_pass **p = &pass_stack_regs.pass.sub;
1050 NEXT_PASS (pass_split_before_regstack);
1051 NEXT_PASS (pass_stack_regs_run);
1053 NEXT_PASS (pass_compute_alignments);
1054 NEXT_PASS (pass_duplicate_computed_gotos);
1055 NEXT_PASS (pass_variable_tracking);
1056 NEXT_PASS (pass_free_cfg);
1057 NEXT_PASS (pass_machine_reorg);
1058 NEXT_PASS (pass_cleanup_barriers);
1059 NEXT_PASS (pass_delay_slots);
1060 NEXT_PASS (pass_split_for_shorten_branches);
1061 NEXT_PASS (pass_convert_to_eh_region_ranges);
1062 NEXT_PASS (pass_shorten_branches);
1063 NEXT_PASS (pass_set_nothrow_function_flags);
1064 NEXT_PASS (pass_final);
1066 NEXT_PASS (pass_df_finish);
1068 NEXT_PASS (pass_clean_state);
1073 /* Register the passes with the tree dump code. */
1074 register_dump_files (all_lowering_passes, PROP_gimple_any);
1075 register_dump_files (all_small_ipa_passes,
1076 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1078 register_dump_files (all_regular_ipa_passes,
1079 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1081 register_dump_files (all_lto_gen_passes,
1082 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1084 register_dump_files (all_passes,
1085 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1089 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1090 function CALLBACK for every function in the call graph. Otherwise,
1091 call CALLBACK on the current function. */
1094 do_per_function (void (*callback) (void *data), void *data)
1096 if (current_function_decl)
1100 struct cgraph_node *node;
1101 for (node = cgraph_nodes; node; node = node->next)
1102 if (node->analyzed && gimple_has_body_p (node->decl)
1103 && (!node->clone_of || node->decl != node->clone_of->decl))
1105 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1106 current_function_decl = node->decl;
1110 free_dominance_info (CDI_DOMINATORS);
1111 free_dominance_info (CDI_POST_DOMINATORS);
1113 current_function_decl = NULL;
1120 /* Because inlining might remove no-longer reachable nodes, we need to
1121 keep the array visible to garbage collector to avoid reading collected
1124 static GTY ((length ("nnodes"))) struct cgraph_node **order;
1126 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1127 function CALLBACK for every function in the call graph. Otherwise,
1128 call CALLBACK on the current function.
1129 This function is global so that plugins can use it. */
1131 do_per_function_toporder (void (*callback) (void *data), void *data)
1135 if (current_function_decl)
1139 gcc_assert (!order);
1140 order = GGC_NEWVEC (struct cgraph_node *, cgraph_n_nodes);
1141 nnodes = cgraph_postorder (order);
1142 for (i = nnodes - 1; i >= 0; i--)
1143 order[i]->process = 1;
1144 for (i = nnodes - 1; i >= 0; i--)
1146 struct cgraph_node *node = order[i];
1148 /* Allow possibly removed nodes to be garbage collected. */
1153 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1154 current_function_decl = node->decl;
1156 free_dominance_info (CDI_DOMINATORS);
1157 free_dominance_info (CDI_POST_DOMINATORS);
1158 current_function_decl = NULL;
1169 /* Perform all TODO actions that ought to be done on each function. */
1172 execute_function_todo (void *data)
1174 unsigned int flags = (size_t)data;
1175 if (cfun->curr_properties & PROP_ssa)
1176 flags |= TODO_verify_ssa;
1177 flags &= ~cfun->last_verified;
1181 statistics_fini_pass ();
1183 /* Always cleanup the CFG before trying to update SSA. */
1184 if (flags & TODO_cleanup_cfg)
1186 bool cleanup = cleanup_tree_cfg ();
1188 if (cleanup && (cfun->curr_properties & PROP_ssa))
1189 flags |= TODO_remove_unused_locals;
1191 /* When cleanup_tree_cfg merges consecutive blocks, it may
1192 perform some simplistic propagation when removing single
1193 valued PHI nodes. This propagation may, in turn, cause the
1194 SSA form to become out-of-date (see PR 22037). So, even
1195 if the parent pass had not scheduled an SSA update, we may
1196 still need to do one. */
1197 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1198 flags |= TODO_update_ssa;
1201 if (flags & TODO_update_ssa_any)
1203 unsigned update_flags = flags & TODO_update_ssa_any;
1204 update_ssa (update_flags);
1205 cfun->last_verified &= ~TODO_verify_ssa;
1208 if (flags & TODO_update_address_taken)
1209 execute_update_addresses_taken (true);
1211 if (flags & TODO_rebuild_alias)
1213 if (!(flags & TODO_update_address_taken))
1214 execute_update_addresses_taken (true);
1215 compute_may_aliases ();
1218 if (flags & TODO_remove_unused_locals)
1219 remove_unused_locals ();
1221 if ((flags & TODO_dump_func) && dump_file && current_function_decl)
1223 if (cfun->curr_properties & PROP_trees)
1224 dump_function_to_file (current_function_decl, dump_file, dump_flags);
1227 if (dump_flags & TDF_SLIM)
1228 print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
1229 else if ((cfun->curr_properties & PROP_cfg)
1230 && (dump_flags & TDF_BLOCKS))
1231 print_rtl_with_bb (dump_file, get_insns ());
1233 print_rtl (dump_file, get_insns ());
1235 if ((cfun->curr_properties & PROP_cfg)
1236 && graph_dump_format != no_graph
1237 && (dump_flags & TDF_GRAPH))
1238 print_rtl_graph_with_bb (dump_file_name, get_insns ());
1241 /* Flush the file. If verification fails, we won't be able to
1242 close the file before aborting. */
1246 if (flags & TODO_rebuild_frequencies)
1248 if (profile_status == PROFILE_GUESSED)
1250 loop_optimizer_init (0);
1251 add_noreturn_fake_exit_edges ();
1252 mark_irreducible_loops ();
1253 connect_infinite_loops_to_exit ();
1254 estimate_bb_frequencies ();
1255 remove_fake_exit_edges ();
1256 loop_optimizer_finalize ();
1258 else if (profile_status == PROFILE_READ)
1264 #if defined ENABLE_CHECKING
1265 if (flags & TODO_verify_ssa
1266 || (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)))
1268 if (flags & TODO_verify_flow)
1269 verify_flow_info ();
1270 if (flags & TODO_verify_stmts)
1272 if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))
1273 verify_loop_closed_ssa (false);
1274 if (flags & TODO_verify_rtl_sharing)
1275 verify_rtl_sharing ();
1278 cfun->last_verified = flags & TODO_verify_all;
1281 /* Perform all TODO actions. */
1283 execute_todo (unsigned int flags)
1285 #if defined ENABLE_CHECKING
1287 && need_ssa_update_p (cfun))
1288 gcc_assert (flags & TODO_update_ssa_any);
1291 /* Inform the pass whether it is the first time it is run. */
1292 first_pass_instance = (flags & TODO_mark_first_instance) != 0;
1294 do_per_function (execute_function_todo, (void *)(size_t) flags);
1296 /* Always remove functions just as before inlining: IPA passes might be
1297 interested to see bodies of extern inline functions that are not inlined
1298 to analyze side effects. The full removal is done just at the end
1299 of IPA pass queue. */
1300 if (flags & TODO_remove_functions)
1303 cgraph_remove_unreachable_nodes (true, dump_file);
1306 if ((flags & TODO_dump_cgraph) && dump_file && !current_function_decl)
1309 dump_cgraph (dump_file);
1310 /* Flush the file. If verification fails, we won't be able to
1311 close the file before aborting. */
1315 if (flags & TODO_ggc_collect)
1318 /* Now that the dumping has been done, we can get rid of the optional
1320 if (flags & TODO_df_finish)
1321 df_finish_pass ((flags & TODO_df_verify) != 0);
1324 /* Verify invariants that should hold between passes. This is a place
1325 to put simple sanity checks. */
1328 verify_interpass_invariants (void)
1330 #ifdef ENABLE_CHECKING
1331 gcc_assert (!fold_deferring_overflow_warnings_p ());
1335 /* Clear the last verified flag. */
1338 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1340 cfun->last_verified = 0;
1343 /* Helper function. Verify that the properties has been turn into the
1344 properties expected by the pass. */
1346 #ifdef ENABLE_CHECKING
1348 verify_curr_properties (void *data)
1350 unsigned int props = (size_t)data;
1351 gcc_assert ((cfun->curr_properties & props) == props);
1355 /* Initialize pass dump file. */
1356 /* This is non-static so that the plugins can use it. */
1359 pass_init_dump_file (struct opt_pass *pass)
1361 /* If a dump file name is present, open it if enabled. */
1362 if (pass->static_pass_number != -1)
1364 bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
1365 dump_file_name = get_dump_file_name (pass->static_pass_number);
1366 dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1367 if (dump_file && current_function_decl)
1369 const char *dname, *aname;
1370 struct cgraph_node *node = cgraph_node (current_function_decl);
1371 dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1372 aname = (IDENTIFIER_POINTER
1373 (DECL_ASSEMBLER_NAME (current_function_decl)));
1374 fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1375 node->frequency == NODE_FREQUENCY_HOT
1377 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
1378 ? " (unlikely executed)"
1379 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
1380 ? " (executed once)"
1383 return initializing_dump;
1389 /* Flush PASS dump file. */
1390 /* This is non-static so that plugins can use it. */
1393 pass_fini_dump_file (struct opt_pass *pass)
1395 /* Flush and close dump file. */
1398 free (CONST_CAST (char *, dump_file_name));
1399 dump_file_name = NULL;
1404 dump_end (pass->static_pass_number, dump_file);
1409 /* After executing the pass, apply expected changes to the function
1413 update_properties_after_pass (void *data)
1415 struct opt_pass *pass = (struct opt_pass *) data;
1416 cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1417 & ~pass->properties_destroyed;
1420 /* Execute summary generation for all of the passes in IPA_PASS. */
1423 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
1427 struct opt_pass *pass = &ipa_pass->pass;
1429 /* Execute all of the IPA_PASSes in the list. */
1430 if (ipa_pass->pass.type == IPA_PASS
1431 && (!pass->gate || pass->gate ())
1432 && ipa_pass->generate_summary)
1434 pass_init_dump_file (pass);
1436 /* If a timevar is present, start it. */
1438 timevar_push (pass->tv_id);
1440 ipa_pass->generate_summary ();
1444 timevar_pop (pass->tv_id);
1446 pass_fini_dump_file (pass);
1448 ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
1452 /* Execute IPA_PASS function transform on NODE. */
1455 execute_one_ipa_transform_pass (struct cgraph_node *node,
1456 struct ipa_opt_pass_d *ipa_pass)
1458 struct opt_pass *pass = &ipa_pass->pass;
1459 unsigned int todo_after = 0;
1461 current_pass = pass;
1462 if (!ipa_pass->function_transform)
1465 /* Note that the folders should only create gimple expressions.
1466 This is a hack until the new folder is ready. */
1467 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1469 pass_init_dump_file (pass);
1471 /* Run pre-pass verification. */
1472 execute_todo (ipa_pass->function_transform_todo_flags_start);
1474 /* If a timevar is present, start it. */
1475 if (pass->tv_id != TV_NONE)
1476 timevar_push (pass->tv_id);
1479 todo_after = ipa_pass->function_transform (node);
1482 if (pass->tv_id != TV_NONE)
1483 timevar_pop (pass->tv_id);
1485 /* Run post-pass cleanup and verification. */
1486 execute_todo (todo_after);
1487 verify_interpass_invariants ();
1489 pass_fini_dump_file (pass);
1491 current_pass = NULL;
1494 /* For the current function, execute all ipa transforms. */
1497 execute_all_ipa_transforms (void)
1499 enum cgraph_state old_state = cgraph_state;
1500 struct cgraph_node *node;
1503 node = cgraph_node (current_function_decl);
1505 /* Statement verification skip verification of nothorw when
1506 state is IPA_SSA because we do not modify function bodies
1507 after setting the flag on function. Instead we leave it
1508 to fixup_cfg to do such a transformation. We need to temporarily
1509 change the cgraph state so statement verifier before
1510 transform do not fire. */
1511 cgraph_state = CGRAPH_STATE_IPA_SSA;
1513 if (node->ipa_transforms_to_apply)
1517 for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply);
1519 execute_one_ipa_transform_pass (node,
1520 VEC_index (ipa_opt_pass,
1521 node->ipa_transforms_to_apply,
1523 VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply);
1524 node->ipa_transforms_to_apply = NULL;
1526 cgraph_state = old_state;
1532 execute_one_pass (struct opt_pass *pass)
1534 bool initializing_dump;
1535 unsigned int todo_after = 0;
1539 /* IPA passes are executed on whole program, so cfun should be NULL.
1540 Other passes need function context set. */
1541 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
1542 gcc_assert (!cfun && !current_function_decl);
1544 gcc_assert (cfun && current_function_decl);
1546 current_pass = pass;
1548 /* Check whether gate check should be avoided.
1549 User controls the value of the gate through the parameter "gate_status". */
1550 gate_status = (pass->gate == NULL) ? true : pass->gate();
1552 /* Override gate with plugin. */
1553 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
1557 current_pass = NULL;
1561 /* Pass execution event trigger: useful to identify passes being
1563 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
1565 if (!quiet_flag && !cfun)
1566 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1568 /* Note that the folders should only create gimple expressions.
1569 This is a hack until the new folder is ready. */
1570 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1572 initializing_dump = pass_init_dump_file (pass);
1574 /* Run pre-pass verification. */
1575 execute_todo (pass->todo_flags_start);
1577 #ifdef ENABLE_CHECKING
1578 do_per_function (verify_curr_properties,
1579 (void *)(size_t)pass->properties_required);
1582 /* If a timevar is present, start it. */
1583 if (pass->tv_id != TV_NONE)
1584 timevar_push (pass->tv_id);
1589 todo_after = pass->execute ();
1590 do_per_function (clear_last_verified, NULL);
1594 if (pass->tv_id != TV_NONE)
1595 timevar_pop (pass->tv_id);
1597 do_per_function (update_properties_after_pass, pass);
1599 if (initializing_dump
1601 && graph_dump_format != no_graph
1603 && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1604 == (PROP_cfg | PROP_rtl))
1606 get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1607 dump_flags |= TDF_GRAPH;
1608 clean_graph_dump_file (dump_file_name);
1611 /* Run post-pass cleanup and verification. */
1612 execute_todo (todo_after | pass->todo_flags_finish);
1613 verify_interpass_invariants ();
1614 if (pass->type == IPA_PASS)
1616 struct cgraph_node *node;
1617 for (node = cgraph_nodes; node; node = node->next)
1619 VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
1620 (struct ipa_opt_pass_d *)pass);
1623 if (!current_function_decl)
1624 cgraph_process_new_functions ();
1626 pass_fini_dump_file (pass);
1628 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
1629 gcc_assert (!(cfun->curr_properties & PROP_trees)
1630 || pass->type != RTL_PASS);
1632 current_pass = NULL;
1638 execute_pass_list (struct opt_pass *pass)
1642 gcc_assert (pass->type == GIMPLE_PASS
1643 || pass->type == RTL_PASS);
1644 if (execute_one_pass (pass) && pass->sub)
1645 execute_pass_list (pass->sub);
1651 /* Same as execute_pass_list but assume that subpasses of IPA passes
1652 are local passes. If SET is not NULL, write out summaries of only
1653 those node in SET. */
1656 ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
1657 varpool_node_set vset,
1658 struct lto_out_decl_state *state)
1662 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
1663 gcc_assert (!current_function_decl);
1665 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1666 if (pass->type == IPA_PASS
1667 && ipa_pass->write_summary
1668 && (!pass->gate || pass->gate ()))
1670 /* If a timevar is present, start it. */
1672 timevar_push (pass->tv_id);
1674 ipa_pass->write_summary (set,vset);
1676 /* If a timevar is present, start it. */
1678 timevar_pop (pass->tv_id);
1681 if (pass->sub && pass->sub->type != GIMPLE_PASS)
1682 ipa_write_summaries_2 (pass->sub, set, vset, state);
1688 /* Helper function of ipa_write_summaries. Creates and destroys the
1689 decl state and calls ipa_write_summaries_2 for all passes that have
1690 summaries. SET is the set of nodes to be written. */
1693 ipa_write_summaries_1 (cgraph_node_set set, varpool_node_set vset)
1695 struct lto_out_decl_state *state = lto_new_out_decl_state ();
1696 compute_ltrans_boundary (state, set, vset);
1698 lto_push_out_decl_state (state);
1700 gcc_assert (!flag_wpa);
1701 ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state);
1702 ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state);
1704 gcc_assert (lto_get_out_decl_state () == state);
1705 lto_pop_out_decl_state ();
1706 lto_delete_out_decl_state (state);
1709 /* Write out summaries for all the nodes in the callgraph. */
1712 ipa_write_summaries (void)
1714 cgraph_node_set set;
1715 varpool_node_set vset;
1716 struct cgraph_node **order;
1717 struct varpool_node *vnode;
1720 if (!flag_generate_lto || errorcount || sorrycount)
1723 set = cgraph_node_set_new ();
1725 /* Create the callgraph set in the same order used in
1726 cgraph_expand_all_functions. This mostly facilitates debugging,
1727 since it causes the gimple file to be processed in the same order
1728 as the source code. */
1729 order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1730 order_pos = cgraph_postorder (order);
1731 gcc_assert (order_pos == cgraph_n_nodes);
1733 for (i = order_pos - 1; i >= 0; i--)
1735 struct cgraph_node *node = order[i];
1739 /* When streaming out references to statements as part of some IPA
1740 pass summary, the statements need to have uids assigned and the
1741 following does that for all the IPA passes here. Naturally, this
1742 ordering then matches the one IPA-passes get in their stmt_fixup
1745 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1746 renumber_gimple_stmt_uids ();
1750 cgraph_node_set_add (set, node);
1752 vset = varpool_node_set_new ();
1754 for (vnode = varpool_nodes; vnode; vnode = vnode->next)
1755 if (vnode->needed && !vnode->alias)
1756 varpool_node_set_add (vset, vnode);
1758 ipa_write_summaries_1 (set, vset);
1765 /* Same as execute_pass_list but assume that subpasses of IPA passes
1766 are local passes. If SET is not NULL, write out optimization summaries of
1767 only those node in SET. */
1770 ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
1771 varpool_node_set vset,
1772 struct lto_out_decl_state *state)
1776 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
1777 gcc_assert (!current_function_decl);
1779 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1780 if (pass->type == IPA_PASS
1781 && ipa_pass->write_optimization_summary
1782 && (!pass->gate || pass->gate ()))
1784 /* If a timevar is present, start it. */
1786 timevar_push (pass->tv_id);
1788 ipa_pass->write_optimization_summary (set, vset);
1790 /* If a timevar is present, start it. */
1792 timevar_pop (pass->tv_id);
1795 if (pass->sub && pass->sub->type != GIMPLE_PASS)
1796 ipa_write_optimization_summaries_1 (pass->sub, set, vset, state);
1802 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
1803 NULL, write out all summaries of all nodes. */
1806 ipa_write_optimization_summaries (cgraph_node_set set, varpool_node_set vset)
1808 struct lto_out_decl_state *state = lto_new_out_decl_state ();
1809 compute_ltrans_boundary (state, set, vset);
1811 lto_push_out_decl_state (state);
1813 gcc_assert (flag_wpa);
1814 ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state);
1815 ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state);
1817 gcc_assert (lto_get_out_decl_state () == state);
1818 lto_pop_out_decl_state ();
1819 lto_delete_out_decl_state (state);
1822 /* Same as execute_pass_list but assume that subpasses of IPA passes
1823 are local passes. */
1826 ipa_read_summaries_1 (struct opt_pass *pass)
1830 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
1832 gcc_assert (!current_function_decl);
1834 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1836 if (pass->gate == NULL || pass->gate ())
1838 if (pass->type == IPA_PASS && ipa_pass->read_summary)
1840 /* If a timevar is present, start it. */
1842 timevar_push (pass->tv_id);
1844 ipa_pass->read_summary ();
1848 timevar_pop (pass->tv_id);
1851 if (pass->sub && pass->sub->type != GIMPLE_PASS)
1852 ipa_read_summaries_1 (pass->sub);
1859 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
1862 ipa_read_summaries (void)
1864 ipa_read_summaries_1 (all_regular_ipa_passes);
1865 ipa_read_summaries_1 (all_lto_gen_passes);
1868 /* Same as execute_pass_list but assume that subpasses of IPA passes
1869 are local passes. */
1872 ipa_read_optimization_summaries_1 (struct opt_pass *pass)
1876 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
1878 gcc_assert (!current_function_decl);
1880 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1882 if (pass->gate == NULL || pass->gate ())
1884 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
1886 /* If a timevar is present, start it. */
1888 timevar_push (pass->tv_id);
1890 ipa_pass->read_optimization_summary ();
1894 timevar_pop (pass->tv_id);
1897 if (pass->sub && pass->sub->type != GIMPLE_PASS)
1898 ipa_read_optimization_summaries_1 (pass->sub);
1904 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
1907 ipa_read_optimization_summaries (void)
1909 ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
1910 ipa_read_optimization_summaries_1 (all_lto_gen_passes);
1913 /* Same as execute_pass_list but assume that subpasses of IPA passes
1914 are local passes. */
1916 execute_ipa_pass_list (struct opt_pass *pass)
1920 gcc_assert (!current_function_decl);
1922 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1923 if (execute_one_pass (pass) && pass->sub)
1925 if (pass->sub->type == GIMPLE_PASS)
1927 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
1928 do_per_function_toporder ((void (*)(void *))execute_pass_list,
1930 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
1932 else if (pass->sub->type == SIMPLE_IPA_PASS
1933 || pass->sub->type == IPA_PASS)
1934 execute_ipa_pass_list (pass->sub);
1938 gcc_assert (!current_function_decl);
1939 cgraph_process_new_functions ();
1945 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
1948 execute_ipa_stmt_fixups (struct opt_pass *pass,
1949 struct cgraph_node *node, gimple *stmts)
1953 /* Execute all of the IPA_PASSes in the list. */
1954 if (pass->type == IPA_PASS
1955 && (!pass->gate || pass->gate ()))
1957 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
1959 if (ipa_pass->stmt_fixup)
1961 pass_init_dump_file (pass);
1962 /* If a timevar is present, start it. */
1964 timevar_push (pass->tv_id);
1966 ipa_pass->stmt_fixup (node, stmts);
1970 timevar_pop (pass->tv_id);
1971 pass_fini_dump_file (pass);
1974 execute_ipa_stmt_fixups (pass->sub, node, stmts);
1980 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
1983 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
1985 execute_ipa_stmt_fixups (all_regular_ipa_passes, node, stmts);
1989 extern void debug_properties (unsigned int);
1990 extern void dump_properties (FILE *, unsigned int);
1993 dump_properties (FILE *dump, unsigned int props)
1995 fprintf (dump, "Properties:\n");
1996 if (props & PROP_gimple_any)
1997 fprintf (dump, "PROP_gimple_any\n");
1998 if (props & PROP_gimple_lcf)
1999 fprintf (dump, "PROP_gimple_lcf\n");
2000 if (props & PROP_gimple_leh)
2001 fprintf (dump, "PROP_gimple_leh\n");
2002 if (props & PROP_cfg)
2003 fprintf (dump, "PROP_cfg\n");
2004 if (props & PROP_referenced_vars)
2005 fprintf (dump, "PROP_referenced_vars\n");
2006 if (props & PROP_ssa)
2007 fprintf (dump, "PROP_ssa\n");
2008 if (props & PROP_no_crit_edges)
2009 fprintf (dump, "PROP_no_crit_edges\n");
2010 if (props & PROP_rtl)
2011 fprintf (dump, "PROP_rtl\n");
2012 if (props & PROP_gimple_lomp)
2013 fprintf (dump, "PROP_gimple_lomp\n");
2014 if (props & PROP_gimple_lcx)
2015 fprintf (dump, "PROP_gimple_lcx\n");
2019 debug_properties (unsigned int props)
2021 dump_properties (stderr, props);
2024 /* Called by local passes to see if function is called by already processed nodes.
2025 Because we process nodes in topological order, this means that function is
2026 in recursive cycle or we introduced new direct calls. */
2028 function_called_by_processed_nodes_p (void)
2030 struct cgraph_edge *e;
2031 for (e = cgraph_node (current_function_decl)->callers; e; e = e->next_caller)
2033 if (e->caller->decl == current_function_decl)
2035 if (!e->caller->analyzed)
2037 if (TREE_ASM_WRITTEN (e->caller->decl))
2039 if (!e->caller->process && !e->caller->global.inlined_to)
2044 fprintf (dump_file, "Already processed call to:\n");
2045 dump_cgraph_node (dump_file, e->caller);
2050 #include "gt-passes.h"