1 /* Driver of optimization process
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This module implements main driver of compilation process.
23 The main scope of this file is to act as an interface in between
24 tree based frontends and the backend.
26 The front-end is supposed to use following functionality:
28 - cgraph_finalize_function
30 This function is called once front-end has parsed whole body of function
31 and it is certain that the function body nor the declaration will change.
33 (There is one exception needed for implementing GCC extern inline
36 - varpool_finalize_decl
38 This function has same behavior as the above but is used for static
43 Insert new toplevel ASM statement
45 - finalize_compilation_unit
47 This function is called once (source level) compilation unit is finalized
48 and it will no longer change.
50 The symbol table is constructed starting from the trivially needed
51 symbols finalized by the frontend. Functions are lowered into
52 GIMPLE representation and callgraph/reference lists are constructed.
53 Those are used to discover other necessary functions and variables.
55 At the end the bodies of unreachable functions are removed.
57 The function can be called multiple times when multiple source level
58 compilation units are combined.
62 This passes control to the back-end. Optimizations are performed and
63 final assembler is generated. This is done in the following way. Note
64 that with link time optimization the process is split into three
65 stages (compile time, linktime analysis and parallel linktime as
70 1) Inter-procedural optimization.
73 This part is further split into:
75 a) early optimizations. These are local passes executed in
76 the topological order on the callgraph.
78 The purpose of early optimiations is to optimize away simple
79 things that may otherwise confuse IP analysis. Very simple
80 propagation across the callgraph is done i.e. to discover
81 functions without side effects and simple inlining is performed.
83 b) early small interprocedural passes.
85 Those are interprocedural passes executed only at compilation
86 time. These include, for example, transational memory lowering,
87 unreachable code removal and other simple transformations.
89 c) IP analysis stage. All interprocedural passes do their
92 Interprocedural passes differ from small interprocedural
93 passes by their ability to operate across whole program
94 at linktime. Their analysis stage is performed early to
95 both reduce linking times and linktime memory usage by
96 not having to represent whole program in memory.
98 d) LTO sreaming. When doing LTO, everything important gets
99 streamed into the object file.
101 Compile time and or linktime analysis stage (WPA):
103 At linktime units gets streamed back and symbol table is
104 merged. Function bodies are not streamed in and not
106 e) IP propagation stage. All IP passes execute their
107 IP propagation. This is done based on the earlier analysis
108 without having function bodies at hand.
109 f) Ltrans streaming. When doing WHOPR LTO, the program
110 is partitioned and streamed into multple object files.
112 Compile time and/or parallel linktime stage (ltrans)
114 Each of the object files is streamed back and compiled
115 separately. Now the function bodies becomes available
118 2) Virtual clone materialization
119 (cgraph_materialize_clone)
121 IP passes can produce copies of existing functoins (such
122 as versioned clones or inline clones) without actually
123 manipulating their bodies by creating virtual clones in
124 the callgraph. At this time the virtual clones are
125 turned into real functions
128 All IP passes transform function bodies based on earlier
129 decision of the IP propagation.
131 4) late small IP passes
133 Simple IP passes working within single program partition.
136 (expand_all_functions)
138 At this stage functions that needs to be output into
139 assembler are identified and compiled in topological order
140 6) Output of variables and aliases
141 Now it is known what variable references was not optimized
142 out and thus all variables are output to the file.
144 Note that with -fno-toplevel-reorder passes 5 and 6
145 are combined together in cgraph_output_in_order.
147 Finally there are functions to manipulate the callgraph from
149 - cgraph_add_new_function is used to add backend produced
150 functions introduced after the unit is finalized.
151 The functions are enqueue for later processing and inserted
152 into callgraph with cgraph_process_new_functions.
154 - cgraph_function_versioning
156 produces a copy of function into new one (a version)
157 and apply simple transformations
162 #include "coretypes.h"
166 #include "stor-layout.h"
167 #include "stringpool.h"
170 #include "basic-block.h"
171 #include "tree-ssa-alias.h"
172 #include "internal-fn.h"
173 #include "gimple-fold.h"
174 #include "gimple-expr.h"
177 #include "gimplify.h"
178 #include "gimple-iterator.h"
179 #include "gimplify-me.h"
180 #include "gimple-ssa.h"
181 #include "tree-cfg.h"
182 #include "tree-into-ssa.h"
183 #include "tree-ssa.h"
184 #include "tree-inline.h"
185 #include "langhooks.h"
190 #include "diagnostic.h"
194 #include "function.h"
195 #include "ipa-prop.h"
196 #include "tree-iterator.h"
197 #include "tree-pass.h"
198 #include "tree-dump.h"
199 #include "gimple-pretty-print.h"
201 #include "coverage.h"
203 #include "ipa-inline.h"
204 #include "ipa-utils.h"
205 #include "lto-streamer.h"
208 #include "regset.h" /* FIXME: For reg_obstack. */
210 #include "pass_manager.h"
211 #include "tree-nested.h"
212 #include "gimplify.h"
214 /* Queue of cgraph nodes scheduled to be added into cgraph. This is a
215 secondary queue used during optimization to accommodate passes that
216 may generate new functions that need to be optimized and expanded. */
217 cgraph_node_set cgraph_new_nodes
;
219 static void expand_all_functions (void);
220 static void mark_functions_to_output (void);
221 static void expand_function (struct cgraph_node
*);
222 static void analyze_function (struct cgraph_node
*);
223 static void handle_alias_pairs (void);
225 FILE *cgraph_dump_file
;
227 /* Linked list of cgraph asm nodes. */
228 struct asm_node
*asm_nodes
;
230 /* Last node in cgraph_asm_nodes. */
231 static GTY(()) struct asm_node
*asm_last_node
;
233 /* Used for vtable lookup in thunk adjusting. */
234 static GTY (()) tree vtable_entry_type
;
236 /* Determine if symbol DECL is needed. That is, visible to something
237 either outside this translation unit, something magic in the system
240 decide_is_symbol_needed (symtab_node
*node
)
242 tree decl
= node
->decl
;
244 /* Double check that no one output the function into assembly file
246 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl
)
247 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)));
249 if (!node
->definition
)
252 if (DECL_EXTERNAL (decl
))
255 /* If the user told us it is used, then it must be so. */
256 if (node
->force_output
)
259 /* ABI forced symbols are needed when they are external. */
260 if (node
->forced_by_abi
&& TREE_PUBLIC (decl
))
263 /* Keep constructors, destructors and virtual functions. */
264 if (TREE_CODE (decl
) == FUNCTION_DECL
265 && (DECL_STATIC_CONSTRUCTOR (decl
) || DECL_STATIC_DESTRUCTOR (decl
)))
268 /* Externally visible variables must be output. The exception is
269 COMDAT variables that must be output only when they are needed. */
270 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
276 /* Head and terminator of the queue of nodes to be processed while building
279 static symtab_node symtab_terminator
;
280 static symtab_node
*queued_nodes
= &symtab_terminator
;
282 /* Add NODE to queue starting at QUEUED_NODES.
283 The queue is linked via AUX pointers and terminated by pointer to 1. */
286 enqueue_node (symtab_node
*node
)
290 gcc_checking_assert (queued_nodes
);
291 node
->aux
= queued_nodes
;
295 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
296 functions into callgraph in a way so they look like ordinary reachable
297 functions inserted into callgraph already at construction time. */
300 cgraph_process_new_functions (void)
303 struct cgraph_node
*node
;
304 cgraph_node_set_iterator csi
;
306 if (!cgraph_new_nodes
)
308 handle_alias_pairs ();
309 /* Note that this queue may grow as its being processed, as the new
310 functions may generate new ones. */
311 for (csi
= csi_start (cgraph_new_nodes
); !csi_end_p (csi
); csi_next (&csi
))
313 node
= csi_node (csi
);
315 switch (cgraph_state
)
317 case CGRAPH_STATE_CONSTRUCTION
:
318 /* At construction time we just need to finalize function and move
319 it into reachable functions list. */
321 cgraph_finalize_function (fndecl
, false);
322 cgraph_call_function_insertion_hooks (node
);
326 case CGRAPH_STATE_IPA
:
327 case CGRAPH_STATE_IPA_SSA
:
328 /* When IPA optimization already started, do all essential
329 transformations that has been already performed on the whole
330 cgraph but not on this function. */
332 gimple_register_cfg_hooks ();
334 analyze_function (node
);
335 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
336 if (cgraph_state
== CGRAPH_STATE_IPA_SSA
337 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
338 g
->get_passes ()->execute_early_local_passes ();
339 else if (inline_summary_vec
!= NULL
)
340 compute_inline_parameters (node
, true);
341 free_dominance_info (CDI_POST_DOMINATORS
);
342 free_dominance_info (CDI_DOMINATORS
);
344 cgraph_call_function_insertion_hooks (node
);
347 case CGRAPH_STATE_EXPANSION
:
348 /* Functions created during expansion shall be compiled
351 cgraph_call_function_insertion_hooks (node
);
352 expand_function (node
);
360 free_cgraph_node_set (cgraph_new_nodes
);
361 cgraph_new_nodes
= NULL
;
364 /* As an GCC extension we allow redefinition of the function. The
365 semantics when both copies of bodies differ is not well defined.
366 We replace the old body with new body so in unit at a time mode
367 we always use new body, while in normal mode we may end up with
368 old body inlined into some functions and new body expanded and
371 ??? It may make more sense to use one body for inlining and other
372 body for expanding the function but this is difficult to do. */
375 cgraph_reset_node (struct cgraph_node
*node
)
377 /* If node->process is set, then we have already begun whole-unit analysis.
378 This is *not* testing for whether we've already emitted the function.
379 That case can be sort-of legitimately seen with real function redefinition
380 errors. I would argue that the front end should never present us with
381 such a case, but don't enforce that for now. */
382 gcc_assert (!node
->process
);
384 /* Reset our data structures so we can analyze the function again. */
385 memset (&node
->local
, 0, sizeof (node
->local
));
386 memset (&node
->global
, 0, sizeof (node
->global
));
387 memset (&node
->rtl
, 0, sizeof (node
->rtl
));
388 node
->analyzed
= false;
389 node
->definition
= false;
391 node
->weakref
= false;
392 node
->cpp_implicit_alias
= false;
394 cgraph_node_remove_callees (node
);
395 ipa_remove_all_references (&node
->ref_list
);
398 /* Return true when there are references to NODE. */
401 referred_to_p (symtab_node
*node
)
405 /* See if there are any references at all. */
406 if (ipa_ref_list_referring_iterate (&node
->ref_list
, 0, ref
))
408 /* For functions check also calls. */
409 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
410 if (cn
&& cn
->callers
)
415 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
416 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
417 the garbage collector run at the moment. We would need to either create
418 a new GC context, or just not compile right now. */
421 cgraph_finalize_function (tree decl
, bool no_collect
)
423 struct cgraph_node
*node
= cgraph_get_create_node (decl
);
425 if (node
->definition
)
427 /* Nested functions should only be defined once. */
428 gcc_assert (!DECL_CONTEXT (decl
)
429 || TREE_CODE (DECL_CONTEXT (decl
)) != FUNCTION_DECL
);
430 cgraph_reset_node (node
);
431 node
->local
.redefined_extern_inline
= true;
434 notice_global_symbol (decl
);
435 node
->definition
= true;
436 node
->lowered
= DECL_STRUCT_FUNCTION (decl
)->cfg
!= NULL
;
438 /* With -fkeep-inline-functions we are keeping all inline functions except
439 for extern inline ones. */
440 if (flag_keep_inline_functions
441 && DECL_DECLARED_INLINE_P (decl
)
442 && !DECL_EXTERNAL (decl
)
443 && !DECL_DISREGARD_INLINE_LIMITS (decl
))
444 node
->force_output
= 1;
446 /* When not optimizing, also output the static functions. (see
447 PR24561), but don't do so for always_inline functions, functions
448 declared inline and nested functions. These were optimized out
449 in the original implementation and it is unclear whether we want
450 to change the behavior here. */
452 && !node
->cpp_implicit_alias
453 && !DECL_DISREGARD_INLINE_LIMITS (decl
)
454 && !DECL_DECLARED_INLINE_P (decl
)
455 && !(DECL_CONTEXT (decl
)
456 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
))
457 && !DECL_COMDAT (decl
) && !DECL_EXTERNAL (decl
))
458 node
->force_output
= 1;
460 /* If we've not yet emitted decl, tell the debug info about it. */
461 if (!TREE_ASM_WRITTEN (decl
))
462 (*debug_hooks
->deferred_inline_function
) (decl
);
464 /* Possibly warn about unused parameters. */
465 if (warn_unused_parameter
)
466 do_warn_unused_parameter (decl
);
471 if (cgraph_state
== CGRAPH_STATE_CONSTRUCTION
472 && (decide_is_symbol_needed (node
)
473 || referred_to_p (node
)))
477 /* Add the function FNDECL to the call graph.
478 Unlike cgraph_finalize_function, this function is intended to be used
479 by middle end and allows insertion of new function at arbitrary point
480 of compilation. The function can be either in high, low or SSA form
483 The function is assumed to be reachable and have address taken (so no
484 API breaking optimizations are performed on it).
486 Main work done by this function is to enqueue the function for later
487 processing to avoid need the passes to be re-entrant. */
490 cgraph_add_new_function (tree fndecl
, bool lowered
)
492 gcc::pass_manager
*passes
= g
->get_passes ();
493 struct cgraph_node
*node
;
494 switch (cgraph_state
)
496 case CGRAPH_STATE_PARSING
:
497 cgraph_finalize_function (fndecl
, false);
499 case CGRAPH_STATE_CONSTRUCTION
:
500 /* Just enqueue function to be processed at nearest occurrence. */
501 node
= cgraph_create_node (fndecl
);
503 node
->lowered
= true;
504 if (!cgraph_new_nodes
)
505 cgraph_new_nodes
= cgraph_node_set_new ();
506 cgraph_node_set_add (cgraph_new_nodes
, node
);
509 case CGRAPH_STATE_IPA
:
510 case CGRAPH_STATE_IPA_SSA
:
511 case CGRAPH_STATE_EXPANSION
:
512 /* Bring the function into finalized state and enqueue for later
513 analyzing and compilation. */
514 node
= cgraph_get_create_node (fndecl
);
515 node
->local
.local
= false;
516 node
->definition
= true;
517 node
->force_output
= true;
518 if (!lowered
&& cgraph_state
== CGRAPH_STATE_EXPANSION
)
520 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
521 gimple_register_cfg_hooks ();
522 bitmap_obstack_initialize (NULL
);
523 execute_pass_list (passes
->all_lowering_passes
);
524 passes
->execute_early_local_passes ();
525 bitmap_obstack_release (NULL
);
531 node
->lowered
= true;
532 if (!cgraph_new_nodes
)
533 cgraph_new_nodes
= cgraph_node_set_new ();
534 cgraph_node_set_add (cgraph_new_nodes
, node
);
537 case CGRAPH_STATE_FINISHED
:
538 /* At the very end of compilation we have to do all the work up
540 node
= cgraph_create_node (fndecl
);
542 node
->lowered
= true;
543 node
->definition
= true;
544 analyze_function (node
);
545 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
546 gimple_register_cfg_hooks ();
547 bitmap_obstack_initialize (NULL
);
548 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl
)))
549 g
->get_passes ()->execute_early_local_passes ();
550 bitmap_obstack_release (NULL
);
552 expand_function (node
);
559 /* Set a personality if required and we already passed EH lowering. */
561 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl
))
562 == eh_personality_lang
))
563 DECL_FUNCTION_PERSONALITY (fndecl
) = lang_hooks
.eh_personality ();
566 /* Add a top-level asm statement to the list. */
569 add_asm_node (tree asm_str
)
571 struct asm_node
*node
;
573 node
= ggc_alloc_cleared_asm_node ();
574 node
->asm_str
= asm_str
;
575 node
->order
= symtab_order
++;
577 if (asm_nodes
== NULL
)
580 asm_last_node
->next
= node
;
581 asm_last_node
= node
;
585 /* Output all asm statements we have stored up to be output. */
588 output_asm_statements (void)
590 struct asm_node
*can
;
595 for (can
= asm_nodes
; can
; can
= can
->next
)
596 assemble_asm (can
->asm_str
);
600 /* Analyze the function scheduled to be output. */
602 analyze_function (struct cgraph_node
*node
)
604 tree decl
= node
->decl
;
605 location_t saved_loc
= input_location
;
606 input_location
= DECL_SOURCE_LOCATION (decl
);
608 if (node
->thunk
.thunk_p
)
610 cgraph_create_edge (node
, cgraph_get_node (node
->thunk
.alias
),
611 NULL
, 0, CGRAPH_FREQ_BASE
);
612 if (!expand_thunk (node
, false))
614 node
->thunk
.alias
= NULL
;
615 node
->analyzed
= true;
618 node
->thunk
.alias
= NULL
;
622 (node
, cgraph_get_node (node
->alias_target
));
623 else if (node
->dispatcher_function
)
625 /* Generate the dispatcher body of multi-versioned functions. */
626 struct cgraph_function_version_info
*dispatcher_version_info
627 = get_cgraph_node_version (node
);
628 if (dispatcher_version_info
!= NULL
629 && (dispatcher_version_info
->dispatcher_resolver
632 tree resolver
= NULL_TREE
;
633 gcc_assert (targetm
.generate_version_dispatcher_body
);
634 resolver
= targetm
.generate_version_dispatcher_body (node
);
635 gcc_assert (resolver
!= NULL_TREE
);
640 push_cfun (DECL_STRUCT_FUNCTION (decl
));
642 assign_assembler_name_if_neeeded (node
->decl
);
644 /* Make sure to gimplify bodies only once. During analyzing a
645 function we lower it, which will require gimplified nested
646 functions, so we can end up here with an already gimplified
648 if (!gimple_has_body_p (decl
))
649 gimplify_function_tree (decl
);
650 dump_function (TDI_generic
, decl
);
652 /* Lower the function. */
656 lower_nested_functions (node
->decl
);
657 gcc_assert (!node
->nested
);
659 gimple_register_cfg_hooks ();
660 bitmap_obstack_initialize (NULL
);
661 execute_pass_list (g
->get_passes ()->all_lowering_passes
);
662 free_dominance_info (CDI_POST_DOMINATORS
);
663 free_dominance_info (CDI_DOMINATORS
);
665 bitmap_obstack_release (NULL
);
666 node
->lowered
= true;
671 node
->analyzed
= true;
673 input_location
= saved_loc
;
676 /* C++ frontend produce same body aliases all over the place, even before PCH
677 gets streamed out. It relies on us linking the aliases with their function
678 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
679 first produce aliases without links, but once C++ FE is sure he won't sream
680 PCH we build the links via this function. */
683 cgraph_process_same_body_aliases (void)
686 FOR_EACH_SYMBOL (node
)
687 if (node
->cpp_implicit_alias
&& !node
->analyzed
)
690 TREE_CODE (node
->alias_target
) == VAR_DECL
691 ? (symtab_node
*)varpool_node_for_decl (node
->alias_target
)
692 : (symtab_node
*)cgraph_get_create_node (node
->alias_target
));
693 cpp_implicit_aliases_done
= true;
696 /* Process attributes common for vars and functions. */
699 process_common_attributes (tree decl
)
701 tree weakref
= lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
));
703 if (weakref
&& !lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)))
705 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
706 "%<weakref%> attribute should be accompanied with"
707 " an %<alias%> attribute");
708 DECL_WEAK (decl
) = 0;
709 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
710 DECL_ATTRIBUTES (decl
));
714 /* Look for externally_visible and used attributes and mark cgraph nodes
717 We cannot mark the nodes at the point the attributes are processed (in
718 handle_*_attribute) because the copy of the declarations available at that
719 point may not be canonical. For example, in:
722 void f() __attribute__((used));
724 the declaration we see in handle_used_attribute will be the second
725 declaration -- but the front end will subsequently merge that declaration
726 with the original declaration and discard the second declaration.
728 Furthermore, we can't mark these nodes in cgraph_finalize_function because:
731 void f() __attribute__((externally_visible));
735 So, we walk the nodes at the end of the translation unit, applying the
736 attributes at that point. */
739 process_function_and_variable_attributes (struct cgraph_node
*first
,
740 varpool_node
*first_var
)
742 struct cgraph_node
*node
;
745 for (node
= cgraph_first_function (); node
!= first
;
746 node
= cgraph_next_function (node
))
748 tree decl
= node
->decl
;
749 if (DECL_PRESERVE_P (decl
))
750 cgraph_mark_force_output_node (node
);
751 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
753 if (! TREE_PUBLIC (node
->decl
))
754 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
755 "%<externally_visible%>"
756 " attribute have effect only on public objects");
758 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
759 && (node
->definition
&& !node
->alias
))
761 warning_at (DECL_SOURCE_LOCATION (node
->decl
), OPT_Wattributes
,
762 "%<weakref%> attribute ignored"
763 " because function is defined");
764 DECL_WEAK (decl
) = 0;
765 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
766 DECL_ATTRIBUTES (decl
));
769 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl
))
770 && !DECL_DECLARED_INLINE_P (decl
)
771 /* redefining extern inline function makes it DECL_UNINLINABLE. */
772 && !DECL_UNINLINABLE (decl
))
773 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wattributes
,
774 "always_inline function might not be inlinable");
776 process_common_attributes (decl
);
778 for (vnode
= varpool_first_variable (); vnode
!= first_var
;
779 vnode
= varpool_next_variable (vnode
))
781 tree decl
= vnode
->decl
;
782 if (DECL_EXTERNAL (decl
)
783 && DECL_INITIAL (decl
))
784 varpool_finalize_decl (decl
);
785 if (DECL_PRESERVE_P (decl
))
786 vnode
->force_output
= true;
787 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl
)))
789 if (! TREE_PUBLIC (vnode
->decl
))
790 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
791 "%<externally_visible%>"
792 " attribute have effect only on public objects");
794 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))
796 && DECL_INITIAL (decl
))
798 warning_at (DECL_SOURCE_LOCATION (vnode
->decl
), OPT_Wattributes
,
799 "%<weakref%> attribute ignored"
800 " because variable is initialized");
801 DECL_WEAK (decl
) = 0;
802 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
803 DECL_ATTRIBUTES (decl
));
805 process_common_attributes (decl
);
809 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
810 middle end to output the variable to asm file, if needed or externally
814 varpool_finalize_decl (tree decl
)
816 varpool_node
*node
= varpool_node_for_decl (decl
);
818 gcc_assert (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
));
820 if (node
->definition
)
822 notice_global_symbol (decl
);
823 node
->definition
= true;
824 if (TREE_THIS_VOLATILE (decl
) || DECL_PRESERVE_P (decl
)
825 /* Traditionally we do not eliminate static variables when not
826 optimizing and when not doing toplevel reoder. */
827 || (!flag_toplevel_reorder
&& !DECL_COMDAT (node
->decl
)
828 && !DECL_ARTIFICIAL (node
->decl
)))
829 node
->force_output
= true;
831 if (cgraph_state
== CGRAPH_STATE_CONSTRUCTION
832 && (decide_is_symbol_needed (node
)
833 || referred_to_p (node
)))
835 if (cgraph_state
>= CGRAPH_STATE_IPA_SSA
)
836 varpool_analyze_node (node
);
837 /* Some frontends produce various interface variables after compilation
839 if (cgraph_state
== CGRAPH_STATE_FINISHED
840 || (!flag_toplevel_reorder
&& cgraph_state
== CGRAPH_STATE_EXPANSION
))
841 varpool_assemble_decl (node
);
844 /* EDGE is an polymorphic call. Mark all possible targets as reachable
845 and if there is only one target, perform trivial devirtualization.
846 REACHABLE_CALL_TARGETS collects target lists we already walked to
847 avoid udplicate work. */
850 walk_polymorphic_call_targets (pointer_set_t
*reachable_call_targets
,
851 struct cgraph_edge
*edge
)
856 vec
<cgraph_node
*>targets
857 = possible_polymorphic_call_targets
858 (edge
, &final
, &cache_token
);
860 if (!pointer_set_insert (reachable_call_targets
,
863 if (cgraph_dump_file
)
864 dump_possible_polymorphic_call_targets
865 (cgraph_dump_file
, edge
);
867 for (i
= 0; i
< targets
.length (); i
++)
869 /* Do not bother to mark virtual methods in anonymous namespace;
870 either we will find use of virtual table defining it, or it is
872 if (targets
[i
]->definition
874 (TREE_TYPE (targets
[i
]->decl
))
876 && !type_in_anonymous_namespace_p
878 (TREE_TYPE (targets
[i
]->decl
))))
879 enqueue_node (targets
[i
]);
883 /* Very trivial devirtualization; when the type is
884 final or anonymous (so we know all its derivation)
885 and there is only one possible virtual call target,
886 make the edge direct. */
889 if (targets
.length () <= 1)
892 if (targets
.length () == 1)
895 target
= cgraph_get_create_node
896 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
));
898 if (cgraph_dump_file
)
900 fprintf (cgraph_dump_file
,
901 "Devirtualizing call: ");
902 print_gimple_stmt (cgraph_dump_file
,
906 cgraph_make_edge_direct (edge
, target
);
907 cgraph_redirect_edge_call_stmt_to_callee (edge
);
908 if (cgraph_dump_file
)
910 fprintf (cgraph_dump_file
,
911 "Devirtualized as: ");
912 print_gimple_stmt (cgraph_dump_file
,
921 /* Discover all functions and variables that are trivially needed, analyze
922 them as well as all functions and variables referred by them */
925 analyze_functions (void)
927 /* Keep track of already processed nodes when called multiple times for
928 intermodule optimization. */
929 static struct cgraph_node
*first_analyzed
;
930 struct cgraph_node
*first_handled
= first_analyzed
;
931 static varpool_node
*first_analyzed_var
;
932 varpool_node
*first_handled_var
= first_analyzed_var
;
933 struct pointer_set_t
*reachable_call_targets
= pointer_set_create ();
940 location_t saved_loc
= input_location
;
942 bitmap_obstack_initialize (NULL
);
943 cgraph_state
= CGRAPH_STATE_CONSTRUCTION
;
944 input_location
= UNKNOWN_LOCATION
;
946 /* Ugly, but the fixup can not happen at a time same body alias is created;
947 C++ FE is confused about the COMDAT groups being right. */
948 if (cpp_implicit_aliases_done
)
949 FOR_EACH_SYMBOL (node
)
950 if (node
->cpp_implicit_alias
)
951 fixup_same_cpp_alias_visibility (node
, symtab_alias_target (node
));
952 if (optimize
&& flag_devirtualize
)
953 build_type_inheritance_graph ();
955 /* Analysis adds static variables that in turn adds references to new functions.
956 So we need to iterate the process until it stabilize. */
960 process_function_and_variable_attributes (first_analyzed
,
963 /* First identify the trivially needed symbols. */
964 for (node
= symtab_nodes
;
965 node
!= first_analyzed
966 && node
!= first_analyzed_var
; node
= node
->next
)
968 if (decide_is_symbol_needed (node
))
971 if (!changed
&& cgraph_dump_file
)
972 fprintf (cgraph_dump_file
, "Trivially needed symbols:");
974 if (cgraph_dump_file
)
975 fprintf (cgraph_dump_file
, " %s", node
->asm_name ());
976 if (!changed
&& cgraph_dump_file
)
977 fprintf (cgraph_dump_file
, "\n");
979 if (node
== first_analyzed
980 || node
== first_analyzed_var
)
983 cgraph_process_new_functions ();
984 first_analyzed_var
= varpool_first_variable ();
985 first_analyzed
= cgraph_first_function ();
987 if (changed
&& dump_file
)
988 fprintf (cgraph_dump_file
, "\n");
990 /* Lower representation, build callgraph edges and references for all trivially
991 needed symbols and all symbols referred by them. */
992 while (queued_nodes
!= &symtab_terminator
)
996 queued_nodes
= (symtab_node
*)queued_nodes
->aux
;
997 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
998 if (cnode
&& cnode
->definition
)
1000 struct cgraph_edge
*edge
;
1001 tree decl
= cnode
->decl
;
1003 /* ??? It is possible to create extern inline function
1004 and later using weak alias attribute to kill its body.
1005 See gcc.c-torture/compile/20011119-1.c */
1006 if (!DECL_STRUCT_FUNCTION (decl
)
1008 && !cnode
->thunk
.thunk_p
1009 && !cnode
->dispatcher_function
)
1011 cgraph_reset_node (cnode
);
1012 cnode
->local
.redefined_extern_inline
= true;
1016 if (!cnode
->analyzed
)
1017 analyze_function (cnode
);
1019 for (edge
= cnode
->callees
; edge
; edge
= edge
->next_callee
)
1020 if (edge
->callee
->definition
)
1021 enqueue_node (edge
->callee
);
1022 if (optimize
&& flag_devirtualize
)
1024 struct cgraph_edge
*next
;
1026 for (edge
= cnode
->indirect_calls
; edge
; edge
= next
)
1028 next
= edge
->next_callee
;
1029 if (edge
->indirect_info
->polymorphic
)
1030 walk_polymorphic_call_targets (reachable_call_targets
,
1035 /* If decl is a clone of an abstract function,
1036 mark that abstract function so that we don't release its body.
1037 The DECL_INITIAL() of that abstract function declaration
1038 will be later needed to output debug info. */
1039 if (DECL_ABSTRACT_ORIGIN (decl
))
1041 struct cgraph_node
*origin_node
1042 = cgraph_get_node (DECL_ABSTRACT_ORIGIN (decl
));
1043 origin_node
->used_as_abstract_origin
= true;
1048 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
1049 if (vnode
&& vnode
->definition
&& !vnode
->analyzed
)
1050 varpool_analyze_node (vnode
);
1053 if (node
->same_comdat_group
)
1056 for (next
= node
->same_comdat_group
;
1058 next
= next
->same_comdat_group
)
1059 enqueue_node (next
);
1061 for (i
= 0; ipa_ref_list_reference_iterate (&node
->ref_list
, i
, ref
); i
++)
1062 if (ref
->referred
->definition
)
1063 enqueue_node (ref
->referred
);
1064 cgraph_process_new_functions ();
1067 if (optimize
&& flag_devirtualize
)
1068 update_type_inheritance_graph ();
1070 /* Collect entry points to the unit. */
1071 if (cgraph_dump_file
)
1073 fprintf (cgraph_dump_file
, "\n\nInitial ");
1074 dump_symtab (cgraph_dump_file
);
1077 if (cgraph_dump_file
)
1078 fprintf (cgraph_dump_file
, "\nRemoving unused symbols:");
1080 for (node
= symtab_nodes
;
1081 node
!= first_handled
1082 && node
!= first_handled_var
; node
= next
)
1085 if (!node
->aux
&& !referred_to_p (node
))
1087 if (cgraph_dump_file
)
1088 fprintf (cgraph_dump_file
, " %s", node
->name ());
1089 symtab_remove_node (node
);
1092 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
))
1094 tree decl
= node
->decl
;
1096 if (cnode
->definition
&& !gimple_has_body_p (decl
)
1098 && !cnode
->thunk
.thunk_p
)
1099 cgraph_reset_node (cnode
);
1101 gcc_assert (!cnode
->definition
|| cnode
->thunk
.thunk_p
1103 || gimple_has_body_p (decl
));
1104 gcc_assert (cnode
->analyzed
== cnode
->definition
);
1108 for (;node
; node
= node
->next
)
1110 first_analyzed
= cgraph_first_function ();
1111 first_analyzed_var
= varpool_first_variable ();
1112 if (cgraph_dump_file
)
1114 fprintf (cgraph_dump_file
, "\n\nReclaimed ");
1115 dump_symtab (cgraph_dump_file
);
1117 bitmap_obstack_release (NULL
);
1118 pointer_set_destroy (reachable_call_targets
);
1120 /* Initialize assembler name hash, in particular we want to trigger C++
1121 mangling and same body alias creation before we free DECL_ARGUMENTS
1124 symtab_initialize_asm_name_hash ();
1126 input_location
= saved_loc
;
1129 /* Translate the ugly representation of aliases as alias pairs into nice
1130 representation in callgraph. We don't handle all cases yet,
1134 handle_alias_pairs (void)
1139 for (i
= 0; alias_pairs
&& alias_pairs
->iterate (i
, &p
);)
1141 symtab_node
*target_node
= symtab_node_for_asm (p
->target
);
1143 /* Weakrefs with target not defined in current unit are easy to handle:
1144 they behave just as external variables except we need to note the
1145 alias flag to later output the weakref pseudo op into asm file. */
1147 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)) != NULL
)
1149 symtab_node
*node
= symtab_get_node (p
->decl
);
1152 node
->alias_target
= p
->target
;
1153 node
->weakref
= true;
1156 alias_pairs
->unordered_remove (i
);
1159 else if (!target_node
)
1161 error ("%q+D aliased to undefined symbol %qE", p
->decl
, p
->target
);
1162 symtab_node
*node
= symtab_get_node (p
->decl
);
1164 node
->alias
= false;
1165 alias_pairs
->unordered_remove (i
);
1169 if (DECL_EXTERNAL (target_node
->decl
)
1170 /* We use local aliases for C++ thunks to force the tailcall
1171 to bind locally. This is a hack - to keep it working do
1172 the following (which is not strictly correct). */
1173 && (! TREE_CODE (target_node
->decl
) == FUNCTION_DECL
1174 || ! DECL_VIRTUAL_P (target_node
->decl
))
1175 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p
->decl
)))
1177 error ("%q+D aliased to external symbol %qE",
1178 p
->decl
, p
->target
);
1181 if (TREE_CODE (p
->decl
) == FUNCTION_DECL
1182 && target_node
&& is_a
<cgraph_node
*> (target_node
))
1184 struct cgraph_node
*src_node
= cgraph_get_node (p
->decl
);
1185 if (src_node
&& src_node
->definition
)
1186 cgraph_reset_node (src_node
);
1187 cgraph_create_function_alias (p
->decl
, target_node
->decl
);
1188 alias_pairs
->unordered_remove (i
);
1190 else if (TREE_CODE (p
->decl
) == VAR_DECL
1191 && target_node
&& is_a
<varpool_node
*> (target_node
))
1193 varpool_create_variable_alias (p
->decl
, target_node
->decl
);
1194 alias_pairs
->unordered_remove (i
);
1198 error ("%q+D alias in between function and variable is not supported",
1200 warning (0, "%q+D aliased declaration",
1202 alias_pairs
->unordered_remove (i
);
1205 vec_free (alias_pairs
);
1209 /* Figure out what functions we want to assemble. */
1212 mark_functions_to_output (void)
1214 struct cgraph_node
*node
;
1215 #ifdef ENABLE_CHECKING
1216 bool check_same_comdat_groups
= false;
1218 FOR_EACH_FUNCTION (node
)
1219 gcc_assert (!node
->process
);
1222 FOR_EACH_FUNCTION (node
)
1224 tree decl
= node
->decl
;
1226 gcc_assert (!node
->process
|| node
->same_comdat_group
);
1230 /* We need to output all local functions that are used and not
1231 always inlined, as well as those that are reachable from
1232 outside the current compilation unit. */
1234 && !node
->thunk
.thunk_p
1236 && !node
->global
.inlined_to
1237 && !TREE_ASM_WRITTEN (decl
)
1238 && !DECL_EXTERNAL (decl
))
1241 if (node
->same_comdat_group
)
1243 struct cgraph_node
*next
;
1244 for (next
= cgraph (node
->same_comdat_group
);
1246 next
= cgraph (next
->same_comdat_group
))
1247 if (!next
->thunk
.thunk_p
&& !next
->alias
1248 && !symtab_comdat_local_p (next
))
1252 else if (node
->same_comdat_group
)
1254 #ifdef ENABLE_CHECKING
1255 check_same_comdat_groups
= true;
1260 /* We should've reclaimed all functions that are not needed. */
1261 #ifdef ENABLE_CHECKING
1262 if (!node
->global
.inlined_to
1263 && gimple_has_body_p (decl
)
1264 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1265 are inside partition, we can end up not removing the body since we no longer
1266 have analyzed node pointing to it. */
1267 && !node
->in_other_partition
1270 && !DECL_EXTERNAL (decl
))
1272 dump_cgraph_node (stderr
, node
);
1273 internal_error ("failed to reclaim unneeded function");
1276 gcc_assert (node
->global
.inlined_to
1277 || !gimple_has_body_p (decl
)
1278 || node
->in_other_partition
1280 || DECL_ARTIFICIAL (decl
)
1281 || DECL_EXTERNAL (decl
));
1286 #ifdef ENABLE_CHECKING
1287 if (check_same_comdat_groups
)
1288 FOR_EACH_FUNCTION (node
)
1289 if (node
->same_comdat_group
&& !node
->process
)
1291 tree decl
= node
->decl
;
1292 if (!node
->global
.inlined_to
1293 && gimple_has_body_p (decl
)
1294 /* FIXME: in an ltrans unit when the offline copy is outside a
1295 partition but inline copies are inside a partition, we can
1296 end up not removing the body since we no longer have an
1297 analyzed node pointing to it. */
1298 && !node
->in_other_partition
1300 && !DECL_EXTERNAL (decl
))
1302 dump_cgraph_node (stderr
, node
);
1303 internal_error ("failed to reclaim unneeded function in same "
1310 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1311 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1313 Set current_function_decl and cfun to newly constructed empty function body.
1314 return basic block in the function body. */
1317 init_lowered_empty_function (tree decl
, bool in_ssa
)
1321 current_function_decl
= decl
;
1322 allocate_struct_function (decl
, false);
1323 gimple_register_cfg_hooks ();
1324 init_empty_tree_cfg ();
1328 init_tree_ssa (cfun
);
1329 init_ssa_operands (cfun
);
1330 cfun
->gimple_df
->in_ssa_p
= true;
1331 cfun
->curr_properties
|= PROP_ssa
;
1334 DECL_INITIAL (decl
) = make_node (BLOCK
);
1336 DECL_SAVED_TREE (decl
) = error_mark_node
;
1337 cfun
->curr_properties
|= (PROP_gimple_lcf
| PROP_gimple_leh
| PROP_gimple_any
1338 | PROP_cfg
| PROP_loops
);
1340 set_loops_for_fn (cfun
, ggc_alloc_cleared_loops ());
1341 init_loops_structure (cfun
, loops_for_fn (cfun
), 1);
1342 loops_for_fn (cfun
)->state
|= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
1344 /* Create BB for body of the function and connect it properly. */
1345 bb
= create_basic_block (NULL
, (void *) 0, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
1346 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), bb
, EDGE_FALLTHRU
);
1347 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1348 add_bb_to_loop (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->loop_father
);
1353 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1354 offset indicated by VIRTUAL_OFFSET, if that is
1355 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1356 zero for a result adjusting thunk. */
1359 thunk_adjust (gimple_stmt_iterator
* bsi
,
1360 tree ptr
, bool this_adjusting
,
1361 HOST_WIDE_INT fixed_offset
, tree virtual_offset
)
1367 && fixed_offset
!= 0)
1369 stmt
= gimple_build_assign
1370 (ptr
, fold_build_pointer_plus_hwi_loc (input_location
,
1373 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1376 /* If there's a virtual offset, look up that value in the vtable and
1377 adjust the pointer again. */
1384 if (!vtable_entry_type
)
1386 tree vfunc_type
= make_node (FUNCTION_TYPE
);
1387 TREE_TYPE (vfunc_type
) = integer_type_node
;
1388 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
1389 layout_type (vfunc_type
);
1391 vtable_entry_type
= build_pointer_type (vfunc_type
);
1395 create_tmp_reg (build_pointer_type
1396 (build_pointer_type (vtable_entry_type
)), "vptr");
1398 /* The vptr is always at offset zero in the object. */
1399 stmt
= gimple_build_assign (vtabletmp
,
1400 build1 (NOP_EXPR
, TREE_TYPE (vtabletmp
),
1402 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1404 /* Form the vtable address. */
1405 vtabletmp2
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp
)),
1407 stmt
= gimple_build_assign (vtabletmp2
,
1408 build_simple_mem_ref (vtabletmp
));
1409 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1411 /* Find the entry with the vcall offset. */
1412 stmt
= gimple_build_assign (vtabletmp2
,
1413 fold_build_pointer_plus_loc (input_location
,
1416 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1418 /* Get the offset itself. */
1419 vtabletmp3
= create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2
)),
1421 stmt
= gimple_build_assign (vtabletmp3
,
1422 build_simple_mem_ref (vtabletmp2
));
1423 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1425 /* Adjust the `this' pointer. */
1426 ptr
= fold_build_pointer_plus_loc (input_location
, ptr
, vtabletmp3
);
1427 ptr
= force_gimple_operand_gsi (bsi
, ptr
, true, NULL_TREE
, false,
1428 GSI_CONTINUE_LINKING
);
1432 && fixed_offset
!= 0)
1433 /* Adjust the pointer by the constant. */
1437 if (TREE_CODE (ptr
) == VAR_DECL
)
1441 ptrtmp
= create_tmp_reg (TREE_TYPE (ptr
), "ptr");
1442 stmt
= gimple_build_assign (ptrtmp
, ptr
);
1443 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1445 ptr
= fold_build_pointer_plus_hwi_loc (input_location
,
1446 ptrtmp
, fixed_offset
);
1449 /* Emit the statement and gimplify the adjustment expression. */
1450 ret
= create_tmp_reg (TREE_TYPE (ptr
), "adjusted_this");
1451 stmt
= gimple_build_assign (ret
, ptr
);
1452 gsi_insert_after (bsi
, stmt
, GSI_NEW_STMT
);
1457 /* Expand thunk NODE to gimple if possible.
1458 When OUTPUT_ASM_THUNK is true, also produce assembler for
1459 thunks that are not lowered. */
1462 expand_thunk (struct cgraph_node
*node
, bool output_asm_thunks
)
1464 bool this_adjusting
= node
->thunk
.this_adjusting
;
1465 HOST_WIDE_INT fixed_offset
= node
->thunk
.fixed_offset
;
1466 HOST_WIDE_INT virtual_value
= node
->thunk
.virtual_value
;
1467 tree virtual_offset
= NULL
;
1468 tree alias
= node
->callees
->callee
->decl
;
1469 tree thunk_fndecl
= node
->decl
;
1474 && targetm
.asm_out
.can_output_mi_thunk (thunk_fndecl
, fixed_offset
,
1475 virtual_value
, alias
))
1479 tree restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1481 if (!output_asm_thunks
)
1485 cgraph_get_body (node
);
1486 a
= DECL_ARGUMENTS (thunk_fndecl
);
1488 current_function_decl
= thunk_fndecl
;
1490 /* Ensure thunks are emitted in their correct sections. */
1491 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1493 DECL_RESULT (thunk_fndecl
)
1494 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl
),
1495 RESULT_DECL
, 0, restype
);
1496 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1497 fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl
));
1499 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1501 fn_block
= make_node (BLOCK
);
1502 BLOCK_VARS (fn_block
) = a
;
1503 DECL_INITIAL (thunk_fndecl
) = fn_block
;
1504 init_function_start (thunk_fndecl
);
1506 insn_locations_init ();
1507 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl
));
1508 prologue_location
= curr_insn_location ();
1509 assemble_start_function (thunk_fndecl
, fnname
);
1511 targetm
.asm_out
.output_mi_thunk (asm_out_file
, thunk_fndecl
,
1512 fixed_offset
, virtual_value
, alias
);
1514 assemble_end_function (thunk_fndecl
, fnname
);
1515 insn_locations_finalize ();
1516 init_insn_lengths ();
1517 free_after_compilation (cfun
);
1519 TREE_ASM_WRITTEN (thunk_fndecl
) = 1;
1520 node
->thunk
.thunk_p
= false;
1521 node
->analyzed
= false;
1526 basic_block bb
, then_bb
, else_bb
, return_bb
;
1527 gimple_stmt_iterator bsi
;
1538 cgraph_get_body (node
);
1539 a
= DECL_ARGUMENTS (thunk_fndecl
);
1541 current_function_decl
= thunk_fndecl
;
1543 /* Ensure thunks are emitted in their correct sections. */
1544 resolve_unique_section (thunk_fndecl
, 0, flag_function_sections
);
1546 DECL_IGNORED_P (thunk_fndecl
) = 1;
1547 bitmap_obstack_initialize (NULL
);
1549 if (node
->thunk
.virtual_offset_p
)
1550 virtual_offset
= size_int (virtual_value
);
1552 /* Build the return declaration for the function. */
1553 restype
= TREE_TYPE (TREE_TYPE (thunk_fndecl
));
1554 if (DECL_RESULT (thunk_fndecl
) == NULL_TREE
)
1556 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
1557 DECL_ARTIFICIAL (resdecl
) = 1;
1558 DECL_IGNORED_P (resdecl
) = 1;
1559 DECL_RESULT (thunk_fndecl
) = resdecl
;
1560 DECL_CONTEXT (DECL_RESULT (thunk_fndecl
)) = thunk_fndecl
;
1563 resdecl
= DECL_RESULT (thunk_fndecl
);
1565 bb
= then_bb
= else_bb
= return_bb
= init_lowered_empty_function (thunk_fndecl
, true);
1567 bsi
= gsi_start_bb (bb
);
1569 /* Build call to the function being thunked. */
1570 if (!VOID_TYPE_P (restype
))
1572 if (DECL_BY_REFERENCE (resdecl
))
1573 restmp
= gimple_fold_indirect_ref (resdecl
);
1574 else if (!is_gimple_reg_type (restype
))
1577 add_local_decl (cfun
, restmp
);
1578 BLOCK_VARS (DECL_INITIAL (current_function_decl
)) = restmp
;
1581 restmp
= create_tmp_reg (restype
, "retval");
1584 for (arg
= a
; arg
; arg
= DECL_CHAIN (arg
))
1586 auto_vec
<tree
> vargs (nargs
);
1588 vargs
.quick_push (thunk_adjust (&bsi
, a
, 1, fixed_offset
,
1591 vargs
.quick_push (a
);
1594 for (i
= 1, arg
= DECL_CHAIN (a
); i
< nargs
; i
++, arg
= DECL_CHAIN (arg
))
1597 if (!is_gimple_val (arg
))
1599 tmp
= create_tmp_reg (TYPE_MAIN_VARIANT
1600 (TREE_TYPE (arg
)), "arg");
1601 gimple stmt
= gimple_build_assign (tmp
, arg
);
1602 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1604 vargs
.quick_push (tmp
);
1606 call
= gimple_build_call_vec (build_fold_addr_expr_loc (0, alias
), vargs
);
1607 node
->callees
->call_stmt
= call
;
1608 gimple_call_set_from_thunk (call
, true);
1611 gimple_call_set_lhs (call
, restmp
);
1612 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp
),
1613 TREE_TYPE (TREE_TYPE (alias
))));
1615 gsi_insert_after (&bsi
, call
, GSI_NEW_STMT
);
1616 if (!(gimple_call_flags (call
) & ECF_NORETURN
))
1618 if (restmp
&& !this_adjusting
1619 && (fixed_offset
|| virtual_offset
))
1621 tree true_label
= NULL_TREE
;
1623 if (TREE_CODE (TREE_TYPE (restmp
)) == POINTER_TYPE
)
1626 /* If the return type is a pointer, we need to
1627 protect against NULL. We know there will be an
1628 adjustment, because that's why we're emitting a
1630 then_bb
= create_basic_block (NULL
, (void *) 0, bb
);
1631 return_bb
= create_basic_block (NULL
, (void *) 0, then_bb
);
1632 else_bb
= create_basic_block (NULL
, (void *) 0, else_bb
);
1633 add_bb_to_loop (then_bb
, bb
->loop_father
);
1634 add_bb_to_loop (return_bb
, bb
->loop_father
);
1635 add_bb_to_loop (else_bb
, bb
->loop_father
);
1636 remove_edge (single_succ_edge (bb
));
1637 true_label
= gimple_block_label (then_bb
);
1638 stmt
= gimple_build_cond (NE_EXPR
, restmp
,
1639 build_zero_cst (TREE_TYPE (restmp
)),
1640 NULL_TREE
, NULL_TREE
);
1641 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1642 make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1643 make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1644 make_edge (return_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
1645 make_edge (then_bb
, return_bb
, EDGE_FALLTHRU
);
1646 make_edge (else_bb
, return_bb
, EDGE_FALLTHRU
);
1647 bsi
= gsi_last_bb (then_bb
);
1650 restmp
= thunk_adjust (&bsi
, restmp
, /*this_adjusting=*/0,
1651 fixed_offset
, virtual_offset
);
1655 bsi
= gsi_last_bb (else_bb
);
1656 stmt
= gimple_build_assign (restmp
,
1657 build_zero_cst (TREE_TYPE (restmp
)));
1658 gsi_insert_after (&bsi
, stmt
, GSI_NEW_STMT
);
1659 bsi
= gsi_last_bb (return_bb
);
1663 gimple_call_set_tail (call
, true);
1665 /* Build return value. */
1666 ret
= gimple_build_return (restmp
);
1667 gsi_insert_after (&bsi
, ret
, GSI_NEW_STMT
);
1671 gimple_call_set_tail (call
, true);
1672 remove_edge (single_succ_edge (bb
));
1675 cfun
->gimple_df
->in_ssa_p
= true;
1676 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
1677 TREE_ASM_WRITTEN (thunk_fndecl
) = false;
1678 delete_unreachable_blocks ();
1679 update_ssa (TODO_update_ssa
);
1680 #ifdef ENABLE_CHECKING
1681 verify_flow_info ();
1684 /* Since we want to emit the thunk, we explicitly mark its name as
1686 node
->thunk
.thunk_p
= false;
1687 node
->lowered
= true;
1688 bitmap_obstack_release (NULL
);
1690 current_function_decl
= NULL
;
1695 /* Assemble thunks and aliases associated to NODE. */
1698 assemble_thunks_and_aliases (struct cgraph_node
*node
)
1700 struct cgraph_edge
*e
;
1702 struct ipa_ref
*ref
;
1704 for (e
= node
->callers
; e
;)
1705 if (e
->caller
->thunk
.thunk_p
)
1707 struct cgraph_node
*thunk
= e
->caller
;
1710 assemble_thunks_and_aliases (thunk
);
1711 expand_thunk (thunk
, true);
1715 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
,
1717 if (ref
->use
== IPA_REF_ALIAS
)
1719 struct cgraph_node
*alias
= ipa_ref_referring_node (ref
);
1720 bool saved_written
= TREE_ASM_WRITTEN (node
->decl
);
1722 /* Force assemble_alias to really output the alias this time instead
1723 of buffering it in same alias pairs. */
1724 TREE_ASM_WRITTEN (node
->decl
) = 1;
1725 do_assemble_alias (alias
->decl
,
1726 DECL_ASSEMBLER_NAME (node
->decl
));
1727 assemble_thunks_and_aliases (alias
);
1728 TREE_ASM_WRITTEN (node
->decl
) = saved_written
;
1732 /* Expand function specified by NODE. */
1735 expand_function (struct cgraph_node
*node
)
1737 tree decl
= node
->decl
;
1738 location_t saved_loc
;
1740 /* We ought to not compile any inline clones. */
1741 gcc_assert (!node
->global
.inlined_to
);
1743 announce_function (decl
);
1745 gcc_assert (node
->lowered
);
1746 cgraph_get_body (node
);
1748 /* Generate RTL for the body of DECL. */
1750 timevar_push (TV_REST_OF_COMPILATION
);
1752 gcc_assert (cgraph_global_info_ready
);
1754 /* Initialize the default bitmap obstack. */
1755 bitmap_obstack_initialize (NULL
);
1757 /* Initialize the RTL code for the function. */
1758 current_function_decl
= decl
;
1759 saved_loc
= input_location
;
1760 input_location
= DECL_SOURCE_LOCATION (decl
);
1761 init_function_start (decl
);
1763 gimple_register_cfg_hooks ();
1765 bitmap_obstack_initialize (®_obstack
); /* FIXME, only at RTL generation*/
1767 execute_all_ipa_transforms ();
1769 /* Perform all tree transforms and optimizations. */
1771 /* Signal the start of passes. */
1772 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START
, NULL
);
1774 execute_pass_list (g
->get_passes ()->all_passes
);
1776 /* Signal the end of passes. */
1777 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END
, NULL
);
1779 bitmap_obstack_release (®_obstack
);
1781 /* Release the default bitmap obstack. */
1782 bitmap_obstack_release (NULL
);
1784 /* If requested, warn about function definitions where the function will
1785 return a value (usually of some struct or union type) which itself will
1786 take up a lot of stack space. */
1787 if (warn_larger_than
&& !DECL_EXTERNAL (decl
) && TREE_TYPE (decl
))
1789 tree ret_type
= TREE_TYPE (TREE_TYPE (decl
));
1791 if (ret_type
&& TYPE_SIZE_UNIT (ret_type
)
1792 && TREE_CODE (TYPE_SIZE_UNIT (ret_type
)) == INTEGER_CST
1793 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type
),
1796 unsigned int size_as_int
1797 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type
));
1799 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type
), size_as_int
) == 0)
1800 warning (OPT_Wlarger_than_
, "size of return value of %q+D is %u bytes",
1803 warning (OPT_Wlarger_than_
, "size of return value of %q+D is larger than %wd bytes",
1804 decl
, larger_than_size
);
1808 gimple_set_body (decl
, NULL
);
1809 if (DECL_STRUCT_FUNCTION (decl
) == 0
1810 && !cgraph_get_node (decl
)->origin
)
1812 /* Stop pointing to the local nodes about to be freed.
1813 But DECL_INITIAL must remain nonzero so we know this
1814 was an actual function definition.
1815 For a nested function, this is done in c_pop_function_context.
1816 If rest_of_compilation set this to 0, leave it 0. */
1817 if (DECL_INITIAL (decl
) != 0)
1818 DECL_INITIAL (decl
) = error_mark_node
;
1821 input_location
= saved_loc
;
1824 timevar_pop (TV_REST_OF_COMPILATION
);
1826 /* Make sure that BE didn't give up on compiling. */
1827 gcc_assert (TREE_ASM_WRITTEN (decl
));
1829 current_function_decl
= NULL
;
1831 /* It would make a lot more sense to output thunks before function body to get more
1832 forward and lest backwarding jumps. This however would need solving problem
1833 with comdats. See PR48668. Also aliases must come after function itself to
1834 make one pass assemblers, like one on AIX, happy. See PR 50689.
1835 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1837 assemble_thunks_and_aliases (node
);
1838 cgraph_release_function_body (node
);
1839 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1840 points to the dead function body. */
1841 cgraph_node_remove_callees (node
);
1842 ipa_remove_all_references (&node
->ref_list
);
1845 /* Node comparer that is responsible for the order that corresponds
1846 to time when a function was launched for the first time. */
1849 node_cmp (const void *pa
, const void *pb
)
1851 const struct cgraph_node
*a
= *(const struct cgraph_node
* const *) pa
;
1852 const struct cgraph_node
*b
= *(const struct cgraph_node
* const *) pb
;
1854 /* Functions with time profile must be before these without profile. */
1855 if (!a
->tp_first_run
|| !b
->tp_first_run
)
1856 return a
->tp_first_run
- b
->tp_first_run
;
1858 return a
->tp_first_run
!= b
->tp_first_run
1859 ? b
->tp_first_run
- a
->tp_first_run
1860 : b
->order
- a
->order
;
1863 /* Expand all functions that must be output.
1865 Attempt to topologically sort the nodes so function is output when
1866 all called functions are already assembled to allow data to be
1867 propagated across the callgraph. Use a stack to get smaller distance
1868 between a function and its callees (later we may choose to use a more
1869 sophisticated algorithm for function reordering; we will likely want
1870 to use subsections to make the output functions appear in top-down
1874 expand_all_functions (void)
1876 struct cgraph_node
*node
;
1877 struct cgraph_node
**order
= XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1878 unsigned int expanded_func_count
= 0, profiled_func_count
= 0;
1879 int order_pos
, new_order_pos
= 0;
1882 order_pos
= ipa_reverse_postorder (order
);
1883 gcc_assert (order_pos
== cgraph_n_nodes
);
1885 /* Garbage collector may remove inline clones we eliminate during
1886 optimization. So we must be sure to not reference them. */
1887 for (i
= 0; i
< order_pos
; i
++)
1888 if (order
[i
]->process
)
1889 order
[new_order_pos
++] = order
[i
];
1891 if (flag_profile_reorder_functions
)
1892 qsort (order
, new_order_pos
, sizeof (struct cgraph_node
*), node_cmp
);
1894 for (i
= new_order_pos
- 1; i
>= 0; i
--)
1900 expanded_func_count
++;
1901 if(node
->tp_first_run
)
1902 profiled_func_count
++;
1904 if (cgraph_dump_file
)
1905 fprintf (cgraph_dump_file
, "Time profile order in expand_all_functions:%s:%d\n", node
->asm_name (), node
->tp_first_run
);
1908 expand_function (node
);
1913 fprintf (dump_file
, "Expanded functions with time profile (%s):%u/%u\n",
1914 main_input_filename
, profiled_func_count
, expanded_func_count
);
1916 if (cgraph_dump_file
&& flag_profile_reorder_functions
)
1917 fprintf (cgraph_dump_file
, "Expanded functions with time profile:%u/%u\n",
1918 profiled_func_count
, expanded_func_count
);
1920 cgraph_process_new_functions ();
1921 free_gimplify_stack ();
1926 /* This is used to sort the node types by the cgraph order number. */
1928 enum cgraph_order_sort_kind
1930 ORDER_UNDEFINED
= 0,
1936 struct cgraph_order_sort
1938 enum cgraph_order_sort_kind kind
;
1941 struct cgraph_node
*f
;
1947 /* Output all functions, variables, and asm statements in the order
1948 according to their order fields, which is the order in which they
1949 appeared in the file. This implements -fno-toplevel-reorder. In
1950 this mode we may output functions and variables which don't really
1951 need to be output. */
1954 output_in_order (void)
1957 struct cgraph_order_sort
*nodes
;
1959 struct cgraph_node
*pf
;
1961 struct asm_node
*pa
;
1964 nodes
= XCNEWVEC (struct cgraph_order_sort
, max
);
1966 FOR_EACH_DEFINED_FUNCTION (pf
)
1968 if (pf
->process
&& !pf
->thunk
.thunk_p
&& !pf
->alias
)
1971 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1972 nodes
[i
].kind
= ORDER_FUNCTION
;
1977 FOR_EACH_DEFINED_VARIABLE (pv
)
1978 if (!DECL_EXTERNAL (pv
->decl
))
1981 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1982 nodes
[i
].kind
= ORDER_VAR
;
1986 for (pa
= asm_nodes
; pa
; pa
= pa
->next
)
1989 gcc_assert (nodes
[i
].kind
== ORDER_UNDEFINED
);
1990 nodes
[i
].kind
= ORDER_ASM
;
1994 /* In toplevel reorder mode we output all statics; mark them as needed. */
1996 for (i
= 0; i
< max
; ++i
)
1997 if (nodes
[i
].kind
== ORDER_VAR
)
1998 varpool_finalize_named_section_flags (nodes
[i
].u
.v
);
2000 for (i
= 0; i
< max
; ++i
)
2002 switch (nodes
[i
].kind
)
2004 case ORDER_FUNCTION
:
2005 nodes
[i
].u
.f
->process
= 0;
2006 expand_function (nodes
[i
].u
.f
);
2010 varpool_assemble_decl (nodes
[i
].u
.v
);
2014 assemble_asm (nodes
[i
].u
.a
->asm_str
);
2017 case ORDER_UNDEFINED
:
2032 gcc::pass_manager
*passes
= g
->get_passes ();
2035 current_function_decl
= NULL
;
2036 gimple_register_cfg_hooks ();
2037 bitmap_obstack_initialize (NULL
);
2039 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START
, NULL
);
2043 execute_ipa_pass_list (passes
->all_small_ipa_passes
);
2048 /* We never run removal of unreachable nodes after early passes. This is
2049 because TODO is run before the subpasses. It is important to remove
2050 the unreachable functions to save works at IPA level and to get LTO
2051 symbol tables right. */
2052 symtab_remove_unreachable_nodes (true, cgraph_dump_file
);
2054 /* If pass_all_early_optimizations was not scheduled, the state of
2055 the cgraph will not be properly updated. Update it now. */
2056 if (cgraph_state
< CGRAPH_STATE_IPA_SSA
)
2057 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
2061 /* Generate coverage variables and constructors. */
2064 /* Process new functions added. */
2066 current_function_decl
= NULL
;
2067 cgraph_process_new_functions ();
2069 execute_ipa_summary_passes
2070 ((ipa_opt_pass_d
*) passes
->all_regular_ipa_passes
);
2073 /* Some targets need to handle LTO assembler output specially. */
2074 if (flag_generate_lto
)
2075 targetm
.asm_out
.lto_start ();
2078 ipa_write_summaries ();
2080 if (flag_generate_lto
)
2081 targetm
.asm_out
.lto_end ();
2083 if (!flag_ltrans
&& (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
))
2084 execute_ipa_pass_list (passes
->all_regular_ipa_passes
);
2085 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END
, NULL
);
2087 bitmap_obstack_release (NULL
);
2091 /* Return string alias is alias of. */
2094 get_alias_symbol (tree decl
)
2096 tree alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
));
2097 return get_identifier (TREE_STRING_POINTER
2098 (TREE_VALUE (TREE_VALUE (alias
))));
2102 /* Weakrefs may be associated to external decls and thus not output
2103 at expansion time. Emit all necessary aliases. */
2106 output_weakrefs (void)
2109 FOR_EACH_SYMBOL (node
)
2111 && !TREE_ASM_WRITTEN (node
->decl
)
2116 /* Weakrefs are special by not requiring target definition in current
2117 compilation unit. It is thus bit hard to work out what we want to
2119 When alias target is defined, we need to fetch it from symtab reference,
2120 otherwise it is pointed to by alias_target. */
2121 if (node
->alias_target
)
2122 target
= (DECL_P (node
->alias_target
)
2123 ? DECL_ASSEMBLER_NAME (node
->alias_target
)
2124 : node
->alias_target
);
2125 else if (node
->analyzed
)
2126 target
= DECL_ASSEMBLER_NAME (symtab_alias_target (node
)->decl
);
2130 target
= get_alias_symbol (node
->decl
);
2132 do_assemble_alias (node
->decl
, target
);
2136 /* Initialize callgraph dump file. */
2141 if (!cgraph_dump_file
)
2142 cgraph_dump_file
= dump_begin (TDI_cgraph
, NULL
);
2146 /* Perform simple optimizations based on callgraph. */
2154 #ifdef ENABLE_CHECKING
2158 timevar_push (TV_CGRAPHOPT
);
2159 if (pre_ipa_mem_report
)
2161 fprintf (stderr
, "Memory consumption before IPA\n");
2162 dump_memory_report (false);
2165 fprintf (stderr
, "Performing interprocedural optimizations\n");
2166 cgraph_state
= CGRAPH_STATE_IPA
;
2168 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2170 lto_streamer_hooks_init ();
2172 /* Don't run the IPA passes if there was any error or sorry messages. */
2176 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2178 || (!in_lto_p
&& flag_lto
&& !flag_fat_lto_objects
))
2180 timevar_pop (TV_CGRAPHOPT
);
2184 /* This pass remove bodies of extern inline functions we never inlined.
2185 Do this later so other IPA passes see what is really going on. */
2186 symtab_remove_unreachable_nodes (false, dump_file
);
2187 cgraph_global_info_ready
= true;
2188 if (cgraph_dump_file
)
2190 fprintf (cgraph_dump_file
, "Optimized ");
2191 dump_symtab (cgraph_dump_file
);
2193 if (post_ipa_mem_report
)
2195 fprintf (stderr
, "Memory consumption after IPA\n");
2196 dump_memory_report (false);
2198 timevar_pop (TV_CGRAPHOPT
);
2200 /* Output everything. */
2201 (*debug_hooks
->assembly_start
) ();
2203 fprintf (stderr
, "Assembling functions:\n");
2204 #ifdef ENABLE_CHECKING
2208 cgraph_materialize_all_clones ();
2209 bitmap_obstack_initialize (NULL
);
2210 execute_ipa_pass_list (g
->get_passes ()->all_late_ipa_passes
);
2211 symtab_remove_unreachable_nodes (true, dump_file
);
2212 #ifdef ENABLE_CHECKING
2215 bitmap_obstack_release (NULL
);
2216 mark_functions_to_output ();
2218 /* When weakref support is missing, we autmatically translate all
2219 references to NODE to references to its ultimate alias target.
2220 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2223 Set up this mapping before we output any assembler but once we are sure
2224 that all symbol renaming is done.
2226 FIXME: All this uglyness can go away if we just do renaming at gimple
2227 level by physically rewritting the IL. At the moment we can only redirect
2228 calls, so we need infrastructure for renaming references as well. */
2229 #ifndef ASM_OUTPUT_WEAKREF
2232 FOR_EACH_SYMBOL (node
)
2234 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
2236 IDENTIFIER_TRANSPARENT_ALIAS
2237 (DECL_ASSEMBLER_NAME (node
->decl
)) = 1;
2238 TREE_CHAIN (DECL_ASSEMBLER_NAME (node
->decl
))
2239 = (node
->alias_target
? node
->alias_target
2240 : DECL_ASSEMBLER_NAME (symtab_alias_target (node
)->decl
));
2244 cgraph_state
= CGRAPH_STATE_EXPANSION
;
2246 if (!flag_toplevel_reorder
)
2250 output_asm_statements ();
2252 expand_all_functions ();
2253 varpool_output_variables ();
2256 cgraph_process_new_functions ();
2257 cgraph_state
= CGRAPH_STATE_FINISHED
;
2260 if (cgraph_dump_file
)
2262 fprintf (cgraph_dump_file
, "\nFinal ");
2263 dump_symtab (cgraph_dump_file
);
2265 #ifdef ENABLE_CHECKING
2267 /* Double check that all inline clones are gone and that all
2268 function bodies have been released from memory. */
2271 struct cgraph_node
*node
;
2272 bool error_found
= false;
2274 FOR_EACH_DEFINED_FUNCTION (node
)
2275 if (node
->global
.inlined_to
2276 || gimple_has_body_p (node
->decl
))
2279 dump_cgraph_node (stderr
, node
);
2282 internal_error ("nodes with unreleased memory found");
2288 /* Analyze the whole compilation unit once it is parsed completely. */
2291 finalize_compilation_unit (void)
2293 timevar_push (TV_CGRAPH
);
2295 /* If we're here there's no current function anymore. Some frontends
2296 are lazy in clearing these. */
2297 current_function_decl
= NULL
;
2300 /* Do not skip analyzing the functions if there were errors, we
2301 miss diagnostics for following functions otherwise. */
2303 /* Emit size functions we didn't inline. */
2304 finalize_size_functions ();
2306 /* Mark alias targets necessary and emit diagnostics. */
2307 handle_alias_pairs ();
2311 fprintf (stderr
, "\nAnalyzing compilation unit\n");
2315 if (flag_dump_passes
)
2318 /* Gimplify and lower all functions, compute reachability and
2319 remove unreachable nodes. */
2320 analyze_functions ();
2322 /* Mark alias targets necessary and emit diagnostics. */
2323 handle_alias_pairs ();
2325 /* Gimplify and lower thunks. */
2326 analyze_functions ();
2328 /* Finally drive the pass manager. */
2331 timevar_pop (TV_CGRAPH
);
2335 #include "gt-cgraphunit.h"