1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This is the top level of cc1/c++.
21 It parses command args, opens files, invokes the various passes
22 in the proper order, and counts the time used by each.
23 Error messages and low-level interface to malloc also handled here. */
27 #include "coretypes.h"
36 #include "insn-attr.h"
37 #include "insn-config.h"
38 #include "insn-flags.h"
39 #include "hard-reg-set.h"
46 #include "basic-block.h"
50 #include "diagnostic-core.h"
55 #include "langhooks.h"
57 #include "hosthooks.h"
60 #include "value-prof.h"
61 #include "tree-inline.h"
62 #include "tree-ssa-alias.h"
63 #include "internal-fn.h"
64 #include "gimple-expr.h"
67 #include "gimple-ssa.h"
69 #include "stringpool.h"
70 #include "tree-ssanames.h"
71 #include "tree-ssa-loop-manip.h"
72 #include "tree-into-ssa.h"
75 #include "tree-pass.h"
76 #include "tree-dump.h"
79 #include "lto-streamer.h"
81 #include "ipa-utils.h"
82 #include "tree-pretty-print.h" /* for dump_function_header */
84 #include "pass_manager.h"
85 #include "tree-ssa-live.h" /* For remove_unused_locals. */
86 #include "tree-cfgcleanup.h"
90 /* This is used for debugging. It allows the current pass to printed
91 from anywhere in compilation.
92 The variable current_pass is also used for statistics and plugins. */
93 struct opt_pass
*current_pass
;
95 static void register_pass_name (struct opt_pass
*, const char *);
97 /* Most passes are single-instance (within their context) and thus don't
98 need to implement cloning, but passes that support multiple instances
99 *must* provide their own implementation of the clone method.
101 Handle this by providing a default implemenation, but make it a fatal
107 internal_error ("pass %s does not support cloning", name
);
122 opt_pass::opt_pass (const pass_data
&data
, context
*ctxt
)
126 static_pass_number (0),
133 pass_manager::execute_early_local_passes ()
135 execute_pass_list (pass_early_local_passes_1
->sub
);
139 pass_manager::execute_pass_mode_switching ()
141 return pass_mode_switching_1
->execute ();
145 /* Call from anywhere to find out what pass this is. Useful for
146 printing out debugging information deep inside an service
149 print_current_pass (FILE *file
)
152 fprintf (file
, "current pass = %s (%d)\n",
153 current_pass
->name
, current_pass
->static_pass_number
);
155 fprintf (file
, "no current pass.\n");
159 /* Call from the debugger to get the current pass name. */
163 print_current_pass (stderr
);
168 /* Global variables used to communicate with passes. */
170 bool first_pass_instance
;
173 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
176 This does nothing for local (non-static) variables, unless the
177 variable is a register variable with DECL_ASSEMBLER_NAME set. In
178 that case, or if the variable is not an automatic, it sets up the
179 RTL and outputs any assembler code (label definition, storage
180 allocation and initialization).
182 DECL is the declaration. TOP_LEVEL is nonzero
183 if this declaration is not within a function. */
186 rest_of_decl_compilation (tree decl
,
190 /* We deferred calling assemble_alias so that we could collect
191 other attributes such as visibility. Emit the alias now. */
195 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
198 alias
= TREE_VALUE (TREE_VALUE (alias
));
199 alias
= get_identifier (TREE_STRING_POINTER (alias
));
200 /* A quirk of the initial implementation of aliases required that the
201 user add "extern" to all of them. Which is silly, but now
202 historical. Do note that the symbol is in fact locally defined. */
203 DECL_EXTERNAL (decl
) = 0;
204 TREE_STATIC (decl
) = 1;
205 assemble_alias (decl
, alias
);
209 /* Can't defer this, because it needs to happen before any
210 later function definitions are processed. */
211 if (DECL_ASSEMBLER_NAME_SET_P (decl
) && DECL_REGISTER (decl
))
212 make_decl_rtl (decl
);
214 /* Forward declarations for nested functions are not "external",
215 but we need to treat them as if they were. */
216 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
217 || TREE_CODE (decl
) == FUNCTION_DECL
)
219 timevar_push (TV_VARCONST
);
221 /* Don't output anything when a tentative file-scope definition
222 is seen. But at end of compilation, do output code for them.
224 We do output all variables and rely on
225 callgraph code to defer them except for forward declarations
226 (see gcc.c-torture/compile/920624-1.c) */
228 || !DECL_DEFER_OUTPUT (decl
)
229 || DECL_INITIAL (decl
))
230 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_HAS_VALUE_EXPR_P (decl
))
231 && !DECL_EXTERNAL (decl
))
233 /* When reading LTO unit, we also read varpool, so do not
235 if (in_lto_p
&& !at_end
)
237 else if (TREE_CODE (decl
) != FUNCTION_DECL
)
238 varpool_finalize_decl (decl
);
241 #ifdef ASM_FINISH_DECLARE_OBJECT
242 if (decl
== last_assemble_variable_decl
)
244 ASM_FINISH_DECLARE_OBJECT (asm_out_file
, decl
,
249 timevar_pop (TV_VARCONST
);
251 else if (TREE_CODE (decl
) == TYPE_DECL
252 /* Like in rest_of_type_compilation, avoid confusing the debug
253 information machinery when there are errors. */
256 timevar_push (TV_SYMOUT
);
257 debug_hooks
->type_decl (decl
, !top_level
);
258 timevar_pop (TV_SYMOUT
);
261 /* Let cgraph know about the existence of variables. */
262 if (in_lto_p
&& !at_end
)
264 else if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
)
265 && TREE_STATIC (decl
))
266 varpool_node_for_decl (decl
);
269 /* Called after finishing a record, union or enumeral type. */
272 rest_of_type_compilation (tree type
, int toplev
)
274 /* Avoid confusing the debug information machinery when there are
279 timevar_push (TV_SYMOUT
);
280 debug_hooks
->type_decl (TYPE_STUB_DECL (type
), !toplev
);
281 timevar_pop (TV_SYMOUT
);
288 finish_optimization_passes (void)
291 struct dump_file_info
*dfi
;
293 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
295 timevar_push (TV_DUMP
);
296 if (profile_arc_flag
|| flag_test_coverage
|| flag_branch_probabilities
)
298 dumps
->dump_start (pass_profile_1
->static_pass_number
, NULL
);
300 dumps
->dump_finish (pass_profile_1
->static_pass_number
);
305 dumps
->dump_start (pass_profile_1
->static_pass_number
, NULL
);
306 print_combine_total_stats ();
307 dumps
->dump_finish (pass_profile_1
->static_pass_number
);
310 /* Do whatever is necessary to finish printing the graphs. */
311 for (i
= TDI_end
; (dfi
= dumps
->get_dump_file_info (i
)) != NULL
; ++i
)
312 if (dumps
->dump_initialized_p (i
)
313 && (dfi
->pflags
& TDF_GRAPH
) != 0
314 && (name
= dumps
->get_dump_file_name (i
)) != NULL
)
316 finish_graph_dump_file (name
);
320 timevar_pop (TV_DUMP
);
324 execute_all_early_local_passes (void)
326 /* Once this pass (and its sub-passes) are complete, all functions
327 will be in SSA form. Technically this state change is happening
328 a tad early, since the sub-passes have not yet run, but since
329 none of the sub-passes are IPA passes and do not create new
330 functions, this is ok. We're setting this value for the benefit
331 of IPA passes that follow. */
332 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
333 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
337 /* Gate: execute, or not, all of the non-trivial optimizations. */
340 gate_all_early_local_passes (void)
342 /* Don't bother doing anything if the program has errors. */
343 return (!seen_error () && !in_lto_p
);
348 const pass_data pass_data_early_local_passes
=
350 SIMPLE_IPA_PASS
, /* type */
351 "early_local_cleanups", /* name */
352 OPTGROUP_NONE
, /* optinfo_flags */
354 true, /* has_execute */
355 TV_EARLY_LOCAL
, /* tv_id */
356 0, /* properties_required */
357 0, /* properties_provided */
358 0, /* properties_destroyed */
359 0, /* todo_flags_start */
360 TODO_remove_functions
, /* todo_flags_finish */
363 class pass_early_local_passes
: public simple_ipa_opt_pass
366 pass_early_local_passes (gcc::context
*ctxt
)
367 : simple_ipa_opt_pass (pass_data_early_local_passes
, ctxt
)
370 /* opt_pass methods: */
371 bool gate () { return gate_all_early_local_passes (); }
372 unsigned int execute () { return execute_all_early_local_passes (); }
374 }; // class pass_early_local_passes
378 simple_ipa_opt_pass
*
379 make_pass_early_local_passes (gcc::context
*ctxt
)
381 return new pass_early_local_passes (ctxt
);
384 /* Gate: execute, or not, all of the non-trivial optimizations. */
387 gate_all_early_optimizations (void)
389 return (optimize
>= 1
390 /* Don't bother doing anything if the program has errors. */
396 const pass_data pass_data_all_early_optimizations
=
398 GIMPLE_PASS
, /* type */
399 "early_optimizations", /* name */
400 OPTGROUP_NONE
, /* optinfo_flags */
402 false, /* has_execute */
404 0, /* properties_required */
405 0, /* properties_provided */
406 0, /* properties_destroyed */
407 0, /* todo_flags_start */
408 0, /* todo_flags_finish */
411 class pass_all_early_optimizations
: public gimple_opt_pass
414 pass_all_early_optimizations (gcc::context
*ctxt
)
415 : gimple_opt_pass (pass_data_all_early_optimizations
, ctxt
)
418 /* opt_pass methods: */
419 bool gate () { return gate_all_early_optimizations (); }
421 }; // class pass_all_early_optimizations
425 static gimple_opt_pass
*
426 make_pass_all_early_optimizations (gcc::context
*ctxt
)
428 return new pass_all_early_optimizations (ctxt
);
431 /* Gate: execute, or not, all of the non-trivial optimizations. */
434 gate_all_optimizations (void)
436 return optimize
>= 1 && !optimize_debug
;
441 const pass_data pass_data_all_optimizations
=
443 GIMPLE_PASS
, /* type */
444 "*all_optimizations", /* name */
445 OPTGROUP_NONE
, /* optinfo_flags */
447 false, /* has_execute */
448 TV_OPTIMIZE
, /* tv_id */
449 0, /* properties_required */
450 0, /* properties_provided */
451 0, /* properties_destroyed */
452 0, /* todo_flags_start */
453 0, /* todo_flags_finish */
456 class pass_all_optimizations
: public gimple_opt_pass
459 pass_all_optimizations (gcc::context
*ctxt
)
460 : gimple_opt_pass (pass_data_all_optimizations
, ctxt
)
463 /* opt_pass methods: */
464 bool gate () { return gate_all_optimizations (); }
466 }; // class pass_all_optimizations
470 static gimple_opt_pass
*
471 make_pass_all_optimizations (gcc::context
*ctxt
)
473 return new pass_all_optimizations (ctxt
);
476 /* Gate: execute, or not, all of the non-trivial optimizations. */
479 gate_all_optimizations_g (void)
481 return optimize
>= 1 && optimize_debug
;
486 const pass_data pass_data_all_optimizations_g
=
488 GIMPLE_PASS
, /* type */
489 "*all_optimizations_g", /* name */
490 OPTGROUP_NONE
, /* optinfo_flags */
492 false, /* has_execute */
493 TV_OPTIMIZE
, /* tv_id */
494 0, /* properties_required */
495 0, /* properties_provided */
496 0, /* properties_destroyed */
497 0, /* todo_flags_start */
498 0, /* todo_flags_finish */
501 class pass_all_optimizations_g
: public gimple_opt_pass
504 pass_all_optimizations_g (gcc::context
*ctxt
)
505 : gimple_opt_pass (pass_data_all_optimizations_g
, ctxt
)
508 /* opt_pass methods: */
509 bool gate () { return gate_all_optimizations_g (); }
511 }; // class pass_all_optimizations_g
515 static gimple_opt_pass
*
516 make_pass_all_optimizations_g (gcc::context
*ctxt
)
518 return new pass_all_optimizations_g (ctxt
);
522 gate_rest_of_compilation (void)
524 /* Early return if there were errors. We can run afoul of our
525 consistency checks, and there's not really much point in fixing them. */
526 return !(rtl_dump_and_exit
|| flag_syntax_only
|| seen_error ());
531 const pass_data pass_data_rest_of_compilation
=
534 "*rest_of_compilation", /* name */
535 OPTGROUP_NONE
, /* optinfo_flags */
537 false, /* has_execute */
538 TV_REST_OF_COMPILATION
, /* tv_id */
539 PROP_rtl
, /* properties_required */
540 0, /* properties_provided */
541 0, /* properties_destroyed */
542 0, /* todo_flags_start */
543 0, /* todo_flags_finish */
546 class pass_rest_of_compilation
: public rtl_opt_pass
549 pass_rest_of_compilation (gcc::context
*ctxt
)
550 : rtl_opt_pass (pass_data_rest_of_compilation
, ctxt
)
553 /* opt_pass methods: */
554 bool gate () { return gate_rest_of_compilation (); }
556 }; // class pass_rest_of_compilation
560 static rtl_opt_pass
*
561 make_pass_rest_of_compilation (gcc::context
*ctxt
)
563 return new pass_rest_of_compilation (ctxt
);
567 gate_postreload (void)
569 return reload_completed
;
574 const pass_data pass_data_postreload
=
577 "*all-postreload", /* name */
578 OPTGROUP_NONE
, /* optinfo_flags */
580 false, /* has_execute */
581 TV_POSTRELOAD
, /* tv_id */
582 PROP_rtl
, /* properties_required */
583 0, /* properties_provided */
584 0, /* properties_destroyed */
585 0, /* todo_flags_start */
586 TODO_verify_rtl_sharing
, /* todo_flags_finish */
589 class pass_postreload
: public rtl_opt_pass
592 pass_postreload (gcc::context
*ctxt
)
593 : rtl_opt_pass (pass_data_postreload
, ctxt
)
596 /* opt_pass methods: */
597 bool gate () { return gate_postreload (); }
599 }; // class pass_postreload
603 static rtl_opt_pass
*
604 make_pass_postreload (gcc::context
*ctxt
)
606 return new pass_postreload (ctxt
);
611 /* Set the static pass number of pass PASS to ID and record that
612 in the mapping from static pass number to pass. */
616 set_pass_for_id (int id
, struct opt_pass
*pass
)
618 pass
->static_pass_number
= id
;
619 if (passes_by_id_size
<= id
)
621 passes_by_id
= XRESIZEVEC (struct opt_pass
*, passes_by_id
, id
+ 1);
622 memset (passes_by_id
+ passes_by_id_size
, 0,
623 (id
+ 1 - passes_by_id_size
) * sizeof (void *));
624 passes_by_id_size
= id
+ 1;
626 passes_by_id
[id
] = pass
;
629 /* Return the pass with the static pass number ID. */
632 pass_manager::get_pass_for_id (int id
) const
634 if (id
>= passes_by_id_size
)
636 return passes_by_id
[id
];
639 /* Iterate over the pass tree allocating dump file numbers. We want
640 to do this depth first, and independent of whether the pass is
644 register_one_dump_file (struct opt_pass
*pass
)
646 g
->get_passes ()->register_one_dump_file (pass
);
650 pass_manager::register_one_dump_file (struct opt_pass
*pass
)
652 char *dot_name
, *flag_name
, *glob_name
;
653 const char *name
, *full_name
, *prefix
;
656 int optgroup_flags
= OPTGROUP_NONE
;
657 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
659 /* See below in next_pass_1. */
661 if (pass
->static_pass_number
!= -1)
662 sprintf (num
, "%d", ((int) pass
->static_pass_number
< 0
663 ? 1 : pass
->static_pass_number
));
665 /* The name is both used to identify the pass for the purposes of plugins,
666 and to specify dump file name and option.
667 The latter two might want something short which is not quite unique; for
668 that reason, we may have a disambiguating prefix, followed by a space
669 to mark the start of the following dump file name / option string. */
670 name
= strchr (pass
->name
, ' ');
671 name
= name
? name
+ 1 : pass
->name
;
672 dot_name
= concat (".", name
, num
, NULL
);
673 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
677 optgroup_flags
|= OPTGROUP_IPA
;
679 else if (pass
->type
== GIMPLE_PASS
)
690 flag_name
= concat (prefix
, name
, num
, NULL
);
691 glob_name
= concat (prefix
, name
, NULL
);
692 optgroup_flags
|= pass
->optinfo_flags
;
693 /* For any passes that do not have an optgroup set, and which are not
694 IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
695 any dump messages are emitted properly under -fopt-info(-optall). */
696 if (optgroup_flags
== OPTGROUP_NONE
)
697 optgroup_flags
= OPTGROUP_OTHER
;
698 id
= dumps
->dump_register (dot_name
, flag_name
, glob_name
, flags
,
700 set_pass_for_id (id
, pass
);
701 full_name
= concat (prefix
, pass
->name
, num
, NULL
);
702 register_pass_name (pass
, full_name
);
703 free (CONST_CAST (char *, full_name
));
706 /* Recursive worker function for register_dump_files. */
710 register_dump_files_1 (struct opt_pass
*pass
, int properties
)
714 int new_properties
= (properties
| pass
->properties_provided
)
715 & ~pass
->properties_destroyed
;
717 if (pass
->name
&& pass
->name
[0] != '*')
718 register_one_dump_file (pass
);
721 new_properties
= register_dump_files_1 (pass
->sub
, new_properties
);
723 /* If we have a gate, combine the properties that we could have with
724 and without the pass being examined. */
726 properties
&= new_properties
;
728 properties
= new_properties
;
737 /* Register the dump files for the pass_manager starting at PASS.
738 PROPERTIES reflects the properties that are guaranteed to be available at
739 the beginning of the pipeline. */
743 register_dump_files (struct opt_pass
*pass
,int properties
)
745 pass
->properties_required
|= properties
;
746 register_dump_files_1 (pass
, properties
);
751 const char* unique_name
;
752 struct opt_pass
*pass
;
755 /* Helper for pass_registry hash table. */
757 struct pass_registry_hasher
: typed_noop_remove
<pass_registry
>
759 typedef pass_registry value_type
;
760 typedef pass_registry compare_type
;
761 static inline hashval_t
hash (const value_type
*);
762 static inline bool equal (const value_type
*, const compare_type
*);
765 /* Pass registry hash function. */
768 pass_registry_hasher::hash (const value_type
*s
)
770 return htab_hash_string (s
->unique_name
);
773 /* Hash equal function */
776 pass_registry_hasher::equal (const value_type
*s1
, const compare_type
*s2
)
778 return !strcmp (s1
->unique_name
, s2
->unique_name
);
781 static hash_table
<pass_registry_hasher
> name_to_pass_map
;
783 /* Register PASS with NAME. */
786 register_pass_name (struct opt_pass
*pass
, const char *name
)
788 struct pass_registry
**slot
;
789 struct pass_registry pr
;
791 if (!name_to_pass_map
.is_created ())
792 name_to_pass_map
.create (256);
794 pr
.unique_name
= name
;
795 slot
= name_to_pass_map
.find_slot (&pr
, INSERT
);
798 struct pass_registry
*new_pr
;
800 new_pr
= XCNEW (struct pass_registry
);
801 new_pr
->unique_name
= xstrdup (name
);
806 return; /* Ignore plugin passes. */
809 /* Map from pass id to canonicalized pass name. */
811 typedef const char *char_ptr
;
812 static vec
<char_ptr
> pass_tab
= vNULL
;
814 /* Callback function for traversing NAME_TO_PASS_MAP. */
817 passes_pass_traverse (pass_registry
**p
, void *data ATTRIBUTE_UNUSED
)
819 struct opt_pass
*pass
= (*p
)->pass
;
821 gcc_assert (pass
->static_pass_number
> 0);
822 gcc_assert (pass_tab
.exists ());
824 pass_tab
[pass
->static_pass_number
] = (*p
)->unique_name
;
829 /* The function traverses NAME_TO_PASS_MAP and creates a pass info
830 table for dumping purpose. */
833 create_pass_tab (void)
835 if (!flag_dump_passes
)
838 pass_tab
.safe_grow_cleared (g
->get_passes ()->passes_by_id_size
+ 1);
839 name_to_pass_map
.traverse
<void *, passes_pass_traverse
> (NULL
);
842 static bool override_gate_status (struct opt_pass
*, tree
, bool);
844 /* Dump the instantiated name for PASS. IS_ON indicates if PASS
845 is turned on or not. */
848 dump_one_pass (struct opt_pass
*pass
, int pass_indent
)
850 int indent
= 3 * pass_indent
;
852 bool is_on
, is_really_on
;
854 is_on
= pass
->has_gate
? pass
->gate () : true;
855 is_really_on
= override_gate_status (pass
, current_function_decl
, is_on
);
857 if (pass
->static_pass_number
<= 0)
860 pn
= pass_tab
[pass
->static_pass_number
];
862 fprintf (stderr
, "%*s%-40s%*s:%s%s\n", indent
, " ", pn
,
863 (15 - indent
< 0 ? 0 : 15 - indent
), " ",
864 is_on
? " ON" : " OFF",
865 ((!is_on
) == (!is_really_on
) ? ""
866 : (is_really_on
? " (FORCED_ON)" : " (FORCED_OFF)")));
869 /* Dump pass list PASS with indentation INDENT. */
872 dump_pass_list (struct opt_pass
*pass
, int indent
)
876 dump_one_pass (pass
, indent
);
878 dump_pass_list (pass
->sub
, indent
+ 1);
884 /* Dump all optimization passes. */
889 g
->get_passes ()->dump_passes ();
893 pass_manager::dump_passes () const
895 struct cgraph_node
*n
, *node
= NULL
;
899 FOR_EACH_FUNCTION (n
)
900 if (DECL_STRUCT_FUNCTION (n
->decl
))
909 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
911 dump_pass_list (all_lowering_passes
, 1);
912 dump_pass_list (all_small_ipa_passes
, 1);
913 dump_pass_list (all_regular_ipa_passes
, 1);
914 dump_pass_list (all_late_ipa_passes
, 1);
915 dump_pass_list (all_passes
, 1);
921 /* Returns the pass with NAME. */
923 static struct opt_pass
*
924 get_pass_by_name (const char *name
)
926 struct pass_registry
**slot
, pr
;
928 pr
.unique_name
= name
;
929 slot
= name_to_pass_map
.find_slot (&pr
, NO_INSERT
);
934 return (*slot
)->pass
;
938 /* Range [start, last]. */
944 const char *assem_name
;
945 struct uid_range
*next
;
948 typedef struct uid_range
*uid_range_p
;
951 static vec
<uid_range_p
>
952 enabled_pass_uid_range_tab
= vNULL
;
953 static vec
<uid_range_p
>
954 disabled_pass_uid_range_tab
= vNULL
;
957 /* Parse option string for -fdisable- and -fenable-
958 The syntax of the options:
961 -fdisable-<pass_name>
963 -fenable-<pass_name>=s1:e1,s2:e2,...
964 -fdisable-<pass_name>=s1:e1,s2:e2,...
968 enable_disable_pass (const char *arg
, bool is_enable
)
970 struct opt_pass
*pass
;
971 char *range_str
, *phase_name
;
972 char *argstr
= xstrdup (arg
);
973 vec
<uid_range_p
> *tab
= 0;
975 range_str
= strchr (argstr
,'=');
986 error ("unrecognized option -fenable");
988 error ("unrecognized option -fdisable");
992 pass
= get_pass_by_name (phase_name
);
993 if (!pass
|| pass
->static_pass_number
== -1)
996 error ("unknown pass %s specified in -fenable", phase_name
);
998 error ("unknown pass %s specified in -fdisable", phase_name
);
1004 tab
= &enabled_pass_uid_range_tab
;
1006 tab
= &disabled_pass_uid_range_tab
;
1008 if ((unsigned) pass
->static_pass_number
>= tab
->length ())
1009 tab
->safe_grow_cleared (pass
->static_pass_number
+ 1);
1014 uid_range_p new_range
= XCNEW (struct uid_range
);
1016 new_range
->start
= 0;
1017 new_range
->last
= (unsigned)-1;
1019 slot
= (*tab
)[pass
->static_pass_number
];
1020 new_range
->next
= slot
;
1021 (*tab
)[pass
->static_pass_number
] = new_range
;
1023 inform (UNKNOWN_LOCATION
, "enable pass %s for functions in the range "
1024 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1026 inform (UNKNOWN_LOCATION
, "disable pass %s for functions in the range "
1027 "of [%u, %u]", phase_name
, new_range
->start
, new_range
->last
);
1031 char *next_range
= NULL
;
1032 char *one_range
= range_str
;
1033 char *end_val
= NULL
;
1038 uid_range_p new_range
;
1039 char *invalid
= NULL
;
1041 char *func_name
= NULL
;
1043 next_range
= strchr (one_range
, ',');
1050 end_val
= strchr (one_range
, ':');
1056 start
= strtol (one_range
, &invalid
, 10);
1057 if (*invalid
|| start
< 0)
1059 if (end_val
|| (one_range
[0] >= '0'
1060 && one_range
[0] <= '9'))
1062 error ("Invalid range %s in option %s",
1064 is_enable
? "-fenable" : "-fdisable");
1068 func_name
= one_range
;
1072 new_range
= XCNEW (struct uid_range
);
1075 new_range
->start
= (unsigned) start
;
1076 new_range
->last
= (unsigned) start
;
1080 new_range
->start
= (unsigned) -1;
1081 new_range
->last
= (unsigned) -1;
1082 new_range
->assem_name
= xstrdup (func_name
);
1087 long last
= strtol (end_val
, &invalid
, 10);
1088 if (*invalid
|| last
< start
)
1090 error ("Invalid range %s in option %s",
1092 is_enable
? "-fenable" : "-fdisable");
1096 new_range
= XCNEW (struct uid_range
);
1097 new_range
->start
= (unsigned) start
;
1098 new_range
->last
= (unsigned) last
;
1101 slot
= (*tab
)[pass
->static_pass_number
];
1102 new_range
->next
= slot
;
1103 (*tab
)[pass
->static_pass_number
] = new_range
;
1106 if (new_range
->assem_name
)
1107 inform (UNKNOWN_LOCATION
,
1108 "enable pass %s for function %s",
1109 phase_name
, new_range
->assem_name
);
1111 inform (UNKNOWN_LOCATION
,
1112 "enable pass %s for functions in the range of [%u, %u]",
1113 phase_name
, new_range
->start
, new_range
->last
);
1117 if (new_range
->assem_name
)
1118 inform (UNKNOWN_LOCATION
,
1119 "disable pass %s for function %s",
1120 phase_name
, new_range
->assem_name
);
1122 inform (UNKNOWN_LOCATION
,
1123 "disable pass %s for functions in the range of [%u, %u]",
1124 phase_name
, new_range
->start
, new_range
->last
);
1127 one_range
= next_range
;
1128 } while (next_range
);
1134 /* Enable pass specified by ARG. */
1137 enable_pass (const char *arg
)
1139 enable_disable_pass (arg
, true);
1142 /* Disable pass specified by ARG. */
1145 disable_pass (const char *arg
)
1147 enable_disable_pass (arg
, false);
1150 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1153 is_pass_explicitly_enabled_or_disabled (struct opt_pass
*pass
,
1155 vec
<uid_range_p
> tab
)
1157 uid_range_p slot
, range
;
1159 const char *aname
= NULL
;
1162 || (unsigned) pass
->static_pass_number
>= tab
.length ()
1163 || pass
->static_pass_number
== -1)
1166 slot
= tab
[pass
->static_pass_number
];
1170 cgraph_uid
= func
? cgraph_get_node (func
)->uid
: 0;
1171 if (func
&& DECL_ASSEMBLER_NAME_SET_P (func
))
1172 aname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func
));
1177 if ((unsigned) cgraph_uid
>= range
->start
1178 && (unsigned) cgraph_uid
<= range
->last
)
1180 if (range
->assem_name
&& aname
1181 && !strcmp (range
->assem_name
, aname
))
1183 range
= range
->next
;
1190 /* Update static_pass_number for passes (and the flag
1191 TODO_mark_first_instance).
1193 Passes are constructed with static_pass_number preinitialized to 0
1195 This field is used in two different ways: initially as instance numbers
1196 of their kind, and then as ids within the entire pass manager.
1198 Within pass_manager::pass_manager:
1200 * In add_pass_instance(), as called by next_pass_1 in
1201 NEXT_PASS in init_optimization_passes
1203 * When the initial instance of a pass within a pass manager is seen,
1204 it is flagged, and its static_pass_number is set to -1
1206 * On subsequent times that it is seen, the static pass number
1207 is decremented each time, so that if there are e.g. 4 dups,
1208 they have static_pass_number -4, 2, 3, 4 respectively (note
1209 how the initial one is negative and gives the count); these
1210 can be thought of as instance numbers of the specific pass
1212 * Within the register_dump_files () traversal, set_pass_for_id()
1213 is called on each pass, using these instance numbers to create
1214 dumpfile switches, and then overwriting them with a pass id,
1215 which are global to the whole pass manager (based on
1216 (TDI_end + current value of extra_dump_files_in_use) ) */
1219 add_pass_instance (struct opt_pass
*new_pass
, bool track_duplicates
,
1220 opt_pass
*initial_pass
)
1222 /* Are we dealing with the first pass of its kind, or a clone? */
1223 if (new_pass
!= initial_pass
)
1225 /* We're dealing with a clone. */
1226 new_pass
->todo_flags_start
&= ~TODO_mark_first_instance
;
1228 /* Indicate to register_dump_files that this pass has duplicates,
1229 and so it should rename the dump file. The first instance will
1230 be -1, and be number of duplicates = -static_pass_number - 1.
1231 Subsequent instances will be > 0 and just the duplicate number. */
1232 if ((new_pass
->name
&& new_pass
->name
[0] != '*') || track_duplicates
)
1234 initial_pass
->static_pass_number
-= 1;
1235 new_pass
->static_pass_number
= -initial_pass
->static_pass_number
;
1240 /* We're dealing with the first pass of its kind. */
1241 new_pass
->todo_flags_start
|= TODO_mark_first_instance
;
1242 new_pass
->static_pass_number
= -1;
1244 invoke_plugin_callbacks (PLUGIN_NEW_PASS
, new_pass
);
1248 /* Add a pass to the pass list. Duplicate the pass if it's already
1251 static struct opt_pass
**
1252 next_pass_1 (struct opt_pass
**list
, struct opt_pass
*pass
,
1253 struct opt_pass
*initial_pass
)
1255 /* Every pass should have a name so that plugins can refer to them. */
1256 gcc_assert (pass
->name
!= NULL
);
1258 add_pass_instance (pass
, false, initial_pass
);
1261 return &(*list
)->next
;
1264 /* List node for an inserted pass instance. We need to keep track of all
1265 the newly-added pass instances (with 'added_pass_nodes' defined below)
1266 so that we can register their dump files after pass-positioning is finished.
1267 Registering dumping files needs to be post-processed or the
1268 static_pass_number of the opt_pass object would be modified and mess up
1269 the dump file names of future pass instances to be added. */
1271 struct pass_list_node
1273 struct opt_pass
*pass
;
1274 struct pass_list_node
*next
;
1277 static struct pass_list_node
*added_pass_nodes
= NULL
;
1278 static struct pass_list_node
*prev_added_pass_node
;
1280 /* Insert the pass at the proper position. Return true if the pass
1281 is successfully added.
1283 NEW_PASS_INFO - new pass to be inserted
1284 PASS_LIST - root of the pass list to insert the new pass to */
1287 position_pass (struct register_pass_info
*new_pass_info
,
1288 struct opt_pass
**pass_list
)
1290 struct opt_pass
*pass
= *pass_list
, *prev_pass
= NULL
;
1291 bool success
= false;
1293 for ( ; pass
; prev_pass
= pass
, pass
= pass
->next
)
1295 /* Check if the current pass is of the same type as the new pass and
1296 matches the name and the instance number of the reference pass. */
1297 if (pass
->type
== new_pass_info
->pass
->type
1299 && !strcmp (pass
->name
, new_pass_info
->reference_pass_name
)
1300 && ((new_pass_info
->ref_pass_instance_number
== 0)
1301 || (new_pass_info
->ref_pass_instance_number
==
1302 pass
->static_pass_number
)
1303 || (new_pass_info
->ref_pass_instance_number
== 1
1304 && pass
->todo_flags_start
& TODO_mark_first_instance
)))
1306 struct opt_pass
*new_pass
;
1307 struct pass_list_node
*new_pass_node
;
1309 if (new_pass_info
->ref_pass_instance_number
== 0)
1311 new_pass
= new_pass_info
->pass
->clone ();
1312 add_pass_instance (new_pass
, true, new_pass_info
->pass
);
1316 new_pass
= new_pass_info
->pass
;
1317 add_pass_instance (new_pass
, true, new_pass
);
1320 /* Insert the new pass instance based on the positioning op. */
1321 switch (new_pass_info
->pos_op
)
1323 case PASS_POS_INSERT_AFTER
:
1324 new_pass
->next
= pass
->next
;
1325 pass
->next
= new_pass
;
1327 /* Skip newly inserted pass to avoid repeated
1328 insertions in the case where the new pass and the
1329 existing one have the same name. */
1332 case PASS_POS_INSERT_BEFORE
:
1333 new_pass
->next
= pass
;
1335 prev_pass
->next
= new_pass
;
1337 *pass_list
= new_pass
;
1339 case PASS_POS_REPLACE
:
1340 new_pass
->next
= pass
->next
;
1342 prev_pass
->next
= new_pass
;
1344 *pass_list
= new_pass
;
1345 new_pass
->sub
= pass
->sub
;
1346 new_pass
->tv_id
= pass
->tv_id
;
1350 error ("invalid pass positioning operation");
1354 /* Save the newly added pass (instance) in the added_pass_nodes
1355 list so that we can register its dump file later. Note that
1356 we cannot register the dump file now because doing so will modify
1357 the static_pass_number of the opt_pass object and therefore
1358 mess up the dump file name of future instances. */
1359 new_pass_node
= XCNEW (struct pass_list_node
);
1360 new_pass_node
->pass
= new_pass
;
1361 if (!added_pass_nodes
)
1362 added_pass_nodes
= new_pass_node
;
1364 prev_added_pass_node
->next
= new_pass_node
;
1365 prev_added_pass_node
= new_pass_node
;
1370 if (pass
->sub
&& position_pass (new_pass_info
, &pass
->sub
))
1377 /* Hooks a new pass into the pass lists.
1379 PASS_INFO - pass information that specifies the opt_pass object,
1380 reference pass, instance number, and how to position
1384 register_pass (struct register_pass_info
*pass_info
)
1386 g
->get_passes ()->register_pass (pass_info
);
1390 register_pass (opt_pass
* pass
, pass_positioning_ops pos
,
1391 const char* ref_pass_name
, int ref_pass_inst_number
)
1393 register_pass_info i
;
1395 i
.reference_pass_name
= ref_pass_name
;
1396 i
.ref_pass_instance_number
= ref_pass_inst_number
;
1399 g
->get_passes ()->register_pass (&i
);
1403 pass_manager::register_pass (struct register_pass_info
*pass_info
)
1405 bool all_instances
, success
;
1406 gcc::dump_manager
*dumps
= m_ctxt
->get_dumps ();
1408 /* The checks below could fail in buggy plugins. Existing GCC
1409 passes should never fail these checks, so we mention plugin in
1411 if (!pass_info
->pass
)
1412 fatal_error ("plugin cannot register a missing pass");
1414 if (!pass_info
->pass
->name
)
1415 fatal_error ("plugin cannot register an unnamed pass");
1417 if (!pass_info
->reference_pass_name
)
1419 ("plugin cannot register pass %qs without reference pass name",
1420 pass_info
->pass
->name
);
1422 /* Try to insert the new pass to the pass lists. We need to check
1423 all five lists as the reference pass could be in one (or all) of
1425 all_instances
= pass_info
->ref_pass_instance_number
== 0;
1426 success
= position_pass (pass_info
, &all_lowering_passes
);
1427 if (!success
|| all_instances
)
1428 success
|= position_pass (pass_info
, &all_small_ipa_passes
);
1429 if (!success
|| all_instances
)
1430 success
|= position_pass (pass_info
, &all_regular_ipa_passes
);
1431 if (!success
|| all_instances
)
1432 success
|= position_pass (pass_info
, &all_late_ipa_passes
);
1433 if (!success
|| all_instances
)
1434 success
|= position_pass (pass_info
, &all_passes
);
1437 ("pass %qs not found but is referenced by new pass %qs",
1438 pass_info
->reference_pass_name
, pass_info
->pass
->name
);
1440 /* OK, we have successfully inserted the new pass. We need to register
1441 the dump files for the newly added pass and its duplicates (if any).
1442 Because the registration of plugin/backend passes happens after the
1443 command-line options are parsed, the options that specify single
1444 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1445 passes. Therefore we currently can only enable dumping of
1446 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1447 are specified. While doing so, we also delete the pass_list_node
1448 objects created during pass positioning. */
1449 while (added_pass_nodes
)
1451 struct pass_list_node
*next_node
= added_pass_nodes
->next
;
1452 enum tree_dump_index tdi
;
1453 register_one_dump_file (added_pass_nodes
->pass
);
1454 if (added_pass_nodes
->pass
->type
== SIMPLE_IPA_PASS
1455 || added_pass_nodes
->pass
->type
== IPA_PASS
)
1457 else if (added_pass_nodes
->pass
->type
== GIMPLE_PASS
)
1461 /* Check if dump-all flag is specified. */
1462 if (dumps
->get_dump_file_info (tdi
)->pstate
)
1463 dumps
->get_dump_file_info (added_pass_nodes
->pass
->static_pass_number
)
1464 ->pstate
= dumps
->get_dump_file_info (tdi
)->pstate
;
1465 XDELETE (added_pass_nodes
);
1466 added_pass_nodes
= next_node
;
1470 /* Construct the pass tree. The sequencing of passes is driven by
1471 the cgraph routines:
1473 finalize_compilation_unit ()
1474 for each node N in the cgraph
1475 cgraph_analyze_function (N)
1476 cgraph_lower_function (N) -> all_lowering_passes
1478 If we are optimizing, compile is then invoked:
1481 ipa_passes () -> all_small_ipa_passes
1482 -> Analysis of all_regular_ipa_passes
1483 * possible LTO streaming at copmilation time *
1484 -> Execution of all_regular_ipa_passes
1485 * possible LTO streaming at link time *
1486 -> all_late_ipa_passes
1487 expand_all_functions ()
1488 for each node N in the cgraph
1489 expand_function (N) -> Transformation of all_regular_ipa_passes
1494 pass_manager::operator new (size_t sz
)
1496 /* Ensure that all fields of the pass manager are zero-initialized. */
1497 return xcalloc (1, sz
);
1500 pass_manager::pass_manager (context
*ctxt
)
1501 : all_passes (NULL
), all_small_ipa_passes (NULL
), all_lowering_passes (NULL
),
1502 all_regular_ipa_passes (NULL
),
1503 all_late_ipa_passes (NULL
), passes_by_id (NULL
), passes_by_id_size (0),
1506 struct opt_pass
**p
;
1508 /* Initialize the pass_lists array. */
1509 #define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1511 #undef DEF_PASS_LIST
1513 /* Build the tree of passes. */
1515 #define INSERT_PASSES_AFTER(PASS) \
1518 #define PUSH_INSERT_PASSES_WITHIN(PASS) \
1520 struct opt_pass **p = &(PASS ## _1)->sub;
1522 #define POP_INSERT_PASSES() \
1525 #define NEXT_PASS(PASS, NUM) \
1527 gcc_assert (NULL == PASS ## _ ## NUM); \
1529 PASS ## _1 = make_##PASS (m_ctxt); \
1532 gcc_assert (PASS ## _1); \
1533 PASS ## _ ## NUM = PASS ## _1->clone (); \
1535 p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1538 #define TERMINATE_PASS_LIST() \
1541 #include "pass-instances.def"
1543 #undef INSERT_PASSES_AFTER
1544 #undef PUSH_INSERT_PASSES_WITHIN
1545 #undef POP_INSERT_PASSES
1547 #undef TERMINATE_PASS_LIST
1549 /* Register the passes with the tree dump code. */
1550 register_dump_files (all_lowering_passes
, PROP_gimple_any
);
1551 register_dump_files (all_small_ipa_passes
,
1552 PROP_gimple_any
| PROP_gimple_lcf
| PROP_gimple_leh
1554 register_dump_files (all_regular_ipa_passes
,
1555 PROP_gimple_any
| PROP_gimple_lcf
| PROP_gimple_leh
1557 register_dump_files (all_late_ipa_passes
,
1558 PROP_gimple_any
| PROP_gimple_lcf
| PROP_gimple_leh
1560 register_dump_files (all_passes
,
1561 PROP_gimple_any
| PROP_gimple_lcf
| PROP_gimple_leh
1565 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1566 function CALLBACK for every function in the call graph. Otherwise,
1567 call CALLBACK on the current function. */
1570 do_per_function (void (*callback
) (void *data
), void *data
)
1572 if (current_function_decl
)
1576 struct cgraph_node
*node
;
1577 FOR_EACH_DEFINED_FUNCTION (node
)
1578 if (node
->analyzed
&& gimple_has_body_p (node
->decl
)
1579 && (!node
->clone_of
|| node
->decl
!= node
->clone_of
->decl
))
1581 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1585 free_dominance_info (CDI_DOMINATORS
);
1586 free_dominance_info (CDI_POST_DOMINATORS
);
1594 /* Because inlining might remove no-longer reachable nodes, we need to
1595 keep the array visible to garbage collector to avoid reading collected
1598 static GTY ((length ("nnodes"))) cgraph_node_ptr
*order
;
1600 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
1601 function CALLBACK for every function in the call graph. Otherwise,
1602 call CALLBACK on the current function.
1603 This function is global so that plugins can use it. */
1605 do_per_function_toporder (void (*callback
) (void *data
), void *data
)
1609 if (current_function_decl
)
1613 gcc_assert (!order
);
1614 order
= ggc_alloc_vec_cgraph_node_ptr (cgraph_n_nodes
);
1615 nnodes
= ipa_reverse_postorder (order
);
1616 for (i
= nnodes
- 1; i
>= 0; i
--)
1617 order
[i
]->process
= 1;
1618 for (i
= nnodes
- 1; i
>= 0; i
--)
1620 struct cgraph_node
*node
= order
[i
];
1622 /* Allow possibly removed nodes to be garbage collected. */
1625 if (cgraph_function_with_gimple_body_p (node
))
1627 cgraph_get_body (node
);
1628 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1630 free_dominance_info (CDI_DOMINATORS
);
1631 free_dominance_info (CDI_POST_DOMINATORS
);
1642 /* Helper function to perform function body dump. */
1645 execute_function_dump (void *data ATTRIBUTE_UNUSED
)
1647 if (dump_file
&& current_function_decl
)
1649 if (cfun
->curr_properties
& PROP_trees
)
1650 dump_function_to_file (current_function_decl
, dump_file
, dump_flags
);
1652 print_rtl_with_bb (dump_file
, get_insns (), dump_flags
);
1654 /* Flush the file. If verification fails, we won't be able to
1655 close the file before aborting. */
1658 if ((cfun
->curr_properties
& PROP_cfg
)
1659 && (dump_flags
& TDF_GRAPH
))
1660 print_graph_cfg (dump_file_name
, cfun
);
1664 static struct profile_record
*profile_record
;
1666 /* Do profile consistency book-keeping for the pass with static number INDEX.
1667 If SUBPASS is zero, we run _before_ the pass, and if SUBPASS is one, then
1668 we run _after_ the pass. RUN is true if the pass really runs, or FALSE
1669 if we are only book-keeping on passes that may have selectively disabled
1670 themselves on a given function. */
1672 check_profile_consistency (int index
, int subpass
, bool run
)
1674 pass_manager
*passes
= g
->get_passes ();
1677 if (!profile_record
)
1678 profile_record
= XCNEWVEC (struct profile_record
,
1679 passes
->passes_by_id_size
);
1680 gcc_assert (index
< passes
->passes_by_id_size
&& index
>= 0);
1681 gcc_assert (subpass
< 2);
1682 profile_record
[index
].run
|= run
;
1683 account_profile_record (&profile_record
[index
], subpass
);
1686 /* Output profile consistency. */
1689 dump_profile_report (void)
1691 g
->get_passes ()->dump_profile_report ();
1695 pass_manager::dump_profile_report () const
1698 int last_freq_in
= 0, last_count_in
= 0, last_freq_out
= 0, last_count_out
= 0;
1699 gcov_type last_time
= 0, last_size
= 0;
1700 double rel_time_change
, rel_size_change
;
1701 int last_reported
= 0;
1703 if (!profile_record
)
1705 fprintf (stderr
, "\nProfile consistency report:\n\n");
1706 fprintf (stderr
, "Pass name |mismatch in |mismated out|Overall\n");
1707 fprintf (stderr
, " |freq count |freq count |size time\n");
1709 for (i
= 0; i
< passes_by_id_size
; i
++)
1710 for (j
= 0 ; j
< 2; j
++)
1711 if (profile_record
[i
].run
)
1714 rel_time_change
= (profile_record
[i
].time
[j
]
1715 - (double)last_time
) * 100 / (double)last_time
;
1717 rel_time_change
= 0;
1719 rel_size_change
= (profile_record
[i
].size
[j
]
1720 - (double)last_size
) * 100 / (double)last_size
;
1722 rel_size_change
= 0;
1724 if (profile_record
[i
].num_mismatched_freq_in
[j
] != last_freq_in
1725 || profile_record
[i
].num_mismatched_freq_out
[j
] != last_freq_out
1726 || profile_record
[i
].num_mismatched_count_in
[j
] != last_count_in
1727 || profile_record
[i
].num_mismatched_count_out
[j
] != last_count_out
1728 || rel_time_change
|| rel_size_change
)
1731 fprintf (stderr
, "%-20s %s",
1732 passes_by_id
[i
]->name
,
1733 j
? "(after TODO)" : " ");
1734 if (profile_record
[i
].num_mismatched_freq_in
[j
] != last_freq_in
)
1735 fprintf (stderr
, "| %+5i",
1736 profile_record
[i
].num_mismatched_freq_in
[j
]
1739 fprintf (stderr
, "| ");
1740 if (profile_record
[i
].num_mismatched_count_in
[j
] != last_count_in
)
1741 fprintf (stderr
, " %+5i",
1742 profile_record
[i
].num_mismatched_count_in
[j
]
1745 fprintf (stderr
, " ");
1746 if (profile_record
[i
].num_mismatched_freq_out
[j
] != last_freq_out
)
1747 fprintf (stderr
, "| %+5i",
1748 profile_record
[i
].num_mismatched_freq_out
[j
]
1751 fprintf (stderr
, "| ");
1752 if (profile_record
[i
].num_mismatched_count_out
[j
] != last_count_out
)
1753 fprintf (stderr
, " %+5i",
1754 profile_record
[i
].num_mismatched_count_out
[j
]
1757 fprintf (stderr
, " ");
1759 /* Size/time units change across gimple and RTL. */
1760 if (i
== pass_expand_1
->static_pass_number
)
1761 fprintf (stderr
, "|----------");
1764 if (rel_size_change
)
1765 fprintf (stderr
, "| %+8.4f%%", rel_size_change
);
1767 fprintf (stderr
, "| ");
1768 if (rel_time_change
)
1769 fprintf (stderr
, " %+8.4f%%", rel_time_change
);
1771 fprintf (stderr
, "\n");
1772 last_freq_in
= profile_record
[i
].num_mismatched_freq_in
[j
];
1773 last_freq_out
= profile_record
[i
].num_mismatched_freq_out
[j
];
1774 last_count_in
= profile_record
[i
].num_mismatched_count_in
[j
];
1775 last_count_out
= profile_record
[i
].num_mismatched_count_out
[j
];
1777 else if (j
&& last_reported
!= i
)
1780 fprintf (stderr
, "%-20s ------------| | |\n",
1781 passes_by_id
[i
]->name
);
1783 last_time
= profile_record
[i
].time
[j
];
1784 last_size
= profile_record
[i
].size
[j
];
1788 /* Perform all TODO actions that ought to be done on each function. */
1791 execute_function_todo (void *data
)
1793 unsigned int flags
= (size_t)data
;
1794 flags
&= ~cfun
->last_verified
;
1798 /* Always cleanup the CFG before trying to update SSA. */
1799 if (flags
& TODO_cleanup_cfg
)
1801 cleanup_tree_cfg ();
1803 /* When cleanup_tree_cfg merges consecutive blocks, it may
1804 perform some simplistic propagation when removing single
1805 valued PHI nodes. This propagation may, in turn, cause the
1806 SSA form to become out-of-date (see PR 22037). So, even
1807 if the parent pass had not scheduled an SSA update, we may
1808 still need to do one. */
1809 if (!(flags
& TODO_update_ssa_any
) && need_ssa_update_p (cfun
))
1810 flags
|= TODO_update_ssa
;
1813 if (flags
& TODO_update_ssa_any
)
1815 unsigned update_flags
= flags
& TODO_update_ssa_any
;
1816 update_ssa (update_flags
);
1817 cfun
->last_verified
&= ~TODO_verify_ssa
;
1820 if (flag_tree_pta
&& (flags
& TODO_rebuild_alias
))
1821 compute_may_aliases ();
1823 if (optimize
&& (flags
& TODO_update_address_taken
))
1824 execute_update_addresses_taken ();
1826 if (flags
& TODO_remove_unused_locals
)
1827 remove_unused_locals ();
1829 if (flags
& TODO_rebuild_frequencies
)
1830 rebuild_frequencies ();
1832 if (flags
& TODO_rebuild_cgraph_edges
)
1833 rebuild_cgraph_edges ();
1835 /* If we've seen errors do not bother running any verifiers. */
1839 #if defined ENABLE_CHECKING
1840 if (flags
& TODO_verify_ssa
1841 || (current_loops
&& loops_state_satisfies_p (LOOP_CLOSED_SSA
)))
1843 verify_gimple_in_cfg (cfun
);
1846 else if (flags
& TODO_verify_stmts
)
1847 verify_gimple_in_cfg (cfun
);
1848 if (flags
& TODO_verify_flow
)
1849 verify_flow_info ();
1850 if (current_loops
&& loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1851 verify_loop_closed_ssa (false);
1852 if (flags
& TODO_verify_rtl_sharing
)
1853 verify_rtl_sharing ();
1856 cfun
->last_verified
= flags
& TODO_verify_all
;
1859 /* Perform all TODO actions. */
1861 execute_todo (unsigned int flags
)
1863 #if defined ENABLE_CHECKING
1865 && need_ssa_update_p (cfun
))
1866 gcc_assert (flags
& TODO_update_ssa_any
);
1869 timevar_push (TV_TODO
);
1871 /* Inform the pass whether it is the first time it is run. */
1872 first_pass_instance
= (flags
& TODO_mark_first_instance
) != 0;
1874 statistics_fini_pass ();
1877 do_per_function (execute_function_todo
, (void *)(size_t) flags
);
1879 /* Always remove functions just as before inlining: IPA passes might be
1880 interested to see bodies of extern inline functions that are not inlined
1881 to analyze side effects. The full removal is done just at the end
1882 of IPA pass queue. */
1883 if (flags
& TODO_remove_functions
)
1886 symtab_remove_unreachable_nodes (true, dump_file
);
1889 if ((flags
& TODO_dump_symtab
) && dump_file
&& !current_function_decl
)
1892 dump_symtab (dump_file
);
1893 /* Flush the file. If verification fails, we won't be able to
1894 close the file before aborting. */
1898 /* Now that the dumping has been done, we can get rid of the optional
1900 if (flags
& TODO_df_finish
)
1901 df_finish_pass ((flags
& TODO_df_verify
) != 0);
1903 timevar_pop (TV_TODO
);
1906 /* Verify invariants that should hold between passes. This is a place
1907 to put simple sanity checks. */
1910 verify_interpass_invariants (void)
1912 gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
1915 /* Clear the last verified flag. */
1918 clear_last_verified (void *data ATTRIBUTE_UNUSED
)
1920 cfun
->last_verified
= 0;
1923 /* Helper function. Verify that the properties has been turn into the
1924 properties expected by the pass. */
1926 #ifdef ENABLE_CHECKING
1928 verify_curr_properties (void *data
)
1930 unsigned int props
= (size_t)data
;
1931 gcc_assert ((cfun
->curr_properties
& props
) == props
);
1935 /* Initialize pass dump file. */
1936 /* This is non-static so that the plugins can use it. */
1939 pass_init_dump_file (struct opt_pass
*pass
)
1941 /* If a dump file name is present, open it if enabled. */
1942 if (pass
->static_pass_number
!= -1)
1944 timevar_push (TV_DUMP
);
1945 gcc::dump_manager
*dumps
= g
->get_dumps ();
1946 bool initializing_dump
=
1947 !dumps
->dump_initialized_p (pass
->static_pass_number
);
1948 dump_file_name
= dumps
->get_dump_file_name (pass
->static_pass_number
);
1949 dumps
->dump_start (pass
->static_pass_number
, &dump_flags
);
1950 if (dump_file
&& current_function_decl
)
1951 dump_function_header (dump_file
, current_function_decl
, dump_flags
);
1952 if (initializing_dump
1953 && dump_file
&& (dump_flags
& TDF_GRAPH
)
1954 && cfun
&& (cfun
->curr_properties
& PROP_cfg
))
1955 clean_graph_dump_file (dump_file_name
);
1956 timevar_pop (TV_DUMP
);
1957 return initializing_dump
;
1963 /* Flush PASS dump file. */
1964 /* This is non-static so that plugins can use it. */
1967 pass_fini_dump_file (struct opt_pass
*pass
)
1969 timevar_push (TV_DUMP
);
1971 /* Flush and close dump file. */
1974 free (CONST_CAST (char *, dump_file_name
));
1975 dump_file_name
= NULL
;
1978 g
->get_dumps ()->dump_finish (pass
->static_pass_number
);
1979 timevar_pop (TV_DUMP
);
1982 /* After executing the pass, apply expected changes to the function
1986 update_properties_after_pass (void *data
)
1988 struct opt_pass
*pass
= (struct opt_pass
*) data
;
1989 cfun
->curr_properties
= (cfun
->curr_properties
| pass
->properties_provided
)
1990 & ~pass
->properties_destroyed
;
1993 /* Execute summary generation for all of the passes in IPA_PASS. */
1996 execute_ipa_summary_passes (struct ipa_opt_pass_d
*ipa_pass
)
2000 struct opt_pass
*pass
= ipa_pass
;
2002 /* Execute all of the IPA_PASSes in the list. */
2003 if (ipa_pass
->type
== IPA_PASS
2004 && ((!pass
->has_gate
) || pass
->gate ())
2005 && ipa_pass
->generate_summary
)
2007 pass_init_dump_file (pass
);
2009 /* If a timevar is present, start it. */
2011 timevar_push (pass
->tv_id
);
2013 ipa_pass
->generate_summary ();
2017 timevar_pop (pass
->tv_id
);
2019 pass_fini_dump_file (pass
);
2021 ipa_pass
= (struct ipa_opt_pass_d
*)ipa_pass
->next
;
2025 /* Execute IPA_PASS function transform on NODE. */
2028 execute_one_ipa_transform_pass (struct cgraph_node
*node
,
2029 struct ipa_opt_pass_d
*ipa_pass
)
2031 struct opt_pass
*pass
= ipa_pass
;
2032 unsigned int todo_after
= 0;
2034 current_pass
= pass
;
2035 if (!ipa_pass
->function_transform
)
2038 /* Note that the folders should only create gimple expressions.
2039 This is a hack until the new folder is ready. */
2040 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2042 pass_init_dump_file (pass
);
2044 /* Run pre-pass verification. */
2045 execute_todo (ipa_pass
->function_transform_todo_flags_start
);
2047 /* If a timevar is present, start it. */
2048 if (pass
->tv_id
!= TV_NONE
)
2049 timevar_push (pass
->tv_id
);
2052 todo_after
= ipa_pass
->function_transform (node
);
2055 if (pass
->tv_id
!= TV_NONE
)
2056 timevar_pop (pass
->tv_id
);
2058 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2059 check_profile_consistency (pass
->static_pass_number
, 0, true);
2061 /* Run post-pass cleanup and verification. */
2062 execute_todo (todo_after
);
2063 verify_interpass_invariants ();
2064 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2065 check_profile_consistency (pass
->static_pass_number
, 1, true);
2068 do_per_function (execute_function_dump
, NULL
);
2069 pass_fini_dump_file (pass
);
2071 current_pass
= NULL
;
2073 /* Signal this is a suitable GC collection point. */
2074 if (!(todo_after
& TODO_do_not_ggc_collect
))
2078 /* For the current function, execute all ipa transforms. */
2081 execute_all_ipa_transforms (void)
2083 struct cgraph_node
*node
;
2086 node
= cgraph_get_node (current_function_decl
);
2088 if (node
->ipa_transforms_to_apply
.exists ())
2092 for (i
= 0; i
< node
->ipa_transforms_to_apply
.length (); i
++)
2093 execute_one_ipa_transform_pass (node
, node
->ipa_transforms_to_apply
[i
]);
2094 node
->ipa_transforms_to_apply
.release ();
2098 /* Callback for do_per_function to apply all IPA transforms. */
2101 apply_ipa_transforms (void *data
)
2103 struct cgraph_node
*node
= cgraph_get_node (current_function_decl
);
2104 if (!node
->global
.inlined_to
&& node
->ipa_transforms_to_apply
.exists ())
2106 *(bool *)data
= true;
2107 execute_all_ipa_transforms ();
2108 rebuild_cgraph_edges ();
2112 /* Check if PASS is explicitly disabled or enabled and return
2113 the gate status. FUNC is the function to be processed, and
2114 GATE_STATUS is the gate status determined by pass manager by
2118 override_gate_status (struct opt_pass
*pass
, tree func
, bool gate_status
)
2120 bool explicitly_enabled
= false;
2121 bool explicitly_disabled
= false;
2124 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2125 enabled_pass_uid_range_tab
);
2127 = is_pass_explicitly_enabled_or_disabled (pass
, func
,
2128 disabled_pass_uid_range_tab
);
2130 gate_status
= !explicitly_disabled
&& (gate_status
|| explicitly_enabled
);
2139 execute_one_pass (struct opt_pass
*pass
)
2141 unsigned int todo_after
= 0;
2145 /* IPA passes are executed on whole program, so cfun should be NULL.
2146 Other passes need function context set. */
2147 if (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
)
2148 gcc_assert (!cfun
&& !current_function_decl
);
2150 gcc_assert (cfun
&& current_function_decl
);
2152 current_pass
= pass
;
2154 /* Check whether gate check should be avoided.
2155 User controls the value of the gate through the parameter "gate_status". */
2156 gate_status
= pass
->has_gate
? pass
->gate () : true;
2157 gate_status
= override_gate_status (pass
, current_function_decl
, gate_status
);
2159 /* Override gate with plugin. */
2160 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE
, &gate_status
);
2164 /* Run so passes selectively disabling themselves on a given function
2165 are not miscounted. */
2166 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2168 check_profile_consistency (pass
->static_pass_number
, 0, false);
2169 check_profile_consistency (pass
->static_pass_number
, 1, false);
2171 current_pass
= NULL
;
2175 /* Pass execution event trigger: useful to identify passes being
2177 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION
, pass
);
2179 /* SIPLE IPA passes do not handle callgraphs with IPA transforms in it.
2180 Apply all trnasforms first. */
2181 if (pass
->type
== SIMPLE_IPA_PASS
)
2183 bool applied
= false;
2184 do_per_function (apply_ipa_transforms
, (void *)&applied
);
2186 symtab_remove_unreachable_nodes (true, dump_file
);
2187 /* Restore current_pass. */
2188 current_pass
= pass
;
2191 if (!quiet_flag
&& !cfun
)
2192 fprintf (stderr
, " <%s>", pass
->name
? pass
->name
: "");
2194 /* Note that the folders should only create gimple expressions.
2195 This is a hack until the new folder is ready. */
2196 in_gimple_form
= (cfun
&& (cfun
->curr_properties
& PROP_trees
)) != 0;
2198 pass_init_dump_file (pass
);
2200 /* Run pre-pass verification. */
2201 execute_todo (pass
->todo_flags_start
);
2203 #ifdef ENABLE_CHECKING
2204 do_per_function (verify_curr_properties
,
2205 (void *)(size_t)pass
->properties_required
);
2208 /* If a timevar is present, start it. */
2209 if (pass
->tv_id
!= TV_NONE
)
2210 timevar_push (pass
->tv_id
);
2213 if (pass
->has_execute
)
2215 todo_after
= pass
->execute ();
2216 do_per_function (clear_last_verified
, NULL
);
2220 if (pass
->tv_id
!= TV_NONE
)
2221 timevar_pop (pass
->tv_id
);
2223 do_per_function (update_properties_after_pass
, pass
);
2225 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2226 check_profile_consistency (pass
->static_pass_number
, 0, true);
2228 /* Run post-pass cleanup and verification. */
2229 execute_todo (todo_after
| pass
->todo_flags_finish
);
2230 if (profile_report
&& cfun
&& (cfun
->curr_properties
& PROP_cfg
))
2231 check_profile_consistency (pass
->static_pass_number
, 1, true);
2233 verify_interpass_invariants ();
2235 do_per_function (execute_function_dump
, NULL
);
2236 if (pass
->type
== IPA_PASS
)
2238 struct cgraph_node
*node
;
2239 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node
)
2240 node
->ipa_transforms_to_apply
.safe_push ((struct ipa_opt_pass_d
*)pass
);
2243 if (!current_function_decl
)
2244 cgraph_process_new_functions ();
2246 pass_fini_dump_file (pass
);
2248 if (pass
->type
!= SIMPLE_IPA_PASS
&& pass
->type
!= IPA_PASS
)
2249 gcc_assert (!(cfun
->curr_properties
& PROP_trees
)
2250 || pass
->type
!= RTL_PASS
);
2252 current_pass
= NULL
;
2254 /* Signal this is a suitable GC collection point. */
2255 if (!((todo_after
| pass
->todo_flags_finish
) & TODO_do_not_ggc_collect
))
2262 execute_pass_list (struct opt_pass
*pass
)
2266 gcc_assert (pass
->type
== GIMPLE_PASS
2267 || pass
->type
== RTL_PASS
);
2268 if (execute_one_pass (pass
) && pass
->sub
)
2269 execute_pass_list (pass
->sub
);
2275 /* Write out all LTO data. */
2279 timevar_push (TV_IPA_LTO_GIMPLE_OUT
);
2281 timevar_pop (TV_IPA_LTO_GIMPLE_OUT
);
2282 timevar_push (TV_IPA_LTO_DECL_OUT
);
2283 produce_asm_for_decls ();
2284 timevar_pop (TV_IPA_LTO_DECL_OUT
);
2287 /* Same as execute_pass_list but assume that subpasses of IPA passes
2288 are local passes. If SET is not NULL, write out summaries of only
2289 those node in SET. */
2292 ipa_write_summaries_2 (struct opt_pass
*pass
, struct lto_out_decl_state
*state
)
2296 struct ipa_opt_pass_d
*ipa_pass
= (struct ipa_opt_pass_d
*)pass
;
2297 gcc_assert (!current_function_decl
);
2299 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2300 if (pass
->type
== IPA_PASS
2301 && ipa_pass
->write_summary
2302 && ((!pass
->has_gate
) || pass
->gate ()))
2304 /* If a timevar is present, start it. */
2306 timevar_push (pass
->tv_id
);
2308 pass_init_dump_file (pass
);
2310 ipa_pass
->write_summary ();
2312 pass_fini_dump_file (pass
);
2314 /* If a timevar is present, start it. */
2316 timevar_pop (pass
->tv_id
);
2319 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2320 ipa_write_summaries_2 (pass
->sub
, state
);
2326 /* Helper function of ipa_write_summaries. Creates and destroys the
2327 decl state and calls ipa_write_summaries_2 for all passes that have
2328 summaries. SET is the set of nodes to be written. */
2331 ipa_write_summaries_1 (lto_symtab_encoder_t encoder
)
2333 pass_manager
*passes
= g
->get_passes ();
2334 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2335 state
->symtab_node_encoder
= encoder
;
2337 lto_push_out_decl_state (state
);
2339 gcc_assert (!flag_wpa
);
2340 ipa_write_summaries_2 (passes
->all_regular_ipa_passes
, state
);
2344 gcc_assert (lto_get_out_decl_state () == state
);
2345 lto_pop_out_decl_state ();
2346 lto_delete_out_decl_state (state
);
2349 /* Write out summaries for all the nodes in the callgraph. */
2352 ipa_write_summaries (void)
2354 lto_symtab_encoder_t encoder
;
2356 struct varpool_node
*vnode
;
2357 struct cgraph_node
*node
;
2358 struct cgraph_node
**order
;
2360 if (!flag_generate_lto
|| seen_error ())
2363 encoder
= lto_symtab_encoder_new (false);
2365 /* Create the callgraph set in the same order used in
2366 cgraph_expand_all_functions. This mostly facilitates debugging,
2367 since it causes the gimple file to be processed in the same order
2368 as the source code. */
2369 order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
2370 order_pos
= ipa_reverse_postorder (order
);
2371 gcc_assert (order_pos
== cgraph_n_nodes
);
2373 for (i
= order_pos
- 1; i
>= 0; i
--)
2375 struct cgraph_node
*node
= order
[i
];
2377 if (cgraph_function_with_gimple_body_p (node
))
2379 /* When streaming out references to statements as part of some IPA
2380 pass summary, the statements need to have uids assigned and the
2381 following does that for all the IPA passes here. Naturally, this
2382 ordering then matches the one IPA-passes get in their stmt_fixup
2385 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2386 renumber_gimple_stmt_uids ();
2389 if (node
->definition
)
2390 lto_set_symtab_encoder_in_partition (encoder
, node
);
2393 FOR_EACH_DEFINED_FUNCTION (node
)
2395 lto_set_symtab_encoder_in_partition (encoder
, node
);
2396 FOR_EACH_DEFINED_VARIABLE (vnode
)
2397 lto_set_symtab_encoder_in_partition (encoder
, vnode
);
2399 ipa_write_summaries_1 (compute_ltrans_boundary (encoder
));
2404 /* Same as execute_pass_list but assume that subpasses of IPA passes
2405 are local passes. If SET is not NULL, write out optimization summaries of
2406 only those node in SET. */
2409 ipa_write_optimization_summaries_1 (struct opt_pass
*pass
, struct lto_out_decl_state
*state
)
2413 struct ipa_opt_pass_d
*ipa_pass
= (struct ipa_opt_pass_d
*)pass
;
2414 gcc_assert (!current_function_decl
);
2416 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2417 if (pass
->type
== IPA_PASS
2418 && ipa_pass
->write_optimization_summary
2419 && ((!pass
->has_gate
) || pass
->gate ()))
2421 /* If a timevar is present, start it. */
2423 timevar_push (pass
->tv_id
);
2425 pass_init_dump_file (pass
);
2427 ipa_pass
->write_optimization_summary ();
2429 pass_fini_dump_file (pass
);
2431 /* If a timevar is present, start it. */
2433 timevar_pop (pass
->tv_id
);
2436 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2437 ipa_write_optimization_summaries_1 (pass
->sub
, state
);
2443 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2444 NULL, write out all summaries of all nodes. */
2447 ipa_write_optimization_summaries (lto_symtab_encoder_t encoder
)
2449 struct lto_out_decl_state
*state
= lto_new_out_decl_state ();
2450 lto_symtab_encoder_iterator lsei
;
2451 state
->symtab_node_encoder
= encoder
;
2453 lto_push_out_decl_state (state
);
2454 for (lsei
= lsei_start_function_in_partition (encoder
);
2455 !lsei_end_p (lsei
); lsei_next_function_in_partition (&lsei
))
2457 struct cgraph_node
*node
= lsei_cgraph_node (lsei
);
2458 /* When streaming out references to statements as part of some IPA
2459 pass summary, the statements need to have uids assigned.
2461 For functions newly born at WPA stage we need to initialize
2463 if (node
->definition
2464 && gimple_has_body_p (node
->decl
))
2466 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2467 renumber_gimple_stmt_uids ();
2472 gcc_assert (flag_wpa
);
2473 pass_manager
*passes
= g
->get_passes ();
2474 ipa_write_optimization_summaries_1 (passes
->all_regular_ipa_passes
, state
);
2478 gcc_assert (lto_get_out_decl_state () == state
);
2479 lto_pop_out_decl_state ();
2480 lto_delete_out_decl_state (state
);
2483 /* Same as execute_pass_list but assume that subpasses of IPA passes
2484 are local passes. */
2487 ipa_read_summaries_1 (struct opt_pass
*pass
)
2491 struct ipa_opt_pass_d
*ipa_pass
= (struct ipa_opt_pass_d
*) pass
;
2493 gcc_assert (!current_function_decl
);
2495 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2497 if ((!pass
->has_gate
) || pass
->gate ())
2499 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_summary
)
2501 /* If a timevar is present, start it. */
2503 timevar_push (pass
->tv_id
);
2505 pass_init_dump_file (pass
);
2507 ipa_pass
->read_summary ();
2509 pass_fini_dump_file (pass
);
2513 timevar_pop (pass
->tv_id
);
2516 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2517 ipa_read_summaries_1 (pass
->sub
);
2524 /* Read all the summaries for all_regular_ipa_passes. */
2527 ipa_read_summaries (void)
2529 pass_manager
*passes
= g
->get_passes ();
2530 ipa_read_summaries_1 (passes
->all_regular_ipa_passes
);
2533 /* Same as execute_pass_list but assume that subpasses of IPA passes
2534 are local passes. */
2537 ipa_read_optimization_summaries_1 (struct opt_pass
*pass
)
2541 struct ipa_opt_pass_d
*ipa_pass
= (struct ipa_opt_pass_d
*) pass
;
2543 gcc_assert (!current_function_decl
);
2545 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2547 if ((!pass
->has_gate
) || pass
->gate ())
2549 if (pass
->type
== IPA_PASS
&& ipa_pass
->read_optimization_summary
)
2551 /* If a timevar is present, start it. */
2553 timevar_push (pass
->tv_id
);
2555 pass_init_dump_file (pass
);
2557 ipa_pass
->read_optimization_summary ();
2559 pass_fini_dump_file (pass
);
2563 timevar_pop (pass
->tv_id
);
2566 if (pass
->sub
&& pass
->sub
->type
!= GIMPLE_PASS
)
2567 ipa_read_optimization_summaries_1 (pass
->sub
);
2573 /* Read all the summaries for all_regular_ipa_passes. */
2576 ipa_read_optimization_summaries (void)
2578 pass_manager
*passes
= g
->get_passes ();
2579 ipa_read_optimization_summaries_1 (passes
->all_regular_ipa_passes
);
2582 /* Same as execute_pass_list but assume that subpasses of IPA passes
2583 are local passes. */
2585 execute_ipa_pass_list (struct opt_pass
*pass
)
2589 gcc_assert (!current_function_decl
);
2591 gcc_assert (pass
->type
== SIMPLE_IPA_PASS
|| pass
->type
== IPA_PASS
);
2592 if (execute_one_pass (pass
) && pass
->sub
)
2594 if (pass
->sub
->type
== GIMPLE_PASS
)
2596 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START
, NULL
);
2597 do_per_function_toporder ((void (*)(void *))execute_pass_list
,
2599 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END
, NULL
);
2601 else if (pass
->sub
->type
== SIMPLE_IPA_PASS
2602 || pass
->sub
->type
== IPA_PASS
)
2603 execute_ipa_pass_list (pass
->sub
);
2607 gcc_assert (!current_function_decl
);
2608 cgraph_process_new_functions ();
2614 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
2617 execute_ipa_stmt_fixups (struct opt_pass
*pass
,
2618 struct cgraph_node
*node
, gimple
*stmts
)
2622 /* Execute all of the IPA_PASSes in the list. */
2623 if (pass
->type
== IPA_PASS
2624 && ((!pass
->has_gate
) || pass
->gate ()))
2626 struct ipa_opt_pass_d
*ipa_pass
= (struct ipa_opt_pass_d
*) pass
;
2628 if (ipa_pass
->stmt_fixup
)
2630 pass_init_dump_file (pass
);
2631 /* If a timevar is present, start it. */
2633 timevar_push (pass
->tv_id
);
2635 ipa_pass
->stmt_fixup (node
, stmts
);
2639 timevar_pop (pass
->tv_id
);
2640 pass_fini_dump_file (pass
);
2643 execute_ipa_stmt_fixups (pass
->sub
, node
, stmts
);
2649 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
2652 execute_all_ipa_stmt_fixups (struct cgraph_node
*node
, gimple
*stmts
)
2654 pass_manager
*passes
= g
->get_passes ();
2655 execute_ipa_stmt_fixups (passes
->all_regular_ipa_passes
, node
, stmts
);
2659 extern void debug_properties (unsigned int);
2660 extern void dump_properties (FILE *, unsigned int);
2663 dump_properties (FILE *dump
, unsigned int props
)
2665 fprintf (dump
, "Properties:\n");
2666 if (props
& PROP_gimple_any
)
2667 fprintf (dump
, "PROP_gimple_any\n");
2668 if (props
& PROP_gimple_lcf
)
2669 fprintf (dump
, "PROP_gimple_lcf\n");
2670 if (props
& PROP_gimple_leh
)
2671 fprintf (dump
, "PROP_gimple_leh\n");
2672 if (props
& PROP_cfg
)
2673 fprintf (dump
, "PROP_cfg\n");
2674 if (props
& PROP_ssa
)
2675 fprintf (dump
, "PROP_ssa\n");
2676 if (props
& PROP_no_crit_edges
)
2677 fprintf (dump
, "PROP_no_crit_edges\n");
2678 if (props
& PROP_rtl
)
2679 fprintf (dump
, "PROP_rtl\n");
2680 if (props
& PROP_gimple_lomp
)
2681 fprintf (dump
, "PROP_gimple_lomp\n");
2682 if (props
& PROP_gimple_lcx
)
2683 fprintf (dump
, "PROP_gimple_lcx\n");
2684 if (props
& PROP_gimple_lvec
)
2685 fprintf (dump
, "PROP_gimple_lvec\n");
2686 if (props
& PROP_cfglayout
)
2687 fprintf (dump
, "PROP_cfglayout\n");
2691 debug_properties (unsigned int props
)
2693 dump_properties (stderr
, props
);
2696 /* Called by local passes to see if function is called by already processed nodes.
2697 Because we process nodes in topological order, this means that function is
2698 in recursive cycle or we introduced new direct calls. */
2700 function_called_by_processed_nodes_p (void)
2702 struct cgraph_edge
*e
;
2703 for (e
= cgraph_get_node (current_function_decl
)->callers
;
2707 if (e
->caller
->decl
== current_function_decl
)
2709 if (!cgraph_function_with_gimple_body_p (e
->caller
))
2711 if (TREE_ASM_WRITTEN (e
->caller
->decl
))
2713 if (!e
->caller
->process
&& !e
->caller
->global
.inlined_to
)
2718 fprintf (dump_file
, "Already processed call to:\n");
2719 dump_cgraph_node (dump_file
, e
->caller
);
2724 #include "gt-passes.h"