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 2011, 2012 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"
52 #include "diagnostic-core.h"
57 #include "langhooks.h"
59 #include "hosthooks.h"
63 #include "value-prof.h"
64 #include "tree-inline.h"
65 #include "tree-flow.h"
66 #include "tree-pass.h"
67 #include "tree-dump.h"
70 #include "lto-streamer.h"
72 #include "ipa-utils.h"
73 #include "tree-pretty-print.h" /* for dump_function_header */
75 /* This is used for debugging. It allows the current pass to printed
76 from anywhere in compilation.
77 The variable current_pass is also used for statistics and plugins. */
78 struct opt_pass *current_pass;
80 static void register_pass_name (struct opt_pass *, const char *);
82 /* Call from anywhere to find out what pass this is. Useful for
83 printing out debugging information deep inside an service
86 print_current_pass (FILE *file)
89 fprintf (file, "current pass = %s (%d)\n",
90 current_pass->name, current_pass->static_pass_number);
92 fprintf (file, "no current pass.\n");
96 /* Call from the debugger to get the current pass name. */
100 print_current_pass (stderr);
105 /* Global variables used to communicate with passes. */
108 bool first_pass_instance;
111 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
114 This does nothing for local (non-static) variables, unless the
115 variable is a register variable with DECL_ASSEMBLER_NAME set. In
116 that case, or if the variable is not an automatic, it sets up the
117 RTL and outputs any assembler code (label definition, storage
118 allocation and initialization).
120 DECL is the declaration. TOP_LEVEL is nonzero
121 if this declaration is not within a function. */
124 rest_of_decl_compilation (tree decl,
128 /* We deferred calling assemble_alias so that we could collect
129 other attributes such as visibility. Emit the alias now. */
133 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
136 alias = TREE_VALUE (TREE_VALUE (alias));
137 alias = get_identifier (TREE_STRING_POINTER (alias));
138 /* A quirk of the initial implementation of aliases required that the
139 user add "extern" to all of them. Which is silly, but now
140 historical. Do note that the symbol is in fact locally defined. */
141 if (!lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
142 DECL_EXTERNAL (decl) = 0;
143 assemble_alias (decl, alias);
147 /* Can't defer this, because it needs to happen before any
148 later function definitions are processed. */
149 if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
150 make_decl_rtl (decl);
152 /* Forward declarations for nested functions are not "external",
153 but we need to treat them as if they were. */
154 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
155 || TREE_CODE (decl) == FUNCTION_DECL)
157 timevar_push (TV_VARCONST);
159 /* Don't output anything when a tentative file-scope definition
160 is seen. But at end of compilation, do output code for them.
162 We do output all variables and rely on
163 callgraph code to defer them except for forward declarations
164 (see gcc.c-torture/compile/920624-1.c) */
166 || !DECL_DEFER_OUTPUT (decl)
167 || DECL_INITIAL (decl))
168 && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl))
169 && !DECL_EXTERNAL (decl))
171 /* When reading LTO unit, we also read varpool, so do not
173 if (in_lto_p && !at_end)
175 else if (TREE_CODE (decl) != FUNCTION_DECL)
176 varpool_finalize_decl (decl);
179 #ifdef ASM_FINISH_DECLARE_OBJECT
180 if (decl == last_assemble_variable_decl)
182 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
187 timevar_pop (TV_VARCONST);
189 else if (TREE_CODE (decl) == TYPE_DECL
190 /* Like in rest_of_type_compilation, avoid confusing the debug
191 information machinery when there are errors. */
194 timevar_push (TV_SYMOUT);
195 debug_hooks->type_decl (decl, !top_level);
196 timevar_pop (TV_SYMOUT);
199 /* Let cgraph know about the existence of variables. */
200 if (in_lto_p && !at_end)
202 else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
203 && TREE_STATIC (decl))
207 /* Called after finishing a record, union or enumeral type. */
210 rest_of_type_compilation (tree type, int toplev)
212 /* Avoid confusing the debug information machinery when there are
217 timevar_push (TV_SYMOUT);
218 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
219 timevar_pop (TV_SYMOUT);
225 finish_optimization_passes (void)
228 struct dump_file_info *dfi;
231 timevar_push (TV_DUMP);
232 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
234 dump_start (pass_profile.pass.static_pass_number, NULL);
236 dump_finish (pass_profile.pass.static_pass_number);
241 dump_start (pass_profile.pass.static_pass_number, NULL);
242 print_combine_total_stats ();
243 dump_finish (pass_combine.pass.static_pass_number);
246 /* Do whatever is necessary to finish printing the graphs. */
247 if (graph_dump_format != no_graph)
248 for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
249 if (dump_initialized_p (i)
250 && (dfi->pflags & TDF_GRAPH) != 0
251 && (name = get_dump_file_name (i)) != NULL)
253 finish_graph_dump_file (name);
257 timevar_pop (TV_DUMP);
261 execute_all_early_local_passes (void)
263 /* Once this pass (and its sub-passes) are complete, all functions
264 will be in SSA form. Technically this state change is happening
265 a tad early, since the sub-passes have not yet run, but since
266 none of the sub-passes are IPA passes and do not create new
267 functions, this is ok. We're setting this value for the benefit
268 of IPA passes that follow. */
269 if (cgraph_state < CGRAPH_STATE_IPA_SSA)
270 cgraph_state = CGRAPH_STATE_IPA_SSA;
274 /* Gate: execute, or not, all of the non-trivial optimizations. */
277 gate_all_early_local_passes (void)
279 /* Don't bother doing anything if the program has errors. */
280 return (!seen_error () && !in_lto_p);
283 struct simple_ipa_opt_pass pass_early_local_passes =
287 "early_local_cleanups", /* name */
288 gate_all_early_local_passes, /* gate */
289 execute_all_early_local_passes, /* execute */
292 0, /* static_pass_number */
293 TV_EARLY_LOCAL, /* tv_id */
294 0, /* properties_required */
295 0, /* properties_provided */
296 0, /* properties_destroyed */
297 0, /* todo_flags_start */
298 TODO_remove_functions /* todo_flags_finish */
302 /* Gate: execute, or not, all of the non-trivial optimizations. */
305 gate_all_early_optimizations (void)
307 return (optimize >= 1
308 /* Don't bother doing anything if the program has errors. */
312 static struct gimple_opt_pass pass_all_early_optimizations =
316 "early_optimizations", /* name */
317 gate_all_early_optimizations, /* gate */
321 0, /* static_pass_number */
323 0, /* properties_required */
324 0, /* properties_provided */
325 0, /* properties_destroyed */
326 0, /* todo_flags_start */
327 0 /* todo_flags_finish */
331 /* Gate: execute, or not, all of the non-trivial optimizations. */
334 gate_all_optimizations (void)
336 return optimize >= 1 && !optimize_debug;
339 static struct gimple_opt_pass pass_all_optimizations =
343 "*all_optimizations", /* name */
344 gate_all_optimizations, /* gate */
348 0, /* static_pass_number */
349 TV_OPTIMIZE, /* tv_id */
350 0, /* properties_required */
351 0, /* properties_provided */
352 0, /* properties_destroyed */
353 0, /* todo_flags_start */
354 0 /* todo_flags_finish */
358 /* Gate: execute, or not, all of the non-trivial optimizations. */
361 gate_all_optimizations_g (void)
363 return optimize >= 1 && optimize_debug;
366 static struct gimple_opt_pass pass_all_optimizations_g =
370 "*all_optimizations_g", /* name */
371 gate_all_optimizations_g, /* gate */
375 0, /* static_pass_number */
376 TV_OPTIMIZE, /* tv_id */
377 0, /* properties_required */
378 0, /* properties_provided */
379 0, /* properties_destroyed */
380 0, /* todo_flags_start */
381 0 /* todo_flags_finish */
386 gate_rest_of_compilation (void)
388 /* Early return if there were errors. We can run afoul of our
389 consistency checks, and there's not really much point in fixing them. */
390 return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
393 static struct rtl_opt_pass pass_rest_of_compilation =
397 "*rest_of_compilation", /* name */
398 gate_rest_of_compilation, /* gate */
402 0, /* static_pass_number */
403 TV_REST_OF_COMPILATION, /* tv_id */
404 PROP_rtl, /* properties_required */
405 0, /* properties_provided */
406 0, /* properties_destroyed */
407 0, /* todo_flags_start */
408 TODO_ggc_collect /* todo_flags_finish */
413 gate_postreload (void)
415 return reload_completed;
418 static struct rtl_opt_pass pass_postreload =
422 "*all-postreload", /* name */
423 gate_postreload, /* gate */
427 0, /* static_pass_number */
428 TV_POSTRELOAD, /* tv_id */
429 PROP_rtl, /* properties_required */
430 0, /* properties_provided */
431 0, /* properties_destroyed */
432 0, /* todo_flags_start */
433 TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */
439 /* The root of the compilation pass tree, once constructed. */
440 struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes,
441 *all_regular_ipa_passes, *all_late_ipa_passes, *all_lto_gen_passes;
443 /* This is used by plugins, and should also be used in register_pass. */
444 #define DEF_PASS_LIST(LIST) &LIST,
445 struct opt_pass **gcc_pass_lists[] = { GCC_PASS_LISTS NULL };
448 /* A map from static pass id to optimization pass. */
449 struct opt_pass **passes_by_id;
450 int passes_by_id_size;
452 /* Set the static pass number of pass PASS to ID and record that
453 in the mapping from static pass number to pass. */
456 set_pass_for_id (int id, struct opt_pass *pass)
458 pass->static_pass_number = id;
459 if (passes_by_id_size <= id)
461 passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1);
462 memset (passes_by_id + passes_by_id_size, 0,
463 (id + 1 - passes_by_id_size) * sizeof (void *));
464 passes_by_id_size = id + 1;
466 passes_by_id[id] = pass;
469 /* Return the pass with the static pass number ID. */
472 get_pass_for_id (int id)
474 if (id >= passes_by_id_size)
476 return passes_by_id[id];
479 /* Iterate over the pass tree allocating dump file numbers. We want
480 to do this depth first, and independent of whether the pass is
484 register_one_dump_file (struct opt_pass *pass)
486 char *dot_name, *flag_name, *glob_name;
487 const char *name, *full_name, *prefix;
491 /* See below in next_pass_1. */
493 if (pass->static_pass_number != -1)
494 sprintf (num, "%d", ((int) pass->static_pass_number < 0
495 ? 1 : pass->static_pass_number));
497 /* The name is both used to identify the pass for the purposes of plugins,
498 and to specify dump file name and option.
499 The latter two might want something short which is not quite unique; for
500 that reason, we may have a disambiguating prefix, followed by a space
501 to mark the start of the following dump file name / option string. */
502 name = strchr (pass->name, ' ');
503 name = name ? name + 1 : pass->name;
504 dot_name = concat (".", name, num, NULL);
505 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
506 prefix = "ipa-", flags = TDF_IPA;
507 else if (pass->type == GIMPLE_PASS)
508 prefix = "tree-", flags = TDF_TREE;
510 prefix = "rtl-", flags = TDF_RTL;
512 flag_name = concat (prefix, name, num, NULL);
513 glob_name = concat (prefix, name, NULL);
514 id = dump_register (dot_name, flag_name, glob_name, flags);
515 set_pass_for_id (id, pass);
516 full_name = concat (prefix, pass->name, num, NULL);
517 register_pass_name (pass, full_name);
518 free (CONST_CAST (char *, full_name));
521 /* Recursive worker function for register_dump_files. */
524 register_dump_files_1 (struct opt_pass *pass, int properties)
528 int new_properties = (properties | pass->properties_provided)
529 & ~pass->properties_destroyed;
531 if (pass->name && pass->name[0] != '*')
532 register_one_dump_file (pass);
535 new_properties = register_dump_files_1 (pass->sub, new_properties);
537 /* If we have a gate, combine the properties that we could have with
538 and without the pass being examined. */
540 properties &= new_properties;
542 properties = new_properties;
551 /* Register the dump files for the pipeline starting at PASS.
552 PROPERTIES reflects the properties that are guaranteed to be available at
553 the beginning of the pipeline. */
556 register_dump_files (struct opt_pass *pass,int properties)
558 pass->properties_required |= properties;
559 register_dump_files_1 (pass, properties);
564 const char* unique_name;
565 struct opt_pass *pass;
568 /* Pass registry hash function. */
571 passr_hash (const void *p)
573 const struct pass_registry *const s = (const struct pass_registry *const) p;
574 return htab_hash_string (s->unique_name);
577 /* Hash equal function */
580 passr_eq (const void *p1, const void *p2)
582 const struct pass_registry *const s1 = (const struct pass_registry *const) p1;
583 const struct pass_registry *const s2 = (const struct pass_registry *const) p2;
585 return !strcmp (s1->unique_name, s2->unique_name);
588 static htab_t name_to_pass_map = NULL;
590 /* Register PASS with NAME. */
593 register_pass_name (struct opt_pass *pass, const char *name)
595 struct pass_registry **slot;
596 struct pass_registry pr;
598 if (!name_to_pass_map)
599 name_to_pass_map = htab_create (256, passr_hash, passr_eq, NULL);
601 pr.unique_name = name;
602 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map, &pr, INSERT);
605 struct pass_registry *new_pr;
607 new_pr = XCNEW (struct pass_registry);
608 new_pr->unique_name = xstrdup (name);
613 return; /* Ignore plugin passes. */
616 /* Map from pass id to canonicalized pass name. */
618 typedef const char *char_ptr;
620 DEF_VEC_ALLOC_P(char_ptr, heap);
621 static VEC(char_ptr, heap) *pass_tab = NULL;
623 /* Callback function for traversing NAME_TO_PASS_MAP. */
626 pass_traverse (void **slot, void *data ATTRIBUTE_UNUSED)
628 struct pass_registry **p = (struct pass_registry **)slot;
629 struct opt_pass *pass = (*p)->pass;
631 gcc_assert (pass->static_pass_number > 0);
632 gcc_assert (pass_tab);
634 VEC_replace (char_ptr, pass_tab, pass->static_pass_number,
640 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
641 table for dumping purpose. */
644 create_pass_tab (void)
646 if (!flag_dump_passes)
649 VEC_safe_grow_cleared (char_ptr, heap,
650 pass_tab, passes_by_id_size + 1);
651 htab_traverse (name_to_pass_map, pass_traverse, NULL);
654 static bool override_gate_status (struct opt_pass *, tree, bool);
656 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
657 is turned on or not. */
660 dump_one_pass (struct opt_pass *pass, int pass_indent)
662 int indent = 3 * pass_indent;
664 bool is_on, is_really_on;
666 is_on = (pass->gate == NULL) ? true : pass->gate();
667 is_really_on = override_gate_status (pass, current_function_decl, is_on);
669 if (pass->static_pass_number <= 0)
672 pn = VEC_index (char_ptr, pass_tab, pass->static_pass_number);
674 fprintf (stderr, "%*s%-40s%*s:%s%s\n", indent, " ", pn,
675 (15 - indent < 0 ? 0 : 15 - indent), " ",
676 is_on ? " ON" : " OFF",
677 ((!is_on) == (!is_really_on) ? ""
678 : (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)")));
681 /* Dump pass list PASS with indentation INDENT. */
684 dump_pass_list (struct opt_pass *pass, int indent)
688 dump_one_pass (pass, indent);
690 dump_pass_list (pass->sub, indent + 1);
696 /* Dump all optimization passes. */
701 struct cgraph_node *n, *node = NULL;
705 FOR_EACH_DEFINED_FUNCTION (n)
706 if (DECL_STRUCT_FUNCTION (n->symbol.decl))
715 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
717 dump_pass_list (all_lowering_passes, 1);
718 dump_pass_list (all_small_ipa_passes, 1);
719 dump_pass_list (all_regular_ipa_passes, 1);
720 dump_pass_list (all_lto_gen_passes, 1);
721 dump_pass_list (all_late_ipa_passes, 1);
722 dump_pass_list (all_passes, 1);
728 /* Returns the pass with NAME. */
730 static struct opt_pass *
731 get_pass_by_name (const char *name)
733 struct pass_registry **slot, pr;
735 pr.unique_name = name;
736 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map,
742 return (*slot)->pass;
746 /* Range [start, last]. */
752 const char *assem_name;
753 struct uid_range *next;
756 typedef struct uid_range *uid_range_p;
758 DEF_VEC_P(uid_range_p);
759 DEF_VEC_ALLOC_P(uid_range_p, heap);
761 static VEC(uid_range_p, heap) *enabled_pass_uid_range_tab = NULL;
762 static VEC(uid_range_p, heap) *disabled_pass_uid_range_tab = NULL;
765 /* Parse option string for -fdisable- and -fenable-
766 The syntax of the options:
769 -fdisable-<pass_name>
771 -fenable-<pass_name>=s1:e1,s2:e2,...
772 -fdisable-<pass_name>=s1:e1,s2:e2,...
776 enable_disable_pass (const char *arg, bool is_enable)
778 struct opt_pass *pass;
779 char *range_str, *phase_name;
780 char *argstr = xstrdup (arg);
781 VEC(uid_range_p, heap) **tab = 0;
783 range_str = strchr (argstr,'=');
794 error ("unrecognized option -fenable");
796 error ("unrecognized option -fdisable");
800 pass = get_pass_by_name (phase_name);
801 if (!pass || pass->static_pass_number == -1)
804 error ("unknown pass %s specified in -fenable", phase_name);
806 error ("unknown pass %s specified in -fdisable", phase_name);
812 tab = &enabled_pass_uid_range_tab;
814 tab = &disabled_pass_uid_range_tab;
816 if ((unsigned) pass->static_pass_number >= VEC_length (uid_range_p, *tab))
817 VEC_safe_grow_cleared (uid_range_p, heap,
818 *tab, pass->static_pass_number + 1);
823 uid_range_p new_range = XCNEW (struct uid_range);
825 new_range->start = 0;
826 new_range->last = (unsigned)-1;
828 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number);
829 new_range->next = slot;
830 VEC_replace (uid_range_p, *tab, pass->static_pass_number,
833 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
834 "of [%u, %u]", phase_name, new_range->start, new_range->last);
836 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
837 "of [%u, %u]", phase_name, new_range->start, new_range->last);
841 char *next_range = NULL;
842 char *one_range = range_str;
843 char *end_val = NULL;
848 uid_range_p new_range;
849 char *invalid = NULL;
851 char *func_name = NULL;
853 next_range = strchr (one_range, ',');
860 end_val = strchr (one_range, ':');
866 start = strtol (one_range, &invalid, 10);
867 if (*invalid || start < 0)
869 if (end_val || (one_range[0] >= '0'
870 && one_range[0] <= '9'))
872 error ("Invalid range %s in option %s",
874 is_enable ? "-fenable" : "-fdisable");
878 func_name = one_range;
882 new_range = XCNEW (struct uid_range);
885 new_range->start = (unsigned) start;
886 new_range->last = (unsigned) start;
890 new_range->start = (unsigned) -1;
891 new_range->last = (unsigned) -1;
892 new_range->assem_name = xstrdup (func_name);
897 long last = strtol (end_val, &invalid, 10);
898 if (*invalid || last < start)
900 error ("Invalid range %s in option %s",
902 is_enable ? "-fenable" : "-fdisable");
906 new_range = XCNEW (struct uid_range);
907 new_range->start = (unsigned) start;
908 new_range->last = (unsigned) last;
911 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number);
912 new_range->next = slot;
913 VEC_replace (uid_range_p, *tab, pass->static_pass_number,
917 if (new_range->assem_name)
918 inform (UNKNOWN_LOCATION,
919 "enable pass %s for function %s",
920 phase_name, new_range->assem_name);
922 inform (UNKNOWN_LOCATION,
923 "enable pass %s for functions in the range of [%u, %u]",
924 phase_name, new_range->start, new_range->last);
928 if (new_range->assem_name)
929 inform (UNKNOWN_LOCATION,
930 "disable pass %s for function %s",
931 phase_name, new_range->assem_name);
933 inform (UNKNOWN_LOCATION,
934 "disable pass %s for functions in the range of [%u, %u]",
935 phase_name, new_range->start, new_range->last);
938 one_range = next_range;
939 } while (next_range);
945 /* Enable pass specified by ARG. */
948 enable_pass (const char *arg)
950 enable_disable_pass (arg, true);
953 /* Disable pass specified by ARG. */
956 disable_pass (const char *arg)
958 enable_disable_pass (arg, false);
961 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
964 is_pass_explicitly_enabled_or_disabled (struct opt_pass *pass,
966 VEC(uid_range_p, heap) *tab)
968 uid_range_p slot, range;
970 const char *aname = NULL;
973 || (unsigned) pass->static_pass_number >= VEC_length (uid_range_p, tab)
974 || pass->static_pass_number == -1)
977 slot = VEC_index (uid_range_p, tab, pass->static_pass_number);
981 cgraph_uid = func ? cgraph_get_node (func)->uid : 0;
982 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
983 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
988 if ((unsigned) cgraph_uid >= range->start
989 && (unsigned) cgraph_uid <= range->last)
991 if (range->assem_name && aname
992 && !strcmp (range->assem_name, aname))
1000 /* Look at the static_pass_number and duplicate the pass
1001 if it is already added to a list. */
1003 static struct opt_pass *
1004 make_pass_instance (struct opt_pass *pass, bool track_duplicates)
1006 /* A nonzero static_pass_number indicates that the
1007 pass is already in the list. */
1008 if (pass->static_pass_number)
1010 struct opt_pass *new_pass;
1012 if (pass->type == GIMPLE_PASS
1013 || pass->type == RTL_PASS
1014 || pass->type == SIMPLE_IPA_PASS)
1016 new_pass = XNEW (struct opt_pass);
1017 memcpy (new_pass, pass, sizeof (struct opt_pass));
1019 else if (pass->type == IPA_PASS)
1021 new_pass = (struct opt_pass *)XNEW (struct ipa_opt_pass_d);
1022 memcpy (new_pass, pass, sizeof (struct ipa_opt_pass_d));
1027 new_pass->next = NULL;
1029 new_pass->todo_flags_start &= ~TODO_mark_first_instance;
1031 /* Indicate to register_dump_files that this pass has duplicates,
1032 and so it should rename the dump file. The first instance will
1033 be -1, and be number of duplicates = -static_pass_number - 1.
1034 Subsequent instances will be > 0 and just the duplicate number. */
1035 if ((pass->name && pass->name[0] != '*') || track_duplicates)
1037 pass->static_pass_number -= 1;
1038 new_pass->static_pass_number = -pass->static_pass_number;
1044 pass->todo_flags_start |= TODO_mark_first_instance;
1045 pass->static_pass_number = -1;
1047 invoke_plugin_callbacks (PLUGIN_NEW_PASS, pass);
1052 /* Add a pass to the pass list. Duplicate the pass if it's already
1055 static struct opt_pass **
1056 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
1058 /* Every pass should have a name so that plugins can refer to them. */
1059 gcc_assert (pass->name != NULL);
1061 *list = make_pass_instance (pass, false);
1063 return &(*list)->next;
1066 /* List node for an inserted pass instance. We need to keep track of all
1067 the newly-added pass instances (with 'added_pass_nodes' defined below)
1068 so that we can register their dump files after pass-positioning is finished.
1069 Registering dumping files needs to be post-processed or the
1070 static_pass_number of the opt_pass object would be modified and mess up
1071 the dump file names of future pass instances to be added. */
1073 struct pass_list_node
1075 struct opt_pass *pass;
1076 struct pass_list_node *next;
1079 static struct pass_list_node *added_pass_nodes = NULL;
1080 static struct pass_list_node *prev_added_pass_node;
1082 /* Insert the pass at the proper position. Return true if the pass
1083 is successfully added.
1085 NEW_PASS_INFO - new pass to be inserted
1086 PASS_LIST - root of the pass list to insert the new pass to */
1089 position_pass (struct register_pass_info *new_pass_info,
1090 struct opt_pass **pass_list)
1092 struct opt_pass *pass = *pass_list, *prev_pass = NULL;
1093 bool success = false;
1095 for ( ; pass; prev_pass = pass, pass = pass->next)
1097 /* Check if the current pass is of the same type as the new pass and
1098 matches the name and the instance number of the reference pass. */
1099 if (pass->type == new_pass_info->pass->type
1101 && !strcmp (pass->name, new_pass_info->reference_pass_name)
1102 && ((new_pass_info->ref_pass_instance_number == 0)
1103 || (new_pass_info->ref_pass_instance_number ==
1104 pass->static_pass_number)
1105 || (new_pass_info->ref_pass_instance_number == 1
1106 && pass->todo_flags_start & TODO_mark_first_instance)))
1108 struct opt_pass *new_pass;
1109 struct pass_list_node *new_pass_node;
1111 new_pass = make_pass_instance (new_pass_info->pass, true);
1113 /* Insert the new pass instance based on the positioning op. */
1114 switch (new_pass_info->pos_op)
1116 case PASS_POS_INSERT_AFTER:
1117 new_pass->next = pass->next;
1118 pass->next = new_pass;
1120 /* Skip newly inserted pass to avoid repeated
1121 insertions in the case where the new pass and the
1122 existing one have the same name. */
1125 case PASS_POS_INSERT_BEFORE:
1126 new_pass->next = pass;
1128 prev_pass->next = new_pass;
1130 *pass_list = new_pass;
1132 case PASS_POS_REPLACE:
1133 new_pass->next = pass->next;
1135 prev_pass->next = new_pass;
1137 *pass_list = new_pass;
1138 new_pass->sub = pass->sub;
1139 new_pass->tv_id = pass->tv_id;
1143 error ("invalid pass positioning operation");
1147 /* Save the newly added pass (instance) in the added_pass_nodes
1148 list so that we can register its dump file later. Note that
1149 we cannot register the dump file now because doing so will modify
1150 the static_pass_number of the opt_pass object and therefore
1151 mess up the dump file name of future instances. */
1152 new_pass_node = XCNEW (struct pass_list_node);
1153 new_pass_node->pass = new_pass;
1154 if (!added_pass_nodes)
1155 added_pass_nodes = new_pass_node;
1157 prev_added_pass_node->next = new_pass_node;
1158 prev_added_pass_node = new_pass_node;
1163 if (pass->sub && position_pass (new_pass_info, &pass->sub))
1170 /* Hooks a new pass into the pass lists.
1172 PASS_INFO - pass information that specifies the opt_pass object,
1173 reference pass, instance number, and how to position
1177 register_pass (struct register_pass_info *pass_info)
1179 bool all_instances, success;
1181 /* The checks below could fail in buggy plugins. Existing GCC
1182 passes should never fail these checks, so we mention plugin in
1184 if (!pass_info->pass)
1185 fatal_error ("plugin cannot register a missing pass");
1187 if (!pass_info->pass->name)
1188 fatal_error ("plugin cannot register an unnamed pass");
1190 if (!pass_info->reference_pass_name)
1192 ("plugin cannot register pass %qs without reference pass name",
1193 pass_info->pass->name);
1195 /* Try to insert the new pass to the pass lists. We need to check
1196 all five lists as the reference pass could be in one (or all) of
1198 all_instances = pass_info->ref_pass_instance_number == 0;
1199 success = position_pass (pass_info, &all_lowering_passes);
1200 if (!success || all_instances)
1201 success |= position_pass (pass_info, &all_small_ipa_passes);
1202 if (!success || all_instances)
1203 success |= position_pass (pass_info, &all_regular_ipa_passes);
1204 if (!success || all_instances)
1205 success |= position_pass (pass_info, &all_lto_gen_passes);
1206 if (!success || all_instances)
1207 success |= position_pass (pass_info, &all_late_ipa_passes);
1208 if (!success || all_instances)
1209 success |= position_pass (pass_info, &all_passes);
1212 ("pass %qs not found but is referenced by new pass %qs",
1213 pass_info->reference_pass_name, pass_info->pass->name);
1215 /* OK, we have successfully inserted the new pass. We need to register
1216 the dump files for the newly added pass and its duplicates (if any).
1217 Because the registration of plugin/backend passes happens after the
1218 command-line options are parsed, the options that specify single
1219 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1220 passes. Therefore we currently can only enable dumping of
1221 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1222 are specified. While doing so, we also delete the pass_list_node
1223 objects created during pass positioning. */
1224 while (added_pass_nodes)
1226 struct pass_list_node *next_node = added_pass_nodes->next;
1227 enum tree_dump_index tdi;
1228 register_one_dump_file (added_pass_nodes->pass);
1229 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
1230 || added_pass_nodes->pass->type == IPA_PASS)
1232 else if (added_pass_nodes->pass->type == GIMPLE_PASS)
1236 /* Check if dump-all flag is specified. */
1237 if (get_dump_file_info (tdi)->pstate)
1238 get_dump_file_info (added_pass_nodes->pass->static_pass_number)
1239 ->pstate = get_dump_file_info (tdi)->pstate;
1240 XDELETE (added_pass_nodes);
1241 added_pass_nodes = next_node;
1245 /* Construct the pass tree. The sequencing of passes is driven by
1246 the cgraph routines:
1248 finalize_compilation_unit ()
1249 for each node N in the cgraph
1250 cgraph_analyze_function (N)
1251 cgraph_lower_function (N) -> all_lowering_passes
1253 If we are optimizing, compile is then invoked:
1256 ipa_passes () -> all_small_ipa_passes
1257 -> Analysis of all_regular_ipa_passes
1258 * possible LTO streaming at copmilation time *
1259 -> Execution of all_regular_ipa_passes
1260 * possible LTO streaming at link time *
1261 -> all_late_ipa_passes
1262 expand_all_functions ()
1263 for each node N in the cgraph
1264 expand_function (N) -> Transformation of all_regular_ipa_passes
1269 init_optimization_passes (void)
1271 struct opt_pass **p;
1273 #define NEXT_PASS(PASS) (p = next_pass_1 (p, &((PASS).pass)))
1275 /* All passes needed to lower the function into shape optimizers can
1276 operate on. These passes are always run first on the function, but
1277 backend might produce already lowered functions that are not processed
1279 p = &all_lowering_passes;
1280 NEXT_PASS (pass_warn_unused_result);
1281 NEXT_PASS (pass_diagnose_omp_blocks);
1282 NEXT_PASS (pass_diagnose_tm_blocks);
1283 NEXT_PASS (pass_mudflap_1);
1284 NEXT_PASS (pass_lower_omp);
1285 NEXT_PASS (pass_lower_cf);
1286 NEXT_PASS (pass_lower_tm);
1287 NEXT_PASS (pass_refactor_eh);
1288 NEXT_PASS (pass_lower_eh);
1289 NEXT_PASS (pass_build_cfg);
1290 NEXT_PASS (pass_warn_function_return);
1291 NEXT_PASS (pass_build_cgraph_edges);
1294 /* Interprocedural optimization passes. */
1295 p = &all_small_ipa_passes;
1296 NEXT_PASS (pass_ipa_free_lang_data);
1297 NEXT_PASS (pass_ipa_function_and_variable_visibility);
1298 NEXT_PASS (pass_early_local_passes);
1300 struct opt_pass **p = &pass_early_local_passes.pass.sub;
1301 NEXT_PASS (pass_fixup_cfg);
1302 NEXT_PASS (pass_init_datastructures);
1303 NEXT_PASS (pass_expand_omp);
1305 NEXT_PASS (pass_build_ssa);
1306 NEXT_PASS (pass_lower_vector);
1307 NEXT_PASS (pass_early_warn_uninitialized);
1308 NEXT_PASS (pass_rebuild_cgraph_edges);
1309 NEXT_PASS (pass_inline_parameters);
1310 NEXT_PASS (pass_early_inline);
1311 NEXT_PASS (pass_all_early_optimizations);
1313 struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
1314 NEXT_PASS (pass_remove_cgraph_callee_edges);
1315 NEXT_PASS (pass_rename_ssa_copies);
1316 NEXT_PASS (pass_ccp);
1317 /* After CCP we rewrite no longer addressed locals into SSA
1318 form if possible. */
1319 NEXT_PASS (pass_forwprop);
1320 /* pass_build_ealias is a dummy pass that ensures that we
1321 execute TODO_rebuild_alias at this point. */
1322 NEXT_PASS (pass_build_ealias);
1323 NEXT_PASS (pass_sra_early);
1324 NEXT_PASS (pass_fre);
1325 NEXT_PASS (pass_copy_prop);
1326 NEXT_PASS (pass_merge_phi);
1327 NEXT_PASS (pass_cd_dce);
1328 NEXT_PASS (pass_early_ipa_sra);
1329 NEXT_PASS (pass_tail_recursion);
1330 NEXT_PASS (pass_convert_switch);
1331 NEXT_PASS (pass_cleanup_eh);
1332 NEXT_PASS (pass_profile);
1333 NEXT_PASS (pass_local_pure_const);
1334 /* Split functions creates parts that are not run through
1335 early optimizations again. It is thus good idea to do this
1337 NEXT_PASS (pass_split_functions);
1339 NEXT_PASS (pass_release_ssa_names);
1340 NEXT_PASS (pass_rebuild_cgraph_edges);
1341 NEXT_PASS (pass_inline_parameters);
1343 NEXT_PASS (pass_ipa_free_inline_summary);
1344 NEXT_PASS (pass_ipa_tree_profile);
1346 struct opt_pass **p = &pass_ipa_tree_profile.pass.sub;
1347 NEXT_PASS (pass_feedback_split_functions);
1349 NEXT_PASS (pass_ipa_increase_alignment);
1350 NEXT_PASS (pass_ipa_tm);
1351 NEXT_PASS (pass_ipa_lower_emutls);
1354 p = &all_regular_ipa_passes;
1355 NEXT_PASS (pass_ipa_whole_program_visibility);
1356 NEXT_PASS (pass_ipa_profile);
1357 NEXT_PASS (pass_ipa_cp);
1358 NEXT_PASS (pass_ipa_cdtor_merge);
1359 NEXT_PASS (pass_ipa_inline);
1360 NEXT_PASS (pass_ipa_pure_const);
1361 NEXT_PASS (pass_ipa_reference);
1364 p = &all_lto_gen_passes;
1365 NEXT_PASS (pass_ipa_lto_gimple_out);
1366 NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */
1369 /* Simple IPA passes executed after the regular passes. In WHOPR mode the
1370 passes are executed after partitioning and thus see just parts of the
1372 p = &all_late_ipa_passes;
1373 NEXT_PASS (pass_ipa_pta);
1376 /* These passes are run after IPA passes on every function that is being
1377 output to the assembler file. */
1379 NEXT_PASS (pass_fixup_cfg);
1380 NEXT_PASS (pass_lower_eh_dispatch);
1381 NEXT_PASS (pass_all_optimizations);
1383 struct opt_pass **p = &pass_all_optimizations.pass.sub;
1384 NEXT_PASS (pass_remove_cgraph_callee_edges);
1385 /* Initial scalar cleanups before alias computation.
1386 They ensure memory accesses are not indirect wherever possible. */
1387 NEXT_PASS (pass_strip_predict_hints);
1388 NEXT_PASS (pass_rename_ssa_copies);
1389 NEXT_PASS (pass_complete_unrolli);
1390 NEXT_PASS (pass_ccp);
1391 /* After CCP we rewrite no longer addressed locals into SSA
1392 form if possible. */
1393 NEXT_PASS (pass_forwprop);
1394 /* pass_build_alias is a dummy pass that ensures that we
1395 execute TODO_rebuild_alias at this point. */
1396 NEXT_PASS (pass_build_alias);
1397 NEXT_PASS (pass_return_slot);
1398 NEXT_PASS (pass_phiprop);
1399 NEXT_PASS (pass_fre);
1400 NEXT_PASS (pass_copy_prop);
1401 NEXT_PASS (pass_merge_phi);
1402 NEXT_PASS (pass_vrp);
1403 NEXT_PASS (pass_dce);
1404 NEXT_PASS (pass_call_cdce);
1405 NEXT_PASS (pass_cselim);
1406 NEXT_PASS (pass_tree_ifcombine);
1407 NEXT_PASS (pass_phiopt);
1408 NEXT_PASS (pass_tail_recursion);
1409 NEXT_PASS (pass_ch);
1410 NEXT_PASS (pass_stdarg);
1411 NEXT_PASS (pass_lower_complex);
1412 NEXT_PASS (pass_sra);
1413 NEXT_PASS (pass_rename_ssa_copies);
1414 /* The dom pass will also resolve all __builtin_constant_p calls
1415 that are still there to 0. This has to be done after some
1416 propagations have already run, but before some more dead code
1417 is removed, and this place fits nicely. Remember this when
1418 trying to move or duplicate pass_dominator somewhere earlier. */
1419 NEXT_PASS (pass_dominator);
1420 /* The only const/copy propagation opportunities left after
1421 DOM should be due to degenerate PHI nodes. So rather than
1422 run the full propagators, run a specialized pass which
1423 only examines PHIs to discover const/copy propagation
1425 NEXT_PASS (pass_phi_only_cprop);
1426 NEXT_PASS (pass_dse);
1427 NEXT_PASS (pass_reassoc);
1428 NEXT_PASS (pass_dce);
1429 NEXT_PASS (pass_forwprop);
1430 NEXT_PASS (pass_phiopt);
1431 NEXT_PASS (pass_object_sizes);
1432 NEXT_PASS (pass_strlen);
1433 NEXT_PASS (pass_ccp);
1434 /* After CCP we rewrite no longer addressed locals into SSA
1435 form if possible. */
1436 NEXT_PASS (pass_copy_prop);
1437 NEXT_PASS (pass_cse_sincos);
1438 NEXT_PASS (pass_optimize_bswap);
1439 NEXT_PASS (pass_split_crit_edges);
1440 NEXT_PASS (pass_pre);
1441 NEXT_PASS (pass_sink_code);
1442 NEXT_PASS (pass_tree_loop);
1444 struct opt_pass **p = &pass_tree_loop.pass.sub;
1445 NEXT_PASS (pass_tree_loop_init);
1446 NEXT_PASS (pass_lim);
1447 NEXT_PASS (pass_copy_prop);
1448 NEXT_PASS (pass_dce_loop);
1449 NEXT_PASS (pass_tree_unswitch);
1450 NEXT_PASS (pass_scev_cprop);
1451 NEXT_PASS (pass_record_bounds);
1452 NEXT_PASS (pass_check_data_deps);
1453 NEXT_PASS (pass_loop_distribution);
1454 NEXT_PASS (pass_copy_prop);
1455 NEXT_PASS (pass_graphite);
1457 struct opt_pass **p = &pass_graphite.pass.sub;
1458 NEXT_PASS (pass_graphite_transforms);
1459 NEXT_PASS (pass_lim);
1460 NEXT_PASS (pass_copy_prop);
1461 NEXT_PASS (pass_dce_loop);
1463 NEXT_PASS (pass_iv_canon);
1464 NEXT_PASS (pass_if_conversion);
1465 NEXT_PASS (pass_vectorize);
1467 struct opt_pass **p = &pass_vectorize.pass.sub;
1468 NEXT_PASS (pass_dce_loop);
1470 NEXT_PASS (pass_predcom);
1471 NEXT_PASS (pass_complete_unroll);
1472 NEXT_PASS (pass_slp_vectorize);
1473 NEXT_PASS (pass_parallelize_loops);
1474 NEXT_PASS (pass_loop_prefetch);
1475 NEXT_PASS (pass_iv_optimize);
1476 NEXT_PASS (pass_lim);
1477 NEXT_PASS (pass_tree_loop_done);
1479 NEXT_PASS (pass_lower_vector_ssa);
1480 NEXT_PASS (pass_cse_reciprocals);
1481 NEXT_PASS (pass_reassoc);
1482 NEXT_PASS (pass_vrp);
1483 NEXT_PASS (pass_strength_reduction);
1484 NEXT_PASS (pass_dominator);
1485 /* The only const/copy propagation opportunities left after
1486 DOM should be due to degenerate PHI nodes. So rather than
1487 run the full propagators, run a specialized pass which
1488 only examines PHIs to discover const/copy propagation
1490 NEXT_PASS (pass_phi_only_cprop);
1491 NEXT_PASS (pass_cd_dce);
1492 NEXT_PASS (pass_tracer);
1494 /* FIXME: If DCE is not run before checking for uninitialized uses,
1495 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
1496 However, this also causes us to misdiagnose cases that should be
1497 real warnings (e.g., testsuite/gcc.dg/pr18501.c).
1499 To fix the false positives in uninit-5.c, we would have to
1500 account for the predicates protecting the set and the use of each
1501 variable. Using a representation like Gated Single Assignment
1503 NEXT_PASS (pass_late_warn_uninitialized);
1504 NEXT_PASS (pass_dse);
1505 NEXT_PASS (pass_forwprop);
1506 NEXT_PASS (pass_phiopt);
1507 NEXT_PASS (pass_fold_builtins);
1508 NEXT_PASS (pass_optimize_widening_mul);
1509 NEXT_PASS (pass_tail_calls);
1510 NEXT_PASS (pass_rename_ssa_copies);
1511 NEXT_PASS (pass_uncprop);
1512 NEXT_PASS (pass_local_pure_const);
1514 NEXT_PASS (pass_all_optimizations_g);
1516 struct opt_pass **p = &pass_all_optimizations_g.pass.sub;
1517 NEXT_PASS (pass_remove_cgraph_callee_edges);
1518 NEXT_PASS (pass_strip_predict_hints);
1519 /* Lower remaining pieces of GIMPLE. */
1520 NEXT_PASS (pass_lower_complex);
1521 NEXT_PASS (pass_lower_vector_ssa);
1522 /* Perform simple scalar cleanup which is constant/copy propagation. */
1523 NEXT_PASS (pass_ccp);
1524 NEXT_PASS (pass_object_sizes);
1525 /* Copy propagation also copy-propagates constants, this is necessary
1526 to forward object-size results properly. */
1527 NEXT_PASS (pass_copy_prop);
1528 NEXT_PASS (pass_rename_ssa_copies);
1529 NEXT_PASS (pass_dce);
1530 /* Fold remaining builtins. */
1531 NEXT_PASS (pass_fold_builtins);
1532 /* ??? We do want some kind of loop invariant motion, but we possibly
1533 need to adjust LIM to be more friendly towards preserving accurate
1534 debug information here. */
1535 NEXT_PASS (pass_late_warn_uninitialized);
1536 NEXT_PASS (pass_uncprop);
1537 NEXT_PASS (pass_local_pure_const);
1539 NEXT_PASS (pass_tm_init);
1541 struct opt_pass **p = &pass_tm_init.pass.sub;
1542 NEXT_PASS (pass_tm_mark);
1543 NEXT_PASS (pass_tm_memopt);
1544 NEXT_PASS (pass_tm_edges);
1546 NEXT_PASS (pass_lower_complex_O0);
1547 NEXT_PASS (pass_cleanup_eh);
1548 NEXT_PASS (pass_lower_resx);
1549 NEXT_PASS (pass_nrv);
1550 NEXT_PASS (pass_mudflap_2);
1551 NEXT_PASS (pass_cleanup_cfg_post_optimizing);
1552 NEXT_PASS (pass_warn_function_noreturn);
1554 NEXT_PASS (pass_expand);
1556 NEXT_PASS (pass_rest_of_compilation);
1558 struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
1559 NEXT_PASS (pass_instantiate_virtual_regs);
1560 NEXT_PASS (pass_into_cfg_layout_mode);
1561 NEXT_PASS (pass_jump);
1562 NEXT_PASS (pass_lower_subreg);
1563 NEXT_PASS (pass_df_initialize_opt);
1564 NEXT_PASS (pass_cse);
1565 NEXT_PASS (pass_rtl_fwprop);
1566 NEXT_PASS (pass_rtl_cprop);
1567 NEXT_PASS (pass_rtl_pre);
1568 NEXT_PASS (pass_rtl_hoist);
1569 NEXT_PASS (pass_rtl_cprop);
1570 NEXT_PASS (pass_rtl_store_motion);
1571 NEXT_PASS (pass_cse_after_global_opts);
1572 NEXT_PASS (pass_rtl_ifcvt);
1573 NEXT_PASS (pass_reginfo_init);
1574 /* Perform loop optimizations. It might be better to do them a bit
1575 sooner, but we want the profile feedback to work more
1577 NEXT_PASS (pass_loop2);
1579 struct opt_pass **p = &pass_loop2.pass.sub;
1580 NEXT_PASS (pass_rtl_loop_init);
1581 NEXT_PASS (pass_rtl_move_loop_invariants);
1582 NEXT_PASS (pass_rtl_unswitch);
1583 NEXT_PASS (pass_rtl_unroll_and_peel_loops);
1584 NEXT_PASS (pass_rtl_doloop);
1585 NEXT_PASS (pass_rtl_loop_done);
1588 NEXT_PASS (pass_web);
1589 NEXT_PASS (pass_rtl_cprop);
1590 NEXT_PASS (pass_cse2);
1591 NEXT_PASS (pass_rtl_dse1);
1592 NEXT_PASS (pass_rtl_fwprop_addr);
1593 NEXT_PASS (pass_inc_dec);
1594 NEXT_PASS (pass_initialize_regs);
1595 NEXT_PASS (pass_ud_rtl_dce);
1596 NEXT_PASS (pass_combine);
1597 NEXT_PASS (pass_if_after_combine);
1598 NEXT_PASS (pass_partition_blocks);
1599 NEXT_PASS (pass_regmove);
1600 NEXT_PASS (pass_outof_cfg_layout_mode);
1601 NEXT_PASS (pass_split_all_insns);
1602 NEXT_PASS (pass_lower_subreg2);
1603 NEXT_PASS (pass_df_initialize_no_opt);
1604 NEXT_PASS (pass_stack_ptr_mod);
1605 NEXT_PASS (pass_mode_switching);
1606 NEXT_PASS (pass_match_asm_constraints);
1607 NEXT_PASS (pass_sms);
1608 NEXT_PASS (pass_sched);
1609 NEXT_PASS (pass_ira);
1610 NEXT_PASS (pass_reload);
1611 NEXT_PASS (pass_postreload);
1613 struct opt_pass **p = &pass_postreload.pass.sub;
1614 NEXT_PASS (pass_postreload_cse);
1615 NEXT_PASS (pass_gcse2);
1616 NEXT_PASS (pass_split_after_reload);
1617 NEXT_PASS (pass_ree);
1618 NEXT_PASS (pass_compare_elim_after_reload);
1619 NEXT_PASS (pass_branch_target_load_optimize1);
1620 NEXT_PASS (pass_thread_prologue_and_epilogue);
1621 NEXT_PASS (pass_rtl_dse2);
1622 NEXT_PASS (pass_stack_adjustments);
1623 NEXT_PASS (pass_jump2);
1624 NEXT_PASS (pass_peephole2);
1625 NEXT_PASS (pass_if_after_reload);
1626 NEXT_PASS (pass_regrename);
1627 NEXT_PASS (pass_cprop_hardreg);
1628 NEXT_PASS (pass_fast_rtl_dce);
1629 NEXT_PASS (pass_reorder_blocks);
1630 NEXT_PASS (pass_branch_target_load_optimize2);
1631 NEXT_PASS (pass_leaf_regs);
1632 NEXT_PASS (pass_split_before_sched2);
1633 NEXT_PASS (pass_sched2);
1634 NEXT_PASS (pass_stack_regs);
1636 struct opt_pass **p = &pass_stack_regs.pass.sub;
1637 NEXT_PASS (pass_split_before_regstack);
1638 NEXT_PASS (pass_stack_regs_run);
1640 NEXT_PASS (pass_compute_alignments);
1641 NEXT_PASS (pass_duplicate_computed_gotos);
1642 NEXT_PASS (pass_variable_tracking);
1643 NEXT_PASS (pass_free_cfg);
1644 NEXT_PASS (pass_machine_reorg);
1645 NEXT_PASS (pass_cleanup_barriers);
1646 NEXT_PASS (pass_delay_slots);
1647 NEXT_PASS (pass_split_for_shorten_branches);
1648 NEXT_PASS (pass_convert_to_eh_region_ranges);
1649 NEXT_PASS (pass_shorten_branches);
1650 NEXT_PASS (pass_set_nothrow_function_flags);
1651 NEXT_PASS (pass_dwarf2_frame);
1652 NEXT_PASS (pass_final);
1654 NEXT_PASS (pass_df_finish);
1656 NEXT_PASS (pass_clean_state);
1661 /* Register the passes with the tree dump code. */
1662 register_dump_files (all_lowering_passes, PROP_gimple_any);
1663 register_dump_files (all_small_ipa_passes,
1664 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1666 register_dump_files (all_regular_ipa_passes,
1667 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1669 register_dump_files (all_lto_gen_passes,
1670 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1672 register_dump_files (all_late_ipa_passes,
1673 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1675 register_dump_files (all_passes,
1676 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
1680 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1681 function CALLBACK for every function in the call graph. Otherwise,
1682 call CALLBACK on the current function. */
1685 do_per_function (void (*callback) (void *data), void *data)
1687 if (current_function_decl)
1691 struct cgraph_node *node;
1692 FOR_EACH_DEFINED_FUNCTION (node)
1693 if (gimple_has_body_p (node->symbol.decl)
1694 && (!node->clone_of || node->symbol.decl != node->clone_of->symbol.decl))
1696 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
1700 free_dominance_info (CDI_DOMINATORS);
1701 free_dominance_info (CDI_POST_DOMINATORS);
1709 /* Because inlining might remove no-longer reachable nodes, we need to
1710 keep the array visible to garbage collector to avoid reading collected
1713 static GTY ((length ("nnodes"))) cgraph_node_ptr *order;
1715 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1716 function CALLBACK for every function in the call graph. Otherwise,
1717 call CALLBACK on the current function.
1718 This function is global so that plugins can use it. */
1720 do_per_function_toporder (void (*callback) (void *data), void *data)
1724 if (current_function_decl)
1728 gcc_assert (!order);
1729 order = ggc_alloc_vec_cgraph_node_ptr (cgraph_n_nodes);
1730 nnodes = ipa_reverse_postorder (order);
1731 for (i = nnodes - 1; i >= 0; i--)
1732 order[i]->process = 1;
1733 for (i = nnodes - 1; i >= 0; i--)
1735 struct cgraph_node *node = order[i];
1737 /* Allow possibly removed nodes to be garbage collected. */
1740 if (cgraph_function_with_gimple_body_p (node))
1742 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
1744 free_dominance_info (CDI_DOMINATORS);
1745 free_dominance_info (CDI_POST_DOMINATORS);
1756 /* Helper function to perform function body dump. */
1759 execute_function_dump (void *data ATTRIBUTE_UNUSED)
1761 if (dump_file && current_function_decl)
1763 if (cfun->curr_properties & PROP_trees)
1764 dump_function_to_file (current_function_decl, dump_file, dump_flags);
1767 print_rtl_with_bb (dump_file, get_insns (), dump_flags);
1769 if ((cfun->curr_properties & PROP_cfg)
1770 && graph_dump_format != no_graph
1771 && (dump_flags & TDF_GRAPH))
1772 print_rtl_graph_with_bb (dump_file_name, get_insns ());
1775 /* Flush the file. If verification fails, we won't be able to
1776 close the file before aborting. */
1781 /* Make statistic about profile consistency. */
1783 struct profile_record
1785 int num_mismatched_freq_in[2];
1786 int num_mismatched_freq_out[2];
1787 int num_mismatched_count_in[2];
1788 int num_mismatched_count_out[2];
1794 static struct profile_record *profile_record;
1797 check_profile_consistency (int index, int subpass, bool run)
1807 if (!profile_record)
1808 profile_record = XCNEWVEC (struct profile_record,
1810 gcc_assert (index < passes_by_id_size && index >= 0);
1811 gcc_assert (subpass < 2);
1812 profile_record[index].run |= run;
1816 if (bb != EXIT_BLOCK_PTR_FOR_FUNCTION (cfun)
1817 && profile_status != PROFILE_ABSENT)
1820 FOR_EACH_EDGE (e, ei, bb->succs)
1821 sum += e->probability;
1822 if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
1823 profile_record[index].num_mismatched_freq_out[subpass]++;
1825 FOR_EACH_EDGE (e, ei, bb->succs)
1827 if (EDGE_COUNT (bb->succs)
1828 && (lsum - bb->count > 100 || lsum - bb->count < -100))
1829 profile_record[index].num_mismatched_count_out[subpass]++;
1831 if (bb != ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun)
1832 && profile_status != PROFILE_ABSENT)
1835 FOR_EACH_EDGE (e, ei, bb->preds)
1836 sum += EDGE_FREQUENCY (e);
1837 if (abs (sum - bb->frequency) > 100
1838 || (MAX (sum, bb->frequency) > 10
1839 && abs ((sum - bb->frequency) * 100 / (MAX (sum, bb->frequency) + 1)) > 10))
1840 profile_record[index].num_mismatched_freq_in[subpass]++;
1842 FOR_EACH_EDGE (e, ei, bb->preds)
1844 if (lsum - bb->count > 100 || lsum - bb->count < -100)
1845 profile_record[index].num_mismatched_count_in[subpass]++;
1847 if (bb == ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun)
1848 || bb == EXIT_BLOCK_PTR_FOR_FUNCTION (cfun))
1850 if ((cfun && (cfun->curr_properties & PROP_trees)))
1852 gimple_stmt_iterator i;
1854 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1856 profile_record[index].size[subpass]
1857 += estimate_num_insns (gsi_stmt (i), &eni_size_weights);
1858 if (profile_status == PROFILE_READ)
1859 profile_record[index].time[subpass]
1860 += estimate_num_insns (gsi_stmt (i),
1861 &eni_time_weights) * bb->count;
1862 else if (profile_status == PROFILE_GUESSED)
1863 profile_record[index].time[subpass]
1864 += estimate_num_insns (gsi_stmt (i),
1865 &eni_time_weights) * bb->frequency;
1868 else if (cfun && (cfun->curr_properties & PROP_rtl))
1871 for (insn = NEXT_INSN (BB_HEAD (bb)); insn && insn != NEXT_INSN (BB_END (bb));
1872 insn = NEXT_INSN (insn))
1875 profile_record[index].size[subpass]
1876 += insn_rtx_cost (PATTERN (insn), false);
1877 if (profile_status == PROFILE_READ)
1878 profile_record[index].time[subpass]
1879 += insn_rtx_cost (PATTERN (insn), true) * bb->count;
1880 else if (profile_status == PROFILE_GUESSED)
1881 profile_record[index].time[subpass]
1882 += insn_rtx_cost (PATTERN (insn), true) * bb->frequency;
1888 /* Output profile consistency. */
1891 dump_profile_report (void)
1894 int last_freq_in = 0, last_count_in = 0, last_freq_out = 0, last_count_out = 0;
1895 gcov_type last_time = 0, last_size = 0;
1896 double rel_time_change, rel_size_change;
1897 int last_reported = 0;
1899 if (!profile_record)
1901 fprintf (stderr, "\nProfile consistency report:\n\n");
1902 fprintf (stderr, "Pass name |mismatch in |mismated out|Overall\n");
1903 fprintf (stderr, " |freq count |freq count |size time\n");
1905 for (i = 0; i < passes_by_id_size; i++)
1906 for (j = 0 ; j < 2; j++)
1907 if (profile_record[i].run)
1910 rel_time_change = (profile_record[i].time[j]
1911 - (double)last_time) * 100 / (double)last_time;
1913 rel_time_change = 0;
1915 rel_size_change = (profile_record[i].size[j]
1916 - (double)last_size) * 100 / (double)last_size;
1918 rel_size_change = 0;
1920 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in
1921 || profile_record[i].num_mismatched_freq_out[j] != last_freq_out
1922 || profile_record[i].num_mismatched_count_in[j] != last_count_in
1923 || profile_record[i].num_mismatched_count_out[j] != last_count_out
1924 || rel_time_change || rel_size_change)
1927 fprintf (stderr, "%-20s %s",
1928 passes_by_id [i]->name,
1929 j ? "(after TODO)" : " ");
1930 if (profile_record[i].num_mismatched_freq_in[j] != last_freq_in)
1931 fprintf (stderr, "| %+5i",
1932 profile_record[i].num_mismatched_freq_in[j]
1935 fprintf (stderr, "| ");
1936 if (profile_record[i].num_mismatched_count_in[j] != last_count_in)
1937 fprintf (stderr, " %+5i",
1938 profile_record[i].num_mismatched_count_in[j]
1941 fprintf (stderr, " ");
1942 if (profile_record[i].num_mismatched_freq_out[j] != last_freq_out)
1943 fprintf (stderr, "| %+5i",
1944 profile_record[i].num_mismatched_freq_out[j]
1947 fprintf (stderr, "| ");
1948 if (profile_record[i].num_mismatched_count_out[j] != last_count_out)
1949 fprintf (stderr, " %+5i",
1950 profile_record[i].num_mismatched_count_out[j]
1953 fprintf (stderr, " ");
1955 /* Size/time units change across gimple and RTL. */
1956 if (i == pass_expand.pass.static_pass_number)
1957 fprintf (stderr, "|----------");
1960 if (rel_size_change)
1961 fprintf (stderr, "| %+8.4f%%", rel_size_change);
1963 fprintf (stderr, "| ");
1964 if (rel_time_change)
1965 fprintf (stderr, " %+8.4f%%", rel_time_change);
1967 fprintf (stderr, "\n");
1968 last_freq_in = profile_record[i].num_mismatched_freq_in[j];
1969 last_freq_out = profile_record[i].num_mismatched_freq_out[j];
1970 last_count_in = profile_record[i].num_mismatched_count_in[j];
1971 last_count_out = profile_record[i].num_mismatched_count_out[j];
1973 else if (j && last_reported != i)
1976 fprintf (stderr, "%-20s ------------| | |\n",
1977 passes_by_id [i]->name);
1979 last_time = profile_record[i].time[j];
1980 last_size = profile_record[i].size[j];
1984 /* Perform all TODO actions that ought to be done on each function. */
1987 execute_function_todo (void *data)
1989 unsigned int flags = (size_t)data;
1990 flags &= ~cfun->last_verified;
1994 /* Always cleanup the CFG before trying to update SSA. */
1995 if (flags & TODO_cleanup_cfg)
1997 bool cleanup = cleanup_tree_cfg ();
1999 if (cleanup && (cfun->curr_properties & PROP_ssa))
2000 flags |= TODO_remove_unused_locals;
2002 /* When cleanup_tree_cfg merges consecutive blocks, it may
2003 perform some simplistic propagation when removing single
2004 valued PHI nodes. This propagation may, in turn, cause the
2005 SSA form to become out-of-date (see PR 22037). So, even
2006 if the parent pass had not scheduled an SSA update, we may
2007 still need to do one. */
2008 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
2009 flags |= TODO_update_ssa;
2012 if (flags & TODO_update_ssa_any)
2014 unsigned update_flags = flags & TODO_update_ssa_any;
2015 update_ssa (update_flags);
2016 cfun->last_verified &= ~TODO_verify_ssa;
2019 if (flag_tree_pta && (flags & TODO_rebuild_alias))
2020 compute_may_aliases ();
2022 if (optimize && (flags & TODO_update_address_taken))
2023 execute_update_addresses_taken ();
2025 if (flags & TODO_remove_unused_locals)
2026 remove_unused_locals ();
2028 if (flags & TODO_rebuild_frequencies)
2029 rebuild_frequencies ();
2031 if (flags & TODO_rebuild_cgraph_edges)
2032 rebuild_cgraph_edges ();
2034 /* If we've seen errors do not bother running any verifiers. */
2038 #if defined ENABLE_CHECKING
2039 if (flags & TODO_verify_ssa
2040 || (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)))
2042 verify_gimple_in_cfg (cfun);
2045 else if (flags & TODO_verify_stmts)
2046 verify_gimple_in_cfg (cfun);
2047 if (flags & TODO_verify_flow)
2048 verify_flow_info ();
2049 if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))
2050 verify_loop_closed_ssa (false);
2051 if (flags & TODO_verify_rtl_sharing)
2052 verify_rtl_sharing ();
2055 cfun->last_verified = flags & TODO_verify_all;
2058 /* Perform all TODO actions. */
2060 execute_todo (unsigned int flags)
2062 #if defined ENABLE_CHECKING
2064 && need_ssa_update_p (cfun))
2065 gcc_assert (flags & TODO_update_ssa_any);
2068 timevar_push (TV_TODO);
2070 /* Inform the pass whether it is the first time it is run. */
2071 first_pass_instance = (flags & TODO_mark_first_instance) != 0;
2073 statistics_fini_pass ();
2075 do_per_function (execute_function_todo, (void *)(size_t) flags);
2077 /* Always remove functions just as before inlining: IPA passes might be
2078 interested to see bodies of extern inline functions that are not inlined
2079 to analyze side effects. The full removal is done just at the end
2080 of IPA pass queue. */
2081 if (flags & TODO_remove_functions)
2084 symtab_remove_unreachable_nodes (true, dump_file);
2087 if ((flags & TODO_dump_symtab) && dump_file && !current_function_decl)
2090 dump_symtab (dump_file);
2091 /* Flush the file. If verification fails, we won't be able to
2092 close the file before aborting. */
2096 if (flags & TODO_ggc_collect)
2099 /* Now that the dumping has been done, we can get rid of the optional
2101 if (flags & TODO_df_finish)
2102 df_finish_pass ((flags & TODO_df_verify) != 0);
2104 timevar_pop (TV_TODO);
2107 /* Verify invariants that should hold between passes. This is a place
2108 to put simple sanity checks. */
2111 verify_interpass_invariants (void)
2113 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2116 /* Clear the last verified flag. */
2119 clear_last_verified (void *data ATTRIBUTE_UNUSED)
2121 cfun->last_verified = 0;
2124 /* Helper function. Verify that the properties has been turn into the
2125 properties expected by the pass. */
2127 #ifdef ENABLE_CHECKING
2129 verify_curr_properties (void *data)
2131 unsigned int props = (size_t)data;
2132 gcc_assert ((cfun->curr_properties & props) == props);
2136 /* Initialize pass dump file. */
2137 /* This is non-static so that the plugins can use it. */
2140 pass_init_dump_file (struct opt_pass *pass)
2142 /* If a dump file name is present, open it if enabled. */
2143 if (pass->static_pass_number != -1)
2145 bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
2146 dump_file_name = get_dump_file_name (pass->static_pass_number);
2147 dump_start (pass->static_pass_number, &dump_flags);
2148 if (dump_file && current_function_decl)
2149 dump_function_header (dump_file, current_function_decl, dump_flags);
2150 return initializing_dump;
2156 /* Flush PASS dump file. */
2157 /* This is non-static so that plugins can use it. */
2160 pass_fini_dump_file (struct opt_pass *pass)
2162 /* Flush and close dump file. */
2165 free (CONST_CAST (char *, dump_file_name));
2166 dump_file_name = NULL;
2169 dump_finish (pass->static_pass_number);
2172 /* After executing the pass, apply expected changes to the function
2176 update_properties_after_pass (void *data)
2178 struct opt_pass *pass = (struct opt_pass *) data;
2179 cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
2180 & ~pass->properties_destroyed;
2183 /* Execute summary generation for all of the passes in IPA_PASS. */
2186 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
2190 struct opt_pass *pass = &ipa_pass->pass;
2192 /* Execute all of the IPA_PASSes in the list. */
2193 if (ipa_pass->pass.type == IPA_PASS
2194 && (!pass->gate || pass->gate ())
2195 && ipa_pass->generate_summary)
2197 pass_init_dump_file (pass);
2199 /* If a timevar is present, start it. */
2201 timevar_push (pass->tv_id);
2203 ipa_pass->generate_summary ();
2207 timevar_pop (pass->tv_id);
2209 pass_fini_dump_file (pass);
2211 ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
2215 /* Execute IPA_PASS function transform on NODE. */
2218 execute_one_ipa_transform_pass (struct cgraph_node *node,
2219 struct ipa_opt_pass_d *ipa_pass)
2221 struct opt_pass *pass = &ipa_pass->pass;
2222 unsigned int todo_after = 0;
2224 current_pass = pass;
2225 if (!ipa_pass->function_transform)
2228 /* Note that the folders should only create gimple expressions.
2229 This is a hack until the new folder is ready. */
2230 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2232 pass_init_dump_file (pass);
2234 /* Run pre-pass verification. */
2235 execute_todo (ipa_pass->function_transform_todo_flags_start);
2237 /* If a timevar is present, start it. */
2238 if (pass->tv_id != TV_NONE)
2239 timevar_push (pass->tv_id);
2242 todo_after = ipa_pass->function_transform (node);
2245 if (pass->tv_id != TV_NONE)
2246 timevar_pop (pass->tv_id);
2248 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2249 check_profile_consistency (pass->static_pass_number, 0, true);
2251 /* Run post-pass cleanup and verification. */
2252 execute_todo (todo_after);
2253 verify_interpass_invariants ();
2254 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2255 check_profile_consistency (pass->static_pass_number, 1, true);
2257 do_per_function (execute_function_dump, NULL);
2258 pass_fini_dump_file (pass);
2260 current_pass = NULL;
2263 /* For the current function, execute all ipa transforms. */
2266 execute_all_ipa_transforms (void)
2268 struct cgraph_node *node;
2271 node = cgraph_get_node (current_function_decl);
2273 if (node->ipa_transforms_to_apply)
2277 for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply);
2279 execute_one_ipa_transform_pass (node,
2280 VEC_index (ipa_opt_pass,
2281 node->ipa_transforms_to_apply,
2283 VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply);
2284 node->ipa_transforms_to_apply = NULL;
2288 /* Callback for do_per_function to apply all IPA transforms. */
2291 apply_ipa_transforms (void *data)
2293 struct cgraph_node *node = cgraph_get_node (current_function_decl);
2294 if (!node->global.inlined_to && node->ipa_transforms_to_apply)
2296 *(bool *)data = true;
2297 execute_all_ipa_transforms();
2298 rebuild_cgraph_edges ();
2302 /* Check if PASS is explicitly disabled or enabled and return
2303 the gate status. FUNC is the function to be processed, and
2304 GATE_STATUS is the gate status determined by pass manager by
2308 override_gate_status (struct opt_pass *pass, tree func, bool gate_status)
2310 bool explicitly_enabled = false;
2311 bool explicitly_disabled = false;
2314 = is_pass_explicitly_enabled_or_disabled (pass, func,
2315 enabled_pass_uid_range_tab);
2317 = is_pass_explicitly_enabled_or_disabled (pass, func,
2318 disabled_pass_uid_range_tab);
2320 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
2329 execute_one_pass (struct opt_pass *pass)
2331 bool initializing_dump;
2332 unsigned int todo_after = 0;
2336 /* IPA passes are executed on whole program, so cfun should be NULL.
2337 Other passes need function context set. */
2338 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2339 gcc_assert (!cfun && !current_function_decl);
2341 gcc_assert (cfun && current_function_decl);
2343 current_pass = pass;
2345 /* Check whether gate check should be avoided.
2346 User controls the value of the gate through the parameter "gate_status". */
2347 gate_status = (pass->gate == NULL) ? true : pass->gate();
2348 gate_status = override_gate_status (pass, current_function_decl, gate_status);
2350 /* Override gate with plugin. */
2351 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status);
2355 /* Run so passes selectively disabling themselves on a given function
2356 are not miscounted. */
2357 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2359 check_profile_consistency (pass->static_pass_number, 0, false);
2360 check_profile_consistency (pass->static_pass_number, 1, false);
2362 current_pass = NULL;
2366 /* Pass execution event trigger: useful to identify passes being
2368 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass);
2370 /* SIPLE IPA passes do not handle callgraphs with IPA transforms in it.
2371 Apply all trnasforms first. */
2372 if (pass->type == SIMPLE_IPA_PASS)
2374 bool applied = false;
2375 do_per_function (apply_ipa_transforms, (void *)&applied);
2377 symtab_remove_unreachable_nodes (true, dump_file);
2378 /* Restore current_pass. */
2379 current_pass = pass;
2382 if (!quiet_flag && !cfun)
2383 fprintf (stderr, " <%s>", pass->name ? pass->name : "");
2385 /* Note that the folders should only create gimple expressions.
2386 This is a hack until the new folder is ready. */
2387 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
2389 initializing_dump = pass_init_dump_file (pass);
2391 /* Run pre-pass verification. */
2392 execute_todo (pass->todo_flags_start);
2394 #ifdef ENABLE_CHECKING
2395 do_per_function (verify_curr_properties,
2396 (void *)(size_t)pass->properties_required);
2399 /* If a timevar is present, start it. */
2400 if (pass->tv_id != TV_NONE)
2401 timevar_push (pass->tv_id);
2406 todo_after = pass->execute ();
2407 do_per_function (clear_last_verified, NULL);
2411 if (pass->tv_id != TV_NONE)
2412 timevar_pop (pass->tv_id);
2414 do_per_function (update_properties_after_pass, pass);
2416 if (initializing_dump
2418 && graph_dump_format != no_graph
2420 && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
2421 == (PROP_cfg | PROP_rtl))
2423 get_dump_file_info (pass->static_pass_number)->pflags |= TDF_GRAPH;
2424 dump_flags |= TDF_GRAPH;
2425 clean_graph_dump_file (dump_file_name);
2428 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2429 check_profile_consistency (pass->static_pass_number, 0, true);
2431 /* Run post-pass cleanup and verification. */
2432 execute_todo (todo_after | pass->todo_flags_finish);
2433 if (profile_report && cfun && (cfun->curr_properties & PROP_cfg))
2434 check_profile_consistency (pass->static_pass_number, 1, true);
2436 verify_interpass_invariants ();
2437 do_per_function (execute_function_dump, NULL);
2438 if (pass->type == IPA_PASS)
2440 struct cgraph_node *node;
2441 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2442 VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
2443 (struct ipa_opt_pass_d *)pass);
2446 if (!current_function_decl)
2447 cgraph_process_new_functions ();
2449 pass_fini_dump_file (pass);
2451 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2452 gcc_assert (!(cfun->curr_properties & PROP_trees)
2453 || pass->type != RTL_PASS);
2455 current_pass = NULL;
2461 execute_pass_list (struct opt_pass *pass)
2465 gcc_assert (pass->type == GIMPLE_PASS
2466 || pass->type == RTL_PASS);
2467 if (execute_one_pass (pass) && pass->sub)
2468 execute_pass_list (pass->sub);
2474 /* Same as execute_pass_list but assume that subpasses of IPA passes
2475 are local passes. If SET is not NULL, write out summaries of only
2476 those node in SET. */
2479 ipa_write_summaries_2 (struct opt_pass *pass, struct lto_out_decl_state *state)
2483 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
2484 gcc_assert (!current_function_decl);
2486 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2487 if (pass->type == IPA_PASS
2488 && ipa_pass->write_summary
2489 && (!pass->gate || pass->gate ()))
2491 /* If a timevar is present, start it. */
2493 timevar_push (pass->tv_id);
2495 pass_init_dump_file (pass);
2497 ipa_pass->write_summary ();
2499 pass_fini_dump_file (pass);
2501 /* If a timevar is present, start it. */
2503 timevar_pop (pass->tv_id);
2506 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2507 ipa_write_summaries_2 (pass->sub, state);
2513 /* Helper function of ipa_write_summaries. Creates and destroys the
2514 decl state and calls ipa_write_summaries_2 for all passes that have
2515 summaries. SET is the set of nodes to be written. */
2518 ipa_write_summaries_1 (lto_symtab_encoder_t encoder)
2520 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2521 state->symtab_node_encoder = encoder;
2523 lto_push_out_decl_state (state);
2525 gcc_assert (!flag_wpa);
2526 ipa_write_summaries_2 (all_regular_ipa_passes, state);
2527 ipa_write_summaries_2 (all_lto_gen_passes, state);
2529 gcc_assert (lto_get_out_decl_state () == state);
2530 lto_pop_out_decl_state ();
2531 lto_delete_out_decl_state (state);
2534 /* Write out summaries for all the nodes in the callgraph. */
2537 ipa_write_summaries (void)
2539 lto_symtab_encoder_t encoder;
2541 struct varpool_node *vnode;
2542 struct cgraph_node **order;
2544 if (!flag_generate_lto || seen_error ())
2547 encoder = lto_symtab_encoder_new (false);
2549 /* Create the callgraph set in the same order used in
2550 cgraph_expand_all_functions. This mostly facilitates debugging,
2551 since it causes the gimple file to be processed in the same order
2552 as the source code. */
2553 order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
2554 order_pos = ipa_reverse_postorder (order);
2555 gcc_assert (order_pos == cgraph_n_nodes);
2557 for (i = order_pos - 1; i >= 0; i--)
2559 struct cgraph_node *node = order[i];
2561 if (cgraph_function_with_gimple_body_p (node))
2563 /* When streaming out references to statements as part of some IPA
2564 pass summary, the statements need to have uids assigned and the
2565 following does that for all the IPA passes here. Naturally, this
2566 ordering then matches the one IPA-passes get in their stmt_fixup
2569 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
2570 renumber_gimple_stmt_uids ();
2574 lto_set_symtab_encoder_in_partition (encoder, (symtab_node)node);
2577 FOR_EACH_DEFINED_VARIABLE (vnode)
2578 if ((!vnode->alias || vnode->alias_of))
2579 lto_set_symtab_encoder_in_partition (encoder, (symtab_node)vnode);
2581 ipa_write_summaries_1 (compute_ltrans_boundary (encoder));
2586 /* Same as execute_pass_list but assume that subpasses of IPA passes
2587 are local passes. If SET is not NULL, write out optimization summaries of
2588 only those node in SET. */
2591 ipa_write_optimization_summaries_1 (struct opt_pass *pass, struct lto_out_decl_state *state)
2595 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
2596 gcc_assert (!current_function_decl);
2598 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2599 if (pass->type == IPA_PASS
2600 && ipa_pass->write_optimization_summary
2601 && (!pass->gate || pass->gate ()))
2603 /* If a timevar is present, start it. */
2605 timevar_push (pass->tv_id);
2607 pass_init_dump_file (pass);
2609 ipa_pass->write_optimization_summary ();
2611 pass_fini_dump_file (pass);
2613 /* If a timevar is present, start it. */
2615 timevar_pop (pass->tv_id);
2618 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2619 ipa_write_optimization_summaries_1 (pass->sub, state);
2625 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2626 NULL, write out all summaries of all nodes. */
2629 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder)
2631 struct lto_out_decl_state *state = lto_new_out_decl_state ();
2632 lto_symtab_encoder_iterator lsei;
2633 state->symtab_node_encoder = encoder;
2635 lto_push_out_decl_state (state);
2636 for (lsei = lsei_start_function_in_partition (encoder);
2637 !lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
2639 struct cgraph_node *node = lsei_cgraph_node (lsei);
2640 /* When streaming out references to statements as part of some IPA
2641 pass summary, the statements need to have uids assigned.
2643 For functions newly born at WPA stage we need to initialize
2646 && gimple_has_body_p (node->symbol.decl))
2648 push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
2649 renumber_gimple_stmt_uids ();
2654 gcc_assert (flag_wpa);
2655 ipa_write_optimization_summaries_1 (all_regular_ipa_passes, state);
2656 ipa_write_optimization_summaries_1 (all_lto_gen_passes, state);
2658 gcc_assert (lto_get_out_decl_state () == state);
2659 lto_pop_out_decl_state ();
2660 lto_delete_out_decl_state (state);
2663 /* Same as execute_pass_list but assume that subpasses of IPA passes
2664 are local passes. */
2667 ipa_read_summaries_1 (struct opt_pass *pass)
2671 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2673 gcc_assert (!current_function_decl);
2675 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2677 if (pass->gate == NULL || pass->gate ())
2679 if (pass->type == IPA_PASS && ipa_pass->read_summary)
2681 /* If a timevar is present, start it. */
2683 timevar_push (pass->tv_id);
2685 pass_init_dump_file (pass);
2687 ipa_pass->read_summary ();
2689 pass_fini_dump_file (pass);
2693 timevar_pop (pass->tv_id);
2696 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2697 ipa_read_summaries_1 (pass->sub);
2704 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
2707 ipa_read_summaries (void)
2709 ipa_read_summaries_1 (all_regular_ipa_passes);
2710 ipa_read_summaries_1 (all_lto_gen_passes);
2713 /* Same as execute_pass_list but assume that subpasses of IPA passes
2714 are local passes. */
2717 ipa_read_optimization_summaries_1 (struct opt_pass *pass)
2721 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2723 gcc_assert (!current_function_decl);
2725 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2727 if (pass->gate == NULL || pass->gate ())
2729 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
2731 /* If a timevar is present, start it. */
2733 timevar_push (pass->tv_id);
2735 pass_init_dump_file (pass);
2737 ipa_pass->read_optimization_summary ();
2739 pass_fini_dump_file (pass);
2743 timevar_pop (pass->tv_id);
2746 if (pass->sub && pass->sub->type != GIMPLE_PASS)
2747 ipa_read_optimization_summaries_1 (pass->sub);
2753 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
2756 ipa_read_optimization_summaries (void)
2758 ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
2759 ipa_read_optimization_summaries_1 (all_lto_gen_passes);
2762 /* Same as execute_pass_list but assume that subpasses of IPA passes
2763 are local passes. */
2765 execute_ipa_pass_list (struct opt_pass *pass)
2769 gcc_assert (!current_function_decl);
2771 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2772 if (execute_one_pass (pass) && pass->sub)
2774 if (pass->sub->type == GIMPLE_PASS)
2776 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
2777 do_per_function_toporder ((void (*)(void *))execute_pass_list,
2779 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
2781 else if (pass->sub->type == SIMPLE_IPA_PASS
2782 || pass->sub->type == IPA_PASS)
2783 execute_ipa_pass_list (pass->sub);
2787 gcc_assert (!current_function_decl);
2788 cgraph_process_new_functions ();
2794 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2797 execute_ipa_stmt_fixups (struct opt_pass *pass,
2798 struct cgraph_node *node, gimple *stmts)
2802 /* Execute all of the IPA_PASSes in the list. */
2803 if (pass->type == IPA_PASS
2804 && (!pass->gate || pass->gate ()))
2806 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
2808 if (ipa_pass->stmt_fixup)
2810 pass_init_dump_file (pass);
2811 /* If a timevar is present, start it. */
2813 timevar_push (pass->tv_id);
2815 ipa_pass->stmt_fixup (node, stmts);
2819 timevar_pop (pass->tv_id);
2820 pass_fini_dump_file (pass);
2823 execute_ipa_stmt_fixups (pass->sub, node, stmts);
2829 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2832 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts)
2834 execute_ipa_stmt_fixups (all_regular_ipa_passes, node, stmts);
2838 extern void debug_properties (unsigned int);
2839 extern void dump_properties (FILE *, unsigned int);
2842 dump_properties (FILE *dump, unsigned int props)
2844 fprintf (dump, "Properties:\n");
2845 if (props & PROP_gimple_any)
2846 fprintf (dump, "PROP_gimple_any\n");
2847 if (props & PROP_gimple_lcf)
2848 fprintf (dump, "PROP_gimple_lcf\n");
2849 if (props & PROP_gimple_leh)
2850 fprintf (dump, "PROP_gimple_leh\n");
2851 if (props & PROP_cfg)
2852 fprintf (dump, "PROP_cfg\n");
2853 if (props & PROP_ssa)
2854 fprintf (dump, "PROP_ssa\n");
2855 if (props & PROP_no_crit_edges)
2856 fprintf (dump, "PROP_no_crit_edges\n");
2857 if (props & PROP_rtl)
2858 fprintf (dump, "PROP_rtl\n");
2859 if (props & PROP_gimple_lomp)
2860 fprintf (dump, "PROP_gimple_lomp\n");
2861 if (props & PROP_gimple_lcx)
2862 fprintf (dump, "PROP_gimple_lcx\n");
2863 if (props & PROP_cfglayout)
2864 fprintf (dump, "PROP_cfglayout\n");
2868 debug_properties (unsigned int props)
2870 dump_properties (stderr, props);
2873 /* Called by local passes to see if function is called by already processed nodes.
2874 Because we process nodes in topological order, this means that function is
2875 in recursive cycle or we introduced new direct calls. */
2877 function_called_by_processed_nodes_p (void)
2879 struct cgraph_edge *e;
2880 for (e = cgraph_get_node (current_function_decl)->callers;
2884 if (e->caller->symbol.decl == current_function_decl)
2886 if (!cgraph_function_with_gimple_body_p (e->caller))
2888 if (TREE_ASM_WRITTEN (e->caller->symbol.decl))
2890 if (!e->caller->process && !e->caller->global.inlined_to)
2895 fprintf (dump_file, "Already processed call to:\n");
2896 dump_cgraph_node (dump_file, e->caller);
2901 #include "gt-passes.h"