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"
37 #include "insn-attr.h"
38 #include "insn-config.h"
39 #include "insn-flags.h"
40 #include "hard-reg-set.h"
47 #include "basic-block.h"
53 #include "diagnostic-core.h"
56 #include "dwarf2asm.h"
57 #include "integrate.h"
60 #include "langhooks.h"
61 #include "cfglayout.h"
63 #include "hosthooks.h"
67 #include "value-prof.h"
68 #include "tree-inline.h"
69 #include "tree-flow.h"
70 #include "tree-pass.h"
71 #include "tree-dump.h"
74 #include "lto-streamer.h"
76 #include "ipa-utils.h"
77 #include "tree-pretty-print.h"
79 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
80 #include "dwarf2out.h"
83 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
87 #ifdef SDB_DEBUGGING_INFO
91 #ifdef XCOFF_DEBUGGING_INFO
92 #include "xcoffout.h" /* Needed for external data
93 declarations for e.g. AIX 4.x. */
96 /* This is used for debugging. It allows the current pass to printed
97 from anywhere in compilation.
98 The variable current_pass is also used for statistics and plugins. */
99 struct opt_pass *current_pass;
101 static void register_pass_name (struct opt_pass *, const char *);
103 /* Call from anywhere to find out what pass this is. Useful for
104 printing out debugging information deep inside an service
107 print_current_pass (FILE *file)
110 fprintf (file, "current pass = %s (%d)\n",
111 current_pass->name, current_pass->static_pass_number);
113 fprintf (file, "no current pass.\n");
117 /* Call from the debugger to get the current pass name. */
121 print_current_pass (stderr);
126 /* Global variables used to communicate with passes. */
129 bool first_pass_instance;
132 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
135 This does nothing for local (non-static) variables, unless the
136 variable is a register variable with DECL_ASSEMBLER_NAME set. In
137 that case, or if the variable is not an automatic, it sets up the
138 RTL and outputs any assembler code (label definition, storage
139 allocation and initialization).
141 DECL is the declaration. TOP_LEVEL is nonzero
142 if this declaration is not within a function. */
145 rest_of_decl_compilation (tree decl,
149 /* We deferred calling assemble_alias so that we could collect
150 other attributes such as visibility. Emit the alias now. */
154 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
157 alias = TREE_VALUE (TREE_VALUE (alias));
158 alias = get_identifier (TREE_STRING_POINTER (alias));
159 assemble_alias (decl, alias);
163 /* Can't defer this, because it needs to happen before any
164 later function definitions are processed. */
165 if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
166 make_decl_rtl (decl);
168 /* Forward declarations for nested functions are not "external",
169 but we need to treat them as if they were. */
170 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
171 || TREE_CODE (decl) == FUNCTION_DECL)
173 timevar_push (TV_VARCONST);
175 /* Don't output anything when a tentative file-scope definition
176 is seen. But at end of compilation, do output code for them.
178 We do output all variables and rely on
179 callgraph code to defer them except for forward declarations
180 (see gcc.c-torture/compile/920624-1.c) */
182 || !DECL_DEFER_OUTPUT (decl)
183 || DECL_INITIAL (decl))
184 && !DECL_EXTERNAL (decl))
186 /* When reading LTO unit, we also read varpool, so do not
188 if (in_lto_p && !at_end)
190 else if (TREE_CODE (decl) != FUNCTION_DECL)
191 varpool_finalize_decl (decl);
194 #ifdef ASM_FINISH_DECLARE_OBJECT
195 if (decl == last_assemble_variable_decl)
197 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
202 timevar_pop (TV_VARCONST);
204 else if (TREE_CODE (decl) == TYPE_DECL
205 /* Like in rest_of_type_compilation, avoid confusing the debug
206 information machinery when there are errors. */
209 timevar_push (TV_SYMOUT);
210 debug_hooks->type_decl (decl, !top_level);
211 timevar_pop (TV_SYMOUT);
214 /* Let cgraph know about the existence of variables. */
215 if (in_lto_p && !at_end)
217 else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
218 && TREE_STATIC (decl))
222 /* Called after finishing a record, union or enumeral type. */
225 rest_of_type_compilation (tree type, int toplev)
227 /* Avoid confusing the debug information machinery when there are
232 timevar_push (TV_SYMOUT);
233 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
234 timevar_pop (TV_SYMOUT);
240 finish_optimization_passes (void)
243 struct dump_file_info *dfi;
246 timevar_push (TV_DUMP);
247 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
249 dump_file = dump_begin (pass_profile.pass.static_pass_number, NULL);
252 dump_end (pass_profile.pass.static_pass_number, dump_file);
257 dump_file = dump_begin (pass_combine.pass.static_pass_number, NULL);
260 dump_combine_total_stats (dump_file);
261 dump_end (pass_combine.pass.static_pass_number, dump_file);
265 /* Do whatever is necessary to finish printing the graphs. */
266 if (graph_dump_format != no_graph)
267 for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
268 if (dump_initialized_p (i)
269 && (dfi->flags & TDF_GRAPH) != 0
270 && (name = get_dump_file_name (i)) != NULL)
272 finish_graph_dump_file (name);
276 timevar_pop (TV_DUMP);
280 gate_rest_of_compilation (void)
282 /* Early return if there were errors. We can run afoul of our
283 consistency checks, and there's not really much point in fixing them. */
284 return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
287 struct gimple_opt_pass pass_rest_of_compilation =
291 "*rest_of_compilation", /* name */
292 gate_rest_of_compilation, /* gate */
296 0, /* static_pass_number */
297 TV_REST_OF_COMPILATION, /* tv_id */
298 PROP_rtl, /* properties_required */
299 0, /* properties_provided */
300 0, /* properties_destroyed */
301 0, /* todo_flags_start */
302 TODO_ggc_collect /* todo_flags_finish */
307 gate_postreload (void)
309 return reload_completed;
312 struct rtl_opt_pass pass_postreload =
316 "*all-postreload", /* name */
317 gate_postreload, /* gate */
321 0, /* static_pass_number */
322 TV_POSTRELOAD, /* tv_id */
323 PROP_rtl, /* properties_required */
324 0, /* properties_provided */
325 0, /* properties_destroyed */
326 0, /* todo_flags_start */
327 TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */
333 /* The root of the compilation pass tree, once constructed. */
334 struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes,
335 *all_regular_ipa_passes, *all_late_ipa_passes, *all_lto_gen_passes;
337 /* This is used by plugins, and should also be used in register_pass. */
338 #define DEF_PASS_LIST(LIST) &LIST,
339 struct opt_pass **gcc_pass_lists[] = { GCC_PASS_LISTS NULL };
342 /* A map from static pass id to optimization pass. */
343 struct opt_pass **passes_by_id;
344 int passes_by_id_size;
346 /* Set the static pass number of pass PASS to ID and record that
347 in the mapping from static pass number to pass. */
350 set_pass_for_id (int id, struct opt_pass *pass)
352 pass->static_pass_number = id;
353 if (passes_by_id_size <= id)
355 passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1);
356 memset (passes_by_id + passes_by_id_size, 0,
357 (id + 1 - passes_by_id_size) * sizeof (void *));
358 passes_by_id_size = id + 1;
360 passes_by_id[id] = pass;
363 /* Return the pass with the static pass number ID. */
366 get_pass_for_id (int id)
368 if (id >= passes_by_id_size)
370 return passes_by_id[id];
373 /* Iterate over the pass tree allocating dump file numbers. We want
374 to do this depth first, and independent of whether the pass is
378 register_one_dump_file (struct opt_pass *pass)
380 char *dot_name, *flag_name, *glob_name;
381 const char *name, *full_name, *prefix;
385 /* See below in next_pass_1. */
387 if (pass->static_pass_number != -1)
388 sprintf (num, "%d", ((int) pass->static_pass_number < 0
389 ? 1 : pass->static_pass_number));
391 /* The name is both used to identify the pass for the purposes of plugins,
392 and to specify dump file name and option.
393 The latter two might want something short which is not quite unique; for
394 that reason, we may have a disambiguating prefix, followed by a space
395 to mark the start of the following dump file name / option string. */
396 name = strchr (pass->name, ' ');
397 name = name ? name + 1 : pass->name;
398 dot_name = concat (".", name, num, NULL);
399 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
400 prefix = "ipa-", flags = TDF_IPA;
401 else if (pass->type == GIMPLE_PASS)
402 prefix = "tree-", flags = TDF_TREE;
404 prefix = "rtl-", flags = TDF_RTL;
406 flag_name = concat (prefix, name, num, NULL);
407 glob_name = concat (prefix, name, NULL);
408 id = dump_register (dot_name, flag_name, glob_name, flags);
409 set_pass_for_id (id, pass);
410 full_name = concat (prefix, pass->name, num, NULL);
411 register_pass_name (pass, full_name);
414 /* Recursive worker function for register_dump_files. */
417 register_dump_files_1 (struct opt_pass *pass, int properties)
421 int new_properties = (properties | pass->properties_provided)
422 & ~pass->properties_destroyed;
424 if (pass->name && pass->name[0] != '*')
425 register_one_dump_file (pass);
428 new_properties = register_dump_files_1 (pass->sub, new_properties);
430 /* If we have a gate, combine the properties that we could have with
431 and without the pass being examined. */
433 properties &= new_properties;
435 properties = new_properties;
444 /* Register the dump files for the pipeline starting at PASS.
445 PROPERTIES reflects the properties that are guaranteed to be available at
446 the beginning of the pipeline. */
449 register_dump_files (struct opt_pass *pass,int properties)
451 pass->properties_required |= properties;
452 register_dump_files_1 (pass, properties);
457 const char* unique_name;
458 struct opt_pass *pass;
461 /* Pass registry hash function. */
464 passr_hash (const void *p)
466 const struct pass_registry *const s = (const struct pass_registry *const) p;
467 return htab_hash_string (s->unique_name);
470 /* Hash equal function */
473 passr_eq (const void *p1, const void *p2)
475 const struct pass_registry *const s1 = (const struct pass_registry *const) p1;
476 const struct pass_registry *const s2 = (const struct pass_registry *const) p2;
478 return !strcmp (s1->unique_name, s2->unique_name);
481 static htab_t name_to_pass_map = NULL;
483 /* Register PASS with NAME. */
486 register_pass_name (struct opt_pass *pass, const char *name)
488 struct pass_registry **slot;
489 struct pass_registry pr;
491 if (!name_to_pass_map)
492 name_to_pass_map = htab_create (256, passr_hash, passr_eq, NULL);
494 pr.unique_name = name;
495 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map, &pr, INSERT);
498 struct pass_registry *new_pr;
500 new_pr = XCNEW (struct pass_registry);
501 new_pr->unique_name = xstrdup (name);
506 return; /* Ignore plugin passes. */
509 /* Map from pass id to canonicalized pass name. */
511 typedef const char *char_ptr;
513 DEF_VEC_ALLOC_P(char_ptr, heap);
514 static VEC(char_ptr, heap) *pass_tab = NULL;
516 /* Callback function for traversing NAME_TO_PASS_MAP. */
519 pass_traverse (void **slot, void *data ATTRIBUTE_UNUSED)
521 struct pass_registry **p = (struct pass_registry **)slot;
522 struct opt_pass *pass = (*p)->pass;
524 gcc_assert (pass->static_pass_number > 0);
525 gcc_assert (pass_tab);
527 VEC_replace (char_ptr, pass_tab, pass->static_pass_number,
533 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
534 table for dumping purpose. */
537 create_pass_tab (void)
539 if (!flag_dump_passes)
542 VEC_safe_grow_cleared (char_ptr, heap,
543 pass_tab, passes_by_id_size + 1);
544 htab_traverse (name_to_pass_map, pass_traverse, NULL);
547 static bool override_gate_status (struct opt_pass *, tree, bool);
549 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
550 is turned on or not. */
553 dump_one_pass (struct opt_pass *pass, int pass_indent)
555 int indent = 3 * pass_indent;
557 bool is_on, is_really_on;
559 is_on = (pass->gate == NULL) ? true : pass->gate();
560 is_really_on = override_gate_status (pass, current_function_decl, is_on);
562 if (pass->static_pass_number <= 0)
565 pn = VEC_index (char_ptr, pass_tab, pass->static_pass_number);
567 fprintf (stderr, "%*s%-40s%*s:%s%s\n", indent, " ", pn,
568 (15 - indent < 0 ? 0 : 15 - indent), " ",
569 is_on ? " ON" : " OFF",
570 ((!is_on) == (!is_really_on) ? ""
571 : (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)")));
574 /* Dump pass list PASS with indentation INDENT. */
577 dump_pass_list (struct opt_pass *pass, int indent)
581 dump_one_pass (pass, indent);
583 dump_pass_list (pass->sub, indent + 1);
589 /* Dump all optimization passes. */
594 struct cgraph_node *n, *node = NULL;
595 tree save_fndecl = current_function_decl;
602 if (DECL_STRUCT_FUNCTION (n->decl))
613 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
614 current_function_decl = node->decl;
616 dump_pass_list (all_lowering_passes, 1);
617 dump_pass_list (all_small_ipa_passes, 1);
618 dump_pass_list (all_regular_ipa_passes, 1);
619 dump_pass_list (all_lto_gen_passes, 1);
620 dump_pass_list (all_late_ipa_passes, 1);
621 dump_pass_list (all_passes, 1);
624 current_function_decl = save_fndecl;
628 /* Returns the pass with NAME. */
630 static struct opt_pass *
631 get_pass_by_name (const char *name)
633 struct pass_registry **slot, pr;
635 pr.unique_name = name;
636 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map,
642 return (*slot)->pass;
646 /* Range [start, last]. */
652 const char *assem_name;
653 struct uid_range *next;
656 typedef struct uid_range *uid_range_p;
658 DEF_VEC_P(uid_range_p);
659 DEF_VEC_ALLOC_P(uid_range_p, heap);
661 static VEC(uid_range_p, heap) *enabled_pass_uid_range_tab = NULL;
662 static VEC(uid_range_p, heap) *disabled_pass_uid_range_tab = NULL;
665 /* Parse option string for -fdisable- and -fenable-
666 The syntax of the options:
669 -fdisable-<pass_name>
671 -fenable-<pass_name>=s1:e1,s2:e2,...
672 -fdisable-<pass_name>=s1:e1,s2:e2,...
676 enable_disable_pass (const char *arg, bool is_enable)
678 struct opt_pass *pass;
679 char *range_str, *phase_name;
680 char *argstr = xstrdup (arg);
681 VEC(uid_range_p, heap) **tab = 0;
683 range_str = strchr (argstr,'=');
694 error ("unrecognized option -fenable");
696 error ("unrecognized option -fdisable");
700 pass = get_pass_by_name (phase_name);
701 if (!pass || pass->static_pass_number == -1)
704 error ("unknown pass %s specified in -fenable", phase_name);
706 error ("unknown pass %s specified in -fdisble", phase_name);
712 tab = &enabled_pass_uid_range_tab;
714 tab = &disabled_pass_uid_range_tab;
716 if ((unsigned) pass->static_pass_number >= VEC_length (uid_range_p, *tab))
717 VEC_safe_grow_cleared (uid_range_p, heap,
718 *tab, pass->static_pass_number + 1);
723 uid_range_p new_range = XCNEW (struct uid_range);
725 new_range->start = 0;
726 new_range->last = (unsigned)-1;
728 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number);
729 new_range->next = slot;
730 VEC_replace (uid_range_p, *tab, pass->static_pass_number,
733 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
734 "of [%u, %u]", phase_name, new_range->start, new_range->last);
736 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
737 "of [%u, %u]", phase_name, new_range->start, new_range->last);
741 char *next_range = NULL;
742 char *one_range = range_str;
743 char *end_val = NULL;
748 uid_range_p new_range;
749 char *invalid = NULL;
751 char *func_name = NULL;
753 next_range = strchr (one_range, ',');
760 end_val = strchr (one_range, ':');
766 start = strtol (one_range, &invalid, 10);
767 if (*invalid || start < 0)
769 if (end_val || (one_range[0] >= '0'
770 && one_range[0] <= '9'))
772 error ("Invalid range %s in option %s",
774 is_enable ? "-fenable" : "-fdisable");
778 func_name = one_range;
782 new_range = XCNEW (struct uid_range);
785 new_range->start = (unsigned) start;
786 new_range->last = (unsigned) start;
790 new_range->start = (unsigned) -1;
791 new_range->last = (unsigned) -1;
792 new_range->assem_name = xstrdup (func_name);
797 long last = strtol (end_val, &invalid, 10);
798 if (*invalid || last < start)
800 error ("Invalid range %s in option %s",
802 is_enable ? "-fenable" : "-fdisable");
806 new_range = XCNEW (struct uid_range);
807 new_range->start = (unsigned) start;
808 new_range->last = (unsigned) last;
811 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number);
812 new_range->next = slot;
813 VEC_replace (uid_range_p, *tab, pass->static_pass_number,
817 if (new_range->assem_name)
818 inform (UNKNOWN_LOCATION,
819 "enable pass %s for function %s",
820 phase_name, new_range->assem_name);
822 inform (UNKNOWN_LOCATION,
823 "enable pass %s for functions in the range of [%u, %u]",
824 phase_name, new_range->start, new_range->last);
828 if (new_range->assem_name)
829 inform (UNKNOWN_LOCATION,
830 "disable pass %s for function %s",
831 phase_name, new_range->assem_name);
833 inform (UNKNOWN_LOCATION,
834 "disable pass %s for functions in the range of [%u, %u]",
835 phase_name, new_range->start, new_range->last);
838 one_range = next_range;
839 } while (next_range);
845 /* Enable pass specified by ARG. */
848 enable_pass (const char *arg)
850 enable_disable_pass (arg, true);
853 /* Disable pass specified by ARG. */
856 disable_pass (const char *arg)
858 enable_disable_pass (arg, false);
861 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
864 is_pass_explicitly_enabled_or_disabled (struct opt_pass *pass,
866 VEC(uid_range_p, heap) *tab)
868 uid_range_p slot, range;
870 const char *aname = NULL;
873 || (unsigned) pass->static_pass_number >= VEC_length (uid_range_p, tab)
874 || pass->static_pass_number == -1)
877 slot = VEC_index (uid_range_p, tab, pass->static_pass_number);
881 cgraph_uid = func ? cgraph_get_node (func)->uid : 0;
882 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
883 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
888 if ((unsigned) cgraph_uid >= range->start
889 && (unsigned) cgraph_uid <= range->last)
891 if (range->assem_name && aname
892 && !strcmp (range->assem_name, aname))
900 /* Look at the static_pass_number and duplicate the pass
901 if it is already added to a list. */
903 static struct opt_pass *
904 make_pass_instance (struct opt_pass *pass, bool track_duplicates)
906 /* A nonzero static_pass_number indicates that the
907 pass is already in the list. */
908 if (pass->static_pass_number)
910 struct opt_pass *new_pass;
912 if (pass->type == GIMPLE_PASS
913 || pass->type == RTL_PASS
914 || pass->type == SIMPLE_IPA_PASS)
916 new_pass = XNEW (struct opt_pass);
917 memcpy (new_pass, pass, sizeof (struct opt_pass));
919 else if (pass->type == IPA_PASS)
921 new_pass = (struct opt_pass *)XNEW (struct ipa_opt_pass_d);
922 memcpy (new_pass, pass, sizeof (struct ipa_opt_pass_d));
927 new_pass->next = NULL;
929 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
931 /* Indicate to register_dump_files that this pass has duplicates,
932 and so it should rename the dump file. The first instance will
933 be -1, and be number of duplicates = -static_pass_number - 1.
934 Subsequent instances will be > 0 and just the duplicate number. */
935 if ((pass->name && pass->name[0] != '*') || track_duplicates)
937 pass->static_pass_number -= 1;
938 new_pass->static_pass_number = -pass->static_pass_number;
944 pass->todo_flags_start |= TODO_mark_first_instance;
945 pass->static_pass_number = -1;
947 invoke_plugin_callbacks (PLUGIN_NEW_PASS, pass);
952 /* Add a pass to the pass list. Duplicate the pass if it's already
955 static struct opt_pass **
956 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
958 /* Every pass should have a name so that plugins can refer to them. */
959 gcc_assert (pass->name != NULL);
961 *list = make_pass_instance (pass, false);
963 return &(*list)->next;
966 /* List node for an inserted pass instance. We need to keep track of all
967 the newly-added pass instances (with 'added_pass_nodes' defined below)
968 so that we can register their dump files after pass-positioning is finished.
969 Registering dumping files needs to be post-processed or the
970 static_pass_number of the opt_pass object would be modified and mess up
971 the dump file names of future pass instances to be added. */
973 struct pass_list_node
975 struct opt_pass *pass;
976 struct pass_list_node *next;
979 static struct pass_list_node *added_pass_nodes = NULL;
980 static struct pass_list_node *prev_added_pass_node;
982 /* Insert the pass at the proper position. Return true if the pass
983 is successfully added.
985 NEW_PASS_INFO - new pass to be inserted
986 PASS_LIST - root of the pass list to insert the new pass to */
989 position_pass (struct register_pass_info *new_pass_info,
990 struct opt_pass **pass_list)
992 struct opt_pass *pass = *pass_list, *prev_pass = NULL;
993 bool success = false;
995 for ( ; pass; prev_pass = pass, pass = pass->next)
997 /* Check if the current pass is of the same type as the new pass and
998 matches the name and the instance number of the reference pass. */
999 if (pass->type == new_pass_info->pass->type
1001 && !strcmp (pass->name, new_pass_info->reference_pass_name)
1002 && ((new_pass_info->ref_pass_instance_number == 0)
1003 || (new_pass_info->ref_pass_instance_number ==
1004 pass->static_pass_number)
1005 || (new_pass_info->ref_pass_instance_number == 1
1006 && pass->todo_flags_start & TODO_mark_first_instance)))
1008 struct opt_pass *new_pass;
1009 struct pass_list_node *new_pass_node;
1011 new_pass = make_pass_instance (new_pass_info->pass, true);
1013 /* Insert the new pass instance based on the positioning op. */
1014 switch (new_pass_info->pos_op)
1016 case PASS_POS_INSERT_AFTER:
1017 new_pass->next = pass->next;
1018 pass->next = new_pass;
1020 /* Skip newly inserted pass to avoid repeated
1021 insertions in the case where the new pass and the
1022 existing one have the same name. */
1025 case PASS_POS_INSERT_BEFORE:
1026 new_pass->next = pass;
1028 prev_pass->next = new_pass;
1030 *pass_list = new_pass;
1032 case PASS_POS_REPLACE:
1033 new_pass->next = pass->next;
1035 prev_pass->next = new_pass;
1037 *pass_list = new_pass;
1038 new_pass->sub = pass->sub;
1039 new_pass->tv_id = pass->tv_id;
1043 error ("invalid pass positioning operation");
1047 /* Save the newly added pass (instance) in the added_pass_nodes
1048 list so that we can register its dump file later. Note that
1049 we cannot register the dump file now because doing so will modify
1050 the static_pass_number of the opt_pass object and therefore
1051 mess up the dump file name of future instances. */
1052 new_pass_node = XCNEW (struct pass_list_node);
1053 new_pass_node->pass = new_pass;
1054 if (!added_pass_nodes)
1055 added_pass_nodes = new_pass_node;
1057 prev_added_pass_node->next = new_pass_node;
1058 prev_added_pass_node = new_pass_node;
1063 if (pass->sub && position_pass (new_pass_info, &pass->sub))
1070 /* Hooks a new pass into the pass lists.
1072 PASS_INFO - pass information that specifies the opt_pass object,
1073 reference pass, instance number, and how to position
1077 register_pass (struct register_pass_info *pass_info)
1079 bool all_instances, success;
1081 /* The checks below could fail in buggy plugins. Existing GCC
1082 passes should never fail these checks, so we mention plugin in
1084 if (!pass_info->pass)
1085 fatal_error ("plugin cannot register a missing pass");
1087 if (!pass_info->pass->name)
1088 fatal_error ("plugin cannot register an unnamed pass");
1090 if (!pass_info->reference_pass_name)
1092 ("plugin cannot register pass %qs without reference pass name",
1093 pass_info->pass->name);
1095 /* Try to insert the new pass to the pass lists. We need to check
1096 all five lists as the reference pass could be in one (or all) of
1098 all_instances = pass_info->ref_pass_instance_number == 0;
1099 success = position_pass (pass_info, &all_lowering_passes);
1100 if (!success || all_instances)
1101 success |= position_pass (pass_info, &all_small_ipa_passes);
1102 if (!success || all_instances)
1103 success |= position_pass (pass_info, &all_regular_ipa_passes);
1104 if (!success || all_instances)
1105 success |= position_pass (pass_info, &all_lto_gen_passes);
1106 if (!success || all_instances)
1107 success |= position_pass (pass_info, &all_late_ipa_passes);
1108 if (!success || all_instances)
1109 success |= position_pass (pass_info, &all_passes);
1112 ("pass %qs not found but is referenced by new pass %qs",
1113 pass_info->reference_pass_name, pass_info->pass->name);
1115 /* OK, we have successfully inserted the new pass. We need to register
1116 the dump files for the newly added pass and its duplicates (if any).
1117 Because the registration of plugin/backend passes happens after the
1118 command-line options are parsed, the options that specify single
1119 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1120 passes. Therefore we currently can only enable dumping of
1121 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1122 are specified. While doing so, we also delete the pass_list_node
1123 objects created during pass positioning. */
1124 while (added_pass_nodes)
1126 struct pass_list_node *next_node = added_pass_nodes->next;
1127 enum tree_dump_index tdi;
1128 register_one_dump_file (added_pass_nodes->pass);
1129 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
1130 || added_pass_nodes->pass->type == IPA_PASS)
1132 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
1136 /* Check if dump-all flag is specified. */
1137 if (get_dump_file_info (tdi)->state)
1138 get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1139 ->state = get_dump_file_info (tdi)->state;
1140 XDELETE (added_pass_nodes);
1141 added_pass_nodes = next_node;
1145 /* Construct the pass tree. The sequencing of passes is driven by
1146 the cgraph routines:
1148 cgraph_finalize_compilation_unit ()
1149 for each node N in the cgraph
1150 cgraph_analyze_function (N)
1151 cgraph_lower_function (N) -> all_lowering_passes
1153 If we are optimizing, cgraph_optimize is then invoked:
1156 ipa_passes () -> all_small_ipa_passes
1157 cgraph_expand_all_functions ()
1158 for each node N in the cgraph
1159 cgraph_expand_function (N)
1160 tree_rest_of_compilation (DECL (N)) -> all_passes
1164 init_optimization_passes (void)
1166 struct opt_pass **p;
1168 #define NEXT_PASS(PASS) (p = next_pass_1 (p, &((PASS).pass)))
1170 /* All passes needed to lower the function into shape optimizers can
1171 operate on. These passes are always run first on the function, but
1172 backend might produce already lowered functions that are not processed
1174 p = &all_lowering_passes;
1175 NEXT_PASS (pass_warn_unused_result);
1176 NEXT_PASS (pass_diagnose_omp_blocks);
1177 NEXT_PASS (pass_mudflap_1);
1178 NEXT_PASS (pass_lower_omp);
1179 NEXT_PASS (pass_lower_cf);
1180 NEXT_PASS (pass_refactor_eh);
1181 NEXT_PASS (pass_lower_eh);
1182 NEXT_PASS (pass_build_cfg);
1183 NEXT_PASS (pass_warn_function_return);
1184 NEXT_PASS (pass_build_cgraph_edges);
1187 /* Interprocedural optimization passes. */
1188 p = &all_small_ipa_passes;
1189 NEXT_PASS (pass_ipa_free_lang_data);
1190 NEXT_PASS (pass_ipa_function_and_variable_visibility);
1191 NEXT_PASS (pass_early_local_passes);
1193 struct opt_pass **p = &pass_early_local_passes.pass.sub;
1194 NEXT_PASS (pass_fixup_cfg);
1195 NEXT_PASS (pass_init_datastructures);
1196 NEXT_PASS (pass_expand_omp);
1198 NEXT_PASS (pass_referenced_vars);
1199 NEXT_PASS (pass_build_ssa);
1200 NEXT_PASS (pass_lower_vector);
1201 NEXT_PASS (pass_early_warn_uninitialized);
1202 NEXT_PASS (pass_rebuild_cgraph_edges);
1203 NEXT_PASS (pass_inline_parameters);
1204 NEXT_PASS (pass_early_inline);
1205 NEXT_PASS (pass_all_early_optimizations);
1207 struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
1208 NEXT_PASS (pass_remove_cgraph_callee_edges);
1209 NEXT_PASS (pass_rename_ssa_copies);
1210 NEXT_PASS (pass_ccp);
1211 NEXT_PASS (pass_forwprop);
1212 /* pass_build_ealias is a dummy pass that ensures that we
1213 execute TODO_rebuild_alias at this point. Re-building
1214 alias information also rewrites no longer addressed
1215 locals into SSA form if possible. */
1216 NEXT_PASS (pass_build_ealias);
1217 NEXT_PASS (pass_sra_early);
1218 NEXT_PASS (pass_fre);
1219 NEXT_PASS (pass_copy_prop);
1220 NEXT_PASS (pass_merge_phi);
1221 NEXT_PASS (pass_cd_dce);
1222 NEXT_PASS (pass_early_ipa_sra);
1223 NEXT_PASS (pass_tail_recursion);
1224 NEXT_PASS (pass_convert_switch);
1225 NEXT_PASS (pass_cleanup_eh);
1226 NEXT_PASS (pass_profile);
1227 NEXT_PASS (pass_local_pure_const);
1228 /* Split functions creates parts that are not run through
1229 early optimizations again. It is thus good idea to do this
1231 NEXT_PASS (pass_split_functions);
1233 NEXT_PASS (pass_release_ssa_names);
1234 NEXT_PASS (pass_rebuild_cgraph_edges);
1235 NEXT_PASS (pass_inline_parameters);
1237 NEXT_PASS (pass_ipa_tree_profile);
1239 struct opt_pass **p = &pass_ipa_tree_profile.pass.sub;
1240 NEXT_PASS (pass_feedback_split_functions);
1242 NEXT_PASS (pass_ipa_increase_alignment);
1243 NEXT_PASS (pass_ipa_matrix_reorg);
1244 NEXT_PASS (pass_ipa_lower_emutls);
1247 p = &all_regular_ipa_passes;
1248 NEXT_PASS (pass_ipa_whole_program_visibility);
1249 NEXT_PASS (pass_ipa_profile);
1250 NEXT_PASS (pass_ipa_cp);
1251 NEXT_PASS (pass_ipa_cdtor_merge);
1252 NEXT_PASS (pass_ipa_inline);
1253 NEXT_PASS (pass_ipa_pure_const);
1254 NEXT_PASS (pass_ipa_reference);
1257 p = &all_lto_gen_passes;
1258 NEXT_PASS (pass_ipa_lto_gimple_out);
1259 NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */
1262 /* Simple IPA passes executed after the regular passes. In WHOPR mode the
1263 passes are executed after partitioning and thus see just parts of the
1265 p = &all_late_ipa_passes;
1266 NEXT_PASS (pass_ipa_pta);
1268 /* These passes are run after IPA passes on every function that is being
1269 output to the assembler file. */
1271 NEXT_PASS (pass_fixup_cfg);
1272 NEXT_PASS (pass_lower_eh_dispatch);
1273 NEXT_PASS (pass_all_optimizations);
1275 struct opt_pass **p = &pass_all_optimizations.pass.sub;
1276 NEXT_PASS (pass_remove_cgraph_callee_edges);
1277 /* Initial scalar cleanups before alias computation.
1278 They ensure memory accesses are not indirect wherever possible. */
1279 NEXT_PASS (pass_strip_predict_hints);
1280 NEXT_PASS (pass_rename_ssa_copies);
1281 NEXT_PASS (pass_complete_unrolli);
1282 NEXT_PASS (pass_ccp);
1283 NEXT_PASS (pass_forwprop);
1284 NEXT_PASS (pass_call_cdce);
1285 /* pass_build_alias is a dummy pass that ensures that we
1286 execute TODO_rebuild_alias at this point. Re-building
1287 alias information also rewrites no longer addressed
1288 locals into SSA form if possible. */
1289 NEXT_PASS (pass_build_alias);
1290 NEXT_PASS (pass_return_slot);
1291 NEXT_PASS (pass_phiprop);
1292 NEXT_PASS (pass_fre);
1293 NEXT_PASS (pass_copy_prop);
1294 NEXT_PASS (pass_merge_phi);
1295 NEXT_PASS (pass_vrp);
1296 NEXT_PASS (pass_dce);
1297 NEXT_PASS (pass_cselim);
1298 NEXT_PASS (pass_tree_ifcombine);
1299 NEXT_PASS (pass_phiopt);
1300 NEXT_PASS (pass_tail_recursion);
1301 NEXT_PASS (pass_ch);
1302 NEXT_PASS (pass_stdarg);
1303 NEXT_PASS (pass_lower_complex);
1304 NEXT_PASS (pass_sra);
1305 NEXT_PASS (pass_rename_ssa_copies);
1306 /* The dom pass will also resolve all __builtin_constant_p calls
1307 that are still there to 0. This has to be done after some
1308 propagations have already run, but before some more dead code
1309 is removed, and this place fits nicely. Remember this when
1310 trying to move or duplicate pass_dominator somewhere earlier. */
1311 NEXT_PASS (pass_dominator);
1312 /* The only const/copy propagation opportunities left after
1313 DOM should be due to degenerate PHI nodes. So rather than
1314 run the full propagators, run a specialized pass which
1315 only examines PHIs to discover const/copy propagation
1317 NEXT_PASS (pass_phi_only_cprop);
1318 NEXT_PASS (pass_dse);
1319 NEXT_PASS (pass_reassoc);
1320 NEXT_PASS (pass_dce);
1321 NEXT_PASS (pass_forwprop);
1322 NEXT_PASS (pass_phiopt);
1323 NEXT_PASS (pass_object_sizes);
1324 NEXT_PASS (pass_ccp);
1325 NEXT_PASS (pass_copy_prop);
1326 NEXT_PASS (pass_cse_sincos);
1327 NEXT_PASS (pass_optimize_bswap);
1328 NEXT_PASS (pass_split_crit_edges);
1329 NEXT_PASS (pass_pre);
1330 NEXT_PASS (pass_sink_code);
1331 NEXT_PASS (pass_tree_loop);
1333 struct opt_pass **p = &pass_tree_loop.pass.sub;
1334 NEXT_PASS (pass_tree_loop_init);
1335 NEXT_PASS (pass_lim);
1336 NEXT_PASS (pass_copy_prop);
1337 NEXT_PASS (pass_dce_loop);
1338 NEXT_PASS (pass_tree_unswitch);
1339 NEXT_PASS (pass_scev_cprop);
1340 NEXT_PASS (pass_record_bounds);
1341 NEXT_PASS (pass_check_data_deps);
1342 NEXT_PASS (pass_loop_distribution);
1343 NEXT_PASS (pass_copy_prop);
1344 NEXT_PASS (pass_graphite);
1346 struct opt_pass **p = &pass_graphite.pass.sub;
1347 NEXT_PASS (pass_graphite_transforms);
1348 NEXT_PASS (pass_lim);
1349 NEXT_PASS (pass_copy_prop);
1350 NEXT_PASS (pass_dce_loop);
1352 NEXT_PASS (pass_iv_canon);
1353 NEXT_PASS (pass_if_conversion);
1354 NEXT_PASS (pass_vectorize);
1356 struct opt_pass **p = &pass_vectorize.pass.sub;
1357 NEXT_PASS (pass_lower_vector_ssa);
1358 NEXT_PASS (pass_dce_loop);
1360 NEXT_PASS (pass_predcom);
1361 NEXT_PASS (pass_complete_unroll);
1362 NEXT_PASS (pass_slp_vectorize);
1363 NEXT_PASS (pass_parallelize_loops);
1364 NEXT_PASS (pass_loop_prefetch);
1365 NEXT_PASS (pass_iv_optimize);
1366 NEXT_PASS (pass_tree_loop_done);
1368 NEXT_PASS (pass_cse_reciprocals);
1369 NEXT_PASS (pass_reassoc);
1370 NEXT_PASS (pass_vrp);
1371 NEXT_PASS (pass_dominator);
1372 /* The only const/copy propagation opportunities left after
1373 DOM should be due to degenerate PHI nodes. So rather than
1374 run the full propagators, run a specialized pass which
1375 only examines PHIs to discover const/copy propagation
1377 NEXT_PASS (pass_phi_only_cprop);
1378 NEXT_PASS (pass_cd_dce);
1379 NEXT_PASS (pass_tracer);
1381 /* FIXME: If DCE is not run before checking for uninitialized uses,
1382 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
1383 However, this also causes us to misdiagnose cases that should be
1384 real warnings (e.g., testsuite/gcc.dg/pr18501.c).
1386 To fix the false positives in uninit-5.c, we would have to
1387 account for the predicates protecting the set and the use of each
1388 variable. Using a representation like Gated Single Assignment
1390 NEXT_PASS (pass_late_warn_uninitialized);
1391 NEXT_PASS (pass_dse);
1392 NEXT_PASS (pass_forwprop);
1393 NEXT_PASS (pass_phiopt);
1394 NEXT_PASS (pass_fold_builtins);
1395 NEXT_PASS (pass_optimize_widening_mul);
1396 NEXT_PASS (pass_tail_calls);
1397 NEXT_PASS (pass_rename_ssa_copies);
1398 NEXT_PASS (pass_uncprop);
1399 NEXT_PASS (pass_local_pure_const);
1401 NEXT_PASS (pass_lower_complex_O0);
1402 NEXT_PASS (pass_cleanup_eh);
1403 NEXT_PASS (pass_lower_resx);
1404 NEXT_PASS (pass_nrv);
1405 NEXT_PASS (pass_mudflap_2);
1406 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
1407 NEXT_PASS (pass_warn_function_noreturn);
1409 NEXT_PASS (pass_expand);
1411 NEXT_PASS (pass_rest_of_compilation);
1413 struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
1414 NEXT_PASS (pass_init_function);
1415 NEXT_PASS (pass_jump);
1416 NEXT_PASS (pass_rtl_eh);
1417 NEXT_PASS (pass_initial_value_sets);
1418 NEXT_PASS (pass_unshare_all_rtl);
1419 NEXT_PASS (pass_instantiate_virtual_regs);
1420 NEXT_PASS (pass_into_cfg_layout_mode);
1421 NEXT_PASS (pass_jump2);
1422 NEXT_PASS (pass_lower_subreg);
1423 NEXT_PASS (pass_df_initialize_opt);
1424 NEXT_PASS (pass_cse);
1425 NEXT_PASS (pass_rtl_fwprop);
1426 NEXT_PASS (pass_rtl_cprop);
1427 NEXT_PASS (pass_rtl_pre);
1428 NEXT_PASS (pass_rtl_hoist);
1429 NEXT_PASS (pass_rtl_cprop);
1430 NEXT_PASS (pass_rtl_store_motion);
1431 NEXT_PASS (pass_cse_after_global_opts);
1432 NEXT_PASS (pass_rtl_ifcvt);
1433 NEXT_PASS (pass_reginfo_init);
1434 /* Perform loop optimizations. It might be better to do them a bit
1435 sooner, but we want the profile feedback to work more
1437 NEXT_PASS (pass_loop2);
1439 struct opt_pass **p = &pass_loop2.pass.sub;
1440 NEXT_PASS (pass_rtl_loop_init);
1441 NEXT_PASS (pass_rtl_move_loop_invariants);
1442 NEXT_PASS (pass_rtl_unswitch);
1443 NEXT_PASS (pass_rtl_unroll_and_peel_loops);
1444 NEXT_PASS (pass_rtl_doloop);
1445 NEXT_PASS (pass_rtl_loop_done);
1448 NEXT_PASS (pass_web);
1449 NEXT_PASS (pass_rtl_cprop);
1450 NEXT_PASS (pass_cse2);
1451 NEXT_PASS (pass_rtl_dse1);
1452 NEXT_PASS (pass_rtl_fwprop_addr);
1453 NEXT_PASS (pass_inc_dec);
1454 NEXT_PASS (pass_initialize_regs);
1455 NEXT_PASS (pass_ud_rtl_dce);
1456 NEXT_PASS (pass_combine);
1457 NEXT_PASS (pass_if_after_combine);
1458 NEXT_PASS (pass_partition_blocks);
1459 NEXT_PASS (pass_regmove);
1460 NEXT_PASS (pass_outof_cfg_layout_mode);
1461 NEXT_PASS (pass_split_all_insns);
1462 NEXT_PASS (pass_lower_subreg2);
1463 NEXT_PASS (pass_df_initialize_no_opt);
1464 NEXT_PASS (pass_stack_ptr_mod);
1465 NEXT_PASS (pass_mode_switching);
1466 NEXT_PASS (pass_match_asm_constraints);
1467 NEXT_PASS (pass_sms);
1468 NEXT_PASS (pass_sched);
1469 NEXT_PASS (pass_ira);
1470 NEXT_PASS (pass_postreload);
1472 struct opt_pass **p = &pass_postreload.pass.sub;
1473 NEXT_PASS (pass_postreload_cse);
1474 NEXT_PASS (pass_gcse2);
1475 NEXT_PASS (pass_split_after_reload);
1476 NEXT_PASS (pass_implicit_zee);
1477 NEXT_PASS (pass_compare_elim_after_reload);
1478 NEXT_PASS (pass_branch_target_load_optimize1);
1479 NEXT_PASS (pass_thread_prologue_and_epilogue);
1480 NEXT_PASS (pass_rtl_dse2);
1481 NEXT_PASS (pass_stack_adjustments);
1482 NEXT_PASS (pass_peephole2);
1483 NEXT_PASS (pass_if_after_reload);
1484 NEXT_PASS (pass_regrename);
1485 NEXT_PASS (pass_cprop_hardreg);
1486 NEXT_PASS (pass_fast_rtl_dce);
1487 NEXT_PASS (pass_reorder_blocks);
1488 NEXT_PASS (pass_branch_target_load_optimize2);
1489 NEXT_PASS (pass_leaf_regs);
1490 NEXT_PASS (pass_split_before_sched2);
1491 NEXT_PASS (pass_sched2);
1492 NEXT_PASS (pass_stack_regs);
1494 struct opt_pass **p = &pass_stack_regs.pass.sub;
1495 NEXT_PASS (pass_split_before_regstack);
1496 NEXT_PASS (pass_stack_regs_run);
1498 NEXT_PASS (pass_compute_alignments);
1499 NEXT_PASS (pass_duplicate_computed_gotos);
1500 NEXT_PASS (pass_variable_tracking);
1501 NEXT_PASS (pass_free_cfg);
1502 NEXT_PASS (pass_machine_reorg);
1503 NEXT_PASS (pass_cleanup_barriers);
1504 NEXT_PASS (pass_delay_slots);
1505 NEXT_PASS (pass_split_for_shorten_branches);
1506 NEXT_PASS (pass_convert_to_eh_region_ranges);
1507 NEXT_PASS (pass_shorten_branches);
1508 NEXT_PASS (pass_set_nothrow_function_flags);
1509 NEXT_PASS (pass_final);
1511 NEXT_PASS (pass_df_finish);
1513 NEXT_PASS (pass_clean_state);
1518 /* Register the passes with the tree dump code. */
1519 register_dump_files (all_lowering_passes, PROP_gimple_any);
1520 register_dump_files (all_small_ipa_passes,
1521 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1523 register_dump_files (all_regular_ipa_passes,
1524 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1526 register_dump_files (all_lto_gen_passes,
1527 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1529 register_dump_files (all_late_ipa_passes,
1530 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1532 register_dump_files (all_passes,
1533 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1537 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1538 function CALLBACK for every function in the call graph. Otherwise,
1539 call CALLBACK on the current function. */
1542 do_per_function (void (*callback) (void *data), void *data)
1544 if (current_function_decl)
1548 struct cgraph_node *node;
1549 for (node = cgraph_nodes; node; node = node->next)
1550 if (node->analyzed && gimple_has_body_p (node->decl)
1551 && (!node->clone_of || node->decl != node->clone_of->decl))
1553 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1554 current_function_decl = node->decl;
1558 free_dominance_info (CDI_DOMINATORS);
1559 free_dominance_info (CDI_POST_DOMINATORS);
1561 current_function_decl = NULL;
1568 /* Because inlining might remove no-longer reachable nodes, we need to
1569 keep the array visible to garbage collector to avoid reading collected
1572 static GTY ((length ("nnodes"))) cgraph_node_ptr *order;
1574 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1575 function CALLBACK for every function in the call graph. Otherwise,
1576 call CALLBACK on the current function.
1577 This function is global so that plugins can use it. */
1579 do_per_function_toporder (void (*callback) (void *data), void *data)
1583 if (current_function_decl)
1587 gcc_assert (!order);
1588 order = ggc_alloc_vec_cgraph_node_ptr (cgraph_n_nodes);
1589 nnodes = ipa_reverse_postorder (order);
1590 for (i = nnodes - 1; i >= 0; i--)
1591 order[i]->process = 1;
1592 for (i = nnodes - 1; i >= 0; i--)
1594 struct cgraph_node *node = order[i];
1596 /* Allow possibly removed nodes to be garbage collected. */
1599 if (cgraph_function_with_gimple_body_p (node))
1601 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1602 current_function_decl = node->decl;
1604 free_dominance_info (CDI_DOMINATORS);
1605 free_dominance_info (CDI_POST_DOMINATORS);
1606 current_function_decl = NULL;
1617 /* Helper function to perform function body dump. */
1620 execute_function_dump (void *data ATTRIBUTE_UNUSED)
1622 if (dump_file && current_function_decl)
1624 if (cfun->curr_properties & PROP_trees)
1625 dump_function_to_file (current_function_decl, dump_file, dump_flags);
1628 if (dump_flags & TDF_SLIM)
1629 print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
1630 else if ((cfun->curr_properties & PROP_cfg)
1631 && (dump_flags & TDF_BLOCKS))
1632 print_rtl_with_bb (dump_file, get_insns ());
1634 print_rtl (dump_file, get_insns ());
1636 if ((cfun->curr_properties & PROP_cfg)
1637 && graph_dump_format != no_graph
1638 && (dump_flags & TDF_GRAPH))
1639 print_rtl_graph_with_bb (dump_file_name, get_insns ());
1642 /* Flush the file. If verification fails, we won't be able to
1643 close the file before aborting. */
1648 /* Perform all TODO actions that ought to be done on each function. */
1651 execute_function_todo (void *data)
1653 unsigned int flags = (size_t)data;
1654 flags &= ~cfun->last_verified;
1658 /* Always cleanup the CFG before trying to update SSA. */
1659 if (flags & TODO_cleanup_cfg)
1661 bool cleanup = cleanup_tree_cfg ();
1663 if (cleanup && (cfun->curr_properties & PROP_ssa))
1664 flags |= TODO_remove_unused_locals;
1666 /* When cleanup_tree_cfg merges consecutive blocks, it may
1667 perform some simplistic propagation when removing single
1668 valued PHI nodes. This propagation may, in turn, cause the
1669 SSA form to become out-of-date (see PR 22037). So, even
1670 if the parent pass had not scheduled an SSA update, we may
1671 still need to do one. */
1672 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
1673 flags |= TODO_update_ssa;
1676 if (flags & TODO_update_ssa_any)
1678 unsigned update_flags = flags & TODO_update_ssa_any;
1679 update_ssa (update_flags);
1680 cfun->last_verified &= ~TODO_verify_ssa;
1683 if (flags & TODO_rebuild_alias)
1685 execute_update_addresses_taken ();
1686 compute_may_aliases ();
1688 else if (optimize && (flags & TODO_update_address_taken))
1689 execute_update_addresses_taken ();
1691 if (flags & TODO_remove_unused_locals)
1692 remove_unused_locals ();
1694 if (flags & TODO_rebuild_frequencies)
1695 rebuild_frequencies ();
1697 if (flags & TODO_rebuild_cgraph_edges)
1698 rebuild_cgraph_edges ();
1700 /* If we've seen errors do not bother running any verifiers. */
1704 #if defined ENABLE_CHECKING
1705 if (flags & TODO_verify_ssa
1706 || (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)))
1708 if (flags & TODO_verify_flow)
1709 verify_flow_info ();
1710 if (flags & TODO_verify_stmts)
1711 verify_gimple_in_cfg (cfun);
1712 if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))
1713 verify_loop_closed_ssa (false);
1714 if (flags & TODO_verify_rtl_sharing)
1715 verify_rtl_sharing ();
1718 cfun->last_verified = flags & TODO_verify_all;
1721 /* Perform all TODO actions. */
1723 execute_todo (unsigned int flags)
1725 #if defined ENABLE_CHECKING
1727 && need_ssa_update_p (cfun))
1728 gcc_assert (flags & TODO_update_ssa_any);
1731 timevar_push (TV_TODO);
1733 /* Inform the pass whether it is the first time it is run. */
1734 first_pass_instance = (flags & TODO_mark_first_instance) != 0;
1736 statistics_fini_pass ();
1738 do_per_function (execute_function_todo, (void *)(size_t) flags);
1740 /* Always remove functions just as before inlining: IPA passes might be
1741 interested to see bodies of extern inline functions that are not inlined
1742 to analyze side effects. The full removal is done just at the end
1743 of IPA pass queue. */
1744 if (flags & TODO_remove_functions)
1747 cgraph_remove_unreachable_nodes (true, dump_file);
1750 if ((flags & TODO_dump_cgraph) && dump_file && !current_function_decl)
1753 dump_cgraph (dump_file);
1754 /* Flush the file. If verification fails, we won't be able to
1755 close the file before aborting. */
1759 if (flags & TODO_ggc_collect)
1762 /* Now that the dumping has been done, we can get rid of the optional
1764 if (flags & TODO_df_finish)
1765 df_finish_pass ((flags & TODO_df_verify) != 0);
1767 timevar_pop (TV_TODO);
1770 /* Verify invariants that should hold between passes. This is a place
1771 to put simple sanity checks. */
1774 verify_interpass_invariants (void)
1776 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
1779 /* Clear the last verified flag. */
1782 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1784 cfun->last_verified = 0;
1787 /* Helper function. Verify that the properties has been turn into the
1788 properties expected by the pass. */
1790 #ifdef ENABLE_CHECKING
1792 verify_curr_properties (void *data)
1794 unsigned int props = (size_t)data;
1795 gcc_assert ((cfun->curr_properties & props) == props);
1799 /* Initialize pass dump file. */
1800 /* This is non-static so that the plugins can use it. */
1803 pass_init_dump_file (struct opt_pass *pass)
1805 /* If a dump file name is present, open it if enabled. */
1806 if (pass->static_pass_number != -1)
1808 bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
1809 dump_file_name = get_dump_file_name (pass->static_pass_number);
1810 dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1811 if (dump_file && current_function_decl)
1812 dump_function_header (dump_file, current_function_decl, dump_flags);
1813 return initializing_dump;
1819 /* Flush PASS dump file. */
1820 /* This is non-static so that plugins can use it. */
1823 pass_fini_dump_file (struct opt_pass *pass)
1825 /* Flush and close dump file. */
1828 free (CONST_CAST (char *, dump_file_name));
1829 dump_file_name = NULL;
1834 dump_end (pass->static_pass_number, dump_file);
1839 /* After executing the pass, apply expected changes to the function
1843 update_properties_after_pass (void *data)
1845 struct opt_pass *pass = (struct opt_pass *) data;
1846 cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1847 & ~pass->properties_destroyed;
1850 /* Execute summary generation for all of the passes in IPA_PASS. */
1853 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
1857 struct opt_pass *pass = &ipa_pass->pass;
1859 /* Execute all of the IPA_PASSes in the list. */
1860 if (ipa_pass->pass.type == IPA_PASS
1861 && (!pass->gate || pass->gate ())
1862 && ipa_pass->generate_summary)
1864 pass_init_dump_file (pass);
1866 /* If a timevar is present, start it. */
1868 timevar_push (pass->tv_id);
1870 ipa_pass->generate_summary ();
1874 timevar_pop (pass->tv_id);
1876 pass_fini_dump_file (pass);
1878 ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
1882 /* Execute IPA_PASS function transform on NODE. */
1885 execute_one_ipa_transform_pass (struct cgraph_node *node,
1886 struct ipa_opt_pass_d *ipa_pass)
1888 struct opt_pass *pass = &ipa_pass->pass;
1889 unsigned int todo_after = 0;
1891 current_pass = pass;
1892 if (!ipa_pass->function_transform)
1895 /* Note that the folders should only create gimple expressions.
1896 This is a hack until the new folder is ready. */
1897 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1899 pass_init_dump_file (pass);
1901 /* Run pre-pass verification. */
1902 execute_todo (ipa_pass->function_transform_todo_flags_start);
1904 /* If a timevar is present, start it. */
1905 if (pass->tv_id != TV_NONE)
1906 timevar_push (pass->tv_id);
1909 todo_after = ipa_pass->function_transform (node);
1912 if (pass->tv_id != TV_NONE)
1913 timevar_pop (pass->tv_id);
1915 /* Run post-pass cleanup and verification. */
1916 execute_todo (todo_after);
1917 verify_interpass_invariants ();
1919 do_per_function (execute_function_dump, NULL);
1920 pass_fini_dump_file (pass);
1922 current_pass = NULL;
1925 /* For the current function, execute all ipa transforms. */
1928 execute_all_ipa_transforms (void)
1930 struct cgraph_node *node;
1933 node = cgraph_get_node (current_function_decl);
1935 if (node->ipa_transforms_to_apply)
1939 for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply);
1941 execute_one_ipa_transform_pass (node,
1942 VEC_index (ipa_opt_pass,
1943 node->ipa_transforms_to_apply,
1945 VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply);
1946 node->ipa_transforms_to_apply = NULL;
1950 /* Callback for do_per_function to apply all IPA transforms. */
1953 apply_ipa_transforms (void *data)
1955 struct cgraph_node *node = cgraph_get_node (current_function_decl);
1956 if (!node->global.inlined_to && node->ipa_transforms_to_apply)
1958 *(bool *)data = true;
1959 execute_all_ipa_transforms();
1960 rebuild_cgraph_edges ();
1964 /* Check if PASS is explicitly disabled or enabled and return
1965 the gate status. FUNC is the function to be processed, and
1966 GATE_STATUS is the gate status determined by pass manager by
1970 override_gate_status (struct opt_pass *pass, tree func, bool gate_status)
1972 bool explicitly_enabled = false;
1973 bool explicitly_disabled = false;
1976 = is_pass_explicitly_enabled_or_disabled (pass, func,
1977 enabled_pass_uid_range_tab);
1979 = is_pass_explicitly_enabled_or_disabled (pass, func,
1980 disabled_pass_uid_range_tab);
1982 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
1991 execute_one_pass (struct opt_pass *pass)
1993 bool initializing_dump;
1994 unsigned int todo_after = 0;
1998 /* IPA passes are executed on whole program, so cfun should be NULL.
1999 Other passes need function context set. */
2000 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2001 gcc_assert (!cfun && !current_function_decl);
2003 gcc_assert (cfun && current_function_decl);
2005 current_pass = pass;
2007 /* Check whether gate check should be avoided.
2008 User controls the value of the gate through the parameter "gate_status". */
2009 gate_status = (pass->gate == NULL) ? true : pass->gate();
2010 gate_status = override_gate_status (pass, current_function_decl, gate_status);
2012 /* Override gate with plugin. */
2013 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
2017 current_pass = NULL;
2021 /* Pass execution event trigger: useful to identify passes being
2023 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
2025 /* SIPLE IPA passes do not handle callgraphs with IPA transforms in it.
2026 Apply all trnasforms first. */
2027 if (pass->type == SIMPLE_IPA_PASS)
2029 bool applied = false;
2030 do_per_function (apply_ipa_transforms, (void *)&applied);
2032 cgraph_remove_unreachable_nodes (true, dump_file);
2033 /* Restore current_pass. */
2034 current_pass = pass;
2037 if (!quiet_flag && !cfun)
2038 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
2040 /* Note that the folders should only create gimple expressions.
2041 This is a hack until the new folder is ready. */
2042 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2044 initializing_dump = pass_init_dump_file (pass);
2046 /* Run pre-pass verification. */
2047 execute_todo (pass->todo_flags_start);
2049 #ifdef ENABLE_CHECKING
2050 do_per_function (verify_curr_properties,
2051 (void *)(size_t)pass->properties_required);
2054 /* If a timevar is present, start it. */
2055 if (pass->tv_id != TV_NONE)
2056 timevar_push (pass->tv_id);
2061 todo_after = pass->execute ();
2062 do_per_function (clear_last_verified, NULL);
2066 if (pass->tv_id != TV_NONE)
2067 timevar_pop (pass->tv_id);
2069 do_per_function (update_properties_after_pass, pass);
2071 if (initializing_dump
2073 && graph_dump_format != no_graph
2075 && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
2076 == (PROP_cfg | PROP_rtl))
2078 get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
2079 dump_flags |= TDF_GRAPH;
2080 clean_graph_dump_file (dump_file_name);
2083 /* Run post-pass cleanup and verification. */
2084 execute_todo (todo_after | pass->todo_flags_finish);
2085 verify_interpass_invariants ();
2086 do_per_function (execute_function_dump, NULL);
2087 if (pass->type == IPA_PASS)
2089 struct cgraph_node *node;
2090 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2091 VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
2092 (struct ipa_opt_pass_d *)pass);
2095 if (!current_function_decl)
2096 cgraph_process_new_functions ();
2098 pass_fini_dump_file (pass);
2100 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2101 gcc_assert (!(cfun->curr_properties & PROP_trees)
2102 || pass->type != RTL_PASS);
2104 current_pass = NULL;
2110 execute_pass_list (struct opt_pass *pass)
2114 gcc_assert (pass->type == GIMPLE_PASS
2115 || pass->type == RTL_PASS);
2116 if (execute_one_pass (pass) && pass->sub)
2117 execute_pass_list (pass->sub);
2123 /* Same as execute_pass_list but assume that subpasses of IPA passes
2124 are local passes. If SET is not NULL, write out summaries of only
2125 those node in SET. */
2128 ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
2129 varpool_node_set vset,
2130 struct lto_out_decl_state *state)
2134 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
2135 gcc_assert (!current_function_decl);
2137 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2138 if (pass->type == IPA_PASS
2139 && ipa_pass->write_summary
2140 && (!pass->gate || pass->gate ()))
2142 /* If a timevar is present, start it. */
2144 timevar_push (pass->tv_id);
2146 pass_init_dump_file (pass);
2148 ipa_pass->write_summary (set,vset);
2150 pass_fini_dump_file (pass);
2152 /* If a timevar is present, start it. */
2154 timevar_pop (pass->tv_id);
2157 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2158 ipa_write_summaries_2 (pass->sub, set, vset, state);
2164 /* Helper function of ipa_write_summaries. Creates and destroys the
2165 decl state and calls ipa_write_summaries_2 for all passes that have
2166 summaries. SET is the set of nodes to be written. */
2169 ipa_write_summaries_1 (cgraph_node_set set, varpool_node_set vset)
2171 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2172 compute_ltrans_boundary (state, set, vset);
2174 lto_push_out_decl_state (state);
2176 gcc_assert (!flag_wpa);
2177 ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state);
2178 ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state);
2180 gcc_assert (lto_get_out_decl_state () == state);
2181 lto_pop_out_decl_state ();
2182 lto_delete_out_decl_state (state);
2185 /* Write out summaries for all the nodes in the callgraph. */
2188 ipa_write_summaries (void)
2190 cgraph_node_set set;
2191 varpool_node_set vset;
2192 struct cgraph_node **order;
2193 struct varpool_node *vnode;
2196 if (!flag_generate_lto || seen_error ())
2199 set = cgraph_node_set_new ();
2201 /* Create the callgraph set in the same order used in
2202 cgraph_expand_all_functions. This mostly facilitates debugging,
2203 since it causes the gimple file to be processed in the same order
2204 as the source code. */
2205 order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
2206 order_pos = ipa_reverse_postorder (order);
2207 gcc_assert (order_pos == cgraph_n_nodes);
2209 for (i = order_pos - 1; i >= 0; i--)
2211 struct cgraph_node *node = order[i];
2213 if (cgraph_function_with_gimple_body_p (node))
2215 /* When streaming out references to statements as part of some IPA
2216 pass summary, the statements need to have uids assigned and the
2217 following does that for all the IPA passes here. Naturally, this
2218 ordering then matches the one IPA-passes get in their stmt_fixup
2221 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2222 renumber_gimple_stmt_uids ();
2226 cgraph_node_set_add (set, node);
2228 vset = varpool_node_set_new ();
2230 for (vnode = varpool_nodes; vnode; vnode = vnode->next)
2231 if (vnode->needed && (!vnode->alias || vnode->alias_of))
2232 varpool_node_set_add (vset, vnode);
2234 ipa_write_summaries_1 (set, vset);
2237 free_cgraph_node_set (set);
2238 free_varpool_node_set (vset);
2241 /* Same as execute_pass_list but assume that subpasses of IPA passes
2242 are local passes. If SET is not NULL, write out optimization summaries of
2243 only those node in SET. */
2246 ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
2247 varpool_node_set vset,
2248 struct lto_out_decl_state *state)
2252 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
2253 gcc_assert (!current_function_decl);
2255 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2256 if (pass->type == IPA_PASS
2257 && ipa_pass->write_optimization_summary
2258 && (!pass->gate || pass->gate ()))
2260 /* If a timevar is present, start it. */
2262 timevar_push (pass->tv_id);
2264 pass_init_dump_file (pass);
2266 ipa_pass->write_optimization_summary (set, vset);
2268 pass_fini_dump_file (pass);
2270 /* If a timevar is present, start it. */
2272 timevar_pop (pass->tv_id);
2275 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2276 ipa_write_optimization_summaries_1 (pass->sub, set, vset, state);
2282 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2283 NULL, write out all summaries of all nodes. */
2286 ipa_write_optimization_summaries (cgraph_node_set set, varpool_node_set vset)
2288 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2289 cgraph_node_set_iterator csi;
2290 compute_ltrans_boundary (state, set, vset);
2292 lto_push_out_decl_state (state);
2293 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2295 struct cgraph_node *node = csi_node (csi);
2296 /* When streaming out references to statements as part of some IPA
2297 pass summary, the statements need to have uids assigned.
2299 For functions newly born at WPA stage we need to initialize
2302 && gimple_has_body_p (node->decl))
2304 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2305 renumber_gimple_stmt_uids ();
2310 gcc_assert (flag_wpa);
2311 ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state);
2312 ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state);
2314 gcc_assert (lto_get_out_decl_state () == state);
2315 lto_pop_out_decl_state ();
2316 lto_delete_out_decl_state (state);
2319 /* Same as execute_pass_list but assume that subpasses of IPA passes
2320 are local passes. */
2323 ipa_read_summaries_1 (struct opt_pass *pass)
2327 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2329 gcc_assert (!current_function_decl);
2331 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2333 if (pass->gate == NULL || pass->gate ())
2335 if (pass->type == IPA_PASS && ipa_pass->read_summary)
2337 /* If a timevar is present, start it. */
2339 timevar_push (pass->tv_id);
2341 pass_init_dump_file (pass);
2343 ipa_pass->read_summary ();
2345 pass_fini_dump_file (pass);
2349 timevar_pop (pass->tv_id);
2352 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2353 ipa_read_summaries_1 (pass->sub);
2360 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
2363 ipa_read_summaries (void)
2365 ipa_read_summaries_1 (all_regular_ipa_passes);
2366 ipa_read_summaries_1 (all_lto_gen_passes);
2369 /* Same as execute_pass_list but assume that subpasses of IPA passes
2370 are local passes. */
2373 ipa_read_optimization_summaries_1 (struct opt_pass *pass)
2377 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2379 gcc_assert (!current_function_decl);
2381 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2383 if (pass->gate == NULL || pass->gate ())
2385 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
2387 /* If a timevar is present, start it. */
2389 timevar_push (pass->tv_id);
2391 pass_init_dump_file (pass);
2393 ipa_pass->read_optimization_summary ();
2395 pass_fini_dump_file (pass);
2399 timevar_pop (pass->tv_id);
2402 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2403 ipa_read_optimization_summaries_1 (pass->sub);
2409 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
2412 ipa_read_optimization_summaries (void)
2414 ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
2415 ipa_read_optimization_summaries_1 (all_lto_gen_passes);
2418 /* Same as execute_pass_list but assume that subpasses of IPA passes
2419 are local passes. */
2421 execute_ipa_pass_list (struct opt_pass *pass)
2425 gcc_assert (!current_function_decl);
2427 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2428 if (execute_one_pass (pass) && pass->sub)
2430 if (pass->sub->type == GIMPLE_PASS)
2432 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
2433 do_per_function_toporder ((void (*)(void *))execute_pass_list,
2435 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
2437 else if (pass->sub->type == SIMPLE_IPA_PASS
2438 || pass->sub->type == IPA_PASS)
2439 execute_ipa_pass_list (pass->sub);
2443 gcc_assert (!current_function_decl);
2444 cgraph_process_new_functions ();
2450 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2453 execute_ipa_stmt_fixups (struct opt_pass *pass,
2454 struct cgraph_node *node, gimple *stmts)
2458 /* Execute all of the IPA_PASSes in the list. */
2459 if (pass->type == IPA_PASS
2460 && (!pass->gate || pass->gate ()))
2462 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2464 if (ipa_pass->stmt_fixup)
2466 pass_init_dump_file (pass);
2467 /* If a timevar is present, start it. */
2469 timevar_push (pass->tv_id);
2471 ipa_pass->stmt_fixup (node, stmts);
2475 timevar_pop (pass->tv_id);
2476 pass_fini_dump_file (pass);
2479 execute_ipa_stmt_fixups (pass->sub, node, stmts);
2485 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2488 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
2490 execute_ipa_stmt_fixups (all_regular_ipa_passes, node, stmts);
2494 extern void debug_properties (unsigned int);
2495 extern void dump_properties (FILE *, unsigned int);
2498 dump_properties (FILE *dump, unsigned int props)
2500 fprintf (dump, "Properties:\n");
2501 if (props & PROP_gimple_any)
2502 fprintf (dump, "PROP_gimple_any\n");
2503 if (props & PROP_gimple_lcf)
2504 fprintf (dump, "PROP_gimple_lcf\n");
2505 if (props & PROP_gimple_leh)
2506 fprintf (dump, "PROP_gimple_leh\n");
2507 if (props & PROP_cfg)
2508 fprintf (dump, "PROP_cfg\n");
2509 if (props & PROP_referenced_vars)
2510 fprintf (dump, "PROP_referenced_vars\n");
2511 if (props & PROP_ssa)
2512 fprintf (dump, "PROP_ssa\n");
2513 if (props & PROP_no_crit_edges)
2514 fprintf (dump, "PROP_no_crit_edges\n");
2515 if (props & PROP_rtl)
2516 fprintf (dump, "PROP_rtl\n");
2517 if (props & PROP_gimple_lomp)
2518 fprintf (dump, "PROP_gimple_lomp\n");
2519 if (props & PROP_gimple_lcx)
2520 fprintf (dump, "PROP_gimple_lcx\n");
2521 if (props & PROP_cfglayout)
2522 fprintf (dump, "PROP_cfglayout\n");
2526 debug_properties (unsigned int props)
2528 dump_properties (stderr, props);
2531 /* Called by local passes to see if function is called by already processed nodes.
2532 Because we process nodes in topological order, this means that function is
2533 in recursive cycle or we introduced new direct calls. */
2535 function_called_by_processed_nodes_p (void)
2537 struct cgraph_edge *e;
2538 for (e = cgraph_get_node (current_function_decl)->callers;
2542 if (e->caller->decl == current_function_decl)
2544 if (!cgraph_function_with_gimple_body_p (e->caller))
2546 if (TREE_ASM_WRITTEN (e->caller->decl))
2548 if (!e->caller->process && !e->caller->global.inlined_to)
2553 fprintf (dump_file, "Already processed call to:\n");
2554 dump_cgraph_node (dump_file, e->caller);
2559 #include "gt-passes.h"